1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright 2003, 2004 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 2 of the
9 License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
24 #ifdef ANSI_PROTOTYPES
34 #include "elf/xtensa.h"
35 #include "xtensa-isa.h"
36 #include "xtensa-config.h"
38 /* Main interface functions. */
39 static void elf_xtensa_info_to_howto_rela
40 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
41 static reloc_howto_type
*elf_xtensa_reloc_type_lookup
42 PARAMS ((bfd
*abfd
, bfd_reloc_code_real_type code
));
43 extern int xtensa_read_table_entries
44 PARAMS ((bfd
*, asection
*, property_table_entry
**, const char *));
45 static bfd_boolean elf_xtensa_check_relocs
46 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
47 const Elf_Internal_Rela
*));
48 static void elf_xtensa_hide_symbol
49 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*, bfd_boolean
));
50 static asection
*elf_xtensa_gc_mark_hook
51 PARAMS ((asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
52 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
53 static bfd_boolean elf_xtensa_gc_sweep_hook
54 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
55 const Elf_Internal_Rela
*));
56 static bfd_boolean elf_xtensa_create_dynamic_sections
57 PARAMS ((bfd
*, struct bfd_link_info
*));
58 static bfd_boolean elf_xtensa_adjust_dynamic_symbol
59 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
60 static bfd_boolean elf_xtensa_size_dynamic_sections
61 PARAMS ((bfd
*, struct bfd_link_info
*));
62 static bfd_boolean elf_xtensa_modify_segment_map
63 PARAMS ((bfd
*, struct bfd_link_info
*));
64 static bfd_boolean elf_xtensa_relocate_section
65 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
66 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
67 static bfd_boolean elf_xtensa_relax_section
68 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*again
));
69 static bfd_boolean elf_xtensa_finish_dynamic_symbol
70 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
72 static bfd_boolean elf_xtensa_finish_dynamic_sections
73 PARAMS ((bfd
*, struct bfd_link_info
*));
74 static bfd_boolean elf_xtensa_merge_private_bfd_data
75 PARAMS ((bfd
*, bfd
*));
76 static bfd_boolean elf_xtensa_set_private_flags
77 PARAMS ((bfd
*, flagword
));
78 extern flagword elf_xtensa_get_private_bfd_flags
80 static bfd_boolean elf_xtensa_print_private_bfd_data
81 PARAMS ((bfd
*, PTR
));
82 static bfd_boolean elf_xtensa_object_p
84 static void elf_xtensa_final_write_processing
85 PARAMS ((bfd
*, bfd_boolean
));
86 static enum elf_reloc_type_class elf_xtensa_reloc_type_class
87 PARAMS ((const Elf_Internal_Rela
*));
88 static bfd_boolean elf_xtensa_discard_info
89 PARAMS ((bfd
*, struct elf_reloc_cookie
*, struct bfd_link_info
*));
90 static bfd_boolean elf_xtensa_ignore_discarded_relocs
91 PARAMS ((asection
*));
92 static bfd_boolean elf_xtensa_grok_prstatus
93 PARAMS ((bfd
*, Elf_Internal_Note
*));
94 static bfd_boolean elf_xtensa_grok_psinfo
95 PARAMS ((bfd
*, Elf_Internal_Note
*));
96 static bfd_boolean elf_xtensa_new_section_hook
97 PARAMS ((bfd
*, asection
*));
100 /* Local helper functions. */
102 static bfd_boolean xtensa_elf_dynamic_symbol_p
103 PARAMS ((struct elf_link_hash_entry
*, struct bfd_link_info
*));
104 static int property_table_compare
105 PARAMS ((const PTR
, const PTR
));
106 static bfd_boolean elf_xtensa_in_literal_pool
107 PARAMS ((property_table_entry
*, int, bfd_vma
));
108 static void elf_xtensa_make_sym_local
109 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
110 static bfd_boolean add_extra_plt_sections
111 PARAMS ((bfd
*, int));
112 static bfd_boolean elf_xtensa_fix_refcounts
113 PARAMS ((struct elf_link_hash_entry
*, PTR
));
114 static bfd_boolean elf_xtensa_allocate_plt_size
115 PARAMS ((struct elf_link_hash_entry
*, PTR
));
116 static bfd_boolean elf_xtensa_allocate_got_size
117 PARAMS ((struct elf_link_hash_entry
*, PTR
));
118 static void elf_xtensa_allocate_local_got_size
119 PARAMS ((struct bfd_link_info
*, asection
*));
120 static bfd_reloc_status_type elf_xtensa_do_reloc
121 PARAMS ((reloc_howto_type
*, bfd
*, asection
*, bfd_vma
, bfd_byte
*,
122 bfd_vma
, bfd_boolean
, char **));
123 static char * vsprint_msg
124 VPARAMS ((const char *, const char *, int, ...));
125 static char *build_encoding_error_message
126 PARAMS ((xtensa_opcode
, xtensa_encode_result
));
127 static bfd_reloc_status_type bfd_elf_xtensa_reloc
128 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
129 static void do_fix_for_relocatable_link
130 PARAMS ((Elf_Internal_Rela
*, bfd
*, asection
*));
131 static void do_fix_for_final_link
132 PARAMS ((Elf_Internal_Rela
*, asection
*, bfd_vma
*));
133 static bfd_vma elf_xtensa_create_plt_entry
134 PARAMS ((bfd
*, bfd
*, unsigned));
135 static int elf_xtensa_combine_prop_entries
136 PARAMS ((bfd
*, asection
*, asection
*));
137 static bfd_boolean elf_xtensa_discard_info_for_section
138 PARAMS ((bfd
*, struct elf_reloc_cookie
*, struct bfd_link_info
*,
141 /* Local functions to handle Xtensa configurability. */
143 static void init_call_opcodes
145 static bfd_boolean is_indirect_call_opcode
146 PARAMS ((xtensa_opcode
));
147 static bfd_boolean is_direct_call_opcode
148 PARAMS ((xtensa_opcode
));
149 static bfd_boolean is_windowed_call_opcode
150 PARAMS ((xtensa_opcode
));
151 static xtensa_opcode get_l32r_opcode
153 static bfd_vma l32r_offset
154 PARAMS ((bfd_vma
, bfd_vma
));
155 static int get_relocation_opnd
156 PARAMS ((Elf_Internal_Rela
*));
157 static xtensa_opcode get_relocation_opcode
158 PARAMS ((asection
*, bfd_byte
*, Elf_Internal_Rela
*));
159 static bfd_boolean is_l32r_relocation
160 PARAMS ((asection
*, bfd_byte
*, Elf_Internal_Rela
*));
162 /* Functions for link-time code simplifications. */
164 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
165 PARAMS ((bfd_byte
*, bfd_vma
, bfd_vma
));
166 static bfd_reloc_status_type contract_asm_expansion
167 PARAMS ((bfd_byte
*, bfd_vma
, Elf_Internal_Rela
*));
168 static xtensa_opcode swap_callx_for_call_opcode
169 PARAMS ((xtensa_opcode
));
170 static xtensa_opcode get_expanded_call_opcode
171 PARAMS ((bfd_byte
*, int));
173 /* Access to internal relocations, section contents and symbols. */
175 static Elf_Internal_Rela
*retrieve_internal_relocs
176 PARAMS ((bfd
*, asection
*, bfd_boolean
));
177 static void pin_internal_relocs
178 PARAMS ((asection
*, Elf_Internal_Rela
*));
179 static void release_internal_relocs
180 PARAMS ((asection
*, Elf_Internal_Rela
*));
181 static bfd_byte
*retrieve_contents
182 PARAMS ((bfd
*, asection
*, bfd_boolean
));
183 static void pin_contents
184 PARAMS ((asection
*, bfd_byte
*));
185 static void release_contents
186 PARAMS ((asection
*, bfd_byte
*));
187 static Elf_Internal_Sym
*retrieve_local_syms
190 /* Miscellaneous utility functions. */
192 static asection
*elf_xtensa_get_plt_section
193 PARAMS ((bfd
*, int));
194 static asection
*elf_xtensa_get_gotplt_section
195 PARAMS ((bfd
*, int));
196 static asection
*get_elf_r_symndx_section
197 PARAMS ((bfd
*, unsigned long));
198 static struct elf_link_hash_entry
*get_elf_r_symndx_hash_entry
199 PARAMS ((bfd
*, unsigned long));
200 static bfd_vma get_elf_r_symndx_offset
201 PARAMS ((bfd
*, unsigned long));
202 static bfd_boolean pcrel_reloc_fits
203 PARAMS ((xtensa_operand
, bfd_vma
, bfd_vma
));
204 static bfd_boolean xtensa_is_property_section
205 PARAMS ((asection
*));
206 static bfd_boolean xtensa_is_littable_section
207 PARAMS ((asection
*));
208 static bfd_boolean is_literal_section
209 PARAMS ((asection
*));
210 static int internal_reloc_compare
211 PARAMS ((const PTR
, const PTR
));
212 extern char *xtensa_get_property_section_name
213 PARAMS ((asection
*, const char *));
215 /* Other functions called directly by the linker. */
217 typedef void (*deps_callback_t
)
218 PARAMS ((asection
*, bfd_vma
, asection
*, bfd_vma
, PTR
));
219 extern bfd_boolean xtensa_callback_required_dependence
220 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*,
221 deps_callback_t
, PTR
));
224 typedef struct xtensa_relax_info_struct xtensa_relax_info
;
227 /* Total count of PLT relocations seen during check_relocs.
228 The actual PLT code must be split into multiple sections and all
229 the sections have to be created before size_dynamic_sections,
230 where we figure out the exact number of PLT entries that will be
231 needed. It is OK if this count is an overestimate, e.g., some
232 relocations may be removed by GC. */
234 static int plt_reloc_count
= 0;
237 /* When this is true, relocations may have been modified to refer to
238 symbols from other input files. The per-section list of "fix"
239 records needs to be checked when resolving relocations. */
241 static bfd_boolean relaxing_section
= FALSE
;
244 static reloc_howto_type elf_howto_table
[] =
246 HOWTO (R_XTENSA_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
247 bfd_elf_xtensa_reloc
, "R_XTENSA_NONE",
248 FALSE
, 0x00000000, 0x00000000, FALSE
),
249 HOWTO (R_XTENSA_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
250 bfd_elf_xtensa_reloc
, "R_XTENSA_32",
251 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
252 /* Replace a 32-bit value with a value from the runtime linker (only
253 used by linker-generated stub functions). The r_addend value is
254 special: 1 means to substitute a pointer to the runtime linker's
255 dynamic resolver function; 2 means to substitute the link map for
256 the shared object. */
257 HOWTO (R_XTENSA_RTLD
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
258 NULL
, "R_XTENSA_RTLD",
259 FALSE
, 0x00000000, 0x00000000, FALSE
),
260 HOWTO (R_XTENSA_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
261 bfd_elf_generic_reloc
, "R_XTENSA_GLOB_DAT",
262 FALSE
, 0xffffffff, 0xffffffff, FALSE
),
263 HOWTO (R_XTENSA_JMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
264 bfd_elf_generic_reloc
, "R_XTENSA_JMP_SLOT",
265 FALSE
, 0xffffffff, 0xffffffff, FALSE
),
266 HOWTO (R_XTENSA_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
267 bfd_elf_generic_reloc
, "R_XTENSA_RELATIVE",
268 FALSE
, 0xffffffff, 0xffffffff, FALSE
),
269 HOWTO (R_XTENSA_PLT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
270 bfd_elf_xtensa_reloc
, "R_XTENSA_PLT",
271 FALSE
, 0xffffffff, 0xffffffff, FALSE
),
273 HOWTO (R_XTENSA_OP0
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
274 bfd_elf_xtensa_reloc
, "R_XTENSA_OP0",
275 FALSE
, 0x00000000, 0x00000000, TRUE
),
276 HOWTO (R_XTENSA_OP1
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
277 bfd_elf_xtensa_reloc
, "R_XTENSA_OP1",
278 FALSE
, 0x00000000, 0x00000000, TRUE
),
279 HOWTO (R_XTENSA_OP2
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
280 bfd_elf_xtensa_reloc
, "R_XTENSA_OP2",
281 FALSE
, 0x00000000, 0x00000000, TRUE
),
282 /* Assembly auto-expansion. */
283 HOWTO (R_XTENSA_ASM_EXPAND
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
284 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_EXPAND",
285 FALSE
, 0x00000000, 0x00000000, FALSE
),
286 /* Relax assembly auto-expansion. */
287 HOWTO (R_XTENSA_ASM_SIMPLIFY
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
288 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_SIMPLIFY",
289 FALSE
, 0x00000000, 0x00000000, TRUE
),
292 /* GNU extension to record C++ vtable hierarchy. */
293 HOWTO (R_XTENSA_GNU_VTINHERIT
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
294 NULL
, "R_XTENSA_GNU_VTINHERIT",
295 FALSE
, 0x00000000, 0x00000000, FALSE
),
296 /* GNU extension to record C++ vtable member usage. */
297 HOWTO (R_XTENSA_GNU_VTENTRY
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
298 _bfd_elf_rel_vtable_reloc_fn
, "R_XTENSA_GNU_VTENTRY",
299 FALSE
, 0x00000000, 0x00000000, FALSE
)
302 #ifdef DEBUG_GEN_RELOC
304 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
309 static reloc_howto_type
*
310 elf_xtensa_reloc_type_lookup (abfd
, code
)
311 bfd
*abfd ATTRIBUTE_UNUSED
;
312 bfd_reloc_code_real_type code
;
317 TRACE ("BFD_RELOC_NONE");
318 return &elf_howto_table
[(unsigned) R_XTENSA_NONE
];
321 TRACE ("BFD_RELOC_32");
322 return &elf_howto_table
[(unsigned) R_XTENSA_32
];
324 case BFD_RELOC_XTENSA_RTLD
:
325 TRACE ("BFD_RELOC_XTENSA_RTLD");
326 return &elf_howto_table
[(unsigned) R_XTENSA_RTLD
];
328 case BFD_RELOC_XTENSA_GLOB_DAT
:
329 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
330 return &elf_howto_table
[(unsigned) R_XTENSA_GLOB_DAT
];
332 case BFD_RELOC_XTENSA_JMP_SLOT
:
333 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
334 return &elf_howto_table
[(unsigned) R_XTENSA_JMP_SLOT
];
336 case BFD_RELOC_XTENSA_RELATIVE
:
337 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
338 return &elf_howto_table
[(unsigned) R_XTENSA_RELATIVE
];
340 case BFD_RELOC_XTENSA_PLT
:
341 TRACE ("BFD_RELOC_XTENSA_PLT");
342 return &elf_howto_table
[(unsigned) R_XTENSA_PLT
];
344 case BFD_RELOC_XTENSA_OP0
:
345 TRACE ("BFD_RELOC_XTENSA_OP0");
346 return &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
348 case BFD_RELOC_XTENSA_OP1
:
349 TRACE ("BFD_RELOC_XTENSA_OP1");
350 return &elf_howto_table
[(unsigned) R_XTENSA_OP1
];
352 case BFD_RELOC_XTENSA_OP2
:
353 TRACE ("BFD_RELOC_XTENSA_OP2");
354 return &elf_howto_table
[(unsigned) R_XTENSA_OP2
];
356 case BFD_RELOC_XTENSA_ASM_EXPAND
:
357 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
358 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_EXPAND
];
360 case BFD_RELOC_XTENSA_ASM_SIMPLIFY
:
361 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
362 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_SIMPLIFY
];
364 case BFD_RELOC_VTABLE_INHERIT
:
365 TRACE ("BFD_RELOC_VTABLE_INHERIT");
366 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTINHERIT
];
368 case BFD_RELOC_VTABLE_ENTRY
:
369 TRACE ("BFD_RELOC_VTABLE_ENTRY");
370 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTENTRY
];
381 /* Given an ELF "rela" relocation, find the corresponding howto and record
382 it in the BFD internal arelent representation of the relocation. */
385 elf_xtensa_info_to_howto_rela (abfd
, cache_ptr
, dst
)
386 bfd
*abfd ATTRIBUTE_UNUSED
;
388 Elf_Internal_Rela
*dst
;
390 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
392 BFD_ASSERT (r_type
< (unsigned int) R_XTENSA_max
);
393 cache_ptr
->howto
= &elf_howto_table
[r_type
];
397 /* Functions for the Xtensa ELF linker. */
399 /* The name of the dynamic interpreter. This is put in the .interp
402 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
404 /* The size in bytes of an entry in the procedure linkage table.
405 (This does _not_ include the space for the literals associated with
408 #define PLT_ENTRY_SIZE 16
410 /* For _really_ large PLTs, we may need to alternate between literals
411 and code to keep the literals within the 256K range of the L32R
412 instructions in the code. It's unlikely that anyone would ever need
413 such a big PLT, but an arbitrary limit on the PLT size would be bad.
414 Thus, we split the PLT into chunks. Since there's very little
415 overhead (2 extra literals) for each chunk, the chunk size is kept
416 small so that the code for handling multiple chunks get used and
417 tested regularly. With 254 entries, there are 1K of literals for
418 each chunk, and that seems like a nice round number. */
420 #define PLT_ENTRIES_PER_CHUNK 254
422 /* PLT entries are actually used as stub functions for lazy symbol
423 resolution. Once the symbol is resolved, the stub function is never
424 invoked. Note: the 32-byte frame size used here cannot be changed
425 without a corresponding change in the runtime linker. */
427 static const bfd_byte elf_xtensa_be_plt_entry
[PLT_ENTRY_SIZE
] =
429 0x6c, 0x10, 0x04, /* entry sp, 32 */
430 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
431 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
432 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
433 0x0a, 0x80, 0x00, /* jx a8 */
437 static const bfd_byte elf_xtensa_le_plt_entry
[PLT_ENTRY_SIZE
] =
439 0x36, 0x41, 0x00, /* entry sp, 32 */
440 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
441 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
442 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
443 0xa0, 0x08, 0x00, /* jx a8 */
448 static inline bfd_boolean
449 xtensa_elf_dynamic_symbol_p (h
, info
)
450 struct elf_link_hash_entry
*h
;
451 struct bfd_link_info
*info
;
453 /* Check if we should do dynamic things to this symbol. The
454 "ignore_protected" argument need not be set, because Xtensa code
455 does not require special handling of STV_PROTECTED to make function
456 pointer comparisons work properly. The PLT addresses are never
457 used for function pointers. */
459 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
464 property_table_compare (ap
, bp
)
468 const property_table_entry
*a
= (const property_table_entry
*) ap
;
469 const property_table_entry
*b
= (const property_table_entry
*) bp
;
471 /* Check if one entry overlaps with the other; this shouldn't happen
472 except when searching for a match. */
473 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
474 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
477 return (a
->address
- b
->address
);
481 /* Get the literal table or instruction table entries for the given
482 section. Sets TABLE_P and returns the number of entries. On error,
483 returns a negative value. */
486 xtensa_read_table_entries (abfd
, section
, table_p
, sec_name
)
489 property_table_entry
**table_p
;
490 const char *sec_name
;
492 asection
*table_section
;
493 char *table_section_name
;
494 bfd_size_type table_size
= 0;
495 bfd_byte
*table_data
;
496 property_table_entry
*blocks
;
498 bfd_size_type num_records
;
499 Elf_Internal_Rela
*internal_relocs
;
502 xtensa_get_property_section_name (section
, sec_name
);
503 table_section
= bfd_get_section_by_name (abfd
, table_section_name
);
504 free (table_section_name
);
505 if (table_section
!= NULL
)
506 table_size
= bfd_get_section_size_before_reloc (table_section
);
514 num_records
= table_size
/ 8;
515 table_data
= retrieve_contents (abfd
, table_section
, TRUE
);
516 blocks
= (property_table_entry
*)
517 bfd_malloc (num_records
* sizeof (property_table_entry
));
520 /* If the file has not yet been relocated, process the relocations
521 and sort out the table entries that apply to the specified section. */
522 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, TRUE
);
527 for (i
= 0; i
< table_section
->reloc_count
; i
++)
529 Elf_Internal_Rela
*rel
= &internal_relocs
[i
];
530 unsigned long r_symndx
;
532 if (ELF32_R_TYPE (rel
->r_info
) == R_XTENSA_NONE
)
535 BFD_ASSERT (ELF32_R_TYPE (rel
->r_info
) == R_XTENSA_32
);
536 r_symndx
= ELF32_R_SYM (rel
->r_info
);
538 if (get_elf_r_symndx_section (abfd
, r_symndx
) == section
)
540 bfd_vma sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
541 blocks
[block_count
].address
=
542 (section
->vma
+ sym_off
+ rel
->r_addend
543 + bfd_get_32 (abfd
, table_data
+ rel
->r_offset
));
544 blocks
[block_count
].size
=
545 bfd_get_32 (abfd
, table_data
+ rel
->r_offset
+ 4);
552 /* No relocations. Presumably the file has been relocated
553 and the addresses are already in the table. */
556 for (off
= 0; off
< table_size
; off
+= 8)
558 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
560 if (address
>= section
->vma
561 && address
< ( section
->vma
+ section
->_raw_size
))
563 blocks
[block_count
].address
= address
;
564 blocks
[block_count
].size
=
565 bfd_get_32 (abfd
, table_data
+ off
+ 4);
571 release_contents (table_section
, table_data
);
572 release_internal_relocs (table_section
, internal_relocs
);
576 /* Now sort them into address order for easy reference. */
577 qsort (blocks
, block_count
, sizeof (property_table_entry
),
578 property_table_compare
);
587 elf_xtensa_in_literal_pool (lit_table
, lit_table_size
, addr
)
588 property_table_entry
*lit_table
;
592 property_table_entry entry
;
594 if (lit_table_size
== 0)
597 entry
.address
= addr
;
600 if (bsearch (&entry
, lit_table
, lit_table_size
,
601 sizeof (property_table_entry
), property_table_compare
))
608 /* Look through the relocs for a section during the first phase, and
609 calculate needed space in the dynamic reloc sections. */
612 elf_xtensa_check_relocs (abfd
, info
, sec
, relocs
)
614 struct bfd_link_info
*info
;
616 const Elf_Internal_Rela
*relocs
;
618 Elf_Internal_Shdr
*symtab_hdr
;
619 struct elf_link_hash_entry
**sym_hashes
;
620 const Elf_Internal_Rela
*rel
;
621 const Elf_Internal_Rela
*rel_end
;
623 if (info
->relocatable
)
626 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
627 sym_hashes
= elf_sym_hashes (abfd
);
629 rel_end
= relocs
+ sec
->reloc_count
;
630 for (rel
= relocs
; rel
< rel_end
; rel
++)
633 unsigned long r_symndx
;
634 struct elf_link_hash_entry
*h
;
636 r_symndx
= ELF32_R_SYM (rel
->r_info
);
637 r_type
= ELF32_R_TYPE (rel
->r_info
);
639 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
641 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
642 bfd_archive_filename (abfd
),
647 if (r_symndx
< symtab_hdr
->sh_info
)
651 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
652 while (h
->root
.type
== bfd_link_hash_indirect
653 || h
->root
.type
== bfd_link_hash_warning
)
654 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
663 if ((sec
->flags
& SEC_ALLOC
) != 0)
665 if (h
->got
.refcount
<= 0)
668 h
->got
.refcount
+= 1;
673 /* If this relocation is against a local symbol, then it's
674 exactly the same as a normal local GOT entry. */
678 if ((sec
->flags
& SEC_ALLOC
) != 0)
680 if (h
->plt
.refcount
<= 0)
682 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
686 h
->plt
.refcount
+= 1;
688 /* Keep track of the total PLT relocation count even if we
689 don't yet know whether the dynamic sections will be
691 plt_reloc_count
+= 1;
693 if (elf_hash_table (info
)->dynamic_sections_created
)
695 if (!add_extra_plt_sections (elf_hash_table (info
)->dynobj
,
703 if ((sec
->flags
& SEC_ALLOC
) != 0)
705 bfd_signed_vma
*local_got_refcounts
;
707 /* This is a global offset table entry for a local symbol. */
708 local_got_refcounts
= elf_local_got_refcounts (abfd
);
709 if (local_got_refcounts
== NULL
)
713 size
= symtab_hdr
->sh_info
;
714 size
*= sizeof (bfd_signed_vma
);
715 local_got_refcounts
= ((bfd_signed_vma
*)
716 bfd_zalloc (abfd
, size
));
717 if (local_got_refcounts
== NULL
)
719 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
721 local_got_refcounts
[r_symndx
] += 1;
728 case R_XTENSA_ASM_EXPAND
:
729 case R_XTENSA_ASM_SIMPLIFY
:
730 /* Nothing to do for these. */
733 case R_XTENSA_GNU_VTINHERIT
:
734 /* This relocation describes the C++ object vtable hierarchy.
735 Reconstruct it for later use during GC. */
736 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
740 case R_XTENSA_GNU_VTENTRY
:
741 /* This relocation describes which C++ vtable entries are actually
742 used. Record for later use during GC. */
743 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
757 elf_xtensa_hide_symbol (info
, h
, force_local
)
758 struct bfd_link_info
*info
;
759 struct elf_link_hash_entry
*h
;
760 bfd_boolean force_local
;
762 /* For a shared link, move the plt refcount to the got refcount to leave
763 space for RELATIVE relocs. */
764 elf_xtensa_make_sym_local (info
, h
);
766 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
770 /* Return the section that should be marked against GC for a given
774 elf_xtensa_gc_mark_hook (sec
, info
, rel
, h
, sym
)
776 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
777 Elf_Internal_Rela
*rel
;
778 struct elf_link_hash_entry
*h
;
779 Elf_Internal_Sym
*sym
;
783 switch (ELF32_R_TYPE (rel
->r_info
))
785 case R_XTENSA_GNU_VTINHERIT
:
786 case R_XTENSA_GNU_VTENTRY
:
790 switch (h
->root
.type
)
792 case bfd_link_hash_defined
:
793 case bfd_link_hash_defweak
:
794 return h
->root
.u
.def
.section
;
796 case bfd_link_hash_common
:
797 return h
->root
.u
.c
.p
->section
;
805 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
810 /* Update the GOT & PLT entry reference counts
811 for the section being removed. */
814 elf_xtensa_gc_sweep_hook (abfd
, info
, sec
, relocs
)
816 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
818 const Elf_Internal_Rela
*relocs
;
820 Elf_Internal_Shdr
*symtab_hdr
;
821 struct elf_link_hash_entry
**sym_hashes
;
822 bfd_signed_vma
*local_got_refcounts
;
823 const Elf_Internal_Rela
*rel
, *relend
;
825 if ((sec
->flags
& SEC_ALLOC
) == 0)
828 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
829 sym_hashes
= elf_sym_hashes (abfd
);
830 local_got_refcounts
= elf_local_got_refcounts (abfd
);
832 relend
= relocs
+ sec
->reloc_count
;
833 for (rel
= relocs
; rel
< relend
; rel
++)
835 unsigned long r_symndx
;
837 struct elf_link_hash_entry
*h
= NULL
;
839 r_symndx
= ELF32_R_SYM (rel
->r_info
);
840 if (r_symndx
>= symtab_hdr
->sh_info
)
841 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
843 r_type
= ELF32_R_TYPE (rel
->r_info
);
849 if (h
->got
.refcount
> 0)
856 if (h
->plt
.refcount
> 0)
861 if (local_got_refcounts
[r_symndx
] > 0)
862 local_got_refcounts
[r_symndx
] -= 1;
874 /* Create all the dynamic sections. */
877 elf_xtensa_create_dynamic_sections (dynobj
, info
)
879 struct bfd_link_info
*info
;
881 flagword flags
, noalloc_flags
;
884 /* First do all the standard stuff. */
885 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
888 /* Create any extra PLT sections in case check_relocs has already
889 been called on all the non-dynamic input files. */
890 if (!add_extra_plt_sections (dynobj
, plt_reloc_count
))
893 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
894 | SEC_LINKER_CREATED
| SEC_READONLY
);
895 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
897 /* Mark the ".got.plt" section READONLY. */
898 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
900 || ! bfd_set_section_flags (dynobj
, s
, flags
))
903 /* Create ".rela.got". */
904 s
= bfd_make_section (dynobj
, ".rela.got");
906 || ! bfd_set_section_flags (dynobj
, s
, flags
)
907 || ! bfd_set_section_alignment (dynobj
, s
, 2))
910 /* Create ".got.loc" (literal tables for use by dynamic linker). */
911 s
= bfd_make_section (dynobj
, ".got.loc");
913 || ! bfd_set_section_flags (dynobj
, s
, flags
)
914 || ! bfd_set_section_alignment (dynobj
, s
, 2))
917 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
918 s
= bfd_make_section (dynobj
, ".xt.lit.plt");
920 || ! bfd_set_section_flags (dynobj
, s
, noalloc_flags
)
921 || ! bfd_set_section_alignment (dynobj
, s
, 2))
929 add_extra_plt_sections (dynobj
, count
)
935 /* Iterate over all chunks except 0 which uses the standard ".plt" and
936 ".got.plt" sections. */
937 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
943 /* Stop when we find a section has already been created. */
944 if (elf_xtensa_get_plt_section (dynobj
, chunk
))
947 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
948 | SEC_LINKER_CREATED
| SEC_READONLY
);
950 sname
= (char *) bfd_malloc (10);
951 sprintf (sname
, ".plt.%u", chunk
);
952 s
= bfd_make_section (dynobj
, sname
);
954 || ! bfd_set_section_flags (dynobj
, s
, flags
| SEC_CODE
)
955 || ! bfd_set_section_alignment (dynobj
, s
, 2))
958 sname
= (char *) bfd_malloc (14);
959 sprintf (sname
, ".got.plt.%u", chunk
);
960 s
= bfd_make_section (dynobj
, sname
);
962 || ! bfd_set_section_flags (dynobj
, s
, flags
)
963 || ! bfd_set_section_alignment (dynobj
, s
, 2))
971 /* Adjust a symbol defined by a dynamic object and referenced by a
972 regular object. The current definition is in some section of the
973 dynamic object, but we're not including those sections. We have to
974 change the definition to something the rest of the link can
978 elf_xtensa_adjust_dynamic_symbol (info
, h
)
979 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
980 struct elf_link_hash_entry
*h
;
982 /* If this is a weak symbol, and there is a real definition, the
983 processor independent code will have arranged for us to see the
984 real definition first, and we can just use the same value. */
985 if (h
->weakdef
!= NULL
)
987 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
988 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
989 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
990 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
994 /* This is a reference to a symbol defined by a dynamic object. The
995 reference must go through the GOT, so there's no need for COPY relocs,
1003 elf_xtensa_make_sym_local (info
, h
)
1004 struct bfd_link_info
*info
;
1005 struct elf_link_hash_entry
*h
;
1009 if (h
->plt
.refcount
> 0)
1011 /* Will use RELATIVE relocs instead of JMP_SLOT relocs. */
1012 if (h
->got
.refcount
< 0)
1013 h
->got
.refcount
= 0;
1014 h
->got
.refcount
+= h
->plt
.refcount
;
1015 h
->plt
.refcount
= 0;
1020 /* Don't need any dynamic relocations at all. */
1021 h
->plt
.refcount
= 0;
1022 h
->got
.refcount
= 0;
1028 elf_xtensa_fix_refcounts (h
, arg
)
1029 struct elf_link_hash_entry
*h
;
1032 struct bfd_link_info
*info
= (struct bfd_link_info
*) arg
;
1034 if (h
->root
.type
== bfd_link_hash_warning
)
1035 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1037 if (! xtensa_elf_dynamic_symbol_p (h
, info
))
1038 elf_xtensa_make_sym_local (info
, h
);
1045 elf_xtensa_allocate_plt_size (h
, arg
)
1046 struct elf_link_hash_entry
*h
;
1049 asection
*srelplt
= (asection
*) arg
;
1051 if (h
->root
.type
== bfd_link_hash_warning
)
1052 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1054 if (h
->plt
.refcount
> 0)
1055 srelplt
->_raw_size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1062 elf_xtensa_allocate_got_size (h
, arg
)
1063 struct elf_link_hash_entry
*h
;
1066 asection
*srelgot
= (asection
*) arg
;
1068 if (h
->root
.type
== bfd_link_hash_warning
)
1069 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1071 if (h
->got
.refcount
> 0)
1072 srelgot
->_raw_size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1079 elf_xtensa_allocate_local_got_size (info
, srelgot
)
1080 struct bfd_link_info
*info
;
1085 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
1087 bfd_signed_vma
*local_got_refcounts
;
1088 bfd_size_type j
, cnt
;
1089 Elf_Internal_Shdr
*symtab_hdr
;
1091 local_got_refcounts
= elf_local_got_refcounts (i
);
1092 if (!local_got_refcounts
)
1095 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1096 cnt
= symtab_hdr
->sh_info
;
1098 for (j
= 0; j
< cnt
; ++j
)
1100 if (local_got_refcounts
[j
] > 0)
1101 srelgot
->_raw_size
+= (local_got_refcounts
[j
]
1102 * sizeof (Elf32_External_Rela
));
1108 /* Set the sizes of the dynamic sections. */
1111 elf_xtensa_size_dynamic_sections (output_bfd
, info
)
1112 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1113 struct bfd_link_info
*info
;
1116 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1117 bfd_boolean relplt
, relgot
;
1118 int plt_entries
, plt_chunks
, chunk
;
1124 dynobj
= elf_hash_table (info
)->dynobj
;
1128 if (elf_hash_table (info
)->dynamic_sections_created
)
1130 /* Set the contents of the .interp section to the interpreter. */
1131 if (info
->executable
)
1133 s
= bfd_get_section_by_name (dynobj
, ".interp");
1136 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1137 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1140 /* Allocate room for one word in ".got". */
1141 s
= bfd_get_section_by_name (dynobj
, ".got");
1146 /* Adjust refcounts for symbols that we now know are not "dynamic". */
1147 elf_link_hash_traverse (elf_hash_table (info
),
1148 elf_xtensa_fix_refcounts
,
1151 /* Allocate space in ".rela.got" for literals that reference
1153 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
1154 if (srelgot
== NULL
)
1156 elf_link_hash_traverse (elf_hash_table (info
),
1157 elf_xtensa_allocate_got_size
,
1160 /* If we are generating a shared object, we also need space in
1161 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1162 reference local symbols. */
1164 elf_xtensa_allocate_local_got_size (info
, srelgot
);
1166 /* Allocate space in ".rela.plt" for literals that have PLT entries. */
1167 srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1168 if (srelplt
== NULL
)
1170 elf_link_hash_traverse (elf_hash_table (info
),
1171 elf_xtensa_allocate_plt_size
,
1174 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1175 each PLT entry, we need the PLT code plus a 4-byte literal.
1176 For each chunk of ".plt", we also need two more 4-byte
1177 literals, two corresponding entries in ".rela.got", and an
1178 8-byte entry in ".xt.lit.plt". */
1179 spltlittbl
= bfd_get_section_by_name (dynobj
, ".xt.lit.plt");
1180 if (spltlittbl
== NULL
)
1183 plt_entries
= srelplt
->_raw_size
/ sizeof (Elf32_External_Rela
);
1185 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1187 /* Iterate over all the PLT chunks, including any extra sections
1188 created earlier because the initial count of PLT relocations
1189 was an overestimate. */
1191 (splt
= elf_xtensa_get_plt_section (dynobj
, chunk
)) != NULL
;
1196 sgotplt
= elf_xtensa_get_gotplt_section (dynobj
, chunk
);
1197 if (sgotplt
== NULL
)
1200 if (chunk
< plt_chunks
- 1)
1201 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1202 else if (chunk
== plt_chunks
- 1)
1203 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1207 if (chunk_entries
!= 0)
1209 sgotplt
->_raw_size
= 4 * (chunk_entries
+ 2);
1210 splt
->_raw_size
= PLT_ENTRY_SIZE
* chunk_entries
;
1211 srelgot
->_raw_size
+= 2 * sizeof (Elf32_External_Rela
);
1212 spltlittbl
->_raw_size
+= 8;
1216 sgotplt
->_raw_size
= 0;
1217 splt
->_raw_size
= 0;
1221 /* Allocate space in ".got.loc" to match the total size of all the
1223 sgotloc
= bfd_get_section_by_name (dynobj
, ".got.loc");
1224 if (sgotloc
== NULL
)
1226 sgotloc
->_raw_size
= spltlittbl
->_raw_size
;
1227 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
1229 if (abfd
->flags
& DYNAMIC
)
1231 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1233 if (! elf_discarded_section (s
)
1234 && xtensa_is_littable_section (s
)
1236 sgotloc
->_raw_size
+= s
->_raw_size
;
1241 /* Allocate memory for dynamic sections. */
1244 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1249 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1252 /* It's OK to base decisions on the section name, because none
1253 of the dynobj section names depend upon the input files. */
1254 name
= bfd_get_section_name (dynobj
, s
);
1258 if (strncmp (name
, ".rela", 5) == 0)
1260 if (strcmp (name
, ".rela.plt") == 0)
1262 else if (strcmp (name
, ".rela.got") == 0)
1265 /* We use the reloc_count field as a counter if we need
1266 to copy relocs into the output file. */
1269 else if (strncmp (name
, ".plt.", 5) == 0
1270 || strncmp (name
, ".got.plt.", 9) == 0)
1272 if (s
->_raw_size
== 0)
1274 /* If we don't need this section, strip it from the output
1275 file. We must create the ".plt*" and ".got.plt*"
1276 sections in create_dynamic_sections and/or check_relocs
1277 based on a conservative estimate of the PLT relocation
1278 count, because the sections must be created before the
1279 linker maps input sections to output sections. The
1280 linker does that before size_dynamic_sections, where we
1281 compute the exact size of the PLT, so there may be more
1282 of these sections than are actually needed. */
1286 else if (strcmp (name
, ".got") != 0
1287 && strcmp (name
, ".plt") != 0
1288 && strcmp (name
, ".got.plt") != 0
1289 && strcmp (name
, ".xt.lit.plt") != 0
1290 && strcmp (name
, ".got.loc") != 0)
1292 /* It's not one of our sections, so don't allocate space. */
1297 _bfd_strip_section_from_output (info
, s
);
1300 /* Allocate memory for the section contents. */
1301 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1302 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1307 if (elf_hash_table (info
)->dynamic_sections_created
)
1309 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1310 known until finish_dynamic_sections, but we need to get the relocs
1311 in place before they are sorted. */
1312 if (srelgot
== NULL
)
1314 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1316 Elf_Internal_Rela irela
;
1320 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1323 loc
= (srelgot
->contents
1324 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1325 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1326 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1327 loc
+ sizeof (Elf32_External_Rela
));
1328 srelgot
->reloc_count
+= 2;
1331 /* Add some entries to the .dynamic section. We fill in the
1332 values later, in elf_xtensa_finish_dynamic_sections, but we
1333 must add the entries now so that we get the correct size for
1334 the .dynamic section. The DT_DEBUG entry is filled in by the
1335 dynamic linker and used by the debugger. */
1336 #define add_dynamic_entry(TAG, VAL) \
1337 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1341 if (!add_dynamic_entry (DT_DEBUG
, 0))
1347 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1348 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1349 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1350 || !add_dynamic_entry (DT_JMPREL
, 0))
1356 if (!add_dynamic_entry (DT_RELA
, 0)
1357 || !add_dynamic_entry (DT_RELASZ
, 0)
1358 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1362 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1363 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1366 #undef add_dynamic_entry
1372 /* Remove any PT_LOAD segments with no allocated sections. Prior to
1373 binutils 2.13, this function used to remove the non-SEC_ALLOC
1374 sections from PT_LOAD segments, but that task has now been moved
1375 into elf.c. We still need this function to remove any empty
1376 segments that result, but there's nothing Xtensa-specific about
1377 this and it probably ought to be moved into elf.c as well. */
1380 elf_xtensa_modify_segment_map (abfd
, info
)
1382 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1384 struct elf_segment_map
**m_p
;
1386 m_p
= &elf_tdata (abfd
)->segment_map
;
1387 while (*m_p
!= NULL
)
1389 if ((*m_p
)->p_type
== PT_LOAD
&& (*m_p
)->count
== 0)
1390 *m_p
= (*m_p
)->next
;
1392 m_p
= &(*m_p
)->next
;
1398 /* Perform the specified relocation. The instruction at (contents + address)
1399 is modified to set one operand to represent the value in "relocation". The
1400 operand position is determined by the relocation type recorded in the
1403 #define CALL_SEGMENT_BITS (30)
1404 #define CALL_SEGMENT_SIZE (1<<CALL_SEGMENT_BITS)
1406 static bfd_reloc_status_type
1407 elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
1408 contents
, address
, is_weak_undef
, error_message
)
1409 reloc_howto_type
*howto
;
1411 asection
*input_section
;
1415 bfd_boolean is_weak_undef
;
1416 char **error_message
;
1418 xtensa_opcode opcode
;
1419 xtensa_operand operand
;
1420 xtensa_encode_result encode_result
;
1421 xtensa_isa isa
= xtensa_default_isa
;
1422 xtensa_insnbuf ibuff
;
1423 bfd_vma self_address
;
1427 switch (howto
->type
)
1430 return bfd_reloc_ok
;
1432 case R_XTENSA_ASM_EXPAND
:
1435 /* Check for windowed CALL across a 1GB boundary. */
1436 xtensa_opcode opcode
=
1437 get_expanded_call_opcode (contents
+ address
,
1438 input_section
->_raw_size
- address
);
1439 if (is_windowed_call_opcode (opcode
))
1441 self_address
= (input_section
->output_section
->vma
1442 + input_section
->output_offset
1444 if ((self_address
>> CALL_SEGMENT_BITS
) !=
1445 (relocation
>> CALL_SEGMENT_BITS
))
1447 *error_message
= "windowed longcall crosses 1GB boundary; "
1449 return bfd_reloc_dangerous
;
1453 return bfd_reloc_ok
;
1455 case R_XTENSA_ASM_SIMPLIFY
:
1457 /* Convert the L32R/CALLX to CALL. */
1458 bfd_reloc_status_type retval
=
1459 elf_xtensa_do_asm_simplify (contents
, address
,
1460 input_section
->_raw_size
);
1461 if (retval
!= bfd_reloc_ok
)
1464 /* The CALL needs to be relocated. Continue below for that part. */
1466 howto
= &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
1474 x
= bfd_get_32 (abfd
, contents
+ address
);
1476 bfd_put_32 (abfd
, x
, contents
+ address
);
1478 return bfd_reloc_ok
;
1481 /* Read the instruction into a buffer and decode the opcode. */
1482 ibuff
= xtensa_insnbuf_alloc (isa
);
1483 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
);
1484 opcode
= xtensa_decode_insn (isa
, ibuff
);
1486 /* Determine which operand is being relocated. */
1487 if (opcode
== XTENSA_UNDEFINED
)
1489 *error_message
= "cannot decode instruction";
1490 return bfd_reloc_dangerous
;
1493 if (howto
->type
< R_XTENSA_OP0
|| howto
->type
> R_XTENSA_OP2
)
1495 *error_message
= "unexpected relocation";
1496 return bfd_reloc_dangerous
;
1499 opnd
= howto
->type
- R_XTENSA_OP0
;
1501 /* Calculate the PC address for this instruction. */
1502 if (!howto
->pc_relative
)
1504 *error_message
= "expected PC-relative relocation";
1505 return bfd_reloc_dangerous
;
1508 self_address
= (input_section
->output_section
->vma
1509 + input_section
->output_offset
1512 /* Apply the relocation. */
1513 operand
= xtensa_get_operand (isa
, opcode
, opnd
);
1514 newval
= xtensa_operand_do_reloc (operand
, relocation
, self_address
);
1515 encode_result
= xtensa_operand_encode (operand
, &newval
);
1516 xtensa_operand_set_field (operand
, ibuff
, newval
);
1518 /* Write the modified instruction back out of the buffer. */
1519 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
);
1522 if (encode_result
!= xtensa_encode_result_ok
)
1524 char *message
= build_encoding_error_message (opcode
, encode_result
);
1525 *error_message
= message
;
1526 return bfd_reloc_dangerous
;
1529 /* Final check for call. */
1530 if (is_direct_call_opcode (opcode
)
1531 && is_windowed_call_opcode (opcode
))
1533 if ((self_address
>> CALL_SEGMENT_BITS
) !=
1534 (relocation
>> CALL_SEGMENT_BITS
))
1536 *error_message
= "windowed call crosses 1GB boundary; "
1538 return bfd_reloc_dangerous
;
1542 return bfd_reloc_ok
;
1547 vsprint_msg
VPARAMS ((const char *origmsg
, const char *fmt
, int arglen
, ...))
1549 /* To reduce the size of the memory leak,
1550 we only use a single message buffer. */
1551 static bfd_size_type alloc_size
= 0;
1552 static char *message
= NULL
;
1553 bfd_size_type orig_len
, len
= 0;
1554 bfd_boolean is_append
;
1556 VA_OPEN (ap
, arglen
);
1557 VA_FIXEDARG (ap
, const char *, origmsg
);
1559 is_append
= (origmsg
== message
);
1561 orig_len
= strlen (origmsg
);
1562 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
1563 if (len
> alloc_size
)
1565 message
= (char *) bfd_realloc (message
, len
);
1569 memcpy (message
, origmsg
, orig_len
);
1570 vsprintf (message
+ orig_len
, fmt
, ap
);
1577 build_encoding_error_message (opcode
, encode_result
)
1578 xtensa_opcode opcode
;
1579 xtensa_encode_result encode_result
;
1581 const char *opname
= xtensa_opcode_name (xtensa_default_isa
, opcode
);
1582 const char *msg
= NULL
;
1584 switch (encode_result
)
1586 case xtensa_encode_result_ok
:
1587 msg
= "unexpected valid encoding";
1589 case xtensa_encode_result_align
:
1590 msg
= "misaligned encoding";
1592 case xtensa_encode_result_not_in_table
:
1593 msg
= "encoding not in lookup table";
1595 case xtensa_encode_result_too_low
:
1596 msg
= "encoding out of range: too low";
1598 case xtensa_encode_result_too_high
:
1599 msg
= "encoding out of range: too high";
1601 case xtensa_encode_result_not_ok
:
1603 msg
= "could not encode";
1607 if (is_direct_call_opcode (opcode
)
1608 && (encode_result
== xtensa_encode_result_too_low
1609 || encode_result
== xtensa_encode_result_too_high
))
1611 msg
= "direct call out of range";
1613 else if (opcode
== get_l32r_opcode ())
1615 /* L32Rs have the strange interaction with encoding in that they
1616 have an unsigned immediate field, so libisa returns "too high"
1617 when the absolute value is out of range and never returns "too
1618 low", but I leave the "too low" message in case anything
1620 if (encode_result
== xtensa_encode_result_too_low
)
1621 msg
= "literal out of range";
1622 else if (encode_result
== xtensa_encode_result_too_high
)
1623 msg
= "literal placed after use";
1626 return vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
1630 /* This function is registered as the "special_function" in the
1631 Xtensa howto for handling simplify operations.
1632 bfd_perform_relocation / bfd_install_relocation use it to
1633 perform (install) the specified relocation. Since this replaces the code
1634 in bfd_perform_relocation, it is basically an Xtensa-specific,
1635 stripped-down version of bfd_perform_relocation. */
1637 static bfd_reloc_status_type
1638 bfd_elf_xtensa_reloc (abfd
, reloc_entry
, symbol
, data
, input_section
,
1639 output_bfd
, error_message
)
1641 arelent
*reloc_entry
;
1644 asection
*input_section
;
1646 char **error_message
;
1649 bfd_reloc_status_type flag
;
1650 bfd_size_type octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
1651 bfd_vma output_base
= 0;
1652 reloc_howto_type
*howto
= reloc_entry
->howto
;
1653 asection
*reloc_target_output_section
;
1654 bfd_boolean is_weak_undef
;
1656 /* ELF relocs are against symbols. If we are producing relocatable
1657 output, and the reloc is against an external symbol, the resulting
1658 reloc will also be against the same symbol. In such a case, we
1659 don't want to change anything about the way the reloc is handled,
1660 since it will all be done at final link time. This test is similar
1661 to what bfd_elf_generic_reloc does except that it lets relocs with
1662 howto->partial_inplace go through even if the addend is non-zero.
1663 (The real problem is that partial_inplace is set for XTENSA_32
1664 relocs to begin with, but that's a long story and there's little we
1665 can do about it now....) */
1667 if (output_bfd
!= (bfd
*) NULL
1668 && (symbol
->flags
& BSF_SECTION_SYM
) == 0)
1670 reloc_entry
->address
+= input_section
->output_offset
;
1671 return bfd_reloc_ok
;
1674 /* Is the address of the relocation really within the section? */
1675 if (reloc_entry
->address
> (input_section
->_cooked_size
1676 / bfd_octets_per_byte (abfd
)))
1677 return bfd_reloc_outofrange
;
1679 /* Work out which section the relocation is targeted at and the
1680 initial relocation command value. */
1682 /* Get symbol value. (Common symbols are special.) */
1683 if (bfd_is_com_section (symbol
->section
))
1686 relocation
= symbol
->value
;
1688 reloc_target_output_section
= symbol
->section
->output_section
;
1690 /* Convert input-section-relative symbol value to absolute. */
1691 if ((output_bfd
&& !howto
->partial_inplace
)
1692 || reloc_target_output_section
== NULL
)
1695 output_base
= reloc_target_output_section
->vma
;
1697 relocation
+= output_base
+ symbol
->section
->output_offset
;
1699 /* Add in supplied addend. */
1700 relocation
+= reloc_entry
->addend
;
1702 /* Here the variable relocation holds the final address of the
1703 symbol we are relocating against, plus any addend. */
1706 if (!howto
->partial_inplace
)
1708 /* This is a partial relocation, and we want to apply the relocation
1709 to the reloc entry rather than the raw data. Everything except
1710 relocations against section symbols has already been handled
1713 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
1714 reloc_entry
->addend
= relocation
;
1715 reloc_entry
->address
+= input_section
->output_offset
;
1716 return bfd_reloc_ok
;
1720 reloc_entry
->address
+= input_section
->output_offset
;
1721 reloc_entry
->addend
= 0;
1725 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
1726 && (symbol
->flags
& BSF_WEAK
) != 0);
1727 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
1728 (bfd_byte
*) data
, (bfd_vma
) octets
,
1729 is_weak_undef
, error_message
);
1731 if (flag
== bfd_reloc_dangerous
)
1733 /* Add the symbol name to the error message. */
1734 if (! *error_message
)
1735 *error_message
= "";
1736 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
1737 strlen (symbol
->name
) + 17,
1738 symbol
->name
, reloc_entry
->addend
);
1745 /* Set up an entry in the procedure linkage table. */
1748 elf_xtensa_create_plt_entry (dynobj
, output_bfd
, reloc_index
)
1751 unsigned reloc_index
;
1753 asection
*splt
, *sgotplt
;
1754 bfd_vma plt_base
, got_base
;
1755 bfd_vma code_offset
, lit_offset
;
1758 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
1759 splt
= elf_xtensa_get_plt_section (dynobj
, chunk
);
1760 sgotplt
= elf_xtensa_get_gotplt_section (dynobj
, chunk
);
1761 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
1763 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
1764 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
1766 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
1767 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
1769 /* Fill in the literal entry. This is the offset of the dynamic
1770 relocation entry. */
1771 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
1772 sgotplt
->contents
+ lit_offset
);
1774 /* Fill in the entry in the procedure linkage table. */
1775 memcpy (splt
->contents
+ code_offset
,
1776 (bfd_big_endian (output_bfd
)
1777 ? elf_xtensa_be_plt_entry
1778 : elf_xtensa_le_plt_entry
),
1780 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
1781 plt_base
+ code_offset
+ 3),
1782 splt
->contents
+ code_offset
+ 4);
1783 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
1784 plt_base
+ code_offset
+ 6),
1785 splt
->contents
+ code_offset
+ 7);
1786 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
1787 plt_base
+ code_offset
+ 9),
1788 splt
->contents
+ code_offset
+ 10);
1790 return plt_base
+ code_offset
;
1794 /* Relocate an Xtensa ELF section. This is invoked by the linker for
1795 both relocatable and final links. */
1798 elf_xtensa_relocate_section (output_bfd
, info
, input_bfd
,
1799 input_section
, contents
, relocs
,
1800 local_syms
, local_sections
)
1802 struct bfd_link_info
*info
;
1804 asection
*input_section
;
1806 Elf_Internal_Rela
*relocs
;
1807 Elf_Internal_Sym
*local_syms
;
1808 asection
**local_sections
;
1810 Elf_Internal_Shdr
*symtab_hdr
;
1811 Elf_Internal_Rela
*rel
;
1812 Elf_Internal_Rela
*relend
;
1813 struct elf_link_hash_entry
**sym_hashes
;
1814 asection
*srelgot
, *srelplt
;
1816 property_table_entry
*lit_table
= 0;
1818 char *error_message
= NULL
;
1820 if (xtensa_default_isa
== NULL
)
1823 dynobj
= elf_hash_table (info
)->dynobj
;
1824 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1825 sym_hashes
= elf_sym_hashes (input_bfd
);
1831 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");;
1832 srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1835 if (elf_hash_table (info
)->dynamic_sections_created
)
1837 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
1838 &lit_table
, XTENSA_LIT_SEC_NAME
);
1844 relend
= relocs
+ input_section
->reloc_count
;
1845 for (; rel
< relend
; rel
++)
1848 reloc_howto_type
*howto
;
1849 unsigned long r_symndx
;
1850 struct elf_link_hash_entry
*h
;
1851 Elf_Internal_Sym
*sym
;
1854 bfd_reloc_status_type r
;
1855 bfd_boolean is_weak_undef
;
1856 bfd_boolean unresolved_reloc
;
1859 r_type
= ELF32_R_TYPE (rel
->r_info
);
1860 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
1861 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
1864 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
1866 bfd_set_error (bfd_error_bad_value
);
1869 howto
= &elf_howto_table
[r_type
];
1871 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1873 if (info
->relocatable
)
1875 /* This is a relocatable link.
1876 1) If the reloc is against a section symbol, adjust
1877 according to the output section.
1878 2) If there is a new target for this relocation,
1879 the new target will be in the same output section.
1880 We adjust the relocation by the output section
1883 if (relaxing_section
)
1885 /* Check if this references a section in another input file. */
1886 do_fix_for_relocatable_link (rel
, input_bfd
, input_section
);
1887 r_type
= ELF32_R_TYPE (rel
->r_info
);
1890 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
1892 /* Convert ASM_SIMPLIFY into the simpler relocation
1893 so that they never escape a relaxing link. */
1894 contract_asm_expansion (contents
, input_section
->_raw_size
, rel
);
1895 r_type
= ELF32_R_TYPE (rel
->r_info
);
1898 /* This is a relocatable link, so we don't have to change
1899 anything unless the reloc is against a section symbol,
1900 in which case we have to adjust according to where the
1901 section symbol winds up in the output section. */
1902 if (r_symndx
< symtab_hdr
->sh_info
)
1904 sym
= local_syms
+ r_symndx
;
1905 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1907 sec
= local_sections
[r_symndx
];
1908 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1912 /* If there is an addend with a partial_inplace howto,
1913 then move the addend to the contents. This is a hack
1914 to work around problems with DWARF in relocatable links
1915 with some previous version of BFD. Now we can't easily get
1916 rid of the hack without breaking backward compatibility.... */
1919 howto
= &elf_howto_table
[r_type
];
1920 if (howto
->partial_inplace
)
1922 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
1923 rel
->r_addend
, contents
,
1924 rel
->r_offset
, FALSE
,
1926 if (r
!= bfd_reloc_ok
)
1928 if (!((*info
->callbacks
->reloc_dangerous
)
1929 (info
, error_message
, input_bfd
, input_section
,
1937 /* Done with work for relocatable link; continue with next reloc. */
1941 /* This is a final link. */
1946 is_weak_undef
= FALSE
;
1947 unresolved_reloc
= FALSE
;
1950 if (howto
->partial_inplace
)
1952 /* Because R_XTENSA_32 was made partial_inplace to fix some
1953 problems with DWARF info in partial links, there may be
1954 an addend stored in the contents. Take it out of there
1955 and move it back into the addend field of the reloc. */
1956 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1957 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
1960 if (r_symndx
< symtab_hdr
->sh_info
)
1962 sym
= local_syms
+ r_symndx
;
1963 sec
= local_sections
[r_symndx
];
1964 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1968 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1969 r_symndx
, symtab_hdr
, sym_hashes
,
1971 unresolved_reloc
, warned
);
1974 && !unresolved_reloc
1975 && h
->root
.type
== bfd_link_hash_undefweak
)
1976 is_weak_undef
= TRUE
;
1979 if (relaxing_section
)
1981 /* Check if this references a section in another input file. */
1982 do_fix_for_final_link (rel
, input_section
, &relocation
);
1984 /* Update some already cached values. */
1985 r_type
= ELF32_R_TYPE (rel
->r_info
);
1986 howto
= &elf_howto_table
[r_type
];
1989 /* Sanity check the address. */
1990 if (rel
->r_offset
>= input_section
->_raw_size
1991 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
1993 bfd_set_error (bfd_error_bad_value
);
1997 /* Generate dynamic relocations. */
1998 if (elf_hash_table (info
)->dynamic_sections_created
)
2000 bfd_boolean dynamic_symbol
= xtensa_elf_dynamic_symbol_p (h
, info
);
2002 if (dynamic_symbol
&& (r_type
== R_XTENSA_OP0
2003 || r_type
== R_XTENSA_OP1
2004 || r_type
== R_XTENSA_OP2
))
2006 /* This is an error. The symbol's real value won't be known
2007 until runtime and it's likely to be out of range anyway. */
2008 const char *name
= h
->root
.root
.string
;
2009 error_message
= vsprint_msg ("invalid relocation for dynamic "
2011 strlen (name
) + 2, name
);
2012 if (!((*info
->callbacks
->reloc_dangerous
)
2013 (info
, error_message
, input_bfd
, input_section
,
2017 else if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
2018 && (input_section
->flags
& SEC_ALLOC
) != 0
2019 && (dynamic_symbol
|| info
->shared
))
2021 Elf_Internal_Rela outrel
;
2025 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2030 BFD_ASSERT (srel
!= NULL
);
2033 _bfd_elf_section_offset (output_bfd
, info
,
2034 input_section
, rel
->r_offset
);
2036 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2037 memset (&outrel
, 0, sizeof outrel
);
2040 outrel
.r_offset
+= (input_section
->output_section
->vma
2041 + input_section
->output_offset
);
2043 /* Complain if the relocation is in a read-only section
2044 and not in a literal pool. */
2045 if ((input_section
->flags
& SEC_READONLY
) != 0
2046 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2051 _("dynamic relocation in read-only section");
2052 if (!((*info
->callbacks
->reloc_dangerous
)
2053 (info
, error_message
, input_bfd
, input_section
,
2060 outrel
.r_addend
= rel
->r_addend
;
2063 if (r_type
== R_XTENSA_32
)
2066 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2069 else /* r_type == R_XTENSA_PLT */
2072 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2074 /* Create the PLT entry and set the initial
2075 contents of the literal entry to the address of
2078 elf_xtensa_create_plt_entry (dynobj
, output_bfd
,
2081 unresolved_reloc
= FALSE
;
2085 /* Generate a RELATIVE relocation. */
2086 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2087 outrel
.r_addend
= 0;
2091 loc
= (srel
->contents
2092 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2093 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2094 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2095 <= srel
->_cooked_size
);
2099 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2100 because such sections are not SEC_ALLOC and thus ld.so will
2101 not process them. */
2102 if (unresolved_reloc
2103 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2104 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
2105 (*_bfd_error_handler
)
2106 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2107 bfd_archive_filename (input_bfd
),
2108 bfd_get_section_name (input_bfd
, input_section
),
2109 (long) rel
->r_offset
,
2110 h
->root
.root
.string
);
2112 /* There's no point in calling bfd_perform_relocation here.
2113 Just go directly to our "special function". */
2114 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2115 relocation
+ rel
->r_addend
,
2116 contents
, rel
->r_offset
, is_weak_undef
,
2119 if (r
!= bfd_reloc_ok
&& !warned
)
2123 BFD_ASSERT (r
== bfd_reloc_dangerous
);
2124 BFD_ASSERT (error_message
!= (char *) NULL
);
2127 name
= h
->root
.root
.string
;
2130 name
= bfd_elf_string_from_elf_section
2131 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
2132 if (name
&& *name
== '\0')
2133 name
= bfd_section_name (input_bfd
, sec
);
2136 error_message
= vsprint_msg (error_message
, ": %s",
2137 strlen (name
), name
);
2138 if (!((*info
->callbacks
->reloc_dangerous
)
2139 (info
, error_message
, input_bfd
, input_section
,
2152 /* Finish up dynamic symbol handling. There's not much to do here since
2153 the PLT and GOT entries are all set up by relocate_section. */
2156 elf_xtensa_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2157 bfd
*output_bfd ATTRIBUTE_UNUSED
;
2158 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2159 struct elf_link_hash_entry
*h
;
2160 Elf_Internal_Sym
*sym
;
2162 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0
2163 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2165 /* Mark the symbol as undefined, rather than as defined in
2166 the .plt section. Leave the value alone. */
2167 sym
->st_shndx
= SHN_UNDEF
;
2170 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2171 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2172 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2173 sym
->st_shndx
= SHN_ABS
;
2179 /* Combine adjacent literal table entries in the output. Adjacent
2180 entries within each input section may have been removed during
2181 relaxation, but we repeat the process here, even though it's too late
2182 to shrink the output section, because it's important to minimize the
2183 number of literal table entries to reduce the start-up work for the
2184 runtime linker. Returns the number of remaining table entries or -1
2188 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
)
2194 property_table_entry
*table
;
2195 bfd_size_type section_size
, sgotloc_size
;
2199 section_size
= (sxtlit
->_cooked_size
!= 0
2200 ? sxtlit
->_cooked_size
: sxtlit
->_raw_size
);
2201 BFD_ASSERT (section_size
% 8 == 0);
2202 num
= section_size
/ 8;
2204 sgotloc_size
= (sgotloc
->_cooked_size
!= 0
2205 ? sgotloc
->_cooked_size
: sgotloc
->_raw_size
);
2206 if (sgotloc_size
!= section_size
)
2208 (*_bfd_error_handler
)
2209 ("internal inconsistency in size of .got.loc section");
2213 contents
= (bfd_byte
*) bfd_malloc (section_size
);
2214 table
= (property_table_entry
*)
2215 bfd_malloc (num
* sizeof (property_table_entry
));
2216 if (contents
== 0 || table
== 0)
2219 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
2220 propagates to the output section, where it doesn't really apply and
2221 where it breaks the following call to bfd_get_section_contents. */
2222 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
2224 if (! bfd_get_section_contents (output_bfd
, sxtlit
, contents
, 0,
2228 /* There should never be any relocations left at this point, so this
2229 is quite a bit easier than what is done during relaxation. */
2231 /* Copy the raw contents into a property table array and sort it. */
2233 for (n
= 0; n
< num
; n
++)
2235 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
2236 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
2239 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
2241 for (n
= 0; n
< num
; n
++)
2243 bfd_boolean remove
= FALSE
;
2245 if (table
[n
].size
== 0)
2248 (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
2250 table
[n
-1].size
+= table
[n
].size
;
2256 for (m
= n
; m
< num
- 1; m
++)
2258 table
[m
].address
= table
[m
+1].address
;
2259 table
[m
].size
= table
[m
+1].size
;
2267 /* Copy the data back to the raw contents. */
2269 for (n
= 0; n
< num
; n
++)
2271 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
2272 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
2276 /* Clear the removed bytes. */
2277 if ((bfd_size_type
) (num
* 8) < section_size
)
2279 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
2280 sxtlit
->_cooked_size
= num
* 8;
2283 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
2287 /* Copy the contents to ".got.loc". */
2288 memcpy (sgotloc
->contents
, contents
, section_size
);
2296 /* Finish up the dynamic sections. */
2299 elf_xtensa_finish_dynamic_sections (output_bfd
, info
)
2301 struct bfd_link_info
*info
;
2304 asection
*sdyn
, *srelplt
, *sgot
, *sxtlit
, *sgotloc
;
2305 Elf32_External_Dyn
*dyncon
, *dynconend
;
2306 int num_xtlit_entries
;
2308 if (! elf_hash_table (info
)->dynamic_sections_created
)
2311 dynobj
= elf_hash_table (info
)->dynobj
;
2312 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2313 BFD_ASSERT (sdyn
!= NULL
);
2315 /* Set the first entry in the global offset table to the address of
2316 the dynamic section. */
2317 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2320 BFD_ASSERT (sgot
->_raw_size
== 4);
2322 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2324 bfd_put_32 (output_bfd
,
2325 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2329 srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
2330 if (srelplt
!= NULL
&& srelplt
->_raw_size
!= 0)
2332 asection
*sgotplt
, *srelgot
, *spltlittbl
;
2333 int chunk
, plt_chunks
, plt_entries
;
2334 Elf_Internal_Rela irela
;
2336 unsigned rtld_reloc
;
2338 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");;
2339 BFD_ASSERT (srelgot
!= NULL
);
2341 spltlittbl
= bfd_get_section_by_name (dynobj
, ".xt.lit.plt");
2342 BFD_ASSERT (spltlittbl
!= NULL
);
2344 /* Find the first XTENSA_RTLD relocation. Presumably the rest
2345 of them follow immediately after.... */
2346 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
2348 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
2349 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
2350 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
2353 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
2355 plt_entries
= (srelplt
->_raw_size
/ sizeof (Elf32_External_Rela
));
2357 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
2359 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
2361 int chunk_entries
= 0;
2363 sgotplt
= elf_xtensa_get_gotplt_section (dynobj
, chunk
);
2364 BFD_ASSERT (sgotplt
!= NULL
);
2366 /* Emit special RTLD relocations for the first two entries in
2367 each chunk of the .got.plt section. */
2369 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
2370 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
2371 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
2372 irela
.r_offset
= (sgotplt
->output_section
->vma
2373 + sgotplt
->output_offset
);
2374 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
2375 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
2377 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
2379 /* Next literal immediately follows the first. */
2380 loc
+= sizeof (Elf32_External_Rela
);
2381 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
2382 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
2383 irela
.r_offset
= (sgotplt
->output_section
->vma
2384 + sgotplt
->output_offset
+ 4);
2385 /* Tell rtld to set value to object's link map. */
2387 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
2389 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
2391 /* Fill in the literal table. */
2392 if (chunk
< plt_chunks
- 1)
2393 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
2395 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
2397 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->_cooked_size
);
2398 bfd_put_32 (output_bfd
,
2399 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
2400 spltlittbl
->contents
+ (chunk
* 8) + 0);
2401 bfd_put_32 (output_bfd
,
2402 8 + (chunk_entries
* 4),
2403 spltlittbl
->contents
+ (chunk
* 8) + 4);
2406 /* All the dynamic relocations have been emitted at this point.
2407 Make sure the relocation sections are the correct size. */
2408 if (srelgot
->_cooked_size
!= (sizeof (Elf32_External_Rela
)
2409 * srelgot
->reloc_count
)
2410 || srelplt
->_cooked_size
!= (sizeof (Elf32_External_Rela
)
2411 * srelplt
->reloc_count
))
2414 /* The .xt.lit.plt section has just been modified. This must
2415 happen before the code below which combines adjacent literal
2416 table entries, and the .xt.lit.plt contents have to be forced to
2418 if (! bfd_set_section_contents (output_bfd
,
2419 spltlittbl
->output_section
,
2420 spltlittbl
->contents
,
2421 spltlittbl
->output_offset
,
2422 spltlittbl
->_raw_size
))
2424 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
2425 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
2428 /* Combine adjacent literal table entries. */
2429 BFD_ASSERT (! info
->relocatable
);
2430 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
2431 sgotloc
= bfd_get_section_by_name (dynobj
, ".got.loc");
2432 BFD_ASSERT (sxtlit
&& sgotloc
);
2434 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
2435 if (num_xtlit_entries
< 0)
2438 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2439 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2440 for (; dyncon
< dynconend
; dyncon
++)
2442 Elf_Internal_Dyn dyn
;
2446 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2453 case DT_XTENSA_GOT_LOC_SZ
:
2454 dyn
.d_un
.d_val
= num_xtlit_entries
;
2457 case DT_XTENSA_GOT_LOC_OFF
:
2466 s
= bfd_get_section_by_name (output_bfd
, name
);
2468 dyn
.d_un
.d_ptr
= s
->vma
;
2472 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2474 dyn
.d_un
.d_val
= (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
2478 /* Adjust RELASZ to not include JMPREL. This matches what
2479 glibc expects and what is done for several other ELF
2480 targets (e.g., i386, alpha), but the "correct" behavior
2481 seems to be unresolved. Since the linker script arranges
2482 for .rela.plt to follow all other relocation sections, we
2483 don't have to worry about changing the DT_RELA entry. */
2484 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2488 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
2493 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2500 /* Functions for dealing with the e_flags field. */
2502 /* Merge backend specific data from an object file to the output
2503 object file when linking. */
2506 elf_xtensa_merge_private_bfd_data (ibfd
, obfd
)
2510 unsigned out_mach
, in_mach
;
2511 flagword out_flag
, in_flag
;
2513 /* Check if we have the same endianess. */
2514 if (!_bfd_generic_verify_endian_match (ibfd
, obfd
))
2517 /* Don't even pretend to support mixed-format linking. */
2518 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2519 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2522 out_flag
= elf_elfheader (obfd
)->e_flags
;
2523 in_flag
= elf_elfheader (ibfd
)->e_flags
;
2525 out_mach
= out_flag
& EF_XTENSA_MACH
;
2526 in_mach
= in_flag
& EF_XTENSA_MACH
;
2527 if (out_mach
!= in_mach
)
2529 (*_bfd_error_handler
)
2530 ("%s: incompatible machine type. Output is 0x%x. Input is 0x%x",
2531 bfd_archive_filename (ibfd
), out_mach
, in_mach
);
2532 bfd_set_error (bfd_error_wrong_format
);
2536 if (! elf_flags_init (obfd
))
2538 elf_flags_init (obfd
) = TRUE
;
2539 elf_elfheader (obfd
)->e_flags
= in_flag
;
2541 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2542 && bfd_get_arch_info (obfd
)->the_default
)
2543 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
2544 bfd_get_mach (ibfd
));
2549 if ((out_flag
& EF_XTENSA_XT_INSN
) !=
2550 (in_flag
& EF_XTENSA_XT_INSN
))
2551 elf_elfheader(obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
2553 if ((out_flag
& EF_XTENSA_XT_LIT
) !=
2554 (in_flag
& EF_XTENSA_XT_LIT
))
2555 elf_elfheader(obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
2562 elf_xtensa_set_private_flags (abfd
, flags
)
2566 BFD_ASSERT (!elf_flags_init (abfd
)
2567 || elf_elfheader (abfd
)->e_flags
== flags
);
2569 elf_elfheader (abfd
)->e_flags
|= flags
;
2570 elf_flags_init (abfd
) = TRUE
;
2577 elf_xtensa_get_private_bfd_flags (abfd
)
2580 return elf_elfheader (abfd
)->e_flags
;
2585 elf_xtensa_print_private_bfd_data (abfd
, farg
)
2589 FILE *f
= (FILE *) farg
;
2590 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
2592 fprintf (f
, "\nXtensa header:\n");
2593 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
2594 fprintf (f
, "\nMachine = Base\n");
2596 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
2598 fprintf (f
, "Insn tables = %s\n",
2599 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
2601 fprintf (f
, "Literal tables = %s\n",
2602 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
2604 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
2608 /* Set the right machine number for an Xtensa ELF file. */
2611 elf_xtensa_object_p (abfd
)
2615 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
2620 mach
= bfd_mach_xtensa
;
2626 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
2631 /* The final processing done just before writing out an Xtensa ELF object
2632 file. This gets the Xtensa architecture right based on the machine
2636 elf_xtensa_final_write_processing (abfd
, linker
)
2638 bfd_boolean linker ATTRIBUTE_UNUSED
;
2643 switch (mach
= bfd_get_mach (abfd
))
2645 case bfd_mach_xtensa
:
2646 val
= E_XTENSA_MACH
;
2652 elf_elfheader (abfd
)->e_flags
&= (~ EF_XTENSA_MACH
);
2653 elf_elfheader (abfd
)->e_flags
|= val
;
2657 static enum elf_reloc_type_class
2658 elf_xtensa_reloc_type_class (rela
)
2659 const Elf_Internal_Rela
*rela
;
2661 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2663 case R_XTENSA_RELATIVE
:
2664 return reloc_class_relative
;
2665 case R_XTENSA_JMP_SLOT
:
2666 return reloc_class_plt
;
2668 return reloc_class_normal
;
2674 elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
)
2676 struct elf_reloc_cookie
*cookie
;
2677 struct bfd_link_info
*info
;
2681 bfd_vma section_size
;
2682 bfd_vma offset
, actual_offset
;
2683 size_t removed_bytes
= 0;
2685 section_size
= (sec
->_cooked_size
? sec
->_cooked_size
: sec
->_raw_size
);
2686 if (section_size
== 0 || section_size
% 8 != 0)
2689 if (sec
->output_section
2690 && bfd_is_abs_section (sec
->output_section
))
2693 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
2697 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
2700 release_contents (sec
, contents
);
2704 cookie
->rel
= cookie
->rels
;
2705 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
2707 for (offset
= 0; offset
< section_size
; offset
+= 8)
2709 actual_offset
= offset
- removed_bytes
;
2711 /* The ...symbol_deleted_p function will skip over relocs but it
2712 won't adjust their offsets, so do that here. */
2713 while (cookie
->rel
< cookie
->relend
2714 && cookie
->rel
->r_offset
< offset
)
2716 cookie
->rel
->r_offset
-= removed_bytes
;
2720 while (cookie
->rel
< cookie
->relend
2721 && cookie
->rel
->r_offset
== offset
)
2723 if (_bfd_elf32_reloc_symbol_deleted_p (offset
, cookie
))
2725 /* Remove the table entry. (If the reloc type is NONE, then
2726 the entry has already been merged with another and deleted
2727 during relaxation.) */
2728 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
2730 /* Shift the contents up. */
2731 if (offset
+ 8 < section_size
)
2732 memmove (&contents
[actual_offset
],
2733 &contents
[actual_offset
+8],
2734 section_size
- offset
- 8);
2738 /* Remove this relocation. */
2739 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
2742 /* Adjust the relocation offset for previous removals. This
2743 should not be done before calling ...symbol_deleted_p
2744 because it might mess up the offset comparisons there.
2745 Make sure the offset doesn't underflow in the case where
2746 the first entry is removed. */
2747 if (cookie
->rel
->r_offset
>= removed_bytes
)
2748 cookie
->rel
->r_offset
-= removed_bytes
;
2750 cookie
->rel
->r_offset
= 0;
2756 if (removed_bytes
!= 0)
2758 /* Adjust any remaining relocs (shouldn't be any). */
2759 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
2761 if (cookie
->rel
->r_offset
>= removed_bytes
)
2762 cookie
->rel
->r_offset
-= removed_bytes
;
2764 cookie
->rel
->r_offset
= 0;
2767 /* Clear the removed bytes. */
2768 memset (&contents
[section_size
- removed_bytes
], 0, removed_bytes
);
2770 pin_contents (sec
, contents
);
2771 pin_internal_relocs (sec
, cookie
->rels
);
2773 sec
->_cooked_size
= section_size
- removed_bytes
;
2774 /* Also shrink _raw_size. See comments in relax_property_section. */
2775 sec
->_raw_size
= sec
->_cooked_size
;
2777 if (xtensa_is_littable_section (sec
))
2779 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
2783 bfd_get_section_by_name (dynobj
, ".got.loc");
2786 bfd_size_type sgotloc_size
=
2787 (sgotloc
->_cooked_size
? sgotloc
->_cooked_size
2788 : sgotloc
->_raw_size
);
2789 sgotloc
->_cooked_size
= sgotloc_size
- removed_bytes
;
2790 sgotloc
->_raw_size
= sgotloc_size
- removed_bytes
;
2797 release_contents (sec
, contents
);
2798 release_internal_relocs (sec
, cookie
->rels
);
2801 return (removed_bytes
!= 0);
2806 elf_xtensa_discard_info (abfd
, cookie
, info
)
2808 struct elf_reloc_cookie
*cookie
;
2809 struct bfd_link_info
*info
;
2812 bfd_boolean changed
= FALSE
;
2814 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2816 if (xtensa_is_property_section (sec
))
2818 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
2828 elf_xtensa_ignore_discarded_relocs (sec
)
2831 return xtensa_is_property_section (sec
);
2835 /* Support for core dump NOTE sections. */
2838 elf_xtensa_grok_prstatus (abfd
, note
)
2840 Elf_Internal_Note
*note
;
2843 unsigned int raw_size
;
2845 /* The size for Xtensa is variable, so don't try to recognize the format
2846 based on the size. Just assume this is GNU/Linux. */
2849 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2852 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2856 raw_size
= note
->descsz
- offset
- 4;
2858 /* Make a ".reg/999" section. */
2859 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
2860 raw_size
, note
->descpos
+ offset
);
2865 elf_xtensa_grok_psinfo (abfd
, note
)
2867 Elf_Internal_Note
*note
;
2869 switch (note
->descsz
)
2874 case 128: /* GNU/Linux elf_prpsinfo */
2875 elf_tdata (abfd
)->core_program
2876 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
2877 elf_tdata (abfd
)->core_command
2878 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
2881 /* Note that for some reason, a spurious space is tacked
2882 onto the end of the args in some (at least one anyway)
2883 implementations, so strip it off if it exists. */
2886 char *command
= elf_tdata (abfd
)->core_command
;
2887 int n
= strlen (command
);
2889 if (0 < n
&& command
[n
- 1] == ' ')
2890 command
[n
- 1] = '\0';
2897 /* Generic Xtensa configurability stuff. */
2899 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
2900 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
2901 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
2902 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
2903 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
2904 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
2905 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
2906 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
2909 init_call_opcodes ()
2911 if (callx0_op
== XTENSA_UNDEFINED
)
2913 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
2914 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
2915 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
2916 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
2917 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
2918 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
2919 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
2920 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
2926 is_indirect_call_opcode (opcode
)
2927 xtensa_opcode opcode
;
2929 init_call_opcodes ();
2930 return (opcode
== callx0_op
2931 || opcode
== callx4_op
2932 || opcode
== callx8_op
2933 || opcode
== callx12_op
);
2938 is_direct_call_opcode (opcode
)
2939 xtensa_opcode opcode
;
2941 init_call_opcodes ();
2942 return (opcode
== call0_op
2943 || opcode
== call4_op
2944 || opcode
== call8_op
2945 || opcode
== call12_op
);
2950 is_windowed_call_opcode (opcode
)
2951 xtensa_opcode opcode
;
2953 init_call_opcodes ();
2954 return (opcode
== call4_op
2955 || opcode
== call8_op
2956 || opcode
== call12_op
2957 || opcode
== callx4_op
2958 || opcode
== callx8_op
2959 || opcode
== callx12_op
);
2963 static xtensa_opcode
2964 get_l32r_opcode (void)
2966 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
2967 if (l32r_opcode
== XTENSA_UNDEFINED
)
2969 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
2970 BFD_ASSERT (l32r_opcode
!= XTENSA_UNDEFINED
);
2977 l32r_offset (addr
, pc
)
2983 offset
= addr
- ((pc
+3) & -4);
2984 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
2985 offset
= (signed int) offset
>> 2;
2986 BFD_ASSERT ((signed int) offset
>> 16 == -1);
2991 /* Get the operand number for a PC-relative relocation.
2992 If the relocation is not a PC-relative one, return (-1). */
2995 get_relocation_opnd (irel
)
2996 Elf_Internal_Rela
*irel
;
2998 if (ELF32_R_TYPE (irel
->r_info
) < R_XTENSA_OP0
2999 || ELF32_R_TYPE (irel
->r_info
) >= R_XTENSA_max
)
3001 return ELF32_R_TYPE (irel
->r_info
) - R_XTENSA_OP0
;
3005 /* Get the opcode for a relocation. */
3007 static xtensa_opcode
3008 get_relocation_opcode (sec
, contents
, irel
)
3011 Elf_Internal_Rela
*irel
;
3013 static xtensa_insnbuf ibuff
= NULL
;
3014 xtensa_isa isa
= xtensa_default_isa
;
3016 if (get_relocation_opnd (irel
) == -1)
3017 return XTENSA_UNDEFINED
;
3019 if (contents
== NULL
)
3020 return XTENSA_UNDEFINED
;
3022 if (sec
->_raw_size
<= irel
->r_offset
)
3023 return XTENSA_UNDEFINED
;
3026 ibuff
= xtensa_insnbuf_alloc (isa
);
3028 /* Decode the instruction. */
3029 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
]);
3030 return xtensa_decode_insn (isa
, ibuff
);
3035 is_l32r_relocation (sec
, contents
, irel
)
3038 Elf_Internal_Rela
*irel
;
3040 xtensa_opcode opcode
;
3042 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_OP1
)
3045 opcode
= get_relocation_opcode (sec
, contents
, irel
);
3046 return (opcode
== get_l32r_opcode ());
3050 /* Code for transforming CALLs at link-time. */
3052 static bfd_reloc_status_type
3053 elf_xtensa_do_asm_simplify (contents
, address
, content_length
)
3056 bfd_vma content_length
;
3058 static xtensa_insnbuf insnbuf
= NULL
;
3059 xtensa_opcode opcode
;
3060 xtensa_operand operand
;
3061 xtensa_opcode direct_call_opcode
;
3062 xtensa_isa isa
= xtensa_default_isa
;
3063 bfd_byte
*chbuf
= contents
+ address
;
3066 if (insnbuf
== NULL
)
3067 insnbuf
= xtensa_insnbuf_alloc (isa
);
3069 if (content_length
< address
)
3071 (*_bfd_error_handler
)
3072 ("Attempt to convert L32R/CALLX to CALL failed");
3073 return bfd_reloc_other
;
3076 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
);
3077 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
3078 if (direct_call_opcode
== XTENSA_UNDEFINED
)
3080 (*_bfd_error_handler
)
3081 ("Attempt to convert L32R/CALLX to CALL failed");
3082 return bfd_reloc_other
;
3085 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
3086 opcode
= xtensa_opcode_lookup (isa
, "or");
3087 xtensa_encode_insn (isa
, opcode
, insnbuf
);
3088 for (opn
= 0; opn
< 3; opn
++)
3090 operand
= xtensa_get_operand (isa
, opcode
, opn
);
3091 xtensa_operand_set_field (operand
, insnbuf
, 1);
3093 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
);
3095 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
3096 xtensa_encode_insn (isa
, direct_call_opcode
, insnbuf
);
3097 operand
= xtensa_get_operand (isa
, opcode
, 0);
3098 xtensa_operand_set_field (operand
, insnbuf
, 0);
3099 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3);
3101 return bfd_reloc_ok
;
3105 static bfd_reloc_status_type
3106 contract_asm_expansion (contents
, content_length
, irel
)
3108 bfd_vma content_length
;
3109 Elf_Internal_Rela
*irel
;
3111 bfd_reloc_status_type retval
=
3112 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
);
3114 if (retval
!= bfd_reloc_ok
)
3117 /* Update the irel->r_offset field so that the right immediate and
3118 the right instruction are modified during the relocation. */
3119 irel
->r_offset
+= 3;
3120 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_OP0
);
3121 return bfd_reloc_ok
;
3125 static xtensa_opcode
3126 swap_callx_for_call_opcode (opcode
)
3127 xtensa_opcode opcode
;
3129 init_call_opcodes ();
3131 if (opcode
== callx0_op
) return call0_op
;
3132 if (opcode
== callx4_op
) return call4_op
;
3133 if (opcode
== callx8_op
) return call8_op
;
3134 if (opcode
== callx12_op
) return call12_op
;
3136 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
3137 return XTENSA_UNDEFINED
;
3141 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" sequence, and
3142 if so, return the CALLX opcode. If not, return XTENSA_UNDEFINED. */
3144 #define L32R_TARGET_REG_OPERAND 0
3145 #define CALLN_SOURCE_OPERAND 0
3147 static xtensa_opcode
3148 get_expanded_call_opcode (buf
, bufsize
)
3152 static xtensa_insnbuf insnbuf
= NULL
;
3153 xtensa_opcode opcode
;
3154 xtensa_operand operand
;
3155 xtensa_isa isa
= xtensa_default_isa
;
3156 uint32 regno
, call_regno
;
3158 /* Buffer must be at least 6 bytes. */
3160 return XTENSA_UNDEFINED
;
3162 if (insnbuf
== NULL
)
3163 insnbuf
= xtensa_insnbuf_alloc (isa
);
3165 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
);
3166 opcode
= xtensa_decode_insn (isa
, insnbuf
);
3168 if (opcode
!= get_l32r_opcode ())
3169 return XTENSA_UNDEFINED
;
3171 operand
= xtensa_get_operand (isa
, opcode
, L32R_TARGET_REG_OPERAND
);
3172 regno
= xtensa_operand_decode
3173 (operand
, xtensa_operand_get_field (operand
, insnbuf
));
3175 /* Next instruction should be an CALLXn with operand 0 == regno. */
3176 xtensa_insnbuf_from_chars (isa
, insnbuf
,
3177 buf
+ xtensa_insn_length (isa
, opcode
));
3178 opcode
= xtensa_decode_insn (isa
, insnbuf
);
3180 if (!is_indirect_call_opcode (opcode
))
3181 return XTENSA_UNDEFINED
;
3183 operand
= xtensa_get_operand (isa
, opcode
, CALLN_SOURCE_OPERAND
);
3184 call_regno
= xtensa_operand_decode
3185 (operand
, xtensa_operand_get_field (operand
, insnbuf
));
3186 if (call_regno
!= regno
)
3187 return XTENSA_UNDEFINED
;
3193 /* Data structures used during relaxation. */
3195 /* r_reloc: relocation values. */
3197 /* Through the relaxation process, we need to keep track of the values
3198 that will result from evaluating relocations. The standard ELF
3199 relocation structure is not sufficient for this purpose because we're
3200 operating on multiple input files at once, so we need to know which
3201 input file a relocation refers to. The r_reloc structure thus
3202 records both the input file (bfd) and ELF relocation.
3204 For efficiency, an r_reloc also contains a "target_offset" field to
3205 cache the target-section-relative offset value that is represented by
3208 typedef struct r_reloc_struct r_reloc
;
3210 struct r_reloc_struct
3213 Elf_Internal_Rela rela
;
3214 bfd_vma target_offset
;
3217 static bfd_boolean r_reloc_is_const
3218 PARAMS ((const r_reloc
*));
3219 static void r_reloc_init
3220 PARAMS ((r_reloc
*, bfd
*, Elf_Internal_Rela
*));
3221 static bfd_vma r_reloc_get_target_offset
3222 PARAMS ((const r_reloc
*));
3223 static asection
*r_reloc_get_section
3224 PARAMS ((const r_reloc
*));
3225 static bfd_boolean r_reloc_is_defined
3226 PARAMS ((const r_reloc
*));
3227 static struct elf_link_hash_entry
*r_reloc_get_hash_entry
3228 PARAMS ((const r_reloc
*));
3231 /* The r_reloc structure is included by value in literal_value, but not
3232 every literal_value has an associated relocation -- some are simple
3233 constants. In such cases, we set all the fields in the r_reloc
3234 struct to zero. The r_reloc_is_const function should be used to
3235 detect this case. */
3238 r_reloc_is_const (r_rel
)
3239 const r_reloc
*r_rel
;
3241 return (r_rel
->abfd
== NULL
);
3246 r_reloc_init (r_rel
, abfd
, irel
)
3249 Elf_Internal_Rela
*irel
;
3253 r_rel
->rela
= *irel
;
3255 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
3258 memset (r_rel
, 0, sizeof (r_reloc
));
3263 r_reloc_get_target_offset (r_rel
)
3264 const r_reloc
*r_rel
;
3266 bfd_vma target_offset
;
3267 unsigned long r_symndx
;
3269 BFD_ASSERT (!r_reloc_is_const (r_rel
));
3270 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
3271 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
3272 return (target_offset
+ r_rel
->rela
.r_addend
);
3276 static struct elf_link_hash_entry
*
3277 r_reloc_get_hash_entry (r_rel
)
3278 const r_reloc
*r_rel
;
3280 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
3281 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
3286 r_reloc_get_section (r_rel
)
3287 const r_reloc
*r_rel
;
3289 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
3290 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
3295 r_reloc_is_defined (r_rel
)
3296 const r_reloc
*r_rel
;
3298 asection
*sec
= r_reloc_get_section (r_rel
);
3299 if (sec
== bfd_abs_section_ptr
3300 || sec
== bfd_com_section_ptr
3301 || sec
== bfd_und_section_ptr
)
3307 /* source_reloc: relocations that reference literal sections. */
3309 /* To determine whether literals can be coalesced, we need to first
3310 record all the relocations that reference the literals. The
3311 source_reloc structure below is used for this purpose. The
3312 source_reloc entries are kept in a per-literal-section array, sorted
3313 by offset within the literal section (i.e., target offset).
3315 The source_sec and r_rel.rela.r_offset fields identify the source of
3316 the relocation. The r_rel field records the relocation value, i.e.,
3317 the offset of the literal being referenced. The opnd field is needed
3318 to determine the range of the immediate field to which the relocation
3319 applies, so we can determine whether another literal with the same
3320 value is within range. The is_null field is true when the relocation
3321 is being removed (e.g., when an L32R is being removed due to a CALLX
3322 that is converted to a direct CALL). */
3324 typedef struct source_reloc_struct source_reloc
;
3326 struct source_reloc_struct
3328 asection
*source_sec
;
3330 xtensa_operand opnd
;
3331 bfd_boolean is_null
;
3335 static void init_source_reloc
3336 PARAMS ((source_reloc
*, asection
*, const r_reloc
*, xtensa_operand
));
3337 static source_reloc
*find_source_reloc
3338 PARAMS ((source_reloc
*, int, asection
*, Elf_Internal_Rela
*));
3339 static int source_reloc_compare
3340 PARAMS ((const PTR
, const PTR
));
3344 init_source_reloc (reloc
, source_sec
, r_rel
, opnd
)
3345 source_reloc
*reloc
;
3346 asection
*source_sec
;
3347 const r_reloc
*r_rel
;
3348 xtensa_operand opnd
;
3350 reloc
->source_sec
= source_sec
;
3351 reloc
->r_rel
= *r_rel
;
3353 reloc
->is_null
= FALSE
;
3357 /* Find the source_reloc for a particular source offset and relocation
3358 type. Note that the array is sorted by _target_ offset, so this is
3359 just a linear search. */
3361 static source_reloc
*
3362 find_source_reloc (src_relocs
, src_count
, sec
, irel
)
3363 source_reloc
*src_relocs
;
3366 Elf_Internal_Rela
*irel
;
3370 for (i
= 0; i
< src_count
; i
++)
3372 if (src_relocs
[i
].source_sec
== sec
3373 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
3374 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
3375 == ELF32_R_TYPE (irel
->r_info
)))
3376 return &src_relocs
[i
];
3384 source_reloc_compare (ap
, bp
)
3388 const source_reloc
*a
= (const source_reloc
*) ap
;
3389 const source_reloc
*b
= (const source_reloc
*) bp
;
3391 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
3395 /* Literal values and value hash tables. */
3397 /* Literals with the same value can be coalesced. The literal_value
3398 structure records the value of a literal: the "r_rel" field holds the
3399 information from the relocation on the literal (if there is one) and
3400 the "value" field holds the contents of the literal word itself.
3402 The value_map structure records a literal value along with the
3403 location of a literal holding that value. The value_map hash table
3404 is indexed by the literal value, so that we can quickly check if a
3405 particular literal value has been seen before and is thus a candidate
3408 typedef struct literal_value_struct literal_value
;
3409 typedef struct value_map_struct value_map
;
3410 typedef struct value_map_hash_table_struct value_map_hash_table
;
3412 struct literal_value_struct
3415 unsigned long value
;
3418 struct value_map_struct
3420 literal_value val
; /* The literal value. */
3421 r_reloc loc
; /* Location of the literal. */
3425 struct value_map_hash_table_struct
3427 unsigned bucket_count
;
3428 value_map
**buckets
;
3433 static bfd_boolean is_same_value
3434 PARAMS ((const literal_value
*, const literal_value
*));
3435 static value_map_hash_table
*value_map_hash_table_init
3437 static unsigned hash_literal_value
3438 PARAMS ((const literal_value
*));
3439 static unsigned hash_bfd_vma
3441 static value_map
*get_cached_value
3442 PARAMS ((value_map_hash_table
*, const literal_value
*));
3443 static value_map
*add_value_map
3444 PARAMS ((value_map_hash_table
*, const literal_value
*, const r_reloc
*));
3448 is_same_value (src1
, src2
)
3449 const literal_value
*src1
;
3450 const literal_value
*src2
;
3452 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
3455 if (r_reloc_is_const (&src1
->r_rel
))
3456 return (src1
->value
== src2
->value
);
3458 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
3459 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
3462 if (r_reloc_get_target_offset (&src1
->r_rel
)
3463 != r_reloc_get_target_offset (&src2
->r_rel
))
3466 if (src1
->value
!= src2
->value
)
3469 /* Now check for the same section and the same elf_hash. */
3470 if (r_reloc_is_defined (&src1
->r_rel
))
3472 if (r_reloc_get_section (&src1
->r_rel
)
3473 != r_reloc_get_section (&src2
->r_rel
))
3478 if (r_reloc_get_hash_entry (&src1
->r_rel
)
3479 != r_reloc_get_hash_entry (&src2
->r_rel
))
3482 if (r_reloc_get_hash_entry (&src1
->r_rel
) == 0)
3490 /* Must be power of 2. */
3491 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
3493 static value_map_hash_table
*
3494 value_map_hash_table_init ()
3496 value_map_hash_table
*values
;
3498 values
= (value_map_hash_table
*)
3499 bfd_malloc (sizeof (value_map_hash_table
));
3501 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
3503 values
->buckets
= (value_map
**)
3504 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
3514 return (val
>> 2) + (val
>> 10);
3519 hash_literal_value (src
)
3520 const literal_value
*src
;
3524 if (r_reloc_is_const (&src
->r_rel
))
3525 return hash_bfd_vma (src
->value
);
3527 hash_val
= (hash_bfd_vma (r_reloc_get_target_offset (&src
->r_rel
))
3528 + hash_bfd_vma (src
->value
));
3530 /* Now check for the same section and the same elf_hash. */
3531 if (r_reloc_is_defined (&src
->r_rel
))
3532 hash_val
+= hash_bfd_vma ((bfd_vma
) (unsigned) r_reloc_get_section (&src
->r_rel
));
3534 hash_val
+= hash_bfd_vma ((bfd_vma
) (unsigned) r_reloc_get_hash_entry (&src
->r_rel
));
3540 /* Check if the specified literal_value has been seen before. */
3543 get_cached_value (map
, val
)
3544 value_map_hash_table
*map
;
3545 const literal_value
*val
;
3551 idx
= hash_literal_value (val
);
3552 idx
= idx
& (map
->bucket_count
- 1);
3553 bucket
= map
->buckets
[idx
];
3554 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
3556 if (is_same_value (&map_e
->val
, val
))
3563 /* Record a new literal value. It is illegal to call this if VALUE
3564 already has an entry here. */
3567 add_value_map (map
, val
, loc
)
3568 value_map_hash_table
*map
;
3569 const literal_value
*val
;
3572 value_map
**bucket_p
;
3575 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
3577 BFD_ASSERT (get_cached_value (map
, val
) == NULL
);
3581 idx
= hash_literal_value (val
);
3582 idx
= idx
& (map
->bucket_count
- 1);
3583 bucket_p
= &map
->buckets
[idx
];
3585 val_e
->next
= *bucket_p
;
3588 /* FIXME: consider resizing the hash table if we get too many entries */
3594 /* Lists of literals being coalesced or removed. */
3596 /* In the usual case, the literal identified by "from" is being
3597 coalesced with another literal identified by "to". If the literal is
3598 unused and is being removed altogether, "to.abfd" will be NULL.
3599 The removed_literal entries are kept on a per-section list, sorted
3600 by the "from" offset field. */
3602 typedef struct removed_literal_struct removed_literal
;
3603 typedef struct removed_literal_list_struct removed_literal_list
;
3605 struct removed_literal_struct
3609 removed_literal
*next
;
3612 struct removed_literal_list_struct
3614 removed_literal
*head
;
3615 removed_literal
*tail
;
3619 static void add_removed_literal
3620 PARAMS ((removed_literal_list
*, const r_reloc
*, const r_reloc
*));
3621 static removed_literal
*find_removed_literal
3622 PARAMS ((removed_literal_list
*, bfd_vma
));
3623 static bfd_vma offset_with_removed_literals
3624 PARAMS ((removed_literal_list
*, bfd_vma
));
3627 /* Record that the literal at "from" is being removed. If "to" is not
3628 NULL, the "from" literal is being coalesced with the "to" literal. */
3631 add_removed_literal (removed_list
, from
, to
)
3632 removed_literal_list
*removed_list
;
3633 const r_reloc
*from
;
3636 removed_literal
*r
, *new_r
, *next_r
;
3638 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
3640 new_r
->from
= *from
;
3644 new_r
->to
.abfd
= NULL
;
3647 r
= removed_list
->head
;
3650 removed_list
->head
= new_r
;
3651 removed_list
->tail
= new_r
;
3653 /* Special check for common case of append. */
3654 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
3656 removed_list
->tail
->next
= new_r
;
3657 removed_list
->tail
= new_r
;
3661 while (r
->from
.target_offset
< from
->target_offset
3668 new_r
->next
= next_r
;
3670 removed_list
->tail
= new_r
;
3675 /* Check if the list of removed literals contains an entry for the
3676 given address. Return the entry if found. */
3678 static removed_literal
*
3679 find_removed_literal (removed_list
, addr
)
3680 removed_literal_list
*removed_list
;
3683 removed_literal
*r
= removed_list
->head
;
3684 while (r
&& r
->from
.target_offset
< addr
)
3686 if (r
&& r
->from
.target_offset
== addr
)
3692 /* Adjust an offset in a section to compensate for literals that are
3693 being removed. Search the list of removed literals and subtract
3694 4 bytes for every removed literal prior to the given address. */
3697 offset_with_removed_literals (removed_list
, addr
)
3698 removed_literal_list
*removed_list
;
3701 removed_literal
*r
= removed_list
->head
;
3702 unsigned num_bytes
= 0;
3707 while (r
&& r
->from
.target_offset
<= addr
)
3712 if (num_bytes
> addr
)
3714 return (addr
- num_bytes
);
3718 /* Coalescing literals may require a relocation to refer to a section in
3719 a different input file, but the standard relocation information
3720 cannot express that. Instead, the reloc_bfd_fix structures are used
3721 to "fix" the relocations that refer to sections in other input files.
3722 These structures are kept on per-section lists. The "src_type" field
3723 records the relocation type in case there are multiple relocations on
3724 the same location. FIXME: This is ugly; an alternative might be to
3725 add new symbols with the "owner" field to some other input file. */
3727 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
3729 struct reloc_bfd_fix_struct
3733 unsigned src_type
; /* Relocation type. */
3736 asection
*target_sec
;
3737 bfd_vma target_offset
;
3739 reloc_bfd_fix
*next
;
3743 static reloc_bfd_fix
*reloc_bfd_fix_init
3744 PARAMS ((asection
*, bfd_vma
, unsigned, bfd
*, asection
*, bfd_vma
));
3745 static reloc_bfd_fix
*get_bfd_fix
3746 PARAMS ((reloc_bfd_fix
*, asection
*, bfd_vma
, unsigned));
3749 static reloc_bfd_fix
*
3750 reloc_bfd_fix_init (src_sec
, src_offset
, src_type
,
3751 target_abfd
, target_sec
, target_offset
)
3756 asection
*target_sec
;
3757 bfd_vma target_offset
;
3761 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
3762 fix
->src_sec
= src_sec
;
3763 fix
->src_offset
= src_offset
;
3764 fix
->src_type
= src_type
;
3765 fix
->target_abfd
= target_abfd
;
3766 fix
->target_sec
= target_sec
;
3767 fix
->target_offset
= target_offset
;
3773 static reloc_bfd_fix
*
3774 get_bfd_fix (fix_list
, sec
, offset
, type
)
3775 reloc_bfd_fix
*fix_list
;
3782 for (r
= fix_list
; r
!= NULL
; r
= r
->next
)
3784 if (r
->src_sec
== sec
3785 && r
->src_offset
== offset
3786 && r
->src_type
== type
)
3793 /* Per-section data for relaxation. */
3795 struct xtensa_relax_info_struct
3797 bfd_boolean is_relaxable_literal_section
;
3798 int visited
; /* Number of times visited. */
3800 source_reloc
*src_relocs
; /* Array[src_count]. */
3802 int src_next
; /* Next src_relocs entry to assign. */
3804 removed_literal_list removed_list
;
3806 reloc_bfd_fix
*fix_list
;
3809 struct elf_xtensa_section_data
3811 struct bfd_elf_section_data elf
;
3812 xtensa_relax_info relax_info
;
3815 static void init_xtensa_relax_info
3816 PARAMS ((asection
*));
3817 static xtensa_relax_info
*get_xtensa_relax_info
3818 PARAMS ((asection
*));
3820 PARAMS ((asection
*, reloc_bfd_fix
*));
3824 elf_xtensa_new_section_hook (abfd
, sec
)
3828 struct elf_xtensa_section_data
*sdata
;
3829 bfd_size_type amt
= sizeof (*sdata
);
3831 sdata
= (struct elf_xtensa_section_data
*) bfd_zalloc (abfd
, amt
);
3834 sec
->used_by_bfd
= (PTR
) sdata
;
3836 return _bfd_elf_new_section_hook (abfd
, sec
);
3841 init_xtensa_relax_info (sec
)
3844 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
3846 relax_info
->is_relaxable_literal_section
= FALSE
;
3847 relax_info
->visited
= 0;
3849 relax_info
->src_relocs
= NULL
;
3850 relax_info
->src_count
= 0;
3851 relax_info
->src_next
= 0;
3853 relax_info
->removed_list
.head
= NULL
;
3854 relax_info
->removed_list
.tail
= NULL
;
3856 relax_info
->fix_list
= NULL
;
3860 static xtensa_relax_info
*
3861 get_xtensa_relax_info (sec
)
3864 struct elf_xtensa_section_data
*section_data
;
3866 /* No info available if no section or if it is an output section. */
3867 if (!sec
|| sec
== sec
->output_section
)
3870 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
3871 return §ion_data
->relax_info
;
3876 add_fix (src_sec
, fix
)
3880 xtensa_relax_info
*relax_info
;
3882 relax_info
= get_xtensa_relax_info (src_sec
);
3883 fix
->next
= relax_info
->fix_list
;
3884 relax_info
->fix_list
= fix
;
3888 /* Access to internal relocations, section contents and symbols. */
3890 /* During relaxation, we need to modify relocations, section contents,
3891 and symbol definitions, and we need to keep the original values from
3892 being reloaded from the input files, i.e., we need to "pin" the
3893 modified values in memory. We also want to continue to observe the
3894 setting of the "keep-memory" flag. The following functions wrap the
3895 standard BFD functions to take care of this for us. */
3897 static Elf_Internal_Rela
*
3898 retrieve_internal_relocs (abfd
, sec
, keep_memory
)
3901 bfd_boolean keep_memory
;
3903 Elf_Internal_Rela
*internal_relocs
;
3905 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
3908 internal_relocs
= elf_section_data (sec
)->relocs
;
3909 if (internal_relocs
== NULL
)
3910 internal_relocs
= (_bfd_elf_link_read_relocs
3911 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
3913 return internal_relocs
;
3918 pin_internal_relocs (sec
, internal_relocs
)
3920 Elf_Internal_Rela
*internal_relocs
;
3922 elf_section_data (sec
)->relocs
= internal_relocs
;
3927 release_internal_relocs (sec
, internal_relocs
)
3929 Elf_Internal_Rela
*internal_relocs
;
3932 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3933 free (internal_relocs
);
3938 retrieve_contents (abfd
, sec
, keep_memory
)
3941 bfd_boolean keep_memory
;
3945 contents
= elf_section_data (sec
)->this_hdr
.contents
;
3947 if (contents
== NULL
&& sec
->_raw_size
!= 0)
3949 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
3950 if (contents
!= NULL
)
3952 if (! bfd_get_section_contents (abfd
, sec
, contents
,
3953 (file_ptr
) 0, sec
->_raw_size
))
3959 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3967 pin_contents (sec
, contents
)
3971 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3976 release_contents (sec
, contents
)
3981 elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3986 static Elf_Internal_Sym
*
3987 retrieve_local_syms (input_bfd
)
3990 Elf_Internal_Shdr
*symtab_hdr
;
3991 Elf_Internal_Sym
*isymbuf
;
3994 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3995 locsymcount
= symtab_hdr
->sh_info
;
3997 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
3998 if (isymbuf
== NULL
&& locsymcount
!= 0)
3999 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
4002 /* Save the symbols for this input file so they won't be read again. */
4003 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
4004 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
4010 /* Code for link-time relaxation. */
4012 /* Local helper functions. */
4013 static bfd_boolean analyze_relocations
4014 PARAMS ((struct bfd_link_info
*));
4015 static bfd_boolean find_relaxable_sections
4016 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*));
4017 static bfd_boolean collect_source_relocs
4018 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*));
4019 static bfd_boolean is_resolvable_asm_expansion
4020 PARAMS ((bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
4021 struct bfd_link_info
*, bfd_boolean
*));
4022 static bfd_boolean remove_literals
4023 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*));
4024 static bfd_boolean relax_section
4025 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*));
4026 static bfd_boolean relax_property_section
4027 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*));
4028 static bfd_boolean relax_section_symbols
4029 PARAMS ((bfd
*, asection
*));
4030 static bfd_boolean relocations_reach
4031 PARAMS ((source_reloc
*, int, const r_reloc
*));
4032 static void translate_reloc
4033 PARAMS ((const r_reloc
*, r_reloc
*));
4034 static Elf_Internal_Rela
*get_irel_at_offset
4035 PARAMS ((asection
*, Elf_Internal_Rela
*, bfd_vma
));
4036 static Elf_Internal_Rela
*find_associated_l32r_irel
4037 PARAMS ((asection
*, bfd_byte
*, Elf_Internal_Rela
*,
4038 Elf_Internal_Rela
*));
4039 static void shrink_dynamic_reloc_sections
4040 PARAMS ((struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*));
4044 elf_xtensa_relax_section (abfd
, sec
, link_info
, again
)
4047 struct bfd_link_info
*link_info
;
4050 static value_map_hash_table
*values
= NULL
;
4051 xtensa_relax_info
*relax_info
;
4055 /* Do some overall initialization for relaxation. */
4056 values
= value_map_hash_table_init ();
4057 relaxing_section
= TRUE
;
4058 if (!analyze_relocations (link_info
))
4063 /* Don't mess with linker-created sections. */
4064 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
4067 relax_info
= get_xtensa_relax_info (sec
);
4068 BFD_ASSERT (relax_info
!= NULL
);
4070 switch (relax_info
->visited
)
4073 /* Note: It would be nice to fold this pass into
4074 analyze_relocations, but it is important for this step that the
4075 sections be examined in link order. */
4076 if (!remove_literals (abfd
, sec
, link_info
, values
))
4082 if (!relax_section (abfd
, sec
, link_info
))
4088 if (!relax_section_symbols (abfd
, sec
))
4093 relax_info
->visited
++;
4097 /* Initialization for relaxation. */
4099 /* This function is called once at the start of relaxation. It scans
4100 all the input sections and marks the ones that are relaxable (i.e.,
4101 literal sections with L32R relocations against them). It then
4102 collect source_reloc information for all the relocations against
4103 those relaxable sections. */
4106 analyze_relocations (link_info
)
4107 struct bfd_link_info
*link_info
;
4111 bfd_boolean is_relaxable
= FALSE
;
4113 /* Initialize the per-section relaxation info. */
4114 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
4115 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4117 init_xtensa_relax_info (sec
);
4120 /* Mark relaxable sections (and count relocations against each one). */
4121 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
4122 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4124 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
4128 /* Bail out if there are no relaxable sections. */
4132 /* Allocate space for source_relocs. */
4133 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
4134 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4136 xtensa_relax_info
*relax_info
;
4138 relax_info
= get_xtensa_relax_info (sec
);
4139 if (relax_info
->is_relaxable_literal_section
)
4141 relax_info
->src_relocs
= (source_reloc
*)
4142 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
4146 /* Collect info on relocations against each relaxable section. */
4147 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
4148 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4150 if (!collect_source_relocs (abfd
, sec
, link_info
))
4158 /* Find all the literal sections that might be relaxed. The motivation
4159 for this pass is that collect_source_relocs() needs to record _all_
4160 the relocations that target each relaxable section. That is
4161 expensive and unnecessary unless the target section is actually going
4162 to be relaxed. This pass identifies all such sections by checking if
4163 they have L32Rs pointing to them. In the process, the total number
4164 of relocations targeting each section is also counted so that we
4165 know how much space to allocate for source_relocs against each
4166 relaxable literal section. */
4169 find_relaxable_sections (abfd
, sec
, link_info
, is_relaxable_p
)
4172 struct bfd_link_info
*link_info
;
4173 bfd_boolean
*is_relaxable_p
;
4175 Elf_Internal_Rela
*internal_relocs
;
4177 bfd_boolean ok
= TRUE
;
4180 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
4181 link_info
->keep_memory
);
4182 if (internal_relocs
== NULL
)
4185 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
4186 if (contents
== NULL
&& sec
->_raw_size
!= 0)
4192 for (i
= 0; i
< sec
->reloc_count
; i
++)
4194 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
4196 asection
*target_sec
;
4197 xtensa_relax_info
*target_relax_info
;
4199 r_reloc_init (&r_rel
, abfd
, irel
);
4201 target_sec
= r_reloc_get_section (&r_rel
);
4202 target_relax_info
= get_xtensa_relax_info (target_sec
);
4203 if (!target_relax_info
)
4206 /* Count relocations against the target section. */
4207 target_relax_info
->src_count
++;
4209 if (is_literal_section (target_sec
)
4210 && is_l32r_relocation (sec
, contents
, irel
)
4211 && r_reloc_is_defined (&r_rel
))
4213 /* Mark the target section as relaxable. */
4214 target_relax_info
->is_relaxable_literal_section
= TRUE
;
4215 *is_relaxable_p
= TRUE
;
4220 release_contents (sec
, contents
);
4221 release_internal_relocs (sec
, internal_relocs
);
4226 /* Record _all_ the relocations that point to relaxable literal
4227 sections, and get rid of ASM_EXPAND relocs by either converting them
4228 to ASM_SIMPLIFY or by removing them. */
4231 collect_source_relocs (abfd
, sec
, link_info
)
4234 struct bfd_link_info
*link_info
;
4236 Elf_Internal_Rela
*internal_relocs
;
4238 bfd_boolean ok
= TRUE
;
4241 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
4242 link_info
->keep_memory
);
4243 if (internal_relocs
== NULL
)
4246 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
4247 if (contents
== NULL
&& sec
->_raw_size
!= 0)
4253 /* Record relocations against relaxable literal sections. */
4254 for (i
= 0; i
< sec
->reloc_count
; i
++)
4256 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
4258 asection
*target_sec
;
4259 xtensa_relax_info
*target_relax_info
;
4261 r_reloc_init (&r_rel
, abfd
, irel
);
4263 target_sec
= r_reloc_get_section (&r_rel
);
4264 target_relax_info
= get_xtensa_relax_info (target_sec
);
4266 if (target_relax_info
4267 && target_relax_info
->is_relaxable_literal_section
)
4269 xtensa_opcode opcode
;
4270 xtensa_operand opnd
;
4271 source_reloc
*s_reloc
;
4274 src_next
= target_relax_info
->src_next
++;
4275 s_reloc
= &target_relax_info
->src_relocs
[src_next
];
4277 opcode
= get_relocation_opcode (sec
, contents
, irel
);
4278 if (opcode
== XTENSA_UNDEFINED
)
4281 opnd
= xtensa_get_operand (xtensa_default_isa
, opcode
,
4282 get_relocation_opnd (irel
));
4284 init_source_reloc (s_reloc
, sec
, &r_rel
, opnd
);
4288 /* Now get rid of ASM_EXPAND relocations. At this point, the
4289 src_relocs array for the target literal section may still be
4290 incomplete, but it must at least contain the entries for the L32R
4291 relocations associated with ASM_EXPANDs because they were just
4292 added in the preceding loop over the relocations. */
4294 for (i
= 0; i
< sec
->reloc_count
; i
++)
4296 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
4297 bfd_boolean is_reachable
;
4299 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
4305 Elf_Internal_Rela
*l32r_irel
;
4307 asection
*target_sec
;
4308 xtensa_relax_info
*target_relax_info
;
4310 /* Mark the source_reloc for the L32R so that it will be
4311 removed in remove_literals(), along with the associated
4313 l32r_irel
= find_associated_l32r_irel (sec
, contents
,
4314 irel
, internal_relocs
);
4315 if (l32r_irel
== NULL
)
4318 r_reloc_init (&r_rel
, abfd
, l32r_irel
);
4320 target_sec
= r_reloc_get_section (&r_rel
);
4321 target_relax_info
= get_xtensa_relax_info (target_sec
);
4323 if (target_relax_info
4324 && target_relax_info
->is_relaxable_literal_section
)
4326 source_reloc
*s_reloc
;
4328 /* Search the source_relocs for the entry corresponding to
4329 the l32r_irel. Note: The src_relocs array is not yet
4330 sorted, but it wouldn't matter anyway because we're
4331 searching by source offset instead of target offset. */
4332 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
4333 target_relax_info
->src_next
,
4335 BFD_ASSERT (s_reloc
);
4336 s_reloc
->is_null
= TRUE
;
4339 /* Convert this reloc to ASM_SIMPLIFY. */
4340 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
4341 R_XTENSA_ASM_SIMPLIFY
);
4342 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
4344 pin_internal_relocs (sec
, internal_relocs
);
4348 /* It is resolvable but doesn't reach. We resolve now
4349 by eliminating the relocation -- the call will remain
4350 expanded into L32R/CALLX. */
4351 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
4352 pin_internal_relocs (sec
, internal_relocs
);
4357 release_contents (sec
, contents
);
4358 release_internal_relocs (sec
, internal_relocs
);
4363 /* Return TRUE if the asm expansion can be resolved. Generally it can
4364 be resolved on a final link or when a partial link locates it in the
4365 same section as the target. Set "is_reachable" flag if the target of
4366 the call is within the range of a direct call, given the current VMA
4367 for this section and the target section. */
4370 is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
4375 Elf_Internal_Rela
*irel
;
4376 struct bfd_link_info
*link_info
;
4377 bfd_boolean
*is_reachable_p
;
4379 asection
*target_sec
;
4380 bfd_vma target_offset
;
4382 xtensa_opcode opcode
, direct_call_opcode
;
4383 bfd_vma self_address
;
4384 bfd_vma dest_address
;
4386 *is_reachable_p
= FALSE
;
4388 if (contents
== NULL
)
4391 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
4394 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
4395 sec
->_raw_size
- irel
->r_offset
);
4397 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4398 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4401 /* Check and see that the target resolves. */
4402 r_reloc_init (&r_rel
, abfd
, irel
);
4403 if (!r_reloc_is_defined (&r_rel
))
4406 target_sec
= r_reloc_get_section (&r_rel
);
4407 target_offset
= r_reloc_get_target_offset (&r_rel
);
4409 /* If the target is in a shared library, then it doesn't reach. This
4410 isn't supposed to come up because the compiler should never generate
4411 non-PIC calls on systems that use shared libraries, but the linker
4412 shouldn't crash regardless. */
4413 if (!target_sec
->output_section
)
4416 /* For relocatable sections, we can only simplify when the output
4417 section of the target is the same as the output section of the
4419 if (link_info
->relocatable
4420 && (target_sec
->output_section
!= sec
->output_section
))
4423 self_address
= (sec
->output_section
->vma
4424 + sec
->output_offset
+ irel
->r_offset
+ 3);
4425 dest_address
= (target_sec
->output_section
->vma
4426 + target_sec
->output_offset
+ target_offset
);
4428 *is_reachable_p
= pcrel_reloc_fits
4429 (xtensa_get_operand (xtensa_default_isa
, direct_call_opcode
, 0),
4430 self_address
, dest_address
);
4432 if ((self_address
>> CALL_SEGMENT_BITS
) !=
4433 (dest_address
>> CALL_SEGMENT_BITS
))
4440 static Elf_Internal_Rela
*
4441 find_associated_l32r_irel (sec
, contents
, other_irel
, internal_relocs
)
4444 Elf_Internal_Rela
*other_irel
;
4445 Elf_Internal_Rela
*internal_relocs
;
4449 for (i
= 0; i
< sec
->reloc_count
; i
++)
4451 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
4453 if (irel
== other_irel
)
4455 if (irel
->r_offset
!= other_irel
->r_offset
)
4457 if (is_l32r_relocation (sec
, contents
, irel
))
4464 /* First relaxation pass. */
4466 /* If the section is relaxable (i.e., a literal section), check each
4467 literal to see if it has the same value as another literal that has
4468 already been seen, either in the current section or a previous one.
4469 If so, add an entry to the per-section list of removed literals. The
4470 actual changes are deferred until the next pass. */
4473 remove_literals (abfd
, sec
, link_info
, values
)
4476 struct bfd_link_info
*link_info
;
4477 value_map_hash_table
*values
;
4479 xtensa_relax_info
*relax_info
;
4481 Elf_Internal_Rela
*internal_relocs
;
4482 source_reloc
*src_relocs
;
4483 bfd_boolean ok
= TRUE
;
4486 /* Do nothing if it is not a relaxable literal section. */
4487 relax_info
= get_xtensa_relax_info (sec
);
4488 BFD_ASSERT (relax_info
);
4490 if (!relax_info
->is_relaxable_literal_section
)
4493 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
4494 link_info
->keep_memory
);
4496 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
4497 if (contents
== NULL
&& sec
->_raw_size
!= 0)
4503 /* Sort the source_relocs by target offset. */
4504 src_relocs
= relax_info
->src_relocs
;
4505 qsort (src_relocs
, relax_info
->src_count
,
4506 sizeof (source_reloc
), source_reloc_compare
);
4508 for (i
= 0; i
< relax_info
->src_count
; i
++)
4511 Elf_Internal_Rela
*irel
= NULL
;
4515 rel
= &src_relocs
[i
];
4516 irel
= get_irel_at_offset (sec
, internal_relocs
,
4517 rel
->r_rel
.target_offset
);
4519 /* If the target_offset for this relocation is the same as the
4520 previous relocation, then we've already considered whether the
4521 literal can be coalesced. Skip to the next one.... */
4522 if (i
!= 0 && (src_relocs
[i
-1].r_rel
.target_offset
4523 == rel
->r_rel
.target_offset
))
4526 /* Check if the relocation was from an L32R that is being removed
4527 because a CALLX was converted to a direct CALL, and check if
4528 there are no other relocations to the literal. */
4530 && (i
== relax_info
->src_count
- 1
4531 || (src_relocs
[i
+1].r_rel
.target_offset
4532 != rel
->r_rel
.target_offset
)))
4534 /* Mark the unused literal so that it will be removed. */
4535 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
4537 /* Zero out the relocation on this literal location. */
4540 if (elf_hash_table (link_info
)->dynamic_sections_created
)
4541 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
4543 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
4549 /* Find the literal value. */
4550 r_reloc_init (&val
.r_rel
, abfd
, irel
);
4551 BFD_ASSERT (rel
->r_rel
.target_offset
< sec
->_raw_size
);
4552 val
.value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
4554 /* Check if we've seen another literal with the same value. */
4555 val_map
= get_cached_value (values
, &val
);
4556 if (val_map
!= NULL
)
4558 /* First check that THIS and all the other relocs to this
4559 literal will FIT if we move them to the new address. */
4561 if (relocations_reach (rel
, relax_info
->src_count
- i
,
4564 /* Mark that the literal will be coalesced. */
4565 add_removed_literal (&relax_info
->removed_list
,
4566 &rel
->r_rel
, &val_map
->loc
);
4570 /* Relocations do not reach -- do not remove this literal. */
4571 val_map
->loc
= rel
->r_rel
;
4576 /* This is the first time we've seen this literal value. */
4577 BFD_ASSERT (sec
== r_reloc_get_section (&rel
->r_rel
));
4578 add_value_map (values
, &val
, &rel
->r_rel
);
4583 release_contents (sec
, contents
);
4584 release_internal_relocs (sec
, internal_relocs
);
4589 /* Check if the original relocations (presumably on L32R instructions)
4590 identified by reloc[0..N] can be changed to reference the literal
4591 identified by r_rel. If r_rel is out of range for any of the
4592 original relocations, then we don't want to coalesce the original
4593 literal with the one at r_rel. We only check reloc[0..N], where the
4594 offsets are all the same as for reloc[0] (i.e., they're all
4595 referencing the same literal) and where N is also bounded by the
4596 number of remaining entries in the "reloc" array. The "reloc" array
4597 is sorted by target offset so we know all the entries for the same
4598 literal will be contiguous. */
4601 relocations_reach (reloc
, remaining_relocs
, r_rel
)
4602 source_reloc
*reloc
;
4603 int remaining_relocs
;
4604 const r_reloc
*r_rel
;
4606 bfd_vma from_offset
, source_address
, dest_address
;
4610 if (!r_reloc_is_defined (r_rel
))
4613 sec
= r_reloc_get_section (r_rel
);
4614 from_offset
= reloc
[0].r_rel
.target_offset
;
4616 for (i
= 0; i
< remaining_relocs
; i
++)
4618 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
4621 /* Ignore relocations that have been removed. */
4622 if (reloc
[i
].is_null
)
4625 /* The original and new output section for these must be the same
4626 in order to coalesce. */
4627 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
4628 != sec
->output_section
)
4631 /* A NULL operand means it is not a PC-relative relocation, so
4632 the literal can be moved anywhere. */
4635 /* Otherwise, check to see that it fits. */
4636 source_address
= (reloc
[i
].source_sec
->output_section
->vma
4637 + reloc
[i
].source_sec
->output_offset
4638 + reloc
[i
].r_rel
.rela
.r_offset
);
4639 dest_address
= (sec
->output_section
->vma
4640 + sec
->output_offset
4641 + r_rel
->target_offset
);
4643 if (!pcrel_reloc_fits (reloc
[i
].opnd
, source_address
, dest_address
))
4652 /* WARNING: linear search here. If the relocation are in order by
4653 address, we can use a faster binary search. ALSO, we assume that
4654 there is only 1 non-NONE relocation per address. */
4656 static Elf_Internal_Rela
*
4657 get_irel_at_offset (sec
, internal_relocs
, offset
)
4659 Elf_Internal_Rela
*internal_relocs
;
4663 if (!internal_relocs
)
4665 for (i
= 0; i
< sec
->reloc_count
; i
++)
4667 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
4668 if (irel
->r_offset
== offset
4669 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
4676 /* Second relaxation pass. */
4678 /* Modify all of the relocations to point to the right spot, and if this
4679 is a relaxable section, delete the unwanted literals and fix the
4683 relax_section (abfd
, sec
, link_info
)
4686 struct bfd_link_info
*link_info
;
4688 Elf_Internal_Rela
*internal_relocs
;
4689 xtensa_relax_info
*relax_info
;
4691 bfd_boolean ok
= TRUE
;
4694 relax_info
= get_xtensa_relax_info (sec
);
4695 BFD_ASSERT (relax_info
);
4697 /* Handle property sections (e.g., literal tables) specially. */
4698 if (xtensa_is_property_section (sec
))
4700 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
4701 return relax_property_section (abfd
, sec
, link_info
);
4704 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
4705 link_info
->keep_memory
);
4706 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
4707 if (contents
== NULL
&& sec
->_raw_size
!= 0)
4713 if (internal_relocs
)
4715 for (i
= 0; i
< sec
->reloc_count
; i
++)
4717 Elf_Internal_Rela
*irel
;
4718 xtensa_relax_info
*target_relax_info
;
4719 bfd_vma source_offset
;
4722 asection
*target_sec
;
4724 /* Locally change the source address.
4725 Translate the target to the new target address.
4726 If it points to this section and has been removed,
4730 irel
= &internal_relocs
[i
];
4731 source_offset
= irel
->r_offset
;
4733 r_type
= ELF32_R_TYPE (irel
->r_info
);
4734 r_reloc_init (&r_rel
, abfd
, irel
);
4736 if (relax_info
->is_relaxable_literal_section
)
4738 if (r_type
!= R_XTENSA_NONE
4739 && find_removed_literal (&relax_info
->removed_list
,
4742 /* Remove this relocation. */
4743 if (elf_hash_table (link_info
)->dynamic_sections_created
)
4744 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
4745 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
4746 irel
->r_offset
= offset_with_removed_literals
4747 (&relax_info
->removed_list
, irel
->r_offset
);
4751 offset_with_removed_literals (&relax_info
->removed_list
,
4753 irel
->r_offset
= source_offset
;
4756 target_sec
= r_reloc_get_section (&r_rel
);
4757 target_relax_info
= get_xtensa_relax_info (target_sec
);
4759 if (target_relax_info
4760 && target_relax_info
->is_relaxable_literal_section
)
4765 translate_reloc (&r_rel
, &new_rel
);
4767 /* FIXME: If the relocation still references a section in
4768 the same input file, the relocation should be modified
4769 directly instead of adding a "fix" record. */
4771 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
, 0,
4772 r_reloc_get_section (&new_rel
),
4773 new_rel
.target_offset
);
4777 pin_internal_relocs (sec
, internal_relocs
);
4781 if (relax_info
->is_relaxable_literal_section
)
4783 /* Walk through the contents and delete literals that are not needed
4786 unsigned long size
= sec
->_cooked_size
;
4787 unsigned long removed
= 0;
4789 removed_literal
*reloc
= relax_info
->removed_list
.head
;
4790 for (; reloc
; reloc
= reloc
->next
)
4792 unsigned long upper
= sec
->_raw_size
;
4793 bfd_vma start
= reloc
->from
.target_offset
+ 4;
4795 upper
= reloc
->next
->from
.target_offset
;
4796 if (upper
- start
!= 0)
4798 BFD_ASSERT (start
<= upper
);
4799 memmove (contents
+ start
- removed
- 4,
4802 pin_contents (sec
, contents
);
4808 /* Change the section size. */
4809 sec
->_cooked_size
= size
;
4810 /* Also shrink _raw_size. (The code in relocate_section that
4811 checks that relocations are within the section must use
4812 _raw_size because of the way the stabs sections are relaxed;
4813 shrinking _raw_size means that these checks will not be
4814 unnecessarily lax.) */
4815 sec
->_raw_size
= size
;
4819 release_internal_relocs (sec
, internal_relocs
);
4820 release_contents (sec
, contents
);
4825 /* Fix up a relocation to take account of removed literals. */
4828 translate_reloc (orig_rel
, new_rel
)
4829 const r_reloc
*orig_rel
;
4833 xtensa_relax_info
*relax_info
;
4834 removed_literal
*removed
;
4835 unsigned long new_offset
;
4837 *new_rel
= *orig_rel
;
4839 if (!r_reloc_is_defined (orig_rel
))
4841 sec
= r_reloc_get_section (orig_rel
);
4843 relax_info
= get_xtensa_relax_info (sec
);
4844 BFD_ASSERT (relax_info
);
4846 if (!relax_info
->is_relaxable_literal_section
)
4849 /* Check if the original relocation is against a literal being removed. */
4850 removed
= find_removed_literal (&relax_info
->removed_list
,
4851 orig_rel
->target_offset
);
4856 /* The fact that there is still a relocation to this literal indicates
4857 that the literal is being coalesced, not simply removed. */
4858 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
4860 /* This was moved to some other address (possibly in another section). */
4861 *new_rel
= removed
->to
;
4862 new_sec
= r_reloc_get_section (new_rel
);
4866 relax_info
= get_xtensa_relax_info (sec
);
4867 if (!relax_info
|| !relax_info
->is_relaxable_literal_section
)
4872 /* ...and the target address may have been moved within its section. */
4873 new_offset
= offset_with_removed_literals (&relax_info
->removed_list
,
4874 new_rel
->target_offset
);
4876 /* Modify the offset and addend. */
4877 new_rel
->target_offset
= new_offset
;
4878 new_rel
->rela
.r_addend
+= (new_offset
- new_rel
->target_offset
);
4882 /* For dynamic links, there may be a dynamic relocation for each
4883 literal. The number of dynamic relocations must be computed in
4884 size_dynamic_sections, which occurs before relaxation. When a
4885 literal is removed, this function checks if there is a corresponding
4886 dynamic relocation and shrinks the size of the appropriate dynamic
4887 relocation section accordingly. At this point, the contents of the
4888 dynamic relocation sections have not yet been filled in, so there's
4889 nothing else that needs to be done. */
4892 shrink_dynamic_reloc_sections (info
, abfd
, input_section
, rel
)
4893 struct bfd_link_info
*info
;
4895 asection
*input_section
;
4896 Elf_Internal_Rela
*rel
;
4898 Elf_Internal_Shdr
*symtab_hdr
;
4899 struct elf_link_hash_entry
**sym_hashes
;
4900 unsigned long r_symndx
;
4902 struct elf_link_hash_entry
*h
;
4903 bfd_boolean dynamic_symbol
;
4905 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4906 sym_hashes
= elf_sym_hashes (abfd
);
4908 r_type
= ELF32_R_TYPE (rel
->r_info
);
4909 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4911 if (r_symndx
< symtab_hdr
->sh_info
)
4914 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4916 dynamic_symbol
= xtensa_elf_dynamic_symbol_p (h
, info
);
4918 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
4919 && (input_section
->flags
& SEC_ALLOC
) != 0
4920 && (dynamic_symbol
|| info
->shared
))
4923 const char *srel_name
;
4925 bfd_boolean is_plt
= FALSE
;
4927 dynobj
= elf_hash_table (info
)->dynobj
;
4928 BFD_ASSERT (dynobj
!= NULL
);
4930 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
4932 srel_name
= ".rela.plt";
4936 srel_name
= ".rela.got";
4938 /* Reduce size of the .rela.* section by one reloc. */
4939 srel
= bfd_get_section_by_name (dynobj
, srel_name
);
4940 BFD_ASSERT (srel
!= NULL
);
4941 BFD_ASSERT (srel
->_cooked_size
>= sizeof (Elf32_External_Rela
));
4942 srel
->_cooked_size
-= sizeof (Elf32_External_Rela
);
4944 /* Also shrink _raw_size. (This seems wrong but other bfd code seems
4945 to assume that linker-created sections will never be relaxed and
4946 hence _raw_size must always equal _cooked_size.) */
4947 srel
->_raw_size
= srel
->_cooked_size
;
4951 asection
*splt
, *sgotplt
, *srelgot
;
4952 int reloc_index
, chunk
;
4954 /* Find the PLT reloc index of the entry being removed. This
4955 is computed from the size of ".rela.plt". It is needed to
4956 figure out which PLT chunk to resize. Usually "last index
4957 = size - 1" since the index starts at zero, but in this
4958 context, the size has just been decremented so there's no
4959 need to subtract one. */
4960 reloc_index
= srel
->_cooked_size
/ sizeof (Elf32_External_Rela
);
4962 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
4963 splt
= elf_xtensa_get_plt_section (dynobj
, chunk
);
4964 sgotplt
= elf_xtensa_get_gotplt_section (dynobj
, chunk
);
4965 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
4967 /* Check if an entire PLT chunk has just been eliminated. */
4968 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
4970 /* The two magic GOT entries for that chunk can go away. */
4971 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
4972 BFD_ASSERT (srelgot
!= NULL
);
4973 srelgot
->reloc_count
-= 2;
4974 srelgot
->_cooked_size
-= 2 * sizeof (Elf32_External_Rela
);
4975 /* Shrink _raw_size (see comment above). */
4976 srelgot
->_raw_size
= srelgot
->_cooked_size
;
4978 sgotplt
->_cooked_size
-= 8;
4980 /* There should be only one entry left (and it will be
4982 BFD_ASSERT (sgotplt
->_cooked_size
== 4);
4983 BFD_ASSERT (splt
->_cooked_size
== PLT_ENTRY_SIZE
);
4986 BFD_ASSERT (sgotplt
->_cooked_size
>= 4);
4987 BFD_ASSERT (splt
->_cooked_size
>= PLT_ENTRY_SIZE
);
4989 sgotplt
->_cooked_size
-= 4;
4990 splt
->_cooked_size
-= PLT_ENTRY_SIZE
;
4992 /* Shrink _raw_sizes (see comment above). */
4993 sgotplt
->_raw_size
= sgotplt
->_cooked_size
;
4994 splt
->_raw_size
= splt
->_cooked_size
;
5000 /* This is similar to relax_section except that when a target is moved,
5001 we shift addresses up. We also need to modify the size. This
5002 algorithm does NOT allow for relocations into the middle of the
5003 property sections. */
5006 relax_property_section (abfd
, sec
, link_info
)
5009 struct bfd_link_info
*link_info
;
5011 Elf_Internal_Rela
*internal_relocs
;
5014 bfd_boolean ok
= TRUE
;
5016 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
5017 link_info
->keep_memory
);
5018 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
5019 if (contents
== NULL
&& sec
->_raw_size
!= 0)
5025 if (internal_relocs
)
5027 for (i
= 0; i
< sec
->reloc_count
; i
++)
5029 Elf_Internal_Rela
*irel
;
5030 xtensa_relax_info
*target_relax_info
;
5033 asection
*target_sec
;
5035 /* Locally change the source address.
5036 Translate the target to the new target address.
5037 If it points to this section and has been removed, MOVE IT.
5038 Also, don't forget to modify the associated SIZE at
5041 irel
= &internal_relocs
[i
];
5042 r_type
= ELF32_R_TYPE (irel
->r_info
);
5043 if (r_type
== R_XTENSA_NONE
)
5046 r_reloc_init (&r_rel
, abfd
, irel
);
5048 target_sec
= r_reloc_get_section (&r_rel
);
5049 target_relax_info
= get_xtensa_relax_info (target_sec
);
5051 if (target_relax_info
5052 && target_relax_info
->is_relaxable_literal_section
)
5054 /* Translate the relocation's destination. */
5056 bfd_vma new_end_offset
;
5058 long old_size
, new_size
;
5061 offset_with_removed_literals (&target_relax_info
->removed_list
,
5062 r_rel
.target_offset
);
5064 /* Assert that we are not out of bounds. */
5065 size_p
= &contents
[irel
->r_offset
+ 4];
5066 old_size
= bfd_get_32 (abfd
, &contents
[irel
->r_offset
+ 4]);
5069 offset_with_removed_literals (&target_relax_info
->removed_list
,
5070 r_rel
.target_offset
+ old_size
);
5072 new_size
= new_end_offset
- new_offset
;
5073 if (new_size
!= old_size
)
5075 bfd_put_32 (abfd
, new_size
, size_p
);
5076 pin_contents (sec
, contents
);
5079 if (new_offset
!= r_rel
.target_offset
)
5081 bfd_vma diff
= new_offset
- r_rel
.target_offset
;
5082 irel
->r_addend
+= diff
;
5083 pin_internal_relocs (sec
, internal_relocs
);
5089 /* Combine adjacent property table entries. This is also done in
5090 finish_dynamic_sections() but at that point it's too late to
5091 reclaim the space in the output section, so we do this twice. */
5093 if (internal_relocs
)
5095 Elf_Internal_Rela
*last_irel
= NULL
;
5096 int removed_bytes
= 0;
5097 bfd_vma offset
, last_irel_offset
;
5098 bfd_vma section_size
;
5100 /* Walk over memory and irels at the same time.
5101 This REQUIRES that the internal_relocs be sorted by offset. */
5102 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
5103 internal_reloc_compare
);
5104 nexti
= 0; /* Index into internal_relocs. */
5106 pin_internal_relocs (sec
, internal_relocs
);
5107 pin_contents (sec
, contents
);
5109 last_irel_offset
= (bfd_vma
) -1;
5110 section_size
= (sec
->_cooked_size
? sec
->_cooked_size
: sec
->_raw_size
);
5111 BFD_ASSERT (section_size
% 8 == 0);
5113 for (offset
= 0; offset
< section_size
; offset
+= 8)
5115 Elf_Internal_Rela
*irel
, *next_irel
;
5116 bfd_vma bytes_to_remove
, size
, actual_offset
;
5117 bfd_boolean remove_this_irel
;
5122 /* Find the next two relocations (if there are that many left),
5123 skipping over any R_XTENSA_NONE relocs. On entry, "nexti" is
5124 the starting reloc index. After these two loops, "i"
5125 is the index of the first non-NONE reloc past that starting
5126 index, and "nexti" is the index for the next non-NONE reloc
5129 for (i
= nexti
; i
< sec
->reloc_count
; i
++)
5131 if (ELF32_R_TYPE (internal_relocs
[i
].r_info
) != R_XTENSA_NONE
)
5133 irel
= &internal_relocs
[i
];
5136 internal_relocs
[i
].r_offset
-= removed_bytes
;
5139 for (nexti
= i
+ 1; nexti
< sec
->reloc_count
; nexti
++)
5141 if (ELF32_R_TYPE (internal_relocs
[nexti
].r_info
)
5144 next_irel
= &internal_relocs
[nexti
];
5147 internal_relocs
[nexti
].r_offset
-= removed_bytes
;
5150 remove_this_irel
= FALSE
;
5151 bytes_to_remove
= 0;
5152 actual_offset
= offset
- removed_bytes
;
5153 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
5155 /* Check that the irels are sorted by offset,
5156 with only one per address. */
5157 BFD_ASSERT (!irel
|| (int) irel
->r_offset
> (int) last_irel_offset
);
5158 BFD_ASSERT (!next_irel
|| next_irel
->r_offset
> irel
->r_offset
);
5160 /* Make sure there isn't a reloc on the size field. */
5161 if (irel
&& irel
->r_offset
== offset
+ 4)
5163 irel
->r_offset
-= removed_bytes
;
5164 last_irel_offset
= irel
->r_offset
;
5166 else if (next_irel
&& next_irel
->r_offset
== offset
+ 4)
5169 irel
->r_offset
-= removed_bytes
;
5170 next_irel
->r_offset
-= removed_bytes
;
5171 last_irel_offset
= next_irel
->r_offset
;
5175 /* Always remove entries with zero size. */
5176 bytes_to_remove
= 8;
5177 if (irel
&& irel
->r_offset
== offset
)
5179 remove_this_irel
= TRUE
;
5181 irel
->r_offset
-= removed_bytes
;
5182 last_irel_offset
= irel
->r_offset
;
5185 else if (irel
&& irel
->r_offset
== offset
)
5187 if (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
)
5192 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
5193 bfd_vma old_address
=
5194 (last_irel
->r_addend
5195 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
5196 bfd_vma new_address
=
5198 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
5200 if ((ELF32_R_SYM (irel
->r_info
) ==
5201 ELF32_R_SYM (last_irel
->r_info
))
5202 && (old_address
+ old_size
== new_address
))
5204 /* fix the old size */
5205 bfd_put_32 (abfd
, old_size
+ size
,
5206 &contents
[last_irel
->r_offset
+ 4]);
5207 bytes_to_remove
= 8;
5208 remove_this_irel
= TRUE
;
5217 irel
->r_offset
-= removed_bytes
;
5218 last_irel_offset
= irel
->r_offset
;
5221 if (remove_this_irel
)
5223 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
5224 irel
->r_offset
-= bytes_to_remove
;
5227 if (bytes_to_remove
!= 0)
5229 removed_bytes
+= bytes_to_remove
;
5230 if (offset
+ 8 < section_size
)
5231 memmove (&contents
[actual_offset
],
5232 &contents
[actual_offset
+8],
5233 section_size
- offset
- 8);
5239 /* Clear the removed bytes. */
5240 memset (&contents
[section_size
- removed_bytes
], 0, removed_bytes
);
5242 sec
->_cooked_size
= section_size
- removed_bytes
;
5243 /* Also shrink _raw_size. (The code in relocate_section that
5244 checks that relocations are within the section must use
5245 _raw_size because of the way the stabs sections are
5246 relaxed; shrinking _raw_size means that these checks will
5247 not be unnecessarily lax.) */
5248 sec
->_raw_size
= sec
->_cooked_size
;
5250 if (xtensa_is_littable_section (sec
))
5252 bfd
*dynobj
= elf_hash_table (link_info
)->dynobj
;
5256 bfd_get_section_by_name (dynobj
, ".got.loc");
5259 bfd_size_type sgotloc_size
=
5260 (sgotloc
->_cooked_size
? sgotloc
->_cooked_size
5261 : sgotloc
->_raw_size
);
5262 sgotloc
->_cooked_size
= sgotloc_size
- removed_bytes
;
5263 sgotloc
->_raw_size
= sgotloc_size
- removed_bytes
;
5271 release_internal_relocs (sec
, internal_relocs
);
5272 release_contents (sec
, contents
);
5277 /* Third relaxation pass. */
5279 /* Change symbol values to account for removed literals. */
5282 relax_section_symbols (abfd
, sec
)
5286 xtensa_relax_info
*relax_info
;
5287 unsigned int sec_shndx
;
5288 Elf_Internal_Shdr
*symtab_hdr
;
5289 Elf_Internal_Sym
*isymbuf
;
5290 unsigned i
, num_syms
, num_locals
;
5292 relax_info
= get_xtensa_relax_info (sec
);
5293 BFD_ASSERT (relax_info
);
5295 if (!relax_info
->is_relaxable_literal_section
)
5298 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
5300 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5301 isymbuf
= retrieve_local_syms (abfd
);
5303 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
5304 num_locals
= symtab_hdr
->sh_info
;
5306 /* Adjust the local symbols defined in this section. */
5307 for (i
= 0; i
< num_locals
; i
++)
5309 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
5311 if (isym
->st_shndx
== sec_shndx
)
5313 bfd_vma new_address
= offset_with_removed_literals
5314 (&relax_info
->removed_list
, isym
->st_value
);
5315 if (new_address
!= isym
->st_value
)
5316 isym
->st_value
= new_address
;
5320 /* Now adjust the global symbols defined in this section. */
5321 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
5323 struct elf_link_hash_entry
*sym_hash
;
5325 sym_hash
= elf_sym_hashes (abfd
)[i
];
5327 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
5328 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
5330 if ((sym_hash
->root
.type
== bfd_link_hash_defined
5331 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
5332 && sym_hash
->root
.u
.def
.section
== sec
)
5334 bfd_vma new_address
= offset_with_removed_literals
5335 (&relax_info
->removed_list
, sym_hash
->root
.u
.def
.value
);
5336 if (new_address
!= sym_hash
->root
.u
.def
.value
)
5337 sym_hash
->root
.u
.def
.value
= new_address
;
5345 /* "Fix" handling functions, called while performing relocations. */
5348 do_fix_for_relocatable_link (rel
, input_bfd
, input_section
)
5349 Elf_Internal_Rela
*rel
;
5351 asection
*input_section
;
5354 asection
*sec
, *old_sec
;
5356 int r_type
= ELF32_R_TYPE (rel
->r_info
);
5357 reloc_bfd_fix
*fix_list
;
5360 if (r_type
== R_XTENSA_NONE
)
5363 fix_list
= (get_xtensa_relax_info (input_section
))->fix_list
;
5364 if (fix_list
== NULL
)
5367 fix
= get_bfd_fix (fix_list
, input_section
, rel
->r_offset
, r_type
);
5371 r_reloc_init (&r_rel
, input_bfd
, rel
);
5372 old_sec
= r_reloc_get_section (&r_rel
);
5373 old_offset
= r_reloc_get_target_offset (&r_rel
);
5375 if (old_sec
== NULL
|| !r_reloc_is_defined (&r_rel
))
5377 BFD_ASSERT (r_type
== R_XTENSA_ASM_EXPAND
);
5378 /* Leave it be. Resolution will happen in a later stage. */
5382 sec
= fix
->target_sec
;
5383 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
5384 - (old_sec
->output_offset
+ old_offset
));
5390 do_fix_for_final_link (rel
, input_section
, relocationp
)
5391 Elf_Internal_Rela
*rel
;
5392 asection
*input_section
;
5393 bfd_vma
*relocationp
;
5396 int r_type
= ELF32_R_TYPE (rel
->r_info
);
5397 reloc_bfd_fix
*fix_list
;
5400 if (r_type
== R_XTENSA_NONE
)
5403 fix_list
= (get_xtensa_relax_info (input_section
))->fix_list
;
5404 if (fix_list
== NULL
)
5407 fix
= get_bfd_fix (fix_list
, input_section
, rel
->r_offset
, r_type
);
5411 sec
= fix
->target_sec
;
5412 *relocationp
= (sec
->output_section
->vma
5413 + sec
->output_offset
5414 + fix
->target_offset
- rel
->r_addend
);
5418 /* Miscellaneous utility functions.... */
5421 elf_xtensa_get_plt_section (dynobj
, chunk
)
5428 return bfd_get_section_by_name (dynobj
, ".plt");
5430 sprintf (plt_name
, ".plt.%u", chunk
);
5431 return bfd_get_section_by_name (dynobj
, plt_name
);
5436 elf_xtensa_get_gotplt_section (dynobj
, chunk
)
5443 return bfd_get_section_by_name (dynobj
, ".got.plt");
5445 sprintf (got_name
, ".got.plt.%u", chunk
);
5446 return bfd_get_section_by_name (dynobj
, got_name
);
5450 /* Get the input section for a given symbol index.
5452 . a section symbol, return the section;
5453 . a common symbol, return the common section;
5454 . an undefined symbol, return the undefined section;
5455 . an indirect symbol, follow the links;
5456 . an absolute value, return the absolute section. */
5459 get_elf_r_symndx_section (abfd
, r_symndx
)
5461 unsigned long r_symndx
;
5463 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5464 asection
*target_sec
= NULL
;
5465 if (r_symndx
< symtab_hdr
->sh_info
)
5467 Elf_Internal_Sym
*isymbuf
;
5468 unsigned int section_index
;
5470 isymbuf
= retrieve_local_syms (abfd
);
5471 section_index
= isymbuf
[r_symndx
].st_shndx
;
5473 if (section_index
== SHN_UNDEF
)
5474 target_sec
= bfd_und_section_ptr
;
5475 else if (section_index
> 0 && section_index
< SHN_LORESERVE
)
5476 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
5477 else if (section_index
== SHN_ABS
)
5478 target_sec
= bfd_abs_section_ptr
;
5479 else if (section_index
== SHN_COMMON
)
5480 target_sec
= bfd_com_section_ptr
;
5487 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
5488 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
5490 while (h
->root
.type
== bfd_link_hash_indirect
5491 || h
->root
.type
== bfd_link_hash_warning
)
5492 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5494 switch (h
->root
.type
)
5496 case bfd_link_hash_defined
:
5497 case bfd_link_hash_defweak
:
5498 target_sec
= h
->root
.u
.def
.section
;
5500 case bfd_link_hash_common
:
5501 target_sec
= bfd_com_section_ptr
;
5503 case bfd_link_hash_undefined
:
5504 case bfd_link_hash_undefweak
:
5505 target_sec
= bfd_und_section_ptr
;
5507 default: /* New indirect warning. */
5508 target_sec
= bfd_und_section_ptr
;
5516 static struct elf_link_hash_entry
*
5517 get_elf_r_symndx_hash_entry (abfd
, r_symndx
)
5519 unsigned long r_symndx
;
5522 struct elf_link_hash_entry
*h
;
5523 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5525 if (r_symndx
< symtab_hdr
->sh_info
)
5528 indx
= r_symndx
- symtab_hdr
->sh_info
;
5529 h
= elf_sym_hashes (abfd
)[indx
];
5530 while (h
->root
.type
== bfd_link_hash_indirect
5531 || h
->root
.type
== bfd_link_hash_warning
)
5532 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5537 /* Get the section-relative offset for a symbol number. */
5540 get_elf_r_symndx_offset (abfd
, r_symndx
)
5542 unsigned long r_symndx
;
5544 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5547 if (r_symndx
< symtab_hdr
->sh_info
)
5549 Elf_Internal_Sym
*isymbuf
;
5550 isymbuf
= retrieve_local_syms (abfd
);
5551 offset
= isymbuf
[r_symndx
].st_value
;
5555 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
5556 struct elf_link_hash_entry
*h
=
5557 elf_sym_hashes (abfd
)[indx
];
5559 while (h
->root
.type
== bfd_link_hash_indirect
5560 || h
->root
.type
== bfd_link_hash_warning
)
5561 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5562 if (h
->root
.type
== bfd_link_hash_defined
5563 || h
->root
.type
== bfd_link_hash_defweak
)
5564 offset
= h
->root
.u
.def
.value
;
5571 pcrel_reloc_fits (opnd
, self_address
, dest_address
)
5572 xtensa_operand opnd
;
5573 bfd_vma self_address
;
5574 bfd_vma dest_address
;
5576 uint32 new_address
=
5577 xtensa_operand_do_reloc (opnd
, dest_address
, self_address
);
5578 return (xtensa_operand_encode (opnd
, &new_address
)
5579 == xtensa_encode_result_ok
);
5583 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
5584 static int insn_sec_len
= sizeof (XTENSA_INSN_SEC_NAME
) - 1;
5585 static int lit_sec_len
= sizeof (XTENSA_LIT_SEC_NAME
) - 1;
5589 xtensa_is_property_section (sec
)
5592 if (strncmp (XTENSA_INSN_SEC_NAME
, sec
->name
, insn_sec_len
) == 0
5593 || strncmp (XTENSA_LIT_SEC_NAME
, sec
->name
, lit_sec_len
) == 0)
5596 if (strncmp (".gnu.linkonce.", sec
->name
, linkonce_len
) == 0
5597 && (sec
->name
[linkonce_len
] == 'x'
5598 || sec
->name
[linkonce_len
] == 'p')
5599 && sec
->name
[linkonce_len
+ 1] == '.')
5607 xtensa_is_littable_section (sec
)
5610 if (strncmp (XTENSA_LIT_SEC_NAME
, sec
->name
, lit_sec_len
) == 0)
5613 if (strncmp (".gnu.linkonce.", sec
->name
, linkonce_len
) == 0
5614 && sec
->name
[linkonce_len
] == 'p'
5615 && sec
->name
[linkonce_len
+ 1] == '.')
5623 is_literal_section (sec
)
5626 /* FIXME: the current definition of this leaves a lot to be desired.... */
5627 if (sec
== NULL
|| sec
->name
== NULL
)
5629 return (strstr (sec
->name
, "literal") != NULL
);
5634 internal_reloc_compare (ap
, bp
)
5638 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
5639 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
5641 return (a
->r_offset
- b
->r_offset
);
5646 xtensa_get_property_section_name (sec
, base_name
)
5648 const char *base_name
;
5650 if (strncmp (sec
->name
, ".gnu.linkonce.", linkonce_len
) == 0)
5652 char *prop_sec_name
;
5654 char linkonce_kind
= 0;
5656 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
5657 linkonce_kind
= 'x';
5658 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
5659 linkonce_kind
= 'p';
5663 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
) + 1);
5664 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
5665 prop_sec_name
[linkonce_len
] = linkonce_kind
;
5666 prop_sec_name
[linkonce_len
+ 1] = '.';
5668 suffix
= sec
->name
+ linkonce_len
;
5672 if (suffix
[-1] == '.')
5675 strcpy (prop_sec_name
+ linkonce_len
+ 2, suffix
);
5677 return prop_sec_name
;
5680 return strdup (base_name
);
5684 /* Other functions called directly by the linker. */
5687 xtensa_callback_required_dependence (abfd
, sec
, link_info
, callback
, closure
)
5690 struct bfd_link_info
*link_info
;
5691 deps_callback_t callback
;
5694 Elf_Internal_Rela
*internal_relocs
;
5697 bfd_boolean ok
= TRUE
;
5699 /* ".plt*" sections have no explicit relocations but they contain L32R
5700 instructions that reference the corresponding ".got.plt*" sections. */
5701 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
5702 && strncmp (sec
->name
, ".plt", 4) == 0)
5706 /* Find the corresponding ".got.plt*" section. */
5707 if (sec
->name
[4] == '\0')
5708 sgotplt
= bfd_get_section_by_name (sec
->owner
, ".got.plt");
5714 BFD_ASSERT (sec
->name
[4] == '.');
5715 chunk
= strtol (&sec
->name
[5], NULL
, 10);
5717 sprintf (got_name
, ".got.plt.%u", chunk
);
5718 sgotplt
= bfd_get_section_by_name (sec
->owner
, got_name
);
5720 BFD_ASSERT (sgotplt
);
5722 /* Assume worst-case offsets: L32R at the very end of the ".plt"
5723 section referencing a literal at the very beginning of
5724 ".got.plt". This is very close to the real dependence, anyway. */
5725 (*callback
) (sec
, sec
->_raw_size
, sgotplt
, 0, closure
);
5728 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
5729 link_info
->keep_memory
);
5730 if (internal_relocs
== NULL
5731 || sec
->reloc_count
== 0)
5734 /* Cache the contents for the duration of this scan. */
5735 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
5736 if (contents
== NULL
&& sec
->_raw_size
!= 0)
5742 if (xtensa_default_isa
== NULL
)
5745 for (i
= 0; i
< sec
->reloc_count
; i
++)
5747 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
5748 if (is_l32r_relocation (sec
, contents
, irel
))
5751 asection
*target_sec
;
5752 bfd_vma target_offset
;
5754 r_reloc_init (&l32r_rel
, abfd
, irel
);
5757 /* L32Rs must be local to the input file. */
5758 if (r_reloc_is_defined (&l32r_rel
))
5760 target_sec
= r_reloc_get_section (&l32r_rel
);
5761 target_offset
= r_reloc_get_target_offset (&l32r_rel
);
5763 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
5769 release_internal_relocs (sec
, internal_relocs
);
5770 release_contents (sec
, contents
);
5774 /* The default literal sections should always be marked as "code" (i.e.,
5775 SHF_EXECINSTR). This is particularly important for the Linux kernel
5776 module loader so that the literals are not placed after the text. */
5777 static struct bfd_elf_special_section
const elf_xtensa_special_sections
[]=
5779 { ".literal", 8, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
5780 { ".init.literal", 13, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
5781 { ".fini.literal", 13, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
5782 { NULL
, 0, 0, 0, 0 }
5787 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
5788 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
5789 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
5790 #define TARGET_BIG_NAME "elf32-xtensa-be"
5791 #define ELF_ARCH bfd_arch_xtensa
5793 /* The new EM_XTENSA value will be recognized beginning in the Xtensa T1040
5794 release. However, we still have to generate files with the EM_XTENSA_OLD
5795 value so that pre-T1040 tools can read the files. As soon as we stop
5796 caring about pre-T1040 tools, the following two values should be
5797 swapped. At the same time, any other code that uses EM_XTENSA_OLD
5798 (e.g., prep_headers() in elf.c) should be changed to use EM_XTENSA. */
5799 #define ELF_MACHINE_CODE EM_XTENSA_OLD
5800 #define ELF_MACHINE_ALT1 EM_XTENSA
5803 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
5804 #else /* !XCHAL_HAVE_MMU */
5805 #define ELF_MAXPAGESIZE 1
5806 #endif /* !XCHAL_HAVE_MMU */
5807 #endif /* ELF_ARCH */
5809 #define elf_backend_can_gc_sections 1
5810 #define elf_backend_can_refcount 1
5811 #define elf_backend_plt_readonly 1
5812 #define elf_backend_got_header_size 4
5813 #define elf_backend_want_dynbss 0
5814 #define elf_backend_want_got_plt 1
5816 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
5818 #define bfd_elf32_bfd_final_link bfd_elf32_bfd_final_link
5819 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
5820 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
5821 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
5822 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
5823 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
5824 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
5826 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
5827 #define elf_backend_check_relocs elf_xtensa_check_relocs
5828 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
5829 #define elf_backend_discard_info elf_xtensa_discard_info
5830 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
5831 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
5832 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
5833 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
5834 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
5835 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
5836 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
5837 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
5838 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
5839 #define elf_backend_modify_segment_map elf_xtensa_modify_segment_map
5840 #define elf_backend_object_p elf_xtensa_object_p
5841 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
5842 #define elf_backend_relocate_section elf_xtensa_relocate_section
5843 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
5844 #define elf_backend_special_sections elf_xtensa_special_sections
5846 #include "elf32-target.h"