1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright 2003 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 void elf_xtensa_copy_indirect_symbol
51 PARAMS ((const struct elf_backend_data *, struct elf_link_hash_entry *,
52 struct elf_link_hash_entry *));
53 static asection *elf_xtensa_gc_mark_hook
54 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
55 struct elf_link_hash_entry *, Elf_Internal_Sym *));
56 static bfd_boolean elf_xtensa_gc_sweep_hook
57 PARAMS ((bfd *, struct bfd_link_info *, asection *,
58 const Elf_Internal_Rela *));
59 static bfd_boolean elf_xtensa_create_dynamic_sections
60 PARAMS ((bfd *, struct bfd_link_info *));
61 static bfd_boolean elf_xtensa_adjust_dynamic_symbol
62 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
63 static bfd_boolean elf_xtensa_size_dynamic_sections
64 PARAMS ((bfd *, struct bfd_link_info *));
65 static bfd_boolean elf_xtensa_modify_segment_map
67 static bfd_boolean elf_xtensa_relocate_section
68 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
69 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
70 static bfd_boolean elf_xtensa_relax_section
71 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *again));
72 static bfd_boolean elf_xtensa_finish_dynamic_symbol
73 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
75 static bfd_boolean elf_xtensa_finish_dynamic_sections
76 PARAMS ((bfd *, struct bfd_link_info *));
77 static bfd_boolean elf_xtensa_merge_private_bfd_data
78 PARAMS ((bfd *, bfd *));
79 static bfd_boolean elf_xtensa_set_private_flags
80 PARAMS ((bfd *, flagword));
81 extern flagword elf_xtensa_get_private_bfd_flags
83 static bfd_boolean elf_xtensa_print_private_bfd_data
84 PARAMS ((bfd *, PTR));
85 static bfd_boolean elf_xtensa_object_p
87 static void elf_xtensa_final_write_processing
88 PARAMS ((bfd *, bfd_boolean));
89 static enum elf_reloc_type_class elf_xtensa_reloc_type_class
90 PARAMS ((const Elf_Internal_Rela *));
91 static bfd_boolean elf_xtensa_discard_info
92 PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *));
93 static bfd_boolean elf_xtensa_ignore_discarded_relocs
94 PARAMS ((asection *));
95 static bfd_boolean elf_xtensa_grok_prstatus
96 PARAMS ((bfd *, Elf_Internal_Note *));
97 static bfd_boolean elf_xtensa_grok_psinfo
98 PARAMS ((bfd *, Elf_Internal_Note *));
99 static bfd_boolean elf_xtensa_new_section_hook
100 PARAMS ((bfd *, asection *));
103 /* Local helper functions. */
105 static bfd_boolean xtensa_elf_dynamic_symbol_p
106 PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *));
107 static int property_table_compare
108 PARAMS ((const PTR, const PTR));
109 static bfd_boolean elf_xtensa_in_literal_pool
110 PARAMS ((property_table_entry *, int, bfd_vma));
111 static void elf_xtensa_make_sym_local
112 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
113 static bfd_boolean add_extra_plt_sections
114 PARAMS ((bfd *, int));
115 static bfd_boolean elf_xtensa_fix_refcounts
116 PARAMS ((struct elf_link_hash_entry *, PTR));
117 static bfd_boolean elf_xtensa_allocate_plt_size
118 PARAMS ((struct elf_link_hash_entry *, PTR));
119 static bfd_boolean elf_xtensa_allocate_got_size
120 PARAMS ((struct elf_link_hash_entry *, PTR));
121 static void elf_xtensa_allocate_local_got_size
122 PARAMS ((struct bfd_link_info *, asection *));
123 static bfd_reloc_status_type elf_xtensa_do_reloc
124 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_vma, bfd_byte *,
125 bfd_vma, bfd_boolean, char **));
126 static char * vsprint_msg
127 VPARAMS ((const char *, const char *, int, ...));
128 static char *build_encoding_error_message
129 PARAMS ((xtensa_opcode, xtensa_encode_result));
130 static bfd_reloc_status_type bfd_elf_xtensa_reloc
131 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
132 static void do_fix_for_relocatable_link
133 PARAMS ((Elf_Internal_Rela *, bfd *, asection *));
134 static void do_fix_for_final_link
135 PARAMS ((Elf_Internal_Rela *, asection *, bfd_vma *));
136 static bfd_vma elf_xtensa_create_plt_entry
137 PARAMS ((bfd *, bfd *, unsigned));
138 static int elf_xtensa_combine_prop_entries
139 PARAMS ((bfd *, asection *, asection *));
140 static bfd_boolean elf_xtensa_discard_info_for_section
141 PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *,
144 /* Local functions to handle Xtensa configurability. */
146 static void init_call_opcodes
148 static bfd_boolean is_indirect_call_opcode
149 PARAMS ((xtensa_opcode));
150 static bfd_boolean is_direct_call_opcode
151 PARAMS ((xtensa_opcode));
152 static bfd_boolean is_windowed_call_opcode
153 PARAMS ((xtensa_opcode));
154 static xtensa_opcode get_l32r_opcode
156 static bfd_vma l32r_offset
157 PARAMS ((bfd_vma, bfd_vma));
158 static int get_relocation_opnd
159 PARAMS ((Elf_Internal_Rela *));
160 static xtensa_opcode get_relocation_opcode
161 PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *));
162 static bfd_boolean is_l32r_relocation
163 PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *));
165 /* Functions for link-time code simplifications. */
167 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
168 PARAMS ((bfd_byte *, bfd_vma, bfd_vma));
169 static bfd_reloc_status_type contract_asm_expansion
170 PARAMS ((bfd_byte *, bfd_vma, Elf_Internal_Rela *));
171 static xtensa_opcode swap_callx_for_call_opcode
172 PARAMS ((xtensa_opcode));
173 static xtensa_opcode get_expanded_call_opcode
174 PARAMS ((bfd_byte *, int));
176 /* Access to internal relocations, section contents and symbols. */
178 static Elf_Internal_Rela *retrieve_internal_relocs
179 PARAMS ((bfd *, asection *, bfd_boolean));
180 static void pin_internal_relocs
181 PARAMS ((asection *, Elf_Internal_Rela *));
182 static void release_internal_relocs
183 PARAMS ((asection *, Elf_Internal_Rela *));
184 static bfd_byte *retrieve_contents
185 PARAMS ((bfd *, asection *, bfd_boolean));
186 static void pin_contents
187 PARAMS ((asection *, bfd_byte *));
188 static void release_contents
189 PARAMS ((asection *, bfd_byte *));
190 static Elf_Internal_Sym *retrieve_local_syms
193 /* Miscellaneous utility functions. */
195 static asection *elf_xtensa_get_plt_section
196 PARAMS ((bfd *, int));
197 static asection *elf_xtensa_get_gotplt_section
198 PARAMS ((bfd *, int));
199 static asection *get_elf_r_symndx_section
200 PARAMS ((bfd *, unsigned long));
201 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
202 PARAMS ((bfd *, unsigned long));
203 static bfd_vma get_elf_r_symndx_offset
204 PARAMS ((bfd *, unsigned long));
205 static bfd_boolean pcrel_reloc_fits
206 PARAMS ((xtensa_operand, bfd_vma, bfd_vma));
207 static bfd_boolean xtensa_is_property_section
208 PARAMS ((asection *));
209 static bfd_boolean xtensa_is_littable_section
210 PARAMS ((asection *));
211 static bfd_boolean is_literal_section
212 PARAMS ((asection *));
213 static int internal_reloc_compare
214 PARAMS ((const PTR, const PTR));
215 static bfd_boolean get_is_linkonce_section
216 PARAMS ((bfd *, asection *));
217 extern char *xtensa_get_property_section_name
218 PARAMS ((bfd *, asection *, const char *));
220 /* Other functions called directly by the linker. */
222 typedef void (*deps_callback_t)
223 PARAMS ((asection *, bfd_vma, asection *, bfd_vma, PTR));
224 extern bfd_boolean xtensa_callback_required_dependence
225 PARAMS ((bfd *, asection *, struct bfd_link_info *,
226 deps_callback_t, PTR));
229 typedef struct xtensa_relax_info_struct xtensa_relax_info;
232 /* Total count of PLT relocations seen during check_relocs.
233 The actual PLT code must be split into multiple sections and all
234 the sections have to be created before size_dynamic_sections,
235 where we figure out the exact number of PLT entries that will be
236 needed. It is OK if this count is an overestimate, e.g., some
237 relocations may be removed by GC. */
239 static int plt_reloc_count = 0;
242 /* When this is true, relocations may have been modified to refer to
243 symbols from other input files. The per-section list of "fix"
244 records needs to be checked when resolving relocations. */
246 static bfd_boolean relaxing_section = FALSE;
249 static reloc_howto_type elf_howto_table[] =
251 HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
252 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
253 FALSE, 0x00000000, 0x00000000, FALSE),
254 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
255 bfd_elf_xtensa_reloc, "R_XTENSA_32",
256 TRUE, 0xffffffff, 0xffffffff, FALSE),
257 /* Replace a 32-bit value with a value from the runtime linker (only
258 used by linker-generated stub functions). The r_addend value is
259 special: 1 means to substitute a pointer to the runtime linker's
260 dynamic resolver function; 2 means to substitute the link map for
261 the shared object. */
262 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
263 NULL, "R_XTENSA_RTLD",
264 FALSE, 0x00000000, 0x00000000, FALSE),
265 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
266 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
267 FALSE, 0xffffffff, 0xffffffff, FALSE),
268 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
269 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
270 FALSE, 0xffffffff, 0xffffffff, FALSE),
271 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
272 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
273 FALSE, 0xffffffff, 0xffffffff, FALSE),
274 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
275 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
276 FALSE, 0xffffffff, 0xffffffff, FALSE),
278 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
279 bfd_elf_xtensa_reloc, "R_XTENSA_OP0",
280 FALSE, 0x00000000, 0x00000000, TRUE),
281 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
282 bfd_elf_xtensa_reloc, "R_XTENSA_OP1",
283 FALSE, 0x00000000, 0x00000000, TRUE),
284 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
285 bfd_elf_xtensa_reloc, "R_XTENSA_OP2",
286 FALSE, 0x00000000, 0x00000000, TRUE),
287 /* Assembly auto-expansion. */
288 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
289 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND",
290 FALSE, 0x00000000, 0x00000000, FALSE),
291 /* Relax assembly auto-expansion. */
292 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
293 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY",
294 FALSE, 0x00000000, 0x00000000, TRUE),
297 /* GNU extension to record C++ vtable hierarchy. */
298 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
299 NULL, "R_XTENSA_GNU_VTINHERIT",
300 FALSE, 0x00000000, 0x00000000, FALSE),
301 /* GNU extension to record C++ vtable member usage. */
302 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
303 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
304 FALSE, 0x00000000, 0x00000000, FALSE)
307 #ifdef DEBUG_GEN_RELOC
309 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
314 static reloc_howto_type *
315 elf_xtensa_reloc_type_lookup (abfd, code)
316 bfd *abfd ATTRIBUTE_UNUSED;
317 bfd_reloc_code_real_type code;
322 TRACE ("BFD_RELOC_NONE");
323 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
326 TRACE ("BFD_RELOC_32");
327 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
329 case BFD_RELOC_XTENSA_RTLD:
330 TRACE ("BFD_RELOC_XTENSA_RTLD");
331 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
333 case BFD_RELOC_XTENSA_GLOB_DAT:
334 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
335 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
337 case BFD_RELOC_XTENSA_JMP_SLOT:
338 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
339 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
341 case BFD_RELOC_XTENSA_RELATIVE:
342 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
343 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
345 case BFD_RELOC_XTENSA_PLT:
346 TRACE ("BFD_RELOC_XTENSA_PLT");
347 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
349 case BFD_RELOC_XTENSA_OP0:
350 TRACE ("BFD_RELOC_XTENSA_OP0");
351 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
353 case BFD_RELOC_XTENSA_OP1:
354 TRACE ("BFD_RELOC_XTENSA_OP1");
355 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
357 case BFD_RELOC_XTENSA_OP2:
358 TRACE ("BFD_RELOC_XTENSA_OP2");
359 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
361 case BFD_RELOC_XTENSA_ASM_EXPAND:
362 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
363 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
365 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
366 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
367 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
369 case BFD_RELOC_VTABLE_INHERIT:
370 TRACE ("BFD_RELOC_VTABLE_INHERIT");
371 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
373 case BFD_RELOC_VTABLE_ENTRY:
374 TRACE ("BFD_RELOC_VTABLE_ENTRY");
375 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
386 /* Given an ELF "rela" relocation, find the corresponding howto and record
387 it in the BFD internal arelent representation of the relocation. */
390 elf_xtensa_info_to_howto_rela (abfd, cache_ptr, dst)
391 bfd *abfd ATTRIBUTE_UNUSED;
393 Elf_Internal_Rela *dst;
395 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
397 BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max);
398 cache_ptr->howto = &elf_howto_table[r_type];
402 /* Functions for the Xtensa ELF linker. */
404 /* The name of the dynamic interpreter. This is put in the .interp
407 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
409 /* The size in bytes of an entry in the procedure linkage table.
410 (This does _not_ include the space for the literals associated with
413 #define PLT_ENTRY_SIZE 16
415 /* For _really_ large PLTs, we may need to alternate between literals
416 and code to keep the literals within the 256K range of the L32R
417 instructions in the code. It's unlikely that anyone would ever need
418 such a big PLT, but an arbitrary limit on the PLT size would be bad.
419 Thus, we split the PLT into chunks. Since there's very little
420 overhead (2 extra literals) for each chunk, the chunk size is kept
421 small so that the code for handling multiple chunks get used and
422 tested regularly. With 254 entries, there are 1K of literals for
423 each chunk, and that seems like a nice round number. */
425 #define PLT_ENTRIES_PER_CHUNK 254
427 /* PLT entries are actually used as stub functions for lazy symbol
428 resolution. Once the symbol is resolved, the stub function is never
429 invoked. Note: the 32-byte frame size used here cannot be changed
430 without a corresponding change in the runtime linker. */
432 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
434 0x6c, 0x10, 0x04, /* entry sp, 32 */
435 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
436 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
437 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
438 0x0a, 0x80, 0x00, /* jx a8 */
442 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
444 0x36, 0x41, 0x00, /* entry sp, 32 */
445 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
446 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
447 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
448 0xa0, 0x08, 0x00, /* jx a8 */
453 static inline bfd_boolean
454 xtensa_elf_dynamic_symbol_p (h, info)
455 struct elf_link_hash_entry *h;
456 struct bfd_link_info *info;
458 /* Check if we should do dynamic things to this symbol. The
459 "ignore_protected" argument need not be set, because Xtensa code
460 does not require special handling of STV_PROTECTED to make function
461 pointer comparisons work properly. The PLT addresses are never
462 used for function pointers. */
464 return _bfd_elf_dynamic_symbol_p (h, info, 0);
469 property_table_compare (ap, bp)
473 const property_table_entry *a = (const property_table_entry *) ap;
474 const property_table_entry *b = (const property_table_entry *) bp;
476 /* Check if one entry overlaps with the other; this shouldn't happen
477 except when searching for a match. */
478 if ((b->address >= a->address && b->address < (a->address + a->size))
479 || (a->address >= b->address && a->address < (b->address + b->size)))
482 return (a->address - b->address);
486 /* Get the literal table or instruction table entries for the given
487 section. Sets TABLE_P and returns the number of entries. On error,
488 returns a negative value. */
491 xtensa_read_table_entries (abfd, section, table_p, sec_name)
494 property_table_entry **table_p;
495 const char *sec_name;
497 asection *table_section;
498 char *table_section_name;
499 bfd_size_type table_size = 0;
500 bfd_byte *table_data;
501 property_table_entry *blocks;
503 bfd_size_type num_records;
504 Elf_Internal_Rela *internal_relocs;
507 xtensa_get_property_section_name (abfd, section, sec_name);
508 table_section = bfd_get_section_by_name (abfd, table_section_name);
509 if (table_section != NULL)
510 table_size = bfd_get_section_size_before_reloc (table_section);
518 num_records = table_size / sizeof (property_table_entry);
519 table_data = retrieve_contents (abfd, table_section, TRUE);
520 blocks = (property_table_entry *)
521 bfd_malloc (num_records * sizeof (property_table_entry));
524 /* If the file has not yet been relocated, process the relocations
525 and sort out the table entries that apply to the specified section. */
526 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
531 for (i = 0; i < table_section->reloc_count; i++)
533 Elf_Internal_Rela *rel = &internal_relocs[i];
534 unsigned long r_symndx;
536 if (ELF32_R_TYPE (rel->r_info) == R_XTENSA_NONE)
539 BFD_ASSERT (ELF32_R_TYPE (rel->r_info) == R_XTENSA_32);
540 r_symndx = ELF32_R_SYM (rel->r_info);
542 if (get_elf_r_symndx_section (abfd, r_symndx) == section)
544 bfd_vma sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
545 blocks[block_count].address =
546 (section->vma + sym_off + rel->r_addend
547 + bfd_get_32 (abfd, table_data + rel->r_offset));
548 blocks[block_count].size =
549 bfd_get_32 (abfd, table_data + rel->r_offset + 4);
556 /* No relocations. Presumably the file has been relocated
557 and the addresses are already in the table. */
560 for (off = 0; off < table_size; off += sizeof (property_table_entry))
562 bfd_vma address = bfd_get_32 (abfd, table_data + off);
564 if (address >= section->vma
565 && address < ( section->vma + section->_raw_size))
567 blocks[block_count].address = address;
568 blocks[block_count].size =
569 bfd_get_32 (abfd, table_data + off + 4);
575 release_contents (table_section, table_data);
576 release_internal_relocs (table_section, internal_relocs);
580 /* Now sort them into address order for easy reference. */
581 qsort (blocks, block_count, sizeof (property_table_entry),
582 property_table_compare);
591 elf_xtensa_in_literal_pool (lit_table, lit_table_size, addr)
592 property_table_entry *lit_table;
596 property_table_entry entry;
598 if (lit_table_size == 0)
601 entry.address = addr;
604 if (bsearch (&entry, lit_table, lit_table_size,
605 sizeof (property_table_entry), property_table_compare))
612 /* Look through the relocs for a section during the first phase, and
613 calculate needed space in the dynamic reloc sections. */
616 elf_xtensa_check_relocs (abfd, info, sec, relocs)
618 struct bfd_link_info *info;
620 const Elf_Internal_Rela *relocs;
622 Elf_Internal_Shdr *symtab_hdr;
623 struct elf_link_hash_entry **sym_hashes;
624 const Elf_Internal_Rela *rel;
625 const Elf_Internal_Rela *rel_end;
626 property_table_entry *lit_table;
629 if (info->relocatable)
632 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
633 sym_hashes = elf_sym_hashes (abfd);
635 ltblsize = xtensa_read_table_entries (abfd, sec, &lit_table,
636 XTENSA_LIT_SEC_NAME);
640 rel_end = relocs + sec->reloc_count;
641 for (rel = relocs; rel < rel_end; rel++)
644 unsigned long r_symndx;
645 struct elf_link_hash_entry *h;
647 r_symndx = ELF32_R_SYM (rel->r_info);
648 r_type = ELF32_R_TYPE (rel->r_info);
650 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
652 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
653 bfd_archive_filename (abfd),
658 if (r_symndx < symtab_hdr->sh_info)
662 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
663 while (h->root.type == bfd_link_hash_indirect
664 || h->root.type == bfd_link_hash_warning)
665 h = (struct elf_link_hash_entry *) h->root.u.i.link;
674 if ((sec->flags & SEC_ALLOC) != 0)
676 if ((sec->flags & SEC_READONLY) != 0
677 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
678 sec->vma + rel->r_offset))
679 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
681 if (h->got.refcount <= 0)
684 h->got.refcount += 1;
689 /* If this relocation is against a local symbol, then it's
690 exactly the same as a normal local GOT entry. */
694 if ((sec->flags & SEC_ALLOC) != 0)
696 if ((sec->flags & SEC_READONLY) != 0
697 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
698 sec->vma + rel->r_offset))
699 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
701 if (h->plt.refcount <= 0)
703 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
707 h->plt.refcount += 1;
709 /* Keep track of the total PLT relocation count even if we
710 don't yet know whether the dynamic sections will be
712 plt_reloc_count += 1;
714 if (elf_hash_table (info)->dynamic_sections_created)
716 if (!add_extra_plt_sections (elf_hash_table (info)->dynobj,
724 if ((sec->flags & SEC_ALLOC) != 0)
726 bfd_signed_vma *local_got_refcounts;
728 /* This is a global offset table entry for a local symbol. */
729 local_got_refcounts = elf_local_got_refcounts (abfd);
730 if (local_got_refcounts == NULL)
734 size = symtab_hdr->sh_info;
735 size *= sizeof (bfd_signed_vma);
736 local_got_refcounts = ((bfd_signed_vma *)
737 bfd_zalloc (abfd, size));
738 if (local_got_refcounts == NULL)
740 elf_local_got_refcounts (abfd) = local_got_refcounts;
742 local_got_refcounts[r_symndx] += 1;
744 /* If the relocation is not inside the GOT, the DF_TEXTREL
745 flag needs to be set. */
747 && (sec->flags & SEC_READONLY) != 0
748 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
749 sec->vma + rel->r_offset))
750 info->flags |= DF_TEXTREL;
757 case R_XTENSA_ASM_EXPAND:
758 case R_XTENSA_ASM_SIMPLIFY:
759 /* Nothing to do for these. */
762 case R_XTENSA_GNU_VTINHERIT:
763 /* This relocation describes the C++ object vtable hierarchy.
764 Reconstruct it for later use during GC. */
765 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
769 case R_XTENSA_GNU_VTENTRY:
770 /* This relocation describes which C++ vtable entries are actually
771 used. Record for later use during GC. */
772 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
787 elf_xtensa_hide_symbol (info, h, force_local)
788 struct bfd_link_info *info;
789 struct elf_link_hash_entry *h;
790 bfd_boolean force_local;
792 /* For a shared link, move the plt refcount to the got refcount to leave
793 space for RELATIVE relocs. */
794 elf_xtensa_make_sym_local (info, h);
796 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
801 elf_xtensa_copy_indirect_symbol (bed, dir, ind)
802 const struct elf_backend_data *bed;
803 struct elf_link_hash_entry *dir, *ind;
805 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
807 /* The standard function doesn't copy the NEEDS_PLT flag. */
808 dir->elf_link_hash_flags |=
809 (ind->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT);
813 /* Return the section that should be marked against GC for a given
817 elf_xtensa_gc_mark_hook (sec, info, rel, h, sym)
819 struct bfd_link_info *info ATTRIBUTE_UNUSED;
820 Elf_Internal_Rela *rel;
821 struct elf_link_hash_entry *h;
822 Elf_Internal_Sym *sym;
826 switch (ELF32_R_TYPE (rel->r_info))
828 case R_XTENSA_GNU_VTINHERIT:
829 case R_XTENSA_GNU_VTENTRY:
833 switch (h->root.type)
835 case bfd_link_hash_defined:
836 case bfd_link_hash_defweak:
837 return h->root.u.def.section;
839 case bfd_link_hash_common:
840 return h->root.u.c.p->section;
848 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
853 /* Update the GOT & PLT entry reference counts
854 for the section being removed. */
857 elf_xtensa_gc_sweep_hook (abfd, info, sec, relocs)
859 struct bfd_link_info *info ATTRIBUTE_UNUSED;
861 const Elf_Internal_Rela *relocs;
863 Elf_Internal_Shdr *symtab_hdr;
864 struct elf_link_hash_entry **sym_hashes;
865 bfd_signed_vma *local_got_refcounts;
866 const Elf_Internal_Rela *rel, *relend;
868 if ((sec->flags & SEC_ALLOC) == 0)
871 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
872 sym_hashes = elf_sym_hashes (abfd);
873 local_got_refcounts = elf_local_got_refcounts (abfd);
875 relend = relocs + sec->reloc_count;
876 for (rel = relocs; rel < relend; rel++)
878 unsigned long r_symndx;
880 struct elf_link_hash_entry *h = NULL;
882 r_symndx = ELF32_R_SYM (rel->r_info);
883 if (r_symndx >= symtab_hdr->sh_info)
884 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
886 r_type = ELF32_R_TYPE (rel->r_info);
892 if (h->got.refcount > 0)
899 if (h->plt.refcount > 0)
904 if (local_got_refcounts[r_symndx] > 0)
905 local_got_refcounts[r_symndx] -= 1;
917 /* Create all the dynamic sections. */
920 elf_xtensa_create_dynamic_sections (dynobj, info)
922 struct bfd_link_info *info;
924 flagword flags, noalloc_flags;
927 /* First do all the standard stuff. */
928 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
931 /* Create any extra PLT sections in case check_relocs has already
932 been called on all the non-dynamic input files. */
933 if (!add_extra_plt_sections (dynobj, plt_reloc_count))
936 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
937 | SEC_LINKER_CREATED | SEC_READONLY);
938 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
940 /* Mark the ".got.plt" section READONLY. */
941 s = bfd_get_section_by_name (dynobj, ".got.plt");
943 || ! bfd_set_section_flags (dynobj, s, flags))
946 /* Create ".rela.got". */
947 s = bfd_make_section (dynobj, ".rela.got");
949 || ! bfd_set_section_flags (dynobj, s, flags)
950 || ! bfd_set_section_alignment (dynobj, s, 2))
953 /* Create ".got.loc" (literal tables for use by dynamic linker). */
954 s = bfd_make_section (dynobj, ".got.loc");
956 || ! bfd_set_section_flags (dynobj, s, flags)
957 || ! bfd_set_section_alignment (dynobj, s, 2))
960 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
961 s = bfd_make_section (dynobj, ".xt.lit.plt");
963 || ! bfd_set_section_flags (dynobj, s, noalloc_flags)
964 || ! bfd_set_section_alignment (dynobj, s, 2))
972 add_extra_plt_sections (dynobj, count)
978 /* Iterate over all chunks except 0 which uses the standard ".plt" and
979 ".got.plt" sections. */
980 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
986 /* Stop when we find a section has already been created. */
987 if (elf_xtensa_get_plt_section (dynobj, chunk))
990 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
991 | SEC_LINKER_CREATED | SEC_READONLY);
993 sname = (char *) bfd_malloc (10);
994 sprintf (sname, ".plt.%u", chunk);
995 s = bfd_make_section (dynobj, sname);
997 || ! bfd_set_section_flags (dynobj, s, flags | SEC_CODE)
998 || ! bfd_set_section_alignment (dynobj, s, 2))
1001 sname = (char *) bfd_malloc (14);
1002 sprintf (sname, ".got.plt.%u", chunk);
1003 s = bfd_make_section (dynobj, sname);
1005 || ! bfd_set_section_flags (dynobj, s, flags)
1006 || ! bfd_set_section_alignment (dynobj, s, 2))
1014 /* Adjust a symbol defined by a dynamic object and referenced by a
1015 regular object. The current definition is in some section of the
1016 dynamic object, but we're not including those sections. We have to
1017 change the definition to something the rest of the link can
1021 elf_xtensa_adjust_dynamic_symbol (info, h)
1022 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1023 struct elf_link_hash_entry *h;
1025 /* If this is a weak symbol, and there is a real definition, the
1026 processor independent code will have arranged for us to see the
1027 real definition first, and we can just use the same value. */
1028 if (h->weakdef != NULL)
1030 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1031 || h->weakdef->root.type == bfd_link_hash_defweak);
1032 h->root.u.def.section = h->weakdef->root.u.def.section;
1033 h->root.u.def.value = h->weakdef->root.u.def.value;
1037 /* This is a reference to a symbol defined by a dynamic object. The
1038 reference must go through the GOT, so there's no need for COPY relocs,
1046 elf_xtensa_make_sym_local (info, h)
1047 struct bfd_link_info *info;
1048 struct elf_link_hash_entry *h;
1052 if (h->plt.refcount > 0)
1054 /* Will use RELATIVE relocs instead of JMP_SLOT relocs. */
1055 if (h->got.refcount < 0)
1056 h->got.refcount = 0;
1057 h->got.refcount += h->plt.refcount;
1058 h->plt.refcount = 0;
1063 /* Don't need any dynamic relocations at all. */
1064 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1065 h->plt.refcount = 0;
1066 h->got.refcount = 0;
1072 elf_xtensa_fix_refcounts (h, arg)
1073 struct elf_link_hash_entry *h;
1076 struct bfd_link_info *info = (struct bfd_link_info *) arg;
1078 if (h->root.type == bfd_link_hash_warning)
1079 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1081 if (! xtensa_elf_dynamic_symbol_p (h, info))
1082 elf_xtensa_make_sym_local (info, h);
1084 /* If the symbol has a relocation outside the GOT, set the
1086 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) != 0)
1087 info->flags |= DF_TEXTREL;
1094 elf_xtensa_allocate_plt_size (h, arg)
1095 struct elf_link_hash_entry *h;
1098 asection *srelplt = (asection *) arg;
1100 if (h->root.type == bfd_link_hash_warning)
1101 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1103 if (h->plt.refcount > 0)
1104 srelplt->_raw_size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1111 elf_xtensa_allocate_got_size (h, arg)
1112 struct elf_link_hash_entry *h;
1115 asection *srelgot = (asection *) arg;
1117 if (h->root.type == bfd_link_hash_warning)
1118 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1120 if (h->got.refcount > 0)
1121 srelgot->_raw_size += (h->got.refcount * sizeof (Elf32_External_Rela));
1128 elf_xtensa_allocate_local_got_size (info, srelgot)
1129 struct bfd_link_info *info;
1134 for (i = info->input_bfds; i; i = i->link_next)
1136 bfd_signed_vma *local_got_refcounts;
1137 bfd_size_type j, cnt;
1138 Elf_Internal_Shdr *symtab_hdr;
1140 local_got_refcounts = elf_local_got_refcounts (i);
1141 if (!local_got_refcounts)
1144 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1145 cnt = symtab_hdr->sh_info;
1147 for (j = 0; j < cnt; ++j)
1149 if (local_got_refcounts[j] > 0)
1150 srelgot->_raw_size += (local_got_refcounts[j]
1151 * sizeof (Elf32_External_Rela));
1157 /* Set the sizes of the dynamic sections. */
1160 elf_xtensa_size_dynamic_sections (output_bfd, info)
1161 bfd *output_bfd ATTRIBUTE_UNUSED;
1162 struct bfd_link_info *info;
1165 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1166 bfd_boolean relplt, relgot;
1167 int plt_entries, plt_chunks, chunk;
1173 dynobj = elf_hash_table (info)->dynobj;
1177 if (elf_hash_table (info)->dynamic_sections_created)
1179 /* Set the contents of the .interp section to the interpreter. */
1182 s = bfd_get_section_by_name (dynobj, ".interp");
1185 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1186 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1189 /* Allocate room for one word in ".got". */
1190 s = bfd_get_section_by_name (dynobj, ".got");
1195 /* Adjust refcounts for symbols that we now know are not "dynamic". */
1196 elf_link_hash_traverse (elf_hash_table (info),
1197 elf_xtensa_fix_refcounts,
1200 /* Allocate space in ".rela.got" for literals that reference
1202 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1203 if (srelgot == NULL)
1205 elf_link_hash_traverse (elf_hash_table (info),
1206 elf_xtensa_allocate_got_size,
1209 /* If we are generating a shared object, we also need space in
1210 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1211 reference local symbols. */
1213 elf_xtensa_allocate_local_got_size (info, srelgot);
1215 /* Allocate space in ".rela.plt" for literals that have PLT entries. */
1216 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1217 if (srelplt == NULL)
1219 elf_link_hash_traverse (elf_hash_table (info),
1220 elf_xtensa_allocate_plt_size,
1223 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1224 each PLT entry, we need the PLT code plus a 4-byte literal.
1225 For each chunk of ".plt", we also need two more 4-byte
1226 literals, two corresponding entries in ".rela.got", and an
1227 8-byte entry in ".xt.lit.plt". */
1228 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
1229 if (spltlittbl == NULL)
1232 plt_entries = srelplt->_raw_size / sizeof (Elf32_External_Rela);
1234 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1236 /* Iterate over all the PLT chunks, including any extra sections
1237 created earlier because the initial count of PLT relocations
1238 was an overestimate. */
1240 (splt = elf_xtensa_get_plt_section (dynobj, chunk)) != NULL;
1245 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1246 if (sgotplt == NULL)
1249 if (chunk < plt_chunks - 1)
1250 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1251 else if (chunk == plt_chunks - 1)
1252 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1256 if (chunk_entries != 0)
1258 sgotplt->_raw_size = 4 * (chunk_entries + 2);
1259 splt->_raw_size = PLT_ENTRY_SIZE * chunk_entries;
1260 srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela);
1261 spltlittbl->_raw_size += 8;
1265 sgotplt->_raw_size = 0;
1266 splt->_raw_size = 0;
1270 /* Allocate space in ".got.loc" to match the total size of all the
1272 sgotloc = bfd_get_section_by_name (dynobj, ".got.loc");
1273 if (sgotloc == NULL)
1275 sgotloc->_raw_size = spltlittbl->_raw_size;
1276 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1278 if (abfd->flags & DYNAMIC)
1280 for (s = abfd->sections; s != NULL; s = s->next)
1282 if (! elf_discarded_section (s)
1283 && xtensa_is_littable_section (s)
1285 sgotloc->_raw_size += s->_raw_size;
1290 /* Allocate memory for dynamic sections. */
1293 for (s = dynobj->sections; s != NULL; s = s->next)
1298 if ((s->flags & SEC_LINKER_CREATED) == 0)
1301 /* It's OK to base decisions on the section name, because none
1302 of the dynobj section names depend upon the input files. */
1303 name = bfd_get_section_name (dynobj, s);
1307 if (strncmp (name, ".rela", 5) == 0)
1309 if (strcmp (name, ".rela.plt") == 0)
1311 else if (strcmp (name, ".rela.got") == 0)
1314 /* We use the reloc_count field as a counter if we need
1315 to copy relocs into the output file. */
1318 else if (strncmp (name, ".plt.", 5) == 0
1319 || strncmp (name, ".got.plt.", 9) == 0)
1321 if (s->_raw_size == 0)
1323 /* If we don't need this section, strip it from the output
1324 file. We must create the ".plt*" and ".got.plt*"
1325 sections in create_dynamic_sections and/or check_relocs
1326 based on a conservative estimate of the PLT relocation
1327 count, because the sections must be created before the
1328 linker maps input sections to output sections. The
1329 linker does that before size_dynamic_sections, where we
1330 compute the exact size of the PLT, so there may be more
1331 of these sections than are actually needed. */
1335 else if (strcmp (name, ".got") != 0
1336 && strcmp (name, ".plt") != 0
1337 && strcmp (name, ".got.plt") != 0
1338 && strcmp (name, ".xt.lit.plt") != 0
1339 && strcmp (name, ".got.loc") != 0)
1341 /* It's not one of our sections, so don't allocate space. */
1346 _bfd_strip_section_from_output (info, s);
1349 /* Allocate memory for the section contents. */
1350 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1351 if (s->contents == NULL && s->_raw_size != 0)
1356 if (elf_hash_table (info)->dynamic_sections_created)
1358 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1359 known until finish_dynamic_sections, but we need to get the relocs
1360 in place before they are sorted. */
1361 if (srelgot == NULL)
1363 for (chunk = 0; chunk < plt_chunks; chunk++)
1365 Elf_Internal_Rela irela;
1369 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1372 loc = (srelgot->contents
1373 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1374 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1375 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1376 loc + sizeof (Elf32_External_Rela));
1377 srelgot->reloc_count += 2;
1380 /* Add some entries to the .dynamic section. We fill in the
1381 values later, in elf_xtensa_finish_dynamic_sections, but we
1382 must add the entries now so that we get the correct size for
1383 the .dynamic section. The DT_DEBUG entry is filled in by the
1384 dynamic linker and used by the debugger. */
1385 #define add_dynamic_entry(TAG, VAL) \
1386 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1390 if (!add_dynamic_entry (DT_DEBUG, 0))
1396 if (!add_dynamic_entry (DT_PLTGOT, 0)
1397 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1398 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1399 || !add_dynamic_entry (DT_JMPREL, 0))
1405 if (!add_dynamic_entry (DT_RELA, 0)
1406 || !add_dynamic_entry (DT_RELASZ, 0)
1407 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1411 if ((info->flags & DF_TEXTREL) != 0)
1413 if (!add_dynamic_entry (DT_TEXTREL, 0))
1417 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1418 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1421 #undef add_dynamic_entry
1427 /* Remove any PT_LOAD segments with no allocated sections. Prior to
1428 binutils 2.13, this function used to remove the non-SEC_ALLOC
1429 sections from PT_LOAD segments, but that task has now been moved
1430 into elf.c. We still need this function to remove any empty
1431 segments that result, but there's nothing Xtensa-specific about
1432 this and it probably ought to be moved into elf.c as well. */
1435 elf_xtensa_modify_segment_map (abfd)
1438 struct elf_segment_map **m_p;
1440 m_p = &elf_tdata (abfd)->segment_map;
1441 while (*m_p != NULL)
1443 if ((*m_p)->p_type == PT_LOAD && (*m_p)->count == 0)
1444 *m_p = (*m_p)->next;
1446 m_p = &(*m_p)->next;
1452 /* Perform the specified relocation. The instruction at (contents + address)
1453 is modified to set one operand to represent the value in "relocation". The
1454 operand position is determined by the relocation type recorded in the
1457 #define CALL_SEGMENT_BITS (30)
1458 #define CALL_SEGMENT_SIZE (1<<CALL_SEGMENT_BITS)
1460 static bfd_reloc_status_type
1461 elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
1462 contents, address, is_weak_undef, error_message)
1463 reloc_howto_type *howto;
1465 asection *input_section;
1469 bfd_boolean is_weak_undef;
1470 char **error_message;
1472 xtensa_opcode opcode;
1473 xtensa_operand operand;
1474 xtensa_encode_result encode_result;
1475 xtensa_isa isa = xtensa_default_isa;
1476 xtensa_insnbuf ibuff;
1477 bfd_vma self_address;
1481 switch (howto->type)
1484 return bfd_reloc_ok;
1486 case R_XTENSA_ASM_EXPAND:
1489 /* Check for windowed CALL across a 1GB boundary. */
1490 xtensa_opcode opcode =
1491 get_expanded_call_opcode (contents + address,
1492 input_section->_raw_size - address);
1493 if (is_windowed_call_opcode (opcode))
1495 self_address = (input_section->output_section->vma
1496 + input_section->output_offset
1498 if ((self_address >> CALL_SEGMENT_BITS) !=
1499 (relocation >> CALL_SEGMENT_BITS))
1501 *error_message = "windowed longcall crosses 1GB boundary; "
1503 return bfd_reloc_dangerous;
1507 return bfd_reloc_ok;
1509 case R_XTENSA_ASM_SIMPLIFY:
1511 /* Convert the L32R/CALLX to CALL. */
1512 bfd_reloc_status_type retval =
1513 elf_xtensa_do_asm_simplify (contents, address,
1514 input_section->_raw_size);
1515 if (retval != bfd_reloc_ok)
1518 /* The CALL needs to be relocated. Continue below for that part. */
1520 howto = &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
1528 x = bfd_get_32 (abfd, contents + address);
1530 bfd_put_32 (abfd, x, contents + address);
1532 return bfd_reloc_ok;
1535 /* Read the instruction into a buffer and decode the opcode. */
1536 ibuff = xtensa_insnbuf_alloc (isa);
1537 xtensa_insnbuf_from_chars (isa, ibuff, contents + address);
1538 opcode = xtensa_decode_insn (isa, ibuff);
1540 /* Determine which operand is being relocated. */
1541 if (opcode == XTENSA_UNDEFINED)
1543 *error_message = "cannot decode instruction";
1544 return bfd_reloc_dangerous;
1547 if (howto->type < R_XTENSA_OP0 || howto->type > R_XTENSA_OP2)
1549 *error_message = "unexpected relocation";
1550 return bfd_reloc_dangerous;
1553 opnd = howto->type - R_XTENSA_OP0;
1555 /* Calculate the PC address for this instruction. */
1556 if (!howto->pc_relative)
1558 *error_message = "expected PC-relative relocation";
1559 return bfd_reloc_dangerous;
1562 self_address = (input_section->output_section->vma
1563 + input_section->output_offset
1566 /* Apply the relocation. */
1567 operand = xtensa_get_operand (isa, opcode, opnd);
1568 newval = xtensa_operand_do_reloc (operand, relocation, self_address);
1569 encode_result = xtensa_operand_encode (operand, &newval);
1570 xtensa_operand_set_field (operand, ibuff, newval);
1572 /* Write the modified instruction back out of the buffer. */
1573 xtensa_insnbuf_to_chars (isa, ibuff, contents + address);
1576 if (encode_result != xtensa_encode_result_ok)
1578 char *message = build_encoding_error_message (opcode, encode_result);
1579 *error_message = message;
1580 return bfd_reloc_dangerous;
1583 /* Final check for call. */
1584 if (is_direct_call_opcode (opcode)
1585 && is_windowed_call_opcode (opcode))
1587 if ((self_address >> CALL_SEGMENT_BITS) !=
1588 (relocation >> CALL_SEGMENT_BITS))
1590 *error_message = "windowed call crosses 1GB boundary; "
1592 return bfd_reloc_dangerous;
1596 return bfd_reloc_ok;
1601 vsprint_msg VPARAMS ((const char *origmsg, const char *fmt, int arglen, ...))
1603 /* To reduce the size of the memory leak,
1604 we only use a single message buffer. */
1605 static bfd_size_type alloc_size = 0;
1606 static char *message = NULL;
1607 bfd_size_type orig_len, len = 0;
1608 bfd_boolean is_append;
1610 VA_OPEN (ap, arglen);
1611 VA_FIXEDARG (ap, const char *, origmsg);
1613 is_append = (origmsg == message);
1615 orig_len = strlen (origmsg);
1616 len = orig_len + strlen (fmt) + arglen + 20;
1617 if (len > alloc_size)
1619 message = (char *) bfd_realloc (message, len);
1623 memcpy (message, origmsg, orig_len);
1624 vsprintf (message + orig_len, fmt, ap);
1631 build_encoding_error_message (opcode, encode_result)
1632 xtensa_opcode opcode;
1633 xtensa_encode_result encode_result;
1635 const char *opname = xtensa_opcode_name (xtensa_default_isa, opcode);
1636 const char *msg = NULL;
1638 switch (encode_result)
1640 case xtensa_encode_result_ok:
1641 msg = "unexpected valid encoding";
1643 case xtensa_encode_result_align:
1644 msg = "misaligned encoding";
1646 case xtensa_encode_result_not_in_table:
1647 msg = "encoding not in lookup table";
1649 case xtensa_encode_result_too_low:
1650 msg = "encoding out of range: too low";
1652 case xtensa_encode_result_too_high:
1653 msg = "encoding out of range: too high";
1655 case xtensa_encode_result_not_ok:
1657 msg = "could not encode";
1661 if (is_direct_call_opcode (opcode)
1662 && (encode_result == xtensa_encode_result_too_low
1663 || encode_result == xtensa_encode_result_too_high))
1665 msg = "direct call out of range";
1667 else if (opcode == get_l32r_opcode ())
1669 /* L32Rs have the strange interaction with encoding in that they
1670 have an unsigned immediate field, so libisa returns "too high"
1671 when the absolute value is out of range and never returns "too
1672 low", but I leave the "too low" message in case anything
1674 if (encode_result == xtensa_encode_result_too_low)
1675 msg = "literal out of range";
1676 else if (encode_result == xtensa_encode_result_too_high)
1677 msg = "literal placed after use";
1680 return vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
1684 /* This function is registered as the "special_function" in the
1685 Xtensa howto for handling simplify operations.
1686 bfd_perform_relocation / bfd_install_relocation use it to
1687 perform (install) the specified relocation. Since this replaces the code
1688 in bfd_perform_relocation, it is basically an Xtensa-specific,
1689 stripped-down version of bfd_perform_relocation. */
1691 static bfd_reloc_status_type
1692 bfd_elf_xtensa_reloc (abfd, reloc_entry, symbol, data, input_section,
1693 output_bfd, error_message)
1695 arelent *reloc_entry;
1698 asection *input_section;
1700 char **error_message;
1703 bfd_reloc_status_type flag;
1704 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1705 bfd_vma output_base = 0;
1706 reloc_howto_type *howto = reloc_entry->howto;
1707 asection *reloc_target_output_section;
1708 bfd_boolean is_weak_undef;
1710 /* ELF relocs are against symbols. If we are producing relocatable
1711 output, and the reloc is against an external symbol, the resulting
1712 reloc will also be against the same symbol. In such a case, we
1713 don't want to change anything about the way the reloc is handled,
1714 since it will all be done at final link time. This test is similar
1715 to what bfd_elf_generic_reloc does except that it lets relocs with
1716 howto->partial_inplace go through even if the addend is non-zero.
1717 (The real problem is that partial_inplace is set for XTENSA_32
1718 relocs to begin with, but that's a long story and there's little we
1719 can do about it now....) */
1721 if (output_bfd != (bfd *) NULL
1722 && (symbol->flags & BSF_SECTION_SYM) == 0)
1724 reloc_entry->address += input_section->output_offset;
1725 return bfd_reloc_ok;
1728 /* Is the address of the relocation really within the section? */
1729 if (reloc_entry->address > (input_section->_cooked_size
1730 / bfd_octets_per_byte (abfd)))
1731 return bfd_reloc_outofrange;
1733 /* Work out which section the relocation is targetted at and the
1734 initial relocation command value. */
1736 /* Get symbol value. (Common symbols are special.) */
1737 if (bfd_is_com_section (symbol->section))
1740 relocation = symbol->value;
1742 reloc_target_output_section = symbol->section->output_section;
1744 /* Convert input-section-relative symbol value to absolute. */
1745 if ((output_bfd && !howto->partial_inplace)
1746 || reloc_target_output_section == NULL)
1749 output_base = reloc_target_output_section->vma;
1751 relocation += output_base + symbol->section->output_offset;
1753 /* Add in supplied addend. */
1754 relocation += reloc_entry->addend;
1756 /* Here the variable relocation holds the final address of the
1757 symbol we are relocating against, plus any addend. */
1760 if (!howto->partial_inplace)
1762 /* This is a partial relocation, and we want to apply the relocation
1763 to the reloc entry rather than the raw data. Everything except
1764 relocations against section symbols has already been handled
1767 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
1768 reloc_entry->addend = relocation;
1769 reloc_entry->address += input_section->output_offset;
1770 return bfd_reloc_ok;
1774 reloc_entry->address += input_section->output_offset;
1775 reloc_entry->addend = 0;
1779 is_weak_undef = (bfd_is_und_section (symbol->section)
1780 && (symbol->flags & BSF_WEAK) != 0);
1781 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
1782 (bfd_byte *) data, (bfd_vma) octets,
1783 is_weak_undef, error_message);
1785 if (flag == bfd_reloc_dangerous)
1787 /* Add the symbol name to the error message. */
1788 if (! *error_message)
1789 *error_message = "";
1790 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
1791 strlen (symbol->name) + 17,
1792 symbol->name, reloc_entry->addend);
1799 /* Set up an entry in the procedure linkage table. */
1802 elf_xtensa_create_plt_entry (dynobj, output_bfd, reloc_index)
1805 unsigned reloc_index;
1807 asection *splt, *sgotplt;
1808 bfd_vma plt_base, got_base;
1809 bfd_vma code_offset, lit_offset;
1812 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
1813 splt = elf_xtensa_get_plt_section (dynobj, chunk);
1814 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1815 BFD_ASSERT (splt != NULL && sgotplt != NULL);
1817 plt_base = splt->output_section->vma + splt->output_offset;
1818 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1820 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
1821 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
1823 /* Fill in the literal entry. This is the offset of the dynamic
1824 relocation entry. */
1825 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
1826 sgotplt->contents + lit_offset);
1828 /* Fill in the entry in the procedure linkage table. */
1829 memcpy (splt->contents + code_offset,
1830 (bfd_big_endian (output_bfd)
1831 ? elf_xtensa_be_plt_entry
1832 : elf_xtensa_le_plt_entry),
1834 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
1835 plt_base + code_offset + 3),
1836 splt->contents + code_offset + 4);
1837 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
1838 plt_base + code_offset + 6),
1839 splt->contents + code_offset + 7);
1840 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
1841 plt_base + code_offset + 9),
1842 splt->contents + code_offset + 10);
1844 return plt_base + code_offset;
1848 /* Relocate an Xtensa ELF section. This is invoked by the linker for
1849 both relocatable and final links. */
1852 elf_xtensa_relocate_section (output_bfd, info, input_bfd,
1853 input_section, contents, relocs,
1854 local_syms, local_sections)
1856 struct bfd_link_info *info;
1858 asection *input_section;
1860 Elf_Internal_Rela *relocs;
1861 Elf_Internal_Sym *local_syms;
1862 asection **local_sections;
1864 Elf_Internal_Shdr *symtab_hdr;
1865 Elf_Internal_Rela *rel;
1866 Elf_Internal_Rela *relend;
1867 struct elf_link_hash_entry **sym_hashes;
1868 asection *srelgot, *srelplt;
1870 char *error_message = NULL;
1872 if (xtensa_default_isa == NULL)
1875 dynobj = elf_hash_table (info)->dynobj;
1876 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1877 sym_hashes = elf_sym_hashes (input_bfd);
1883 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
1884 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1888 relend = relocs + input_section->reloc_count;
1889 for (; rel < relend; rel++)
1892 reloc_howto_type *howto;
1893 unsigned long r_symndx;
1894 struct elf_link_hash_entry *h;
1895 Elf_Internal_Sym *sym;
1898 bfd_reloc_status_type r;
1899 bfd_boolean is_weak_undef;
1900 bfd_boolean unresolved_reloc;
1903 r_type = ELF32_R_TYPE (rel->r_info);
1904 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
1905 || r_type == (int) R_XTENSA_GNU_VTENTRY)
1908 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
1910 bfd_set_error (bfd_error_bad_value);
1913 howto = &elf_howto_table[r_type];
1915 r_symndx = ELF32_R_SYM (rel->r_info);
1917 if (info->relocatable)
1919 /* This is a relocatable link.
1920 1) If the reloc is against a section symbol, adjust
1921 according to the output section.
1922 2) If there is a new target for this relocation,
1923 the new target will be in the same output section.
1924 We adjust the relocation by the output section
1927 if (relaxing_section)
1929 /* Check if this references a section in another input file. */
1930 do_fix_for_relocatable_link (rel, input_bfd, input_section);
1931 r_type = ELF32_R_TYPE (rel->r_info);
1934 if (r_type == R_XTENSA_ASM_SIMPLIFY)
1936 /* Convert ASM_SIMPLIFY into the simpler relocation
1937 so that they never escape a relaxing link. */
1938 contract_asm_expansion (contents, input_section->_raw_size, rel);
1939 r_type = ELF32_R_TYPE (rel->r_info);
1942 /* This is a relocatable link, so we don't have to change
1943 anything unless the reloc is against a section symbol,
1944 in which case we have to adjust according to where the
1945 section symbol winds up in the output section. */
1946 if (r_symndx < symtab_hdr->sh_info)
1948 sym = local_syms + r_symndx;
1949 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1951 sec = local_sections[r_symndx];
1952 rel->r_addend += sec->output_offset + sym->st_value;
1956 /* If there is an addend with a partial_inplace howto,
1957 then move the addend to the contents. This is a hack
1958 to work around problems with DWARF in relocatable links
1959 with some previous version of BFD. Now we can't easily get
1960 rid of the hack without breaking backward compatibility.... */
1963 howto = &elf_howto_table[r_type];
1964 if (howto->partial_inplace)
1966 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
1967 rel->r_addend, contents,
1968 rel->r_offset, FALSE,
1970 if (r != bfd_reloc_ok)
1972 if (!((*info->callbacks->reloc_dangerous)
1973 (info, error_message, input_bfd, input_section,
1981 /* Done with work for relocatable link; continue with next reloc. */
1985 /* This is a final link. */
1990 is_weak_undef = FALSE;
1991 unresolved_reloc = FALSE;
1994 if (howto->partial_inplace)
1996 /* Because R_XTENSA_32 was made partial_inplace to fix some
1997 problems with DWARF info in partial links, there may be
1998 an addend stored in the contents. Take it out of there
1999 and move it back into the addend field of the reloc. */
2000 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2001 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2004 if (r_symndx < symtab_hdr->sh_info)
2006 sym = local_syms + r_symndx;
2007 sec = local_sections[r_symndx];
2008 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
2012 RELOC_FOR_GLOBAL_SYMBOL (h, sym_hashes, r_symndx,
2013 symtab_hdr, relocation, sec,
2014 unresolved_reloc, info,
2018 && !unresolved_reloc
2019 && h->root.type == bfd_link_hash_undefweak)
2020 is_weak_undef = TRUE;
2023 if (relaxing_section)
2025 /* Check if this references a section in another input file. */
2026 do_fix_for_final_link (rel, input_section, &relocation);
2028 /* Update some already cached values. */
2029 r_type = ELF32_R_TYPE (rel->r_info);
2030 howto = &elf_howto_table[r_type];
2033 /* Sanity check the address. */
2034 if (rel->r_offset >= input_section->_raw_size
2035 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2037 bfd_set_error (bfd_error_bad_value);
2041 /* Generate dynamic relocations. */
2042 if (elf_hash_table (info)->dynamic_sections_created)
2044 bfd_boolean dynamic_symbol = xtensa_elf_dynamic_symbol_p (h, info);
2046 if (dynamic_symbol && (r_type == R_XTENSA_OP0
2047 || r_type == R_XTENSA_OP1
2048 || r_type == R_XTENSA_OP2))
2050 /* This is an error. The symbol's real value won't be known
2051 until runtime and it's likely to be out of range anyway. */
2052 const char *name = h->root.root.string;
2053 error_message = vsprint_msg ("invalid relocation for dynamic "
2055 strlen (name) + 2, name);
2056 if (!((*info->callbacks->reloc_dangerous)
2057 (info, error_message, input_bfd, input_section,
2061 else if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
2062 && (input_section->flags & SEC_ALLOC) != 0
2063 && (dynamic_symbol || info->shared))
2065 Elf_Internal_Rela outrel;
2069 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2074 BFD_ASSERT (srel != NULL);
2077 _bfd_elf_section_offset (output_bfd, info,
2078 input_section, rel->r_offset);
2080 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2081 memset (&outrel, 0, sizeof outrel);
2084 outrel.r_offset = (input_section->output_section->vma
2085 + input_section->output_offset);
2089 outrel.r_addend = rel->r_addend;
2092 if (r_type == R_XTENSA_32)
2095 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2098 else /* r_type == R_XTENSA_PLT */
2101 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2103 /* Create the PLT entry and set the initial
2104 contents of the literal entry to the address of
2107 elf_xtensa_create_plt_entry (dynobj, output_bfd,
2110 unresolved_reloc = FALSE;
2114 /* Generate a RELATIVE relocation. */
2115 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2116 outrel.r_addend = 0;
2120 loc = (srel->contents
2121 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2122 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2123 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2124 <= srel->_cooked_size);
2128 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2129 because such sections are not SEC_ALLOC and thus ld.so will
2130 not process them. */
2131 if (unresolved_reloc
2132 && !((input_section->flags & SEC_DEBUGGING) != 0
2133 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2134 (*_bfd_error_handler)
2135 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2136 bfd_archive_filename (input_bfd),
2137 bfd_get_section_name (input_bfd, input_section),
2138 (long) rel->r_offset,
2139 h->root.root.string);
2141 /* There's no point in calling bfd_perform_relocation here.
2142 Just go directly to our "special function". */
2143 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2144 relocation + rel->r_addend,
2145 contents, rel->r_offset, is_weak_undef,
2148 if (r != bfd_reloc_ok && !warned)
2152 BFD_ASSERT (r == bfd_reloc_dangerous);
2153 BFD_ASSERT (error_message != (char *) NULL);
2156 name = h->root.root.string;
2159 name = bfd_elf_string_from_elf_section
2160 (input_bfd, symtab_hdr->sh_link, sym->st_name);
2161 if (name && *name == '\0')
2162 name = bfd_section_name (input_bfd, sec);
2165 error_message = vsprint_msg (error_message, ": %s",
2166 strlen (name), name);
2167 if (!((*info->callbacks->reloc_dangerous)
2168 (info, error_message, input_bfd, input_section,
2178 /* Finish up dynamic symbol handling. There's not much to do here since
2179 the PLT and GOT entries are all set up by relocate_section. */
2182 elf_xtensa_finish_dynamic_symbol (output_bfd, info, h, sym)
2183 bfd *output_bfd ATTRIBUTE_UNUSED;
2184 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2185 struct elf_link_hash_entry *h;
2186 Elf_Internal_Sym *sym;
2188 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
2189 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2191 /* Mark the symbol as undefined, rather than as defined in
2192 the .plt section. Leave the value alone. */
2193 sym->st_shndx = SHN_UNDEF;
2196 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2197 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2198 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2199 sym->st_shndx = SHN_ABS;
2205 /* Combine adjacent literal table entries in the output. Adjacent
2206 entries within each input section may have been removed during
2207 relaxation, but we repeat the process here, even though it's too late
2208 to shrink the output section, because it's important to minimize the
2209 number of literal table entries to reduce the start-up work for the
2210 runtime linker. Returns the number of remaining table entries or -1
2214 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc)
2220 property_table_entry *table;
2221 bfd_size_type section_size, sgotloc_size;
2225 section_size = (sxtlit->_cooked_size != 0
2226 ? sxtlit->_cooked_size : sxtlit->_raw_size);
2227 BFD_ASSERT (section_size % 8 == 0);
2228 num = section_size / 8;
2230 sgotloc_size = (sgotloc->_cooked_size != 0
2231 ? sgotloc->_cooked_size : sgotloc->_raw_size);
2232 if (sgotloc_size != section_size)
2234 (*_bfd_error_handler)
2235 ("internal inconsistency in size of .got.loc section");
2239 contents = (bfd_byte *) bfd_malloc (section_size);
2240 table = (property_table_entry *)
2241 bfd_malloc (num * sizeof (property_table_entry));
2242 if (contents == 0 || table == 0)
2245 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
2246 propagates to the output section, where it doesn't really apply and
2247 where it breaks the following call to bfd_get_section_contents. */
2248 sxtlit->flags &= ~SEC_IN_MEMORY;
2250 if (! bfd_get_section_contents (output_bfd, sxtlit, contents, 0,
2254 /* There should never be any relocations left at this point, so this
2255 is quite a bit easier than what is done during relaxation. */
2257 /* Copy the raw contents into a property table array and sort it. */
2259 for (n = 0; n < num; n++)
2261 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
2262 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
2265 qsort (table, num, sizeof (property_table_entry), property_table_compare);
2267 for (n = 0; n < num; n++)
2269 bfd_boolean remove = FALSE;
2271 if (table[n].size == 0)
2274 (table[n-1].address + table[n-1].size == table[n].address))
2276 table[n-1].size += table[n].size;
2282 for (m = n; m < num - 1; m++)
2284 table[m].address = table[m+1].address;
2285 table[m].size = table[m+1].size;
2293 /* Copy the data back to the raw contents. */
2295 for (n = 0; n < num; n++)
2297 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
2298 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
2302 /* Clear the removed bytes. */
2303 if ((bfd_size_type) (num * 8) < section_size)
2305 memset (&contents[num * 8], 0, section_size - num * 8);
2306 sxtlit->_cooked_size = num * 8;
2309 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
2313 /* Copy the contents to ".got.loc". */
2314 memcpy (sgotloc->contents, contents, section_size);
2321 /* Finish up the dynamic sections. */
2324 elf_xtensa_finish_dynamic_sections (output_bfd, info)
2326 struct bfd_link_info *info;
2329 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
2330 Elf32_External_Dyn *dyncon, *dynconend;
2331 int num_xtlit_entries;
2333 if (! elf_hash_table (info)->dynamic_sections_created)
2336 dynobj = elf_hash_table (info)->dynobj;
2337 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2338 BFD_ASSERT (sdyn != NULL);
2340 /* Set the first entry in the global offset table to the address of
2341 the dynamic section. */
2342 sgot = bfd_get_section_by_name (dynobj, ".got");
2345 BFD_ASSERT (sgot->_raw_size == 4);
2347 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2349 bfd_put_32 (output_bfd,
2350 sdyn->output_section->vma + sdyn->output_offset,
2354 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
2355 if (srelplt != NULL && srelplt->_raw_size != 0)
2357 asection *sgotplt, *srelgot, *spltlittbl;
2358 int chunk, plt_chunks, plt_entries;
2359 Elf_Internal_Rela irela;
2361 unsigned rtld_reloc;
2363 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
2364 BFD_ASSERT (srelgot != NULL);
2366 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
2367 BFD_ASSERT (spltlittbl != NULL);
2369 /* Find the first XTENSA_RTLD relocation. Presumably the rest
2370 of them follow immediately after.... */
2371 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
2373 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2374 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2375 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
2378 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
2380 plt_entries = (srelplt->_raw_size / sizeof (Elf32_External_Rela));
2382 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
2384 for (chunk = 0; chunk < plt_chunks; chunk++)
2386 int chunk_entries = 0;
2388 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
2389 BFD_ASSERT (sgotplt != NULL);
2391 /* Emit special RTLD relocations for the first two entries in
2392 each chunk of the .got.plt section. */
2394 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2395 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2396 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2397 irela.r_offset = (sgotplt->output_section->vma
2398 + sgotplt->output_offset);
2399 irela.r_addend = 1; /* tell rtld to set value to resolver function */
2400 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2402 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2404 /* Next literal immediately follows the first. */
2405 loc += sizeof (Elf32_External_Rela);
2406 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2407 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2408 irela.r_offset = (sgotplt->output_section->vma
2409 + sgotplt->output_offset + 4);
2410 /* Tell rtld to set value to object's link map. */
2412 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2414 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2416 /* Fill in the literal table. */
2417 if (chunk < plt_chunks - 1)
2418 chunk_entries = PLT_ENTRIES_PER_CHUNK;
2420 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
2422 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->_cooked_size);
2423 bfd_put_32 (output_bfd,
2424 sgotplt->output_section->vma + sgotplt->output_offset,
2425 spltlittbl->contents + (chunk * 8) + 0);
2426 bfd_put_32 (output_bfd,
2427 8 + (chunk_entries * 4),
2428 spltlittbl->contents + (chunk * 8) + 4);
2431 /* All the dynamic relocations have been emitted at this point.
2432 Make sure the relocation sections are the correct size. */
2433 if (srelgot->_cooked_size != (sizeof (Elf32_External_Rela)
2434 * srelgot->reloc_count)
2435 || srelplt->_cooked_size != (sizeof (Elf32_External_Rela)
2436 * srelplt->reloc_count))
2439 /* The .xt.lit.plt section has just been modified. This must
2440 happen before the code below which combines adjacent literal
2441 table entries, and the .xt.lit.plt contents have to be forced to
2443 if (! bfd_set_section_contents (output_bfd,
2444 spltlittbl->output_section,
2445 spltlittbl->contents,
2446 spltlittbl->output_offset,
2447 spltlittbl->_raw_size))
2449 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
2450 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
2453 /* Combine adjacent literal table entries. */
2454 BFD_ASSERT (! info->relocatable);
2455 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
2456 sgotloc = bfd_get_section_by_name (dynobj, ".got.loc");
2457 BFD_ASSERT (sxtlit && sgotloc);
2459 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
2460 if (num_xtlit_entries < 0)
2463 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2464 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2465 for (; dyncon < dynconend; dyncon++)
2467 Elf_Internal_Dyn dyn;
2471 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2478 case DT_XTENSA_GOT_LOC_SZ:
2479 dyn.d_un.d_val = num_xtlit_entries;
2482 case DT_XTENSA_GOT_LOC_OFF:
2491 s = bfd_get_section_by_name (output_bfd, name);
2493 dyn.d_un.d_ptr = s->vma;
2497 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2499 dyn.d_un.d_val = (s->_cooked_size ? s->_cooked_size : s->_raw_size);
2503 /* Adjust RELASZ to not include JMPREL. This matches what
2504 glibc expects and what is done for several other ELF
2505 targets (e.g., i386, alpha), but the "correct" behavior
2506 seems to be unresolved. Since the linker script arranges
2507 for .rela.plt to follow all other relocation sections, we
2508 don't have to worry about changing the DT_RELA entry. */
2509 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2513 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
2518 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2525 /* Functions for dealing with the e_flags field. */
2527 /* Merge backend specific data from an object file to the output
2528 object file when linking. */
2531 elf_xtensa_merge_private_bfd_data (ibfd, obfd)
2535 unsigned out_mach, in_mach;
2536 flagword out_flag, in_flag;
2538 /* Check if we have the same endianess. */
2539 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
2542 /* Don't even pretend to support mixed-format linking. */
2543 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2544 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2547 out_flag = elf_elfheader (obfd)->e_flags;
2548 in_flag = elf_elfheader (ibfd)->e_flags;
2550 out_mach = out_flag & EF_XTENSA_MACH;
2551 in_mach = in_flag & EF_XTENSA_MACH;
2552 if (out_mach != in_mach)
2554 (*_bfd_error_handler)
2555 ("%s: incompatible machine type. Output is 0x%x. Input is 0x%x",
2556 bfd_archive_filename (ibfd), out_mach, in_mach);
2557 bfd_set_error (bfd_error_wrong_format);
2561 if (! elf_flags_init (obfd))
2563 elf_flags_init (obfd) = TRUE;
2564 elf_elfheader (obfd)->e_flags = in_flag;
2566 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2567 && bfd_get_arch_info (obfd)->the_default)
2568 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2569 bfd_get_mach (ibfd));
2574 if ((out_flag & EF_XTENSA_XT_INSN) !=
2575 (in_flag & EF_XTENSA_XT_INSN))
2576 elf_elfheader(obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
2578 if ((out_flag & EF_XTENSA_XT_LIT) !=
2579 (in_flag & EF_XTENSA_XT_LIT))
2580 elf_elfheader(obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
2587 elf_xtensa_set_private_flags (abfd, flags)
2591 BFD_ASSERT (!elf_flags_init (abfd)
2592 || elf_elfheader (abfd)->e_flags == flags);
2594 elf_elfheader (abfd)->e_flags |= flags;
2595 elf_flags_init (abfd) = TRUE;
2602 elf_xtensa_get_private_bfd_flags (abfd)
2605 return elf_elfheader (abfd)->e_flags;
2610 elf_xtensa_print_private_bfd_data (abfd, farg)
2614 FILE *f = (FILE *) farg;
2615 flagword e_flags = elf_elfheader (abfd)->e_flags;
2617 fprintf (f, "\nXtensa header:\n");
2618 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
2619 fprintf (f, "\nMachine = Base\n");
2621 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
2623 fprintf (f, "Insn tables = %s\n",
2624 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
2626 fprintf (f, "Literal tables = %s\n",
2627 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
2629 return _bfd_elf_print_private_bfd_data (abfd, farg);
2633 /* Set the right machine number for an Xtensa ELF file. */
2636 elf_xtensa_object_p (abfd)
2640 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
2645 mach = bfd_mach_xtensa;
2651 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
2656 /* The final processing done just before writing out an Xtensa ELF object
2657 file. This gets the Xtensa architecture right based on the machine
2661 elf_xtensa_final_write_processing (abfd, linker)
2663 bfd_boolean linker ATTRIBUTE_UNUSED;
2668 switch (mach = bfd_get_mach (abfd))
2670 case bfd_mach_xtensa:
2671 val = E_XTENSA_MACH;
2677 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
2678 elf_elfheader (abfd)->e_flags |= val;
2682 static enum elf_reloc_type_class
2683 elf_xtensa_reloc_type_class (rela)
2684 const Elf_Internal_Rela *rela;
2686 switch ((int) ELF32_R_TYPE (rela->r_info))
2688 case R_XTENSA_RELATIVE:
2689 return reloc_class_relative;
2690 case R_XTENSA_JMP_SLOT:
2691 return reloc_class_plt;
2693 return reloc_class_normal;
2699 elf_xtensa_discard_info_for_section (abfd, cookie, info, sec)
2701 struct elf_reloc_cookie *cookie;
2702 struct bfd_link_info *info;
2706 bfd_vma section_size;
2707 bfd_vma offset, actual_offset;
2708 size_t removed_bytes = 0;
2710 section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size);
2711 if (section_size == 0 || section_size % 8 != 0)
2714 if (sec->output_section
2715 && bfd_is_abs_section (sec->output_section))
2718 contents = retrieve_contents (abfd, sec, info->keep_memory);
2722 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
2725 release_contents (sec, contents);
2729 cookie->rel = cookie->rels;
2730 cookie->relend = cookie->rels + sec->reloc_count;
2732 for (offset = 0; offset < section_size; offset += 8)
2734 actual_offset = offset - removed_bytes;
2736 /* The ...symbol_deleted_p function will skip over relocs but it
2737 won't adjust their offsets, so do that here. */
2738 while (cookie->rel < cookie->relend
2739 && cookie->rel->r_offset < offset)
2741 cookie->rel->r_offset -= removed_bytes;
2745 while (cookie->rel < cookie->relend
2746 && cookie->rel->r_offset == offset)
2748 if (_bfd_elf32_reloc_symbol_deleted_p (offset, cookie))
2750 /* Remove the table entry. (If the reloc type is NONE, then
2751 the entry has already been merged with another and deleted
2752 during relaxation.) */
2753 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
2755 /* Shift the contents up. */
2756 if (offset + 8 < section_size)
2757 memmove (&contents[actual_offset],
2758 &contents[actual_offset+8],
2759 section_size - offset - 8);
2763 /* Remove this relocation. */
2764 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
2767 /* Adjust the relocation offset for previous removals. This
2768 should not be done before calling ...symbol_deleted_p
2769 because it might mess up the offset comparisons there.
2770 Make sure the offset doesn't underflow in the case where
2771 the first entry is removed. */
2772 if (cookie->rel->r_offset >= removed_bytes)
2773 cookie->rel->r_offset -= removed_bytes;
2775 cookie->rel->r_offset = 0;
2781 if (removed_bytes != 0)
2783 /* Adjust any remaining relocs (shouldn't be any). */
2784 for (; cookie->rel < cookie->relend; cookie->rel++)
2786 if (cookie->rel->r_offset >= removed_bytes)
2787 cookie->rel->r_offset -= removed_bytes;
2789 cookie->rel->r_offset = 0;
2792 /* Clear the removed bytes. */
2793 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
2795 pin_contents (sec, contents);
2796 pin_internal_relocs (sec, cookie->rels);
2798 sec->_cooked_size = section_size - removed_bytes;
2799 /* Also shrink _raw_size. See comments in relax_property_section. */
2800 sec->_raw_size = sec->_cooked_size;
2802 if (xtensa_is_littable_section (sec))
2804 bfd *dynobj = elf_hash_table (info)->dynobj;
2808 bfd_get_section_by_name (dynobj, ".got.loc");
2811 bfd_size_type sgotloc_size =
2812 (sgotloc->_cooked_size ? sgotloc->_cooked_size
2813 : sgotloc->_raw_size);
2814 sgotloc->_cooked_size = sgotloc_size - removed_bytes;
2815 sgotloc->_raw_size = sgotloc_size - removed_bytes;
2822 release_contents (sec, contents);
2823 release_internal_relocs (sec, cookie->rels);
2826 return (removed_bytes != 0);
2831 elf_xtensa_discard_info (abfd, cookie, info)
2833 struct elf_reloc_cookie *cookie;
2834 struct bfd_link_info *info;
2837 bfd_boolean changed = FALSE;
2839 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2841 if (xtensa_is_property_section (sec))
2843 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
2853 elf_xtensa_ignore_discarded_relocs (sec)
2856 return xtensa_is_property_section (sec);
2860 /* Support for core dump NOTE sections. */
2863 elf_xtensa_grok_prstatus (abfd, note)
2865 Elf_Internal_Note *note;
2868 unsigned int raw_size;
2870 /* The size for Xtensa is variable, so don't try to recognize the format
2871 based on the size. Just assume this is GNU/Linux. */
2874 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2877 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
2881 raw_size = note->descsz - offset - 4;
2883 /* Make a ".reg/999" section. */
2884 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2885 raw_size, note->descpos + offset);
2890 elf_xtensa_grok_psinfo (abfd, note)
2892 Elf_Internal_Note *note;
2894 switch (note->descsz)
2899 case 128: /* GNU/Linux elf_prpsinfo */
2900 elf_tdata (abfd)->core_program
2901 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
2902 elf_tdata (abfd)->core_command
2903 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
2906 /* Note that for some reason, a spurious space is tacked
2907 onto the end of the args in some (at least one anyway)
2908 implementations, so strip it off if it exists. */
2911 char *command = elf_tdata (abfd)->core_command;
2912 int n = strlen (command);
2914 if (0 < n && command[n - 1] == ' ')
2915 command[n - 1] = '\0';
2922 /* Generic Xtensa configurability stuff. */
2924 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
2925 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
2926 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
2927 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
2928 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
2929 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
2930 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
2931 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
2934 init_call_opcodes ()
2936 if (callx0_op == XTENSA_UNDEFINED)
2938 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
2939 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
2940 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
2941 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
2942 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
2943 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
2944 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
2945 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
2951 is_indirect_call_opcode (opcode)
2952 xtensa_opcode opcode;
2954 init_call_opcodes ();
2955 return (opcode == callx0_op
2956 || opcode == callx4_op
2957 || opcode == callx8_op
2958 || opcode == callx12_op);
2963 is_direct_call_opcode (opcode)
2964 xtensa_opcode opcode;
2966 init_call_opcodes ();
2967 return (opcode == call0_op
2968 || opcode == call4_op
2969 || opcode == call8_op
2970 || opcode == call12_op);
2975 is_windowed_call_opcode (opcode)
2976 xtensa_opcode opcode;
2978 init_call_opcodes ();
2979 return (opcode == call4_op
2980 || opcode == call8_op
2981 || opcode == call12_op
2982 || opcode == callx4_op
2983 || opcode == callx8_op
2984 || opcode == callx12_op);
2988 static xtensa_opcode
2989 get_l32r_opcode (void)
2991 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
2992 if (l32r_opcode == XTENSA_UNDEFINED)
2994 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
2995 BFD_ASSERT (l32r_opcode != XTENSA_UNDEFINED);
3002 l32r_offset (addr, pc)
3008 offset = addr - ((pc+3) & -4);
3009 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3010 offset = (signed int) offset >> 2;
3011 BFD_ASSERT ((signed int) offset >> 16 == -1);
3016 /* Get the operand number for a PC-relative relocation.
3017 If the relocation is not a PC-relative one, return (-1). */
3020 get_relocation_opnd (irel)
3021 Elf_Internal_Rela *irel;
3023 if (ELF32_R_TYPE (irel->r_info) < R_XTENSA_OP0
3024 || ELF32_R_TYPE (irel->r_info) >= R_XTENSA_max)
3026 return ELF32_R_TYPE (irel->r_info) - R_XTENSA_OP0;
3030 /* Get the opcode for a relocation. */
3032 static xtensa_opcode
3033 get_relocation_opcode (sec, contents, irel)
3036 Elf_Internal_Rela *irel;
3038 static xtensa_insnbuf ibuff = NULL;
3039 xtensa_isa isa = xtensa_default_isa;
3041 if (get_relocation_opnd (irel) == -1)
3042 return XTENSA_UNDEFINED;
3044 if (contents == NULL)
3045 return XTENSA_UNDEFINED;
3047 if (sec->_raw_size <= irel->r_offset)
3048 return XTENSA_UNDEFINED;
3051 ibuff = xtensa_insnbuf_alloc (isa);
3053 /* Decode the instruction. */
3054 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset]);
3055 return xtensa_decode_insn (isa, ibuff);
3060 is_l32r_relocation (sec, contents, irel)
3063 Elf_Internal_Rela *irel;
3065 xtensa_opcode opcode;
3067 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_OP1)
3070 opcode = get_relocation_opcode (sec, contents, irel);
3071 return (opcode == get_l32r_opcode ());
3075 /* Code for transforming CALLs at link-time. */
3077 static bfd_reloc_status_type
3078 elf_xtensa_do_asm_simplify (contents, address, content_length)
3081 bfd_vma content_length;
3083 static xtensa_insnbuf insnbuf = NULL;
3084 xtensa_opcode opcode;
3085 xtensa_operand operand;
3086 xtensa_opcode direct_call_opcode;
3087 xtensa_isa isa = xtensa_default_isa;
3088 bfd_byte *chbuf = contents + address;
3091 if (insnbuf == NULL)
3092 insnbuf = xtensa_insnbuf_alloc (isa);
3094 if (content_length < address)
3096 (*_bfd_error_handler)
3097 ("Attempt to convert L32R/CALLX to CALL failed");
3098 return bfd_reloc_other;
3101 opcode = get_expanded_call_opcode (chbuf, content_length - address);
3102 direct_call_opcode = swap_callx_for_call_opcode (opcode);
3103 if (direct_call_opcode == XTENSA_UNDEFINED)
3105 (*_bfd_error_handler)
3106 ("Attempt to convert L32R/CALLX to CALL failed");
3107 return bfd_reloc_other;
3110 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
3111 opcode = xtensa_opcode_lookup (isa, "or");
3112 xtensa_encode_insn (isa, opcode, insnbuf);
3113 for (opn = 0; opn < 3; opn++)
3115 operand = xtensa_get_operand (isa, opcode, opn);
3116 xtensa_operand_set_field (operand, insnbuf, 1);
3118 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf);
3120 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
3121 xtensa_encode_insn (isa, direct_call_opcode, insnbuf);
3122 operand = xtensa_get_operand (isa, opcode, 0);
3123 xtensa_operand_set_field (operand, insnbuf, 0);
3124 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3);
3126 return bfd_reloc_ok;
3130 static bfd_reloc_status_type
3131 contract_asm_expansion (contents, content_length, irel)
3133 bfd_vma content_length;
3134 Elf_Internal_Rela *irel;
3136 bfd_reloc_status_type retval =
3137 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length);
3139 if (retval != bfd_reloc_ok)
3142 /* Update the irel->r_offset field so that the right immediate and
3143 the right instruction are modified during the relocation. */
3144 irel->r_offset += 3;
3145 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_OP0);
3146 return bfd_reloc_ok;
3150 static xtensa_opcode
3151 swap_callx_for_call_opcode (opcode)
3152 xtensa_opcode opcode;
3154 init_call_opcodes ();
3156 if (opcode == callx0_op) return call0_op;
3157 if (opcode == callx4_op) return call4_op;
3158 if (opcode == callx8_op) return call8_op;
3159 if (opcode == callx12_op) return call12_op;
3161 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
3162 return XTENSA_UNDEFINED;
3166 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" sequence, and
3167 if so, return the CALLX opcode. If not, return XTENSA_UNDEFINED. */
3169 #define L32R_TARGET_REG_OPERAND 0
3170 #define CALLN_SOURCE_OPERAND 0
3172 static xtensa_opcode
3173 get_expanded_call_opcode (buf, bufsize)
3177 static xtensa_insnbuf insnbuf = NULL;
3178 xtensa_opcode opcode;
3179 xtensa_operand operand;
3180 xtensa_isa isa = xtensa_default_isa;
3181 uint32 regno, call_regno;
3183 /* Buffer must be at least 6 bytes. */
3185 return XTENSA_UNDEFINED;
3187 if (insnbuf == NULL)
3188 insnbuf = xtensa_insnbuf_alloc (isa);
3190 xtensa_insnbuf_from_chars (isa, insnbuf, buf);
3191 opcode = xtensa_decode_insn (isa, insnbuf);
3193 if (opcode != get_l32r_opcode ())
3194 return XTENSA_UNDEFINED;
3196 operand = xtensa_get_operand (isa, opcode, L32R_TARGET_REG_OPERAND);
3197 regno = xtensa_operand_decode
3198 (operand, xtensa_operand_get_field (operand, insnbuf));
3200 /* Next instruction should be an CALLXn with operand 0 == regno. */
3201 xtensa_insnbuf_from_chars (isa, insnbuf,
3202 buf + xtensa_insn_length (isa, opcode));
3203 opcode = xtensa_decode_insn (isa, insnbuf);
3205 if (!is_indirect_call_opcode (opcode))
3206 return XTENSA_UNDEFINED;
3208 operand = xtensa_get_operand (isa, opcode, CALLN_SOURCE_OPERAND);
3209 call_regno = xtensa_operand_decode
3210 (operand, xtensa_operand_get_field (operand, insnbuf));
3211 if (call_regno != regno)
3212 return XTENSA_UNDEFINED;
3218 /* Data structures used during relaxation. */
3220 /* r_reloc: relocation values. */
3222 /* Through the relaxation process, we need to keep track of the values
3223 that will result from evaluating relocations. The standard ELF
3224 relocation structure is not sufficient for this purpose because we're
3225 operating on multiple input files at once, so we need to know which
3226 input file a relocation refers to. The r_reloc structure thus
3227 records both the input file (bfd) and ELF relocation.
3229 For efficiency, an r_reloc also contains a "target_offset" field to
3230 cache the target-section-relative offset value that is represented by
3233 typedef struct r_reloc_struct r_reloc;
3235 struct r_reloc_struct
3238 Elf_Internal_Rela rela;
3239 bfd_vma target_offset;
3242 static bfd_boolean r_reloc_is_const
3243 PARAMS ((const r_reloc *));
3244 static void r_reloc_init
3245 PARAMS ((r_reloc *, bfd *, Elf_Internal_Rela *));
3246 static bfd_vma r_reloc_get_target_offset
3247 PARAMS ((const r_reloc *));
3248 static asection *r_reloc_get_section
3249 PARAMS ((const r_reloc *));
3250 static bfd_boolean r_reloc_is_defined
3251 PARAMS ((const r_reloc *));
3252 static struct elf_link_hash_entry *r_reloc_get_hash_entry
3253 PARAMS ((const r_reloc *));
3256 /* The r_reloc structure is included by value in literal_value, but not
3257 every literal_value has an associated relocation -- some are simple
3258 constants. In such cases, we set all the fields in the r_reloc
3259 struct to zero. The r_reloc_is_const function should be used to
3260 detect this case. */
3263 r_reloc_is_const (r_rel)
3264 const r_reloc *r_rel;
3266 return (r_rel->abfd == NULL);
3271 r_reloc_init (r_rel, abfd, irel)
3274 Elf_Internal_Rela *irel;
3278 r_rel->rela = *irel;
3280 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
3283 memset (r_rel, 0, sizeof (r_reloc));
3288 r_reloc_get_target_offset (r_rel)
3289 const r_reloc *r_rel;
3291 bfd_vma target_offset;
3292 unsigned long r_symndx;
3294 BFD_ASSERT (!r_reloc_is_const (r_rel));
3295 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3296 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
3297 return (target_offset + r_rel->rela.r_addend);
3301 static struct elf_link_hash_entry *
3302 r_reloc_get_hash_entry (r_rel)
3303 const r_reloc *r_rel;
3305 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3306 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
3311 r_reloc_get_section (r_rel)
3312 const r_reloc *r_rel;
3314 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3315 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
3320 r_reloc_is_defined (r_rel)
3321 const r_reloc *r_rel;
3323 asection *sec = r_reloc_get_section (r_rel);
3324 if (sec == bfd_abs_section_ptr
3325 || sec == bfd_com_section_ptr
3326 || sec == bfd_und_section_ptr)
3332 /* source_reloc: relocations that reference literal sections. */
3334 /* To determine whether literals can be coalesced, we need to first
3335 record all the relocations that reference the literals. The
3336 source_reloc structure below is used for this purpose. The
3337 source_reloc entries are kept in a per-literal-section array, sorted
3338 by offset within the literal section (i.e., target offset).
3340 The source_sec and r_rel.rela.r_offset fields identify the source of
3341 the relocation. The r_rel field records the relocation value, i.e.,
3342 the offset of the literal being referenced. The opnd field is needed
3343 to determine the range of the immediate field to which the relocation
3344 applies, so we can determine whether another literal with the same
3345 value is within range. The is_null field is true when the relocation
3346 is being removed (e.g., when an L32R is being removed due to a CALLX
3347 that is converted to a direct CALL). */
3349 typedef struct source_reloc_struct source_reloc;
3351 struct source_reloc_struct
3353 asection *source_sec;
3355 xtensa_operand opnd;
3356 bfd_boolean is_null;
3360 static void init_source_reloc
3361 PARAMS ((source_reloc *, asection *, const r_reloc *, xtensa_operand));
3362 static source_reloc *find_source_reloc
3363 PARAMS ((source_reloc *, int, asection *, Elf_Internal_Rela *));
3364 static int source_reloc_compare
3365 PARAMS ((const PTR, const PTR));
3369 init_source_reloc (reloc, source_sec, r_rel, opnd)
3370 source_reloc *reloc;
3371 asection *source_sec;
3372 const r_reloc *r_rel;
3373 xtensa_operand opnd;
3375 reloc->source_sec = source_sec;
3376 reloc->r_rel = *r_rel;
3378 reloc->is_null = FALSE;
3382 /* Find the source_reloc for a particular source offset and relocation
3383 type. Note that the array is sorted by _target_ offset, so this is
3384 just a linear search. */
3386 static source_reloc *
3387 find_source_reloc (src_relocs, src_count, sec, irel)
3388 source_reloc *src_relocs;
3391 Elf_Internal_Rela *irel;
3395 for (i = 0; i < src_count; i++)
3397 if (src_relocs[i].source_sec == sec
3398 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
3399 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
3400 == ELF32_R_TYPE (irel->r_info)))
3401 return &src_relocs[i];
3409 source_reloc_compare (ap, bp)
3413 const source_reloc *a = (const source_reloc *) ap;
3414 const source_reloc *b = (const source_reloc *) bp;
3416 return (a->r_rel.target_offset - b->r_rel.target_offset);
3420 /* Literal values and value hash tables. */
3422 /* Literals with the same value can be coalesced. The literal_value
3423 structure records the value of a literal: the "r_rel" field holds the
3424 information from the relocation on the literal (if there is one) and
3425 the "value" field holds the contents of the literal word itself.
3427 The value_map structure records a literal value along with the
3428 location of a literal holding that value. The value_map hash table
3429 is indexed by the literal value, so that we can quickly check if a
3430 particular literal value has been seen before and is thus a candidate
3433 typedef struct literal_value_struct literal_value;
3434 typedef struct value_map_struct value_map;
3435 typedef struct value_map_hash_table_struct value_map_hash_table;
3437 struct literal_value_struct
3440 unsigned long value;
3443 struct value_map_struct
3445 literal_value val; /* The literal value. */
3446 r_reloc loc; /* Location of the literal. */
3450 struct value_map_hash_table_struct
3452 unsigned bucket_count;
3453 value_map **buckets;
3458 static bfd_boolean is_same_value
3459 PARAMS ((const literal_value *, const literal_value *));
3460 static value_map_hash_table *value_map_hash_table_init
3462 static unsigned hash_literal_value
3463 PARAMS ((const literal_value *));
3464 static unsigned hash_bfd_vma
3466 static value_map *get_cached_value
3467 PARAMS ((value_map_hash_table *, const literal_value *));
3468 static value_map *add_value_map
3469 PARAMS ((value_map_hash_table *, const literal_value *, const r_reloc *));
3473 is_same_value (src1, src2)
3474 const literal_value *src1;
3475 const literal_value *src2;
3477 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
3480 if (r_reloc_is_const (&src1->r_rel))
3481 return (src1->value == src2->value);
3483 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
3484 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
3487 if (r_reloc_get_target_offset (&src1->r_rel)
3488 != r_reloc_get_target_offset (&src2->r_rel))
3491 if (src1->value != src2->value)
3494 /* Now check for the same section and the same elf_hash. */
3495 if (r_reloc_is_defined (&src1->r_rel))
3497 if (r_reloc_get_section (&src1->r_rel)
3498 != r_reloc_get_section (&src2->r_rel))
3503 if (r_reloc_get_hash_entry (&src1->r_rel)
3504 != r_reloc_get_hash_entry (&src2->r_rel))
3507 if (r_reloc_get_hash_entry (&src1->r_rel) == 0)
3515 /* Must be power of 2. */
3516 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
3518 static value_map_hash_table *
3519 value_map_hash_table_init ()
3521 value_map_hash_table *values;
3523 values = (value_map_hash_table *)
3524 bfd_malloc (sizeof (value_map_hash_table));
3526 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
3528 values->buckets = (value_map **)
3529 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
3539 return (val >> 2) + (val >> 10);
3544 hash_literal_value (src)
3545 const literal_value *src;
3549 if (r_reloc_is_const (&src->r_rel))
3550 return hash_bfd_vma (src->value);
3552 hash_val = (hash_bfd_vma (r_reloc_get_target_offset (&src->r_rel))
3553 + hash_bfd_vma (src->value));
3555 /* Now check for the same section and the same elf_hash. */
3556 if (r_reloc_is_defined (&src->r_rel))
3557 hash_val += hash_bfd_vma ((bfd_vma) (unsigned) r_reloc_get_section (&src->r_rel));
3559 hash_val += hash_bfd_vma ((bfd_vma) (unsigned) r_reloc_get_hash_entry (&src->r_rel));
3565 /* Check if the specified literal_value has been seen before. */
3568 get_cached_value (map, val)
3569 value_map_hash_table *map;
3570 const literal_value *val;
3576 idx = hash_literal_value (val);
3577 idx = idx & (map->bucket_count - 1);
3578 bucket = map->buckets[idx];
3579 for (map_e = bucket; map_e; map_e = map_e->next)
3581 if (is_same_value (&map_e->val, val))
3588 /* Record a new literal value. It is illegal to call this if VALUE
3589 already has an entry here. */
3592 add_value_map (map, val, loc)
3593 value_map_hash_table *map;
3594 const literal_value *val;
3597 value_map **bucket_p;
3600 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
3602 BFD_ASSERT (get_cached_value (map, val) == NULL);
3606 idx = hash_literal_value (val);
3607 idx = idx & (map->bucket_count - 1);
3608 bucket_p = &map->buckets[idx];
3610 val_e->next = *bucket_p;
3613 /* FIXME: consider resizing the hash table if we get too many entries */
3619 /* Lists of literals being coalesced or removed. */
3621 /* In the usual case, the literal identified by "from" is being
3622 coalesced with another literal identified by "to". If the literal is
3623 unused and is being removed altogether, "to.abfd" will be NULL.
3624 The removed_literal entries are kept on a per-section list, sorted
3625 by the "from" offset field. */
3627 typedef struct removed_literal_struct removed_literal;
3628 typedef struct removed_literal_list_struct removed_literal_list;
3630 struct removed_literal_struct
3634 removed_literal *next;
3637 struct removed_literal_list_struct
3639 removed_literal *head;
3640 removed_literal *tail;
3644 static void add_removed_literal
3645 PARAMS ((removed_literal_list *, const r_reloc *, const r_reloc *));
3646 static removed_literal *find_removed_literal
3647 PARAMS ((removed_literal_list *, bfd_vma));
3648 static bfd_vma offset_with_removed_literals
3649 PARAMS ((removed_literal_list *, bfd_vma));
3652 /* Record that the literal at "from" is being removed. If "to" is not
3653 NULL, the "from" literal is being coalesced with the "to" literal. */
3656 add_removed_literal (removed_list, from, to)
3657 removed_literal_list *removed_list;
3658 const r_reloc *from;
3661 removed_literal *r, *new_r, *next_r;
3663 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
3665 new_r->from = *from;
3669 new_r->to.abfd = NULL;
3672 r = removed_list->head;
3675 removed_list->head = new_r;
3676 removed_list->tail = new_r;
3678 /* Special check for common case of append. */
3679 else if (removed_list->tail->from.target_offset < from->target_offset)
3681 removed_list->tail->next = new_r;
3682 removed_list->tail = new_r;
3686 while (r->from.target_offset < from->target_offset
3693 new_r->next = next_r;
3695 removed_list->tail = new_r;
3700 /* Check if the list of removed literals contains an entry for the
3701 given address. Return the entry if found. */
3703 static removed_literal *
3704 find_removed_literal (removed_list, addr)
3705 removed_literal_list *removed_list;
3708 removed_literal *r = removed_list->head;
3709 while (r && r->from.target_offset < addr)
3711 if (r && r->from.target_offset == addr)
3717 /* Adjust an offset in a section to compensate for literals that are
3718 being removed. Search the list of removed literals and subtract
3719 4 bytes for every removed literal prior to the given address. */
3722 offset_with_removed_literals (removed_list, addr)
3723 removed_literal_list *removed_list;
3726 removed_literal *r = removed_list->head;
3727 unsigned num_bytes = 0;
3732 while (r && r->from.target_offset <= addr)
3737 if (num_bytes > addr)
3739 return (addr - num_bytes);
3743 /* Coalescing literals may require a relocation to refer to a section in
3744 a different input file, but the standard relocation information
3745 cannot express that. Instead, the reloc_bfd_fix structures are used
3746 to "fix" the relocations that refer to sections in other input files.
3747 These structures are kept on per-section lists. The "src_type" field
3748 records the relocation type in case there are multiple relocations on
3749 the same location. FIXME: This is ugly; an alternative might be to
3750 add new symbols with the "owner" field to some other input file. */
3752 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
3754 struct reloc_bfd_fix_struct
3758 unsigned src_type; /* Relocation type. */
3761 asection *target_sec;
3762 bfd_vma target_offset;
3764 reloc_bfd_fix *next;
3768 static reloc_bfd_fix *reloc_bfd_fix_init
3769 PARAMS ((asection *, bfd_vma, unsigned, bfd *, asection *, bfd_vma));
3770 static reloc_bfd_fix *get_bfd_fix
3771 PARAMS ((reloc_bfd_fix *, asection *, bfd_vma, unsigned));
3774 static reloc_bfd_fix *
3775 reloc_bfd_fix_init (src_sec, src_offset, src_type,
3776 target_abfd, target_sec, target_offset)
3781 asection *target_sec;
3782 bfd_vma target_offset;
3786 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
3787 fix->src_sec = src_sec;
3788 fix->src_offset = src_offset;
3789 fix->src_type = src_type;
3790 fix->target_abfd = target_abfd;
3791 fix->target_sec = target_sec;
3792 fix->target_offset = target_offset;
3798 static reloc_bfd_fix *
3799 get_bfd_fix (fix_list, sec, offset, type)
3800 reloc_bfd_fix *fix_list;
3807 for (r = fix_list; r != NULL; r = r->next)
3809 if (r->src_sec == sec
3810 && r->src_offset == offset
3811 && r->src_type == type)
3818 /* Per-section data for relaxation. */
3820 struct xtensa_relax_info_struct
3822 bfd_boolean is_relaxable_literal_section;
3823 int visited; /* Number of times visited. */
3825 source_reloc *src_relocs; /* Array[src_count]. */
3827 int src_next; /* Next src_relocs entry to assign. */
3829 removed_literal_list removed_list;
3831 reloc_bfd_fix *fix_list;
3834 struct elf_xtensa_section_data
3836 struct bfd_elf_section_data elf;
3837 xtensa_relax_info relax_info;
3840 static void init_xtensa_relax_info
3841 PARAMS ((asection *));
3842 static xtensa_relax_info *get_xtensa_relax_info
3843 PARAMS ((asection *));
3845 PARAMS ((asection *, reloc_bfd_fix *));
3849 elf_xtensa_new_section_hook (abfd, sec)
3853 struct elf_xtensa_section_data *sdata;
3854 bfd_size_type amt = sizeof (*sdata);
3856 sdata = (struct elf_xtensa_section_data *) bfd_zalloc (abfd, amt);
3859 sec->used_by_bfd = (PTR) sdata;
3861 return _bfd_elf_new_section_hook (abfd, sec);
3866 init_xtensa_relax_info (sec)
3869 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
3871 relax_info->is_relaxable_literal_section = FALSE;
3872 relax_info->visited = 0;
3874 relax_info->src_relocs = NULL;
3875 relax_info->src_count = 0;
3876 relax_info->src_next = 0;
3878 relax_info->removed_list.head = NULL;
3879 relax_info->removed_list.tail = NULL;
3881 relax_info->fix_list = NULL;
3885 static xtensa_relax_info *
3886 get_xtensa_relax_info (sec)
3889 struct elf_xtensa_section_data *section_data;
3891 /* No info available if no section or if it is an output section. */
3892 if (!sec || sec == sec->output_section)
3895 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
3896 return §ion_data->relax_info;
3901 add_fix (src_sec, fix)
3905 xtensa_relax_info *relax_info;
3907 relax_info = get_xtensa_relax_info (src_sec);
3908 fix->next = relax_info->fix_list;
3909 relax_info->fix_list = fix;
3913 /* Access to internal relocations, section contents and symbols. */
3915 /* During relaxation, we need to modify relocations, section contents,
3916 and symbol definitions, and we need to keep the original values from
3917 being reloaded from the input files, i.e., we need to "pin" the
3918 modified values in memory. We also want to continue to observe the
3919 setting of the "keep-memory" flag. The following functions wrap the
3920 standard BFD functions to take care of this for us. */
3922 static Elf_Internal_Rela *
3923 retrieve_internal_relocs (abfd, sec, keep_memory)
3926 bfd_boolean keep_memory;
3928 Elf_Internal_Rela *internal_relocs;
3930 if ((sec->flags & SEC_LINKER_CREATED) != 0)
3933 internal_relocs = elf_section_data (sec)->relocs;
3934 if (internal_relocs == NULL)
3935 internal_relocs = (_bfd_elf_link_read_relocs
3936 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
3938 return internal_relocs;
3943 pin_internal_relocs (sec, internal_relocs)
3945 Elf_Internal_Rela *internal_relocs;
3947 elf_section_data (sec)->relocs = internal_relocs;
3952 release_internal_relocs (sec, internal_relocs)
3954 Elf_Internal_Rela *internal_relocs;
3957 && elf_section_data (sec)->relocs != internal_relocs)
3958 free (internal_relocs);
3963 retrieve_contents (abfd, sec, keep_memory)
3966 bfd_boolean keep_memory;
3970 contents = elf_section_data (sec)->this_hdr.contents;
3972 if (contents == NULL && sec->_raw_size != 0)
3974 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
3975 if (contents != NULL)
3977 if (! bfd_get_section_contents (abfd, sec, contents,
3978 (file_ptr) 0, sec->_raw_size))
3984 elf_section_data (sec)->this_hdr.contents = contents;
3992 pin_contents (sec, contents)
3996 elf_section_data (sec)->this_hdr.contents = contents;
4001 release_contents (sec, contents)
4006 elf_section_data (sec)->this_hdr.contents != contents)
4011 static Elf_Internal_Sym *
4012 retrieve_local_syms (input_bfd)
4015 Elf_Internal_Shdr *symtab_hdr;
4016 Elf_Internal_Sym *isymbuf;
4019 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4020 locsymcount = symtab_hdr->sh_info;
4022 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4023 if (isymbuf == NULL && locsymcount != 0)
4024 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
4027 /* Save the symbols for this input file so they won't be read again. */
4028 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
4029 symtab_hdr->contents = (unsigned char *) isymbuf;
4035 /* Code for link-time relaxation. */
4037 /* Local helper functions. */
4038 static bfd_boolean analyze_relocations
4039 PARAMS ((struct bfd_link_info *));
4040 static bfd_boolean find_relaxable_sections
4041 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
4042 static bfd_boolean collect_source_relocs
4043 PARAMS ((bfd *, asection *, struct bfd_link_info *));
4044 static bfd_boolean is_resolvable_asm_expansion
4045 PARAMS ((bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
4046 struct bfd_link_info *, bfd_boolean *));
4047 static bfd_boolean remove_literals
4048 PARAMS ((bfd *, asection *, struct bfd_link_info *, value_map_hash_table *));
4049 static bfd_boolean relax_section
4050 PARAMS ((bfd *, asection *, struct bfd_link_info *));
4051 static bfd_boolean relax_property_section
4052 PARAMS ((bfd *, asection *, struct bfd_link_info *));
4053 static bfd_boolean relax_section_symbols
4054 PARAMS ((bfd *, asection *));
4055 static bfd_boolean relocations_reach
4056 PARAMS ((source_reloc *, int, const r_reloc *));
4057 static void translate_reloc
4058 PARAMS ((const r_reloc *, r_reloc *));
4059 static Elf_Internal_Rela *get_irel_at_offset
4060 PARAMS ((asection *, Elf_Internal_Rela *, bfd_vma));
4061 static Elf_Internal_Rela *find_associated_l32r_irel
4062 PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *,
4063 Elf_Internal_Rela *));
4064 static void shrink_dynamic_reloc_sections
4065 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *));
4069 elf_xtensa_relax_section (abfd, sec, link_info, again)
4072 struct bfd_link_info *link_info;
4075 static value_map_hash_table *values = NULL;
4076 xtensa_relax_info *relax_info;
4080 /* Do some overall initialization for relaxation. */
4081 values = value_map_hash_table_init ();
4082 relaxing_section = TRUE;
4083 if (!analyze_relocations (link_info))
4088 /* Don't mess with linker-created sections. */
4089 if ((sec->flags & SEC_LINKER_CREATED) != 0)
4092 relax_info = get_xtensa_relax_info (sec);
4093 BFD_ASSERT (relax_info != NULL);
4095 switch (relax_info->visited)
4098 /* Note: It would be nice to fold this pass into
4099 analyze_relocations, but it is important for this step that the
4100 sections be examined in link order. */
4101 if (!remove_literals (abfd, sec, link_info, values))
4107 if (!relax_section (abfd, sec, link_info))
4113 if (!relax_section_symbols (abfd, sec))
4118 relax_info->visited++;
4122 /* Initialization for relaxation. */
4124 /* This function is called once at the start of relaxation. It scans
4125 all the input sections and marks the ones that are relaxable (i.e.,
4126 literal sections with L32R relocations against them). It then
4127 collect source_reloc information for all the relocations against
4128 those relaxable sections. */
4131 analyze_relocations (link_info)
4132 struct bfd_link_info *link_info;
4136 bfd_boolean is_relaxable = FALSE;
4138 /* Initialize the per-section relaxation info. */
4139 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4140 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4142 init_xtensa_relax_info (sec);
4145 /* Mark relaxable sections (and count relocations against each one). */
4146 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4147 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4149 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
4153 /* Bail out if there are no relaxable sections. */
4157 /* Allocate space for source_relocs. */
4158 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4159 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4161 xtensa_relax_info *relax_info;
4163 relax_info = get_xtensa_relax_info (sec);
4164 if (relax_info->is_relaxable_literal_section)
4166 relax_info->src_relocs = (source_reloc *)
4167 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
4171 /* Collect info on relocations against each relaxable section. */
4172 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4173 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4175 if (!collect_source_relocs (abfd, sec, link_info))
4183 /* Find all the literal sections that might be relaxed. The motivation
4184 for this pass is that collect_source_relocs() needs to record _all_
4185 the relocations that target each relaxable section. That is
4186 expensive and unnecessary unless the target section is actually going
4187 to be relaxed. This pass identifies all such sections by checking if
4188 they have L32Rs pointing to them. In the process, the total number
4189 of relocations targetting each section is also counted so that we
4190 know how much space to allocate for source_relocs against each
4191 relaxable literal section. */
4194 find_relaxable_sections (abfd, sec, link_info, is_relaxable_p)
4197 struct bfd_link_info *link_info;
4198 bfd_boolean *is_relaxable_p;
4200 Elf_Internal_Rela *internal_relocs;
4202 bfd_boolean ok = TRUE;
4205 internal_relocs = retrieve_internal_relocs (abfd, sec,
4206 link_info->keep_memory);
4207 if (internal_relocs == NULL)
4210 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4211 if (contents == NULL && sec->_raw_size != 0)
4217 for (i = 0; i < sec->reloc_count; i++)
4219 Elf_Internal_Rela *irel = &internal_relocs[i];
4221 asection *target_sec;
4222 xtensa_relax_info *target_relax_info;
4224 r_reloc_init (&r_rel, abfd, irel);
4226 target_sec = r_reloc_get_section (&r_rel);
4227 target_relax_info = get_xtensa_relax_info (target_sec);
4228 if (!target_relax_info)
4231 /* Count relocations against the target section. */
4232 target_relax_info->src_count++;
4234 if (is_literal_section (target_sec)
4235 && is_l32r_relocation (sec, contents, irel)
4236 && r_reloc_is_defined (&r_rel))
4238 /* Mark the target section as relaxable. */
4239 target_relax_info->is_relaxable_literal_section = TRUE;
4240 *is_relaxable_p = TRUE;
4245 release_contents (sec, contents);
4246 release_internal_relocs (sec, internal_relocs);
4251 /* Record _all_ the relocations that point to relaxable literal
4252 sections, and get rid of ASM_EXPAND relocs by either converting them
4253 to ASM_SIMPLIFY or by removing them. */
4256 collect_source_relocs (abfd, sec, link_info)
4259 struct bfd_link_info *link_info;
4261 Elf_Internal_Rela *internal_relocs;
4263 bfd_boolean ok = TRUE;
4266 internal_relocs = retrieve_internal_relocs (abfd, sec,
4267 link_info->keep_memory);
4268 if (internal_relocs == NULL)
4271 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4272 if (contents == NULL && sec->_raw_size != 0)
4278 /* Record relocations against relaxable literal sections. */
4279 for (i = 0; i < sec->reloc_count; i++)
4281 Elf_Internal_Rela *irel = &internal_relocs[i];
4283 asection *target_sec;
4284 xtensa_relax_info *target_relax_info;
4286 r_reloc_init (&r_rel, abfd, irel);
4288 target_sec = r_reloc_get_section (&r_rel);
4289 target_relax_info = get_xtensa_relax_info (target_sec);
4291 if (target_relax_info
4292 && target_relax_info->is_relaxable_literal_section)
4294 xtensa_opcode opcode;
4295 xtensa_operand opnd;
4296 source_reloc *s_reloc;
4299 src_next = target_relax_info->src_next++;
4300 s_reloc = &target_relax_info->src_relocs[src_next];
4302 opcode = get_relocation_opcode (sec, contents, irel);
4303 if (opcode == XTENSA_UNDEFINED)
4306 opnd = xtensa_get_operand (xtensa_default_isa, opcode,
4307 get_relocation_opnd (irel));
4309 init_source_reloc (s_reloc, sec, &r_rel, opnd);
4313 /* Now get rid of ASM_EXPAND relocations. At this point, the
4314 src_relocs array for the target literal section may still be
4315 incomplete, but it must at least contain the entries for the L32R
4316 relocations associated with ASM_EXPANDs because they were just
4317 added in the preceding loop over the relocations. */
4319 for (i = 0; i < sec->reloc_count; i++)
4321 Elf_Internal_Rela *irel = &internal_relocs[i];
4322 bfd_boolean is_reachable;
4324 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
4330 Elf_Internal_Rela *l32r_irel;
4332 asection *target_sec;
4333 xtensa_relax_info *target_relax_info;
4335 /* Mark the source_reloc for the L32R so that it will be
4336 removed in remove_literals(), along with the associated
4338 l32r_irel = find_associated_l32r_irel (sec, contents,
4339 irel, internal_relocs);
4340 if (l32r_irel == NULL)
4343 r_reloc_init (&r_rel, abfd, l32r_irel);
4345 target_sec = r_reloc_get_section (&r_rel);
4346 target_relax_info = get_xtensa_relax_info (target_sec);
4348 if (target_relax_info
4349 && target_relax_info->is_relaxable_literal_section)
4351 source_reloc *s_reloc;
4353 /* Search the source_relocs for the entry corresponding to
4354 the l32r_irel. Note: The src_relocs array is not yet
4355 sorted, but it wouldn't matter anyway because we're
4356 searching by source offset instead of target offset. */
4357 s_reloc = find_source_reloc (target_relax_info->src_relocs,
4358 target_relax_info->src_next,
4360 BFD_ASSERT (s_reloc);
4361 s_reloc->is_null = TRUE;
4364 /* Convert this reloc to ASM_SIMPLIFY. */
4365 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4366 R_XTENSA_ASM_SIMPLIFY);
4367 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4369 pin_internal_relocs (sec, internal_relocs);
4373 /* It is resolvable but doesn't reach. We resolve now
4374 by eliminating the relocation -- the call will remain
4375 expanded into L32R/CALLX. */
4376 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4377 pin_internal_relocs (sec, internal_relocs);
4382 release_contents (sec, contents);
4383 release_internal_relocs (sec, internal_relocs);
4388 /* Return TRUE if the asm expansion can be resolved. Generally it can
4389 be resolved on a final link or when a partial link locates it in the
4390 same section as the target. Set "is_reachable" flag if the target of
4391 the call is within the range of a direct call, given the current VMA
4392 for this section and the target section. */
4395 is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
4400 Elf_Internal_Rela *irel;
4401 struct bfd_link_info *link_info;
4402 bfd_boolean *is_reachable_p;
4404 asection *target_sec;
4405 bfd_vma target_offset;
4407 xtensa_opcode opcode, direct_call_opcode;
4408 bfd_vma self_address;
4409 bfd_vma dest_address;
4411 *is_reachable_p = FALSE;
4413 if (contents == NULL)
4416 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
4419 opcode = get_expanded_call_opcode (contents + irel->r_offset,
4420 sec->_raw_size - irel->r_offset);
4422 direct_call_opcode = swap_callx_for_call_opcode (opcode);
4423 if (direct_call_opcode == XTENSA_UNDEFINED)
4426 /* Check and see that the target resolves. */
4427 r_reloc_init (&r_rel, abfd, irel);
4428 if (!r_reloc_is_defined (&r_rel))
4431 target_sec = r_reloc_get_section (&r_rel);
4432 target_offset = r_reloc_get_target_offset (&r_rel);
4434 /* If the target is in a shared library, then it doesn't reach. This
4435 isn't supposed to come up because the compiler should never generate
4436 non-PIC calls on systems that use shared libraries, but the linker
4437 shouldn't crash regardless. */
4438 if (!target_sec->output_section)
4441 /* For relocatable sections, we can only simplify when the output
4442 section of the target is the same as the output section of the
4444 if (link_info->relocatable
4445 && (target_sec->output_section != sec->output_section))
4448 self_address = (sec->output_section->vma
4449 + sec->output_offset + irel->r_offset + 3);
4450 dest_address = (target_sec->output_section->vma
4451 + target_sec->output_offset + target_offset);
4453 *is_reachable_p = pcrel_reloc_fits
4454 (xtensa_get_operand (xtensa_default_isa, direct_call_opcode, 0),
4455 self_address, dest_address);
4457 if ((self_address >> CALL_SEGMENT_BITS) !=
4458 (dest_address >> CALL_SEGMENT_BITS))
4465 static Elf_Internal_Rela *
4466 find_associated_l32r_irel (sec, contents, other_irel, internal_relocs)
4469 Elf_Internal_Rela *other_irel;
4470 Elf_Internal_Rela *internal_relocs;
4474 for (i = 0; i < sec->reloc_count; i++)
4476 Elf_Internal_Rela *irel = &internal_relocs[i];
4478 if (irel == other_irel)
4480 if (irel->r_offset != other_irel->r_offset)
4482 if (is_l32r_relocation (sec, contents, irel))
4489 /* First relaxation pass. */
4491 /* If the section is relaxable (i.e., a literal section), check each
4492 literal to see if it has the same value as another literal that has
4493 already been seen, either in the current section or a previous one.
4494 If so, add an entry to the per-section list of removed literals. The
4495 actual changes are deferred until the next pass. */
4498 remove_literals (abfd, sec, link_info, values)
4501 struct bfd_link_info *link_info;
4502 value_map_hash_table *values;
4504 xtensa_relax_info *relax_info;
4506 Elf_Internal_Rela *internal_relocs;
4507 source_reloc *src_relocs;
4508 bfd_boolean ok = TRUE;
4511 /* Do nothing if it is not a relaxable literal section. */
4512 relax_info = get_xtensa_relax_info (sec);
4513 BFD_ASSERT (relax_info);
4515 if (!relax_info->is_relaxable_literal_section)
4518 internal_relocs = retrieve_internal_relocs (abfd, sec,
4519 link_info->keep_memory);
4521 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4522 if (contents == NULL && sec->_raw_size != 0)
4528 /* Sort the source_relocs by target offset. */
4529 src_relocs = relax_info->src_relocs;
4530 qsort (src_relocs, relax_info->src_count,
4531 sizeof (source_reloc), source_reloc_compare);
4533 for (i = 0; i < relax_info->src_count; i++)
4536 Elf_Internal_Rela *irel = NULL;
4540 rel = &src_relocs[i];
4541 irel = get_irel_at_offset (sec, internal_relocs,
4542 rel->r_rel.target_offset);
4544 /* If the target_offset for this relocation is the same as the
4545 previous relocation, then we've already considered whether the
4546 literal can be coalesced. Skip to the next one.... */
4547 if (i != 0 && (src_relocs[i-1].r_rel.target_offset
4548 == rel->r_rel.target_offset))
4551 /* Check if the relocation was from an L32R that is being removed
4552 because a CALLX was converted to a direct CALL, and check if
4553 there are no other relocations to the literal. */
4555 && (i == relax_info->src_count - 1
4556 || (src_relocs[i+1].r_rel.target_offset
4557 != rel->r_rel.target_offset)))
4559 /* Mark the unused literal so that it will be removed. */
4560 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
4562 /* Zero out the relocation on this literal location. */
4565 if (elf_hash_table (link_info)->dynamic_sections_created)
4566 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
4568 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4574 /* Find the literal value. */
4575 r_reloc_init (&val.r_rel, abfd, irel);
4576 BFD_ASSERT (rel->r_rel.target_offset < sec->_raw_size);
4577 val.value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
4579 /* Check if we've seen another literal with the same value. */
4580 val_map = get_cached_value (values, &val);
4581 if (val_map != NULL)
4583 /* First check that THIS and all the other relocs to this
4584 literal will FIT if we move them to the new address. */
4586 if (relocations_reach (rel, relax_info->src_count - i,
4589 /* Mark that the literal will be coalesced. */
4590 add_removed_literal (&relax_info->removed_list,
4591 &rel->r_rel, &val_map->loc);
4595 /* Relocations do not reach -- do not remove this literal. */
4596 val_map->loc = rel->r_rel;
4601 /* This is the first time we've seen this literal value. */
4602 BFD_ASSERT (sec == r_reloc_get_section (&rel->r_rel));
4603 add_value_map (values, &val, &rel->r_rel);
4608 release_contents (sec, contents);
4609 release_internal_relocs (sec, internal_relocs);
4614 /* Check if the original relocations (presumably on L32R instructions)
4615 identified by reloc[0..N] can be changed to reference the literal
4616 identified by r_rel. If r_rel is out of range for any of the
4617 original relocations, then we don't want to coalesce the original
4618 literal with the one at r_rel. We only check reloc[0..N], where the
4619 offsets are all the same as for reloc[0] (i.e., they're all
4620 referencing the same literal) and where N is also bounded by the
4621 number of remaining entries in the "reloc" array. The "reloc" array
4622 is sorted by target offset so we know all the entries for the same
4623 literal will be contiguous. */
4626 relocations_reach (reloc, remaining_relocs, r_rel)
4627 source_reloc *reloc;
4628 int remaining_relocs;
4629 const r_reloc *r_rel;
4631 bfd_vma from_offset, source_address, dest_address;
4635 if (!r_reloc_is_defined (r_rel))
4638 sec = r_reloc_get_section (r_rel);
4639 from_offset = reloc[0].r_rel.target_offset;
4641 for (i = 0; i < remaining_relocs; i++)
4643 if (reloc[i].r_rel.target_offset != from_offset)
4646 /* Ignore relocations that have been removed. */
4647 if (reloc[i].is_null)
4650 /* The original and new output section for these must be the same
4651 in order to coalesce. */
4652 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
4653 != sec->output_section)
4656 /* A NULL operand means it is not a PC-relative relocation, so
4657 the literal can be moved anywhere. */
4660 /* Otherwise, check to see that it fits. */
4661 source_address = (reloc[i].source_sec->output_section->vma
4662 + reloc[i].source_sec->output_offset
4663 + reloc[i].r_rel.rela.r_offset);
4664 dest_address = (sec->output_section->vma
4665 + sec->output_offset
4666 + r_rel->target_offset);
4668 if (!pcrel_reloc_fits (reloc[i].opnd, source_address, dest_address))
4677 /* WARNING: linear search here. If the relocation are in order by
4678 address, we can use a faster binary search. ALSO, we assume that
4679 there is only 1 non-NONE relocation per address. */
4681 static Elf_Internal_Rela *
4682 get_irel_at_offset (sec, internal_relocs, offset)
4684 Elf_Internal_Rela *internal_relocs;
4688 if (!internal_relocs)
4690 for (i = 0; i < sec->reloc_count; i++)
4692 Elf_Internal_Rela *irel = &internal_relocs[i];
4693 if (irel->r_offset == offset
4694 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
4701 /* Second relaxation pass. */
4703 /* Modify all of the relocations to point to the right spot, and if this
4704 is a relaxable section, delete the unwanted literals and fix the
4708 relax_section (abfd, sec, link_info)
4711 struct bfd_link_info *link_info;
4713 Elf_Internal_Rela *internal_relocs;
4714 xtensa_relax_info *relax_info;
4716 bfd_boolean ok = TRUE;
4719 relax_info = get_xtensa_relax_info (sec);
4720 BFD_ASSERT (relax_info);
4722 /* Handle property sections (e.g., literal tables) specially. */
4723 if (xtensa_is_property_section (sec))
4725 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
4726 return relax_property_section (abfd, sec, link_info);
4729 internal_relocs = retrieve_internal_relocs (abfd, sec,
4730 link_info->keep_memory);
4731 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4732 if (contents == NULL && sec->_raw_size != 0)
4738 if (internal_relocs)
4740 for (i = 0; i < sec->reloc_count; i++)
4742 Elf_Internal_Rela *irel;
4743 xtensa_relax_info *target_relax_info;
4744 bfd_vma source_offset;
4747 asection *target_sec;
4749 /* Locally change the source address.
4750 Translate the target to the new target address.
4751 If it points to this section and has been removed,
4755 irel = &internal_relocs[i];
4756 source_offset = irel->r_offset;
4758 r_type = ELF32_R_TYPE (irel->r_info);
4759 r_reloc_init (&r_rel, abfd, irel);
4761 if (relax_info->is_relaxable_literal_section)
4763 if (r_type != R_XTENSA_NONE
4764 && find_removed_literal (&relax_info->removed_list,
4767 /* Remove this relocation. */
4768 if (elf_hash_table (link_info)->dynamic_sections_created)
4769 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
4770 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4771 irel->r_offset = offset_with_removed_literals
4772 (&relax_info->removed_list, irel->r_offset);
4776 offset_with_removed_literals (&relax_info->removed_list,
4778 irel->r_offset = source_offset;
4781 target_sec = r_reloc_get_section (&r_rel);
4782 target_relax_info = get_xtensa_relax_info (target_sec);
4784 if (target_relax_info
4785 && target_relax_info->is_relaxable_literal_section)
4790 translate_reloc (&r_rel, &new_rel);
4792 /* FIXME: If the relocation still references a section in
4793 the same input file, the relocation should be modified
4794 directly instead of adding a "fix" record. */
4796 fix = reloc_bfd_fix_init (sec, source_offset, r_type, 0,
4797 r_reloc_get_section (&new_rel),
4798 new_rel.target_offset);
4802 pin_internal_relocs (sec, internal_relocs);
4806 if (relax_info->is_relaxable_literal_section)
4808 /* Walk through the contents and delete literals that are not needed
4811 unsigned long size = sec->_cooked_size;
4812 unsigned long removed = 0;
4814 removed_literal *reloc = relax_info->removed_list.head;
4815 for (; reloc; reloc = reloc->next)
4817 unsigned long upper = sec->_raw_size;
4818 bfd_vma start = reloc->from.target_offset + 4;
4820 upper = reloc->next->from.target_offset;
4821 if (upper - start != 0)
4823 BFD_ASSERT (start <= upper);
4824 memmove (contents + start - removed - 4,
4827 pin_contents (sec, contents);
4833 /* Change the section size. */
4834 sec->_cooked_size = size;
4835 /* Also shrink _raw_size. (The code in relocate_section that
4836 checks that relocations are within the section must use
4837 _raw_size because of the way the stabs sections are relaxed;
4838 shrinking _raw_size means that these checks will not be
4839 unnecessarily lax.) */
4840 sec->_raw_size = size;
4844 release_internal_relocs (sec, internal_relocs);
4845 release_contents (sec, contents);
4850 /* Fix up a relocation to take account of removed literals. */
4853 translate_reloc (orig_rel, new_rel)
4854 const r_reloc *orig_rel;
4858 xtensa_relax_info *relax_info;
4859 removed_literal *removed;
4860 unsigned long new_offset;
4862 *new_rel = *orig_rel;
4864 if (!r_reloc_is_defined (orig_rel))
4866 sec = r_reloc_get_section (orig_rel);
4868 relax_info = get_xtensa_relax_info (sec);
4869 BFD_ASSERT (relax_info);
4871 if (!relax_info->is_relaxable_literal_section)
4874 /* Check if the original relocation is against a literal being removed. */
4875 removed = find_removed_literal (&relax_info->removed_list,
4876 orig_rel->target_offset);
4881 /* The fact that there is still a relocation to this literal indicates
4882 that the literal is being coalesced, not simply removed. */
4883 BFD_ASSERT (removed->to.abfd != NULL);
4885 /* This was moved to some other address (possibly in another section). */
4886 *new_rel = removed->to;
4887 new_sec = r_reloc_get_section (new_rel);
4891 relax_info = get_xtensa_relax_info (sec);
4892 if (!relax_info || !relax_info->is_relaxable_literal_section)
4897 /* ...and the target address may have been moved within its section. */
4898 new_offset = offset_with_removed_literals (&relax_info->removed_list,
4899 new_rel->target_offset);
4901 /* Modify the offset and addend. */
4902 new_rel->target_offset = new_offset;
4903 new_rel->rela.r_addend += (new_offset - new_rel->target_offset);
4907 /* For dynamic links, there may be a dynamic relocation for each
4908 literal. The number of dynamic relocations must be computed in
4909 size_dynamic_sections, which occurs before relaxation. When a
4910 literal is removed, this function checks if there is a corresponding
4911 dynamic relocation and shrinks the size of the appropriate dynamic
4912 relocation section accordingly. At this point, the contents of the
4913 dynamic relocation sections have not yet been filled in, so there's
4914 nothing else that needs to be done. */
4917 shrink_dynamic_reloc_sections (info, abfd, input_section, rel)
4918 struct bfd_link_info *info;
4920 asection *input_section;
4921 Elf_Internal_Rela *rel;
4923 Elf_Internal_Shdr *symtab_hdr;
4924 struct elf_link_hash_entry **sym_hashes;
4925 unsigned long r_symndx;
4927 struct elf_link_hash_entry *h;
4928 bfd_boolean dynamic_symbol;
4930 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4931 sym_hashes = elf_sym_hashes (abfd);
4933 r_type = ELF32_R_TYPE (rel->r_info);
4934 r_symndx = ELF32_R_SYM (rel->r_info);
4936 if (r_symndx < symtab_hdr->sh_info)
4939 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4941 dynamic_symbol = xtensa_elf_dynamic_symbol_p (h, info);
4943 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
4944 && (input_section->flags & SEC_ALLOC) != 0
4945 && (dynamic_symbol || info->shared))
4948 const char *srel_name;
4950 bfd_boolean is_plt = FALSE;
4952 dynobj = elf_hash_table (info)->dynobj;
4953 BFD_ASSERT (dynobj != NULL);
4955 if (dynamic_symbol && r_type == R_XTENSA_PLT)
4957 srel_name = ".rela.plt";
4961 srel_name = ".rela.got";
4963 /* Reduce size of the .rela.* section by one reloc. */
4964 srel = bfd_get_section_by_name (dynobj, srel_name);
4965 BFD_ASSERT (srel != NULL);
4966 BFD_ASSERT (srel->_cooked_size >= sizeof (Elf32_External_Rela));
4967 srel->_cooked_size -= sizeof (Elf32_External_Rela);
4969 /* Also shrink _raw_size. (This seems wrong but other bfd code seems
4970 to assume that linker-created sections will never be relaxed and
4971 hence _raw_size must always equal _cooked_size.) */
4972 srel->_raw_size = srel->_cooked_size;
4976 asection *splt, *sgotplt, *srelgot;
4977 int reloc_index, chunk;
4979 /* Find the PLT reloc index of the entry being removed. This
4980 is computed from the size of ".rela.plt". It is needed to
4981 figure out which PLT chunk to resize. Usually "last index
4982 = size - 1" since the index starts at zero, but in this
4983 context, the size has just been decremented so there's no
4984 need to subtract one. */
4985 reloc_index = srel->_cooked_size / sizeof (Elf32_External_Rela);
4987 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
4988 splt = elf_xtensa_get_plt_section (dynobj, chunk);
4989 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
4990 BFD_ASSERT (splt != NULL && sgotplt != NULL);
4992 /* Check if an entire PLT chunk has just been eliminated. */
4993 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
4995 /* The two magic GOT entries for that chunk can go away. */
4996 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4997 BFD_ASSERT (srelgot != NULL);
4998 srelgot->reloc_count -= 2;
4999 srelgot->_cooked_size -= 2 * sizeof (Elf32_External_Rela);
5000 /* Shrink _raw_size (see comment above). */
5001 srelgot->_raw_size = srelgot->_cooked_size;
5003 sgotplt->_cooked_size -= 8;
5005 /* There should be only one entry left (and it will be
5007 BFD_ASSERT (sgotplt->_cooked_size == 4);
5008 BFD_ASSERT (splt->_cooked_size == PLT_ENTRY_SIZE);
5011 BFD_ASSERT (sgotplt->_cooked_size >= 4);
5012 BFD_ASSERT (splt->_cooked_size >= PLT_ENTRY_SIZE);
5014 sgotplt->_cooked_size -= 4;
5015 splt->_cooked_size -= PLT_ENTRY_SIZE;
5017 /* Shrink _raw_sizes (see comment above). */
5018 sgotplt->_raw_size = sgotplt->_cooked_size;
5019 splt->_raw_size = splt->_cooked_size;
5025 /* This is similar to relax_section except that when a target is moved,
5026 we shift addresses up. We also need to modify the size. This
5027 algorithm does NOT allow for relocations into the middle of the
5028 property sections. */
5031 relax_property_section (abfd, sec, link_info)
5034 struct bfd_link_info *link_info;
5036 Elf_Internal_Rela *internal_relocs;
5039 bfd_boolean ok = TRUE;
5041 internal_relocs = retrieve_internal_relocs (abfd, sec,
5042 link_info->keep_memory);
5043 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5044 if (contents == NULL && sec->_raw_size != 0)
5050 if (internal_relocs)
5052 for (i = 0; i < sec->reloc_count; i++)
5054 Elf_Internal_Rela *irel;
5055 xtensa_relax_info *target_relax_info;
5058 asection *target_sec;
5060 /* Locally change the source address.
5061 Translate the target to the new target address.
5062 If it points to this section and has been removed, MOVE IT.
5063 Also, don't forget to modify the associated SIZE at
5066 irel = &internal_relocs[i];
5067 r_type = ELF32_R_TYPE (irel->r_info);
5068 if (r_type == R_XTENSA_NONE)
5071 r_reloc_init (&r_rel, abfd, irel);
5073 target_sec = r_reloc_get_section (&r_rel);
5074 target_relax_info = get_xtensa_relax_info (target_sec);
5076 if (target_relax_info
5077 && target_relax_info->is_relaxable_literal_section)
5079 /* Translate the relocation's destination. */
5081 bfd_vma new_end_offset;
5083 long old_size, new_size;
5086 offset_with_removed_literals (&target_relax_info->removed_list,
5087 r_rel.target_offset);
5089 /* Assert that we are not out of bounds. */
5090 size_p = &contents[irel->r_offset + 4];
5091 old_size = bfd_get_32 (abfd, &contents[irel->r_offset + 4]);
5094 offset_with_removed_literals (&target_relax_info->removed_list,
5095 r_rel.target_offset + old_size);
5097 new_size = new_end_offset - new_offset;
5098 if (new_size != old_size)
5100 bfd_put_32 (abfd, new_size, size_p);
5101 pin_contents (sec, contents);
5104 if (new_offset != r_rel.target_offset)
5106 bfd_vma diff = new_offset - r_rel.target_offset;
5107 irel->r_addend += diff;
5108 pin_internal_relocs (sec, internal_relocs);
5114 /* Combine adjacent property table entries. This is also done in
5115 finish_dynamic_sections() but at that point it's too late to
5116 reclaim the space in the output section, so we do this twice. */
5118 if (internal_relocs)
5120 Elf_Internal_Rela *last_irel = NULL;
5121 int removed_bytes = 0;
5122 bfd_vma offset, last_irel_offset;
5123 bfd_vma section_size;
5125 /* Walk over memory and irels at the same time.
5126 This REQUIRES that the internal_relocs be sorted by offset. */
5127 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
5128 internal_reloc_compare);
5129 nexti = 0; /* Index into internal_relocs. */
5131 pin_internal_relocs (sec, internal_relocs);
5132 pin_contents (sec, contents);
5134 last_irel_offset = (bfd_vma) -1;
5135 section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size);
5136 BFD_ASSERT (section_size % 8 == 0);
5138 for (offset = 0; offset < section_size; offset += 8)
5140 Elf_Internal_Rela *irel, *next_irel;
5141 bfd_vma bytes_to_remove, size, actual_offset;
5142 bfd_boolean remove_this_irel;
5147 /* Find the next two relocations (if there are that many left),
5148 skipping over any R_XTENSA_NONE relocs. On entry, "nexti" is
5149 the starting reloc index. After these two loops, "i"
5150 is the index of the first non-NONE reloc past that starting
5151 index, and "nexti" is the index for the next non-NONE reloc
5154 for (i = nexti; i < sec->reloc_count; i++)
5156 if (ELF32_R_TYPE (internal_relocs[i].r_info) != R_XTENSA_NONE)
5158 irel = &internal_relocs[i];
5161 internal_relocs[i].r_offset -= removed_bytes;
5164 for (nexti = i + 1; nexti < sec->reloc_count; nexti++)
5166 if (ELF32_R_TYPE (internal_relocs[nexti].r_info)
5169 next_irel = &internal_relocs[nexti];
5172 internal_relocs[nexti].r_offset -= removed_bytes;
5175 remove_this_irel = FALSE;
5176 bytes_to_remove = 0;
5177 actual_offset = offset - removed_bytes;
5178 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
5180 /* Check that the irels are sorted by offset,
5181 with only one per address. */
5182 BFD_ASSERT (!irel || (int) irel->r_offset > (int) last_irel_offset);
5183 BFD_ASSERT (!next_irel || next_irel->r_offset > irel->r_offset);
5185 /* Make sure there isn't a reloc on the size field. */
5186 if (irel && irel->r_offset == offset + 4)
5188 irel->r_offset -= removed_bytes;
5189 last_irel_offset = irel->r_offset;
5191 else if (next_irel && next_irel->r_offset == offset + 4)
5194 irel->r_offset -= removed_bytes;
5195 next_irel->r_offset -= removed_bytes;
5196 last_irel_offset = next_irel->r_offset;
5200 /* Always remove entries with zero size. */
5201 bytes_to_remove = 8;
5202 if (irel && irel->r_offset == offset)
5204 remove_this_irel = TRUE;
5206 irel->r_offset -= removed_bytes;
5207 last_irel_offset = irel->r_offset;
5210 else if (irel && irel->r_offset == offset)
5212 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32)
5217 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
5218 bfd_vma old_address =
5219 (last_irel->r_addend
5220 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
5221 bfd_vma new_address =
5223 + bfd_get_32 (abfd, &contents[actual_offset]));
5225 if ((ELF32_R_SYM (irel->r_info) ==
5226 ELF32_R_SYM (last_irel->r_info))
5227 && (old_address + old_size == new_address))
5229 /* fix the old size */
5230 bfd_put_32 (abfd, old_size + size,
5231 &contents[last_irel->r_offset + 4]);
5232 bytes_to_remove = 8;
5233 remove_this_irel = TRUE;
5242 irel->r_offset -= removed_bytes;
5243 last_irel_offset = irel->r_offset;
5246 if (remove_this_irel)
5248 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
5249 irel->r_offset -= bytes_to_remove;
5252 if (bytes_to_remove != 0)
5254 removed_bytes += bytes_to_remove;
5255 if (offset + 8 < section_size)
5256 memmove (&contents[actual_offset],
5257 &contents[actual_offset+8],
5258 section_size - offset - 8);
5264 /* Clear the removed bytes. */
5265 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
5267 sec->_cooked_size = section_size - removed_bytes;
5268 /* Also shrink _raw_size. (The code in relocate_section that
5269 checks that relocations are within the section must use
5270 _raw_size because of the way the stabs sections are
5271 relaxed; shrinking _raw_size means that these checks will
5272 not be unnecessarily lax.) */
5273 sec->_raw_size = sec->_cooked_size;
5275 if (xtensa_is_littable_section (sec))
5277 bfd *dynobj = elf_hash_table (link_info)->dynobj;
5281 bfd_get_section_by_name (dynobj, ".got.loc");
5284 bfd_size_type sgotloc_size =
5285 (sgotloc->_cooked_size ? sgotloc->_cooked_size
5286 : sgotloc->_raw_size);
5287 sgotloc->_cooked_size = sgotloc_size - removed_bytes;
5288 sgotloc->_raw_size = sgotloc_size - removed_bytes;
5296 release_internal_relocs (sec, internal_relocs);
5297 release_contents (sec, contents);
5302 /* Third relaxation pass. */
5304 /* Change symbol values to account for removed literals. */
5307 relax_section_symbols (abfd, sec)
5311 xtensa_relax_info *relax_info;
5312 unsigned int sec_shndx;
5313 Elf_Internal_Shdr *symtab_hdr;
5314 Elf_Internal_Sym *isymbuf;
5315 unsigned i, num_syms, num_locals;
5317 relax_info = get_xtensa_relax_info (sec);
5318 BFD_ASSERT (relax_info);
5320 if (!relax_info->is_relaxable_literal_section)
5323 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5325 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5326 isymbuf = retrieve_local_syms (abfd);
5328 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
5329 num_locals = symtab_hdr->sh_info;
5331 /* Adjust the local symbols defined in this section. */
5332 for (i = 0; i < num_locals; i++)
5334 Elf_Internal_Sym *isym = &isymbuf[i];
5336 if (isym->st_shndx == sec_shndx)
5338 bfd_vma new_address = offset_with_removed_literals
5339 (&relax_info->removed_list, isym->st_value);
5340 if (new_address != isym->st_value)
5341 isym->st_value = new_address;
5345 /* Now adjust the global symbols defined in this section. */
5346 for (i = 0; i < (num_syms - num_locals); i++)
5348 struct elf_link_hash_entry *sym_hash;
5350 sym_hash = elf_sym_hashes (abfd)[i];
5352 if (sym_hash->root.type == bfd_link_hash_warning)
5353 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
5355 if ((sym_hash->root.type == bfd_link_hash_defined
5356 || sym_hash->root.type == bfd_link_hash_defweak)
5357 && sym_hash->root.u.def.section == sec)
5359 bfd_vma new_address = offset_with_removed_literals
5360 (&relax_info->removed_list, sym_hash->root.u.def.value);
5361 if (new_address != sym_hash->root.u.def.value)
5362 sym_hash->root.u.def.value = new_address;
5370 /* "Fix" handling functions, called while performing relocations. */
5373 do_fix_for_relocatable_link (rel, input_bfd, input_section)
5374 Elf_Internal_Rela *rel;
5376 asection *input_section;
5379 asection *sec, *old_sec;
5381 int r_type = ELF32_R_TYPE (rel->r_info);
5382 reloc_bfd_fix *fix_list;
5385 if (r_type == R_XTENSA_NONE)
5388 fix_list = (get_xtensa_relax_info (input_section))->fix_list;
5389 if (fix_list == NULL)
5392 fix = get_bfd_fix (fix_list, input_section, rel->r_offset, r_type);
5396 r_reloc_init (&r_rel, input_bfd, rel);
5397 old_sec = r_reloc_get_section (&r_rel);
5398 old_offset = r_reloc_get_target_offset (&r_rel);
5400 if (old_sec == NULL || !r_reloc_is_defined (&r_rel))
5402 BFD_ASSERT (r_type == R_XTENSA_ASM_EXPAND);
5403 /* Leave it be. Resolution will happen in a later stage. */
5407 sec = fix->target_sec;
5408 rel->r_addend += ((sec->output_offset + fix->target_offset)
5409 - (old_sec->output_offset + old_offset));
5415 do_fix_for_final_link (rel, input_section, relocationp)
5416 Elf_Internal_Rela *rel;
5417 asection *input_section;
5418 bfd_vma *relocationp;
5421 int r_type = ELF32_R_TYPE (rel->r_info);
5422 reloc_bfd_fix *fix_list;
5425 if (r_type == R_XTENSA_NONE)
5428 fix_list = (get_xtensa_relax_info (input_section))->fix_list;
5429 if (fix_list == NULL)
5432 fix = get_bfd_fix (fix_list, input_section, rel->r_offset, r_type);
5436 sec = fix->target_sec;
5437 *relocationp = (sec->output_section->vma
5438 + sec->output_offset
5439 + fix->target_offset - rel->r_addend);
5443 /* Miscellaneous utility functions.... */
5446 elf_xtensa_get_plt_section (dynobj, chunk)
5453 return bfd_get_section_by_name (dynobj, ".plt");
5455 sprintf (plt_name, ".plt.%u", chunk);
5456 return bfd_get_section_by_name (dynobj, plt_name);
5461 elf_xtensa_get_gotplt_section (dynobj, chunk)
5468 return bfd_get_section_by_name (dynobj, ".got.plt");
5470 sprintf (got_name, ".got.plt.%u", chunk);
5471 return bfd_get_section_by_name (dynobj, got_name);
5475 /* Get the input section for a given symbol index.
5477 . a section symbol, return the section;
5478 . a common symbol, return the common section;
5479 . an undefined symbol, return the undefined section;
5480 . an indirect symbol, follow the links;
5481 . an absolute value, return the absolute section. */
5484 get_elf_r_symndx_section (abfd, r_symndx)
5486 unsigned long r_symndx;
5488 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5489 asection *target_sec = NULL;
5490 if (r_symndx < symtab_hdr->sh_info)
5492 Elf_Internal_Sym *isymbuf;
5493 unsigned int section_index;
5495 isymbuf = retrieve_local_syms (abfd);
5496 section_index = isymbuf[r_symndx].st_shndx;
5498 if (section_index == SHN_UNDEF)
5499 target_sec = bfd_und_section_ptr;
5500 else if (section_index > 0 && section_index < SHN_LORESERVE)
5501 target_sec = bfd_section_from_elf_index (abfd, section_index);
5502 else if (section_index == SHN_ABS)
5503 target_sec = bfd_abs_section_ptr;
5504 else if (section_index == SHN_COMMON)
5505 target_sec = bfd_com_section_ptr;
5512 unsigned long indx = r_symndx - symtab_hdr->sh_info;
5513 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
5515 while (h->root.type == bfd_link_hash_indirect
5516 || h->root.type == bfd_link_hash_warning)
5517 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5519 switch (h->root.type)
5521 case bfd_link_hash_defined:
5522 case bfd_link_hash_defweak:
5523 target_sec = h->root.u.def.section;
5525 case bfd_link_hash_common:
5526 target_sec = bfd_com_section_ptr;
5528 case bfd_link_hash_undefined:
5529 case bfd_link_hash_undefweak:
5530 target_sec = bfd_und_section_ptr;
5532 default: /* New indirect warning. */
5533 target_sec = bfd_und_section_ptr;
5541 static struct elf_link_hash_entry *
5542 get_elf_r_symndx_hash_entry (abfd, r_symndx)
5544 unsigned long r_symndx;
5547 struct elf_link_hash_entry *h;
5548 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5550 if (r_symndx < symtab_hdr->sh_info)
5553 indx = r_symndx - symtab_hdr->sh_info;
5554 h = elf_sym_hashes (abfd)[indx];
5555 while (h->root.type == bfd_link_hash_indirect
5556 || h->root.type == bfd_link_hash_warning)
5557 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5562 /* Get the section-relative offset for a symbol number. */
5565 get_elf_r_symndx_offset (abfd, r_symndx)
5567 unsigned long r_symndx;
5569 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5572 if (r_symndx < symtab_hdr->sh_info)
5574 Elf_Internal_Sym *isymbuf;
5575 isymbuf = retrieve_local_syms (abfd);
5576 offset = isymbuf[r_symndx].st_value;
5580 unsigned long indx = r_symndx - symtab_hdr->sh_info;
5581 struct elf_link_hash_entry *h =
5582 elf_sym_hashes (abfd)[indx];
5584 while (h->root.type == bfd_link_hash_indirect
5585 || h->root.type == bfd_link_hash_warning)
5586 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5587 if (h->root.type == bfd_link_hash_defined
5588 || h->root.type == bfd_link_hash_defweak)
5589 offset = h->root.u.def.value;
5596 pcrel_reloc_fits (opnd, self_address, dest_address)
5597 xtensa_operand opnd;
5598 bfd_vma self_address;
5599 bfd_vma dest_address;
5601 uint32 new_address =
5602 xtensa_operand_do_reloc (opnd, dest_address, self_address);
5603 return (xtensa_operand_encode (opnd, &new_address)
5604 == xtensa_encode_result_ok);
5609 xtensa_is_property_section (sec)
5612 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
5614 if (strncmp (".xt.insn", sec->name, 8) == 0
5615 || strncmp (".xt.lit", sec->name, 7) == 0)
5618 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0)
5620 if (strncmp ("x.", sec->name + linkonce_len, 2) == 0
5621 || strncmp ("p.", sec->name + linkonce_len, 2) == 0)
5623 if (strstr (sec->name + linkonce_len, ".xt.insn") != NULL
5624 || strstr (sec->name + linkonce_len, ".xt.lit") != NULL)
5632 xtensa_is_littable_section (sec)
5635 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
5637 if (strncmp (".xt.lit", sec->name, 7) == 0)
5640 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0)
5642 if (strncmp ("p.", sec->name + linkonce_len, 2) == 0)
5644 if (strstr (sec->name + linkonce_len, ".xt.lit") != NULL)
5652 is_literal_section (sec)
5655 /* FIXME: the current definition of this leaves a lot to be desired.... */
5656 if (sec == NULL || sec->name == NULL)
5658 return (strstr (sec->name, "literal") != NULL);
5663 internal_reloc_compare (ap, bp)
5667 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
5668 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
5670 return (a->r_offset - b->r_offset);
5675 get_is_linkonce_section (abfd, sec)
5676 bfd *abfd ATTRIBUTE_UNUSED;
5679 flagword flags, link_once_flags;
5680 bfd_boolean is_linkonce = FALSE;;
5682 flags = bfd_get_section_flags (abfd, sec);
5683 link_once_flags = (flags & SEC_LINK_ONCE);
5684 if (link_once_flags != 0)
5687 /* In order for this to be useful to the assembler
5688 before the linkonce flag is set we need to
5689 check for the GNU extension name. */
5691 strncmp (sec->name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
5699 xtensa_get_property_section_name (abfd, sec, base_name)
5702 const char * base_name;
5704 char *table_sec_name = NULL;
5705 bfd_boolean is_linkonce;
5707 is_linkonce = get_is_linkonce_section (abfd, sec);
5711 table_sec_name = strdup (base_name);
5715 static size_t prefix_len = sizeof (".gnu.linkonce.t.") - 1;
5716 size_t len = strlen (sec->name) + 1;
5717 char repl_char = '\0';
5718 const char *segname = sec->name;
5720 if (strncmp (segname, ".gnu.linkonce.t.", prefix_len) == 0)
5722 if (strcmp (base_name, ".xt.insn") == 0)
5724 else if (strcmp (base_name, ".xt.lit") == 0)
5728 if (repl_char != '\0')
5730 char *name = (char *) bfd_malloc (len);
5731 memcpy (name, sec->name, len);
5732 name[prefix_len - 2] = repl_char;
5733 table_sec_name = name;
5737 size_t base_len = strlen (base_name) + 1;
5738 char *name = (char *) bfd_malloc (len + base_len);
5739 memcpy (name, sec->name, len - 1);
5740 memcpy (name + len - 1, base_name, base_len);
5741 table_sec_name = name;
5745 return table_sec_name;
5749 /* Other functions called directly by the linker. */
5752 xtensa_callback_required_dependence (abfd, sec, link_info, callback, closure)
5755 struct bfd_link_info *link_info;
5756 deps_callback_t callback;
5759 Elf_Internal_Rela *internal_relocs;
5762 bfd_boolean ok = TRUE;
5764 /* ".plt*" sections have no explicit relocations but they contain L32R
5765 instructions that reference the corresponding ".got.plt*" sections. */
5766 if ((sec->flags & SEC_LINKER_CREATED) != 0
5767 && strncmp (sec->name, ".plt", 4) == 0)
5771 /* Find the corresponding ".got.plt*" section. */
5772 if (sec->name[4] == '\0')
5773 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
5779 BFD_ASSERT (sec->name[4] == '.');
5780 chunk = strtol (&sec->name[5], NULL, 10);
5782 sprintf (got_name, ".got.plt.%u", chunk);
5783 sgotplt = bfd_get_section_by_name (sec->owner, got_name);
5785 BFD_ASSERT (sgotplt);
5787 /* Assume worst-case offsets: L32R at the very end of the ".plt"
5788 section referencing a literal at the very beginning of
5789 ".got.plt". This is very close to the real dependence, anyway. */
5790 (*callback) (sec, sec->_raw_size, sgotplt, 0, closure);
5793 internal_relocs = retrieve_internal_relocs (abfd, sec,
5794 link_info->keep_memory);
5795 if (internal_relocs == NULL
5796 || sec->reloc_count == 0)
5799 /* Cache the contents for the duration of this scan. */
5800 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5801 if (contents == NULL && sec->_raw_size != 0)
5807 if (xtensa_default_isa == NULL)
5810 for (i = 0; i < sec->reloc_count; i++)
5812 Elf_Internal_Rela *irel = &internal_relocs[i];
5813 if (is_l32r_relocation (sec, contents, irel))
5816 asection *target_sec;
5817 bfd_vma target_offset;
5819 r_reloc_init (&l32r_rel, abfd, irel);
5822 /* L32Rs must be local to the input file. */
5823 if (r_reloc_is_defined (&l32r_rel))
5825 target_sec = r_reloc_get_section (&l32r_rel);
5826 target_offset = r_reloc_get_target_offset (&l32r_rel);
5828 (*callback) (sec, irel->r_offset, target_sec, target_offset,
5834 release_internal_relocs (sec, internal_relocs);
5835 release_contents (sec, contents);
5839 /* The default literal sections should always be marked as "code" (i.e.,
5840 SHF_EXECINSTR). This is particularly important for the Linux kernel
5841 module loader so that the literals are not placed after the text. */
5842 static struct bfd_elf_special_section const elf_xtensa_special_sections[]=
5844 { ".literal", 8, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
5845 { ".init.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
5846 { ".fini.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
5847 { NULL, 0, 0, 0, 0 }
5852 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
5853 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
5854 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
5855 #define TARGET_BIG_NAME "elf32-xtensa-be"
5856 #define ELF_ARCH bfd_arch_xtensa
5858 /* The new EM_XTENSA value will be recognized beginning in the Xtensa T1040
5859 release. However, we still have to generate files with the EM_XTENSA_OLD
5860 value so that pre-T1040 tools can read the files. As soon as we stop
5861 caring about pre-T1040 tools, the following two values should be
5862 swapped. At the same time, any other code that uses EM_XTENSA_OLD
5863 (e.g., prep_headers() in elf.c) should be changed to use EM_XTENSA. */
5864 #define ELF_MACHINE_CODE EM_XTENSA_OLD
5865 #define ELF_MACHINE_ALT1 EM_XTENSA
5868 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
5869 #else /* !XCHAL_HAVE_MMU */
5870 #define ELF_MAXPAGESIZE 1
5871 #endif /* !XCHAL_HAVE_MMU */
5872 #endif /* ELF_ARCH */
5874 #define elf_backend_can_gc_sections 1
5875 #define elf_backend_can_refcount 1
5876 #define elf_backend_plt_readonly 1
5877 #define elf_backend_got_header_size 4
5878 #define elf_backend_want_dynbss 0
5879 #define elf_backend_want_got_plt 1
5881 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
5883 #define bfd_elf32_bfd_final_link bfd_elf32_bfd_final_link
5884 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
5885 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
5886 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
5887 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
5888 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
5889 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
5891 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
5892 #define elf_backend_check_relocs elf_xtensa_check_relocs
5893 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
5894 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
5895 #define elf_backend_discard_info elf_xtensa_discard_info
5896 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
5897 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
5898 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
5899 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
5900 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
5901 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
5902 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
5903 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
5904 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
5905 #define elf_backend_modify_segment_map elf_xtensa_modify_segment_map
5906 #define elf_backend_object_p elf_xtensa_object_p
5907 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
5908 #define elf_backend_relocate_section elf_xtensa_relocate_section
5909 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
5910 #define elf_backend_special_sections elf_xtensa_special_sections
5912 #include "elf32-target.h"