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 ((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 int property_table_compare
106 PARAMS ((const PTR, const PTR));
107 static bfd_boolean elf_xtensa_in_literal_pool
108 PARAMS ((property_table_entry *, int, bfd_vma));
109 static void elf_xtensa_make_sym_local
110 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
111 static bfd_boolean add_extra_plt_sections
112 PARAMS ((bfd *, int));
113 static bfd_boolean elf_xtensa_fix_refcounts
114 PARAMS ((struct elf_link_hash_entry *, PTR));
115 static bfd_boolean elf_xtensa_allocate_plt_size
116 PARAMS ((struct elf_link_hash_entry *, PTR));
117 static bfd_boolean elf_xtensa_allocate_got_size
118 PARAMS ((struct elf_link_hash_entry *, PTR));
119 static void elf_xtensa_allocate_local_got_size
120 PARAMS ((struct bfd_link_info *, asection *));
121 static bfd_reloc_status_type elf_xtensa_do_reloc
122 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_vma, bfd_byte *,
123 bfd_vma, bfd_boolean, char **));
124 static char * vsprint_msg
125 VPARAMS ((const char *, const char *, int, ...));
126 static char *build_encoding_error_message
127 PARAMS ((xtensa_opcode, xtensa_encode_result));
128 static bfd_reloc_status_type bfd_elf_xtensa_reloc
129 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
130 static void do_fix_for_relocateable_link
131 PARAMS ((Elf_Internal_Rela *, bfd *, asection *));
132 static void do_fix_for_final_link
133 PARAMS ((Elf_Internal_Rela *, asection *, bfd_vma *));
134 static bfd_boolean xtensa_elf_dynamic_symbol_p
135 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
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 *, const char *));
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 is_literal_section
210 PARAMS ((asection *));
211 static int internal_reloc_compare
212 PARAMS ((const PTR, const PTR));
213 static bfd_boolean get_is_linkonce_section
214 PARAMS ((bfd *, asection *));
215 extern char *xtensa_get_property_section_name
216 PARAMS ((bfd *, asection *, const char *));
218 /* Other functions called directly by the linker. */
220 typedef void (*deps_callback_t)
221 PARAMS ((asection *, bfd_vma, asection *, bfd_vma, PTR));
222 extern bfd_boolean xtensa_callback_required_dependence
223 PARAMS ((bfd *, asection *, struct bfd_link_info *,
224 deps_callback_t, PTR));
227 typedef struct xtensa_relax_info_struct xtensa_relax_info;
230 /* Total count of PLT relocations seen during check_relocs.
231 The actual PLT code must be split into multiple sections and all
232 the sections have to be created before size_dynamic_sections,
233 where we figure out the exact number of PLT entries that will be
234 needed. It is OK is this count is an overestimate, e.g., some
235 relocations may be removed by GC. */
237 static int plt_reloc_count = 0;
240 /* When this is true, relocations may have been modified to refer to
241 symbols from other input files. The per-section list of "fix"
242 records needs to be checked when resolving relocations. */
244 static bfd_boolean relaxing_section = FALSE;
247 static reloc_howto_type elf_howto_table[] =
249 HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
250 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
251 FALSE, 0x00000000, 0x00000000, FALSE),
252 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
253 bfd_elf_xtensa_reloc, "R_XTENSA_32",
254 TRUE, 0xffffffff, 0xffffffff, FALSE),
255 /* Replace a 32-bit value with a value from the runtime linker (only
256 used by linker-generated stub functions). The r_addend value is
257 special: 1 means to substitute a pointer to the runtime linker's
258 dynamic resolver function; 2 means to substitute the link map for
259 the shared object. */
260 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
261 NULL, "R_XTENSA_RTLD",
262 FALSE, 0x00000000, 0x00000000, FALSE),
263 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
264 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
265 FALSE, 0xffffffff, 0xffffffff, FALSE),
266 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
267 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
268 FALSE, 0xffffffff, 0xffffffff, FALSE),
269 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
270 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
271 FALSE, 0xffffffff, 0xffffffff, FALSE),
272 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
273 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
274 FALSE, 0xffffffff, 0xffffffff, FALSE),
276 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
277 bfd_elf_xtensa_reloc, "R_XTENSA_OP0",
278 FALSE, 0x00000000, 0x00000000, TRUE),
279 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
280 bfd_elf_xtensa_reloc, "R_XTENSA_OP1",
281 FALSE, 0x00000000, 0x00000000, TRUE),
282 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
283 bfd_elf_xtensa_reloc, "R_XTENSA_OP2",
284 FALSE, 0x00000000, 0x00000000, TRUE),
285 /* Assembly auto-expansion. */
286 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
287 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND",
288 FALSE, 0x00000000, 0x00000000, FALSE),
289 /* Relax assembly auto-expansion. */
290 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
291 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY",
292 FALSE, 0x00000000, 0x00000000, TRUE),
295 /* GNU extension to record C++ vtable hierarchy. */
296 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
297 NULL, "R_XTENSA_GNU_VTINHERIT",
298 FALSE, 0x00000000, 0x00000000, FALSE),
299 /* GNU extension to record C++ vtable member usage. */
300 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
301 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
302 FALSE, 0x00000000, 0x00000000, FALSE)
305 #ifdef DEBUG_GEN_RELOC
307 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
312 static reloc_howto_type *
313 elf_xtensa_reloc_type_lookup (abfd, code)
314 bfd *abfd ATTRIBUTE_UNUSED;
315 bfd_reloc_code_real_type code;
320 TRACE ("BFD_RELOC_NONE");
321 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
324 TRACE ("BFD_RELOC_32");
325 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
327 case BFD_RELOC_XTENSA_RTLD:
328 TRACE ("BFD_RELOC_XTENSA_RTLD");
329 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
331 case BFD_RELOC_XTENSA_GLOB_DAT:
332 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
333 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
335 case BFD_RELOC_XTENSA_JMP_SLOT:
336 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
337 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
339 case BFD_RELOC_XTENSA_RELATIVE:
340 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
341 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
343 case BFD_RELOC_XTENSA_PLT:
344 TRACE ("BFD_RELOC_XTENSA_PLT");
345 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
347 case BFD_RELOC_XTENSA_OP0:
348 TRACE ("BFD_RELOC_XTENSA_OP0");
349 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
351 case BFD_RELOC_XTENSA_OP1:
352 TRACE ("BFD_RELOC_XTENSA_OP1");
353 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
355 case BFD_RELOC_XTENSA_OP2:
356 TRACE ("BFD_RELOC_XTENSA_OP2");
357 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
359 case BFD_RELOC_XTENSA_ASM_EXPAND:
360 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
361 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
363 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
364 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
365 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
367 case BFD_RELOC_VTABLE_INHERIT:
368 TRACE ("BFD_RELOC_VTABLE_INHERIT");
369 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
371 case BFD_RELOC_VTABLE_ENTRY:
372 TRACE ("BFD_RELOC_VTABLE_ENTRY");
373 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
384 /* Given an ELF "rela" relocation, find the corresponding howto and record
385 it in the BFD internal arelent representation of the relocation. */
388 elf_xtensa_info_to_howto_rela (abfd, cache_ptr, dst)
389 bfd *abfd ATTRIBUTE_UNUSED;
391 Elf_Internal_Rela *dst;
393 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
395 BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max);
396 cache_ptr->howto = &elf_howto_table[r_type];
400 /* Functions for the Xtensa ELF linker. */
402 /* The name of the dynamic interpreter. This is put in the .interp
405 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
407 /* The size in bytes of an entry in the procedure linkage table.
408 (This does _not_ include the space for the literals associated with
411 #define PLT_ENTRY_SIZE 16
413 /* For _really_ large PLTs, we may need to alternate between literals
414 and code to keep the literals within the 256K range of the L32R
415 instructions in the code. It's unlikely that anyone would ever need
416 such a big PLT, but an arbitrary limit on the PLT size would be bad.
417 Thus, we split the PLT into chunks. Since there's very little
418 overhead (2 extra literals) for each chunk, the chunk size is kept
419 small so that the code for handling multiple chunks get used and
420 tested regularly. With 254 entries, there are 1K of literals for
421 each chunk, and that seems like a nice round number. */
423 #define PLT_ENTRIES_PER_CHUNK 254
425 /* PLT entries are actually used as stub functions for lazy symbol
426 resolution. Once the symbol is resolved, the stub function is never
427 invoked. Note: the 32-byte frame size used here cannot be changed
428 without a corresponding change in the runtime linker. */
430 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
432 0x6c, 0x10, 0x04, /* entry sp, 32 */
433 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
434 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
435 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
436 0x0a, 0x80, 0x00, /* jx a8 */
440 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
442 0x36, 0x41, 0x00, /* entry sp, 32 */
443 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
444 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
445 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
446 0xa0, 0x08, 0x00, /* jx a8 */
452 property_table_compare (ap, bp)
456 const property_table_entry *a = (const property_table_entry *) ap;
457 const property_table_entry *b = (const property_table_entry *) bp;
459 /* Check if one entry overlaps with the other; this shouldn't happen
460 except when searching for a match. */
461 if ((b->address >= a->address && b->address < (a->address + a->size))
462 || (a->address >= b->address && a->address < (b->address + b->size)))
465 return (a->address - b->address);
469 /* Get the literal table or instruction table entries for the given
470 section. Sets TABLE_P and returns the number of entries. On error,
471 returns a negative value. */
474 xtensa_read_table_entries (abfd, section, table_p, sec_name)
477 property_table_entry **table_p;
478 const char *sec_name;
480 asection *table_section;
481 char *table_section_name;
482 bfd_size_type table_size = 0;
483 bfd_byte *table_data;
484 property_table_entry *blocks;
486 bfd_size_type num_records;
487 Elf_Internal_Rela *internal_relocs;
490 xtensa_get_property_section_name (abfd, section, sec_name);
491 table_section = bfd_get_section_by_name (abfd, table_section_name);
492 if (table_section != NULL)
493 table_size = bfd_get_section_size_before_reloc (table_section);
501 num_records = table_size / sizeof (property_table_entry);
502 table_data = retrieve_contents (abfd, table_section, TRUE);
503 blocks = (property_table_entry *)
504 bfd_malloc (num_records * sizeof (property_table_entry));
507 /* If the file has not yet been relocated, process the relocations
508 and sort out the table entries that apply to the specified section. */
509 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
514 for (i = 0; i < table_section->reloc_count; i++)
516 Elf_Internal_Rela *rel = &internal_relocs[i];
517 unsigned long r_symndx;
519 if (ELF32_R_TYPE (rel->r_info) == R_XTENSA_NONE)
522 BFD_ASSERT (ELF32_R_TYPE (rel->r_info) == R_XTENSA_32);
523 r_symndx = ELF32_R_SYM (rel->r_info);
525 if (get_elf_r_symndx_section (abfd, r_symndx) == section)
527 bfd_vma sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
528 blocks[block_count].address =
529 (section->vma + sym_off + rel->r_addend
530 + bfd_get_32 (abfd, table_data + rel->r_offset));
531 blocks[block_count].size =
532 bfd_get_32 (abfd, table_data + rel->r_offset + 4);
539 /* No relocations. Presumably the file has been relocated
540 and the addresses are already in the table. */
543 for (off = 0; off < table_size; off += sizeof (property_table_entry))
545 bfd_vma address = bfd_get_32 (abfd, table_data + off);
547 if (address >= section->vma
548 && address < ( section->vma + section->_raw_size))
550 blocks[block_count].address = address;
551 blocks[block_count].size =
552 bfd_get_32 (abfd, table_data + off + 4);
558 release_contents (table_section, table_data);
559 release_internal_relocs (table_section, internal_relocs);
563 /* Now sort them into address order for easy reference. */
564 qsort (blocks, block_count, sizeof (property_table_entry),
565 property_table_compare);
574 elf_xtensa_in_literal_pool (lit_table, lit_table_size, addr)
575 property_table_entry *lit_table;
579 property_table_entry entry;
581 if (lit_table_size == 0)
584 entry.address = addr;
587 if (bsearch (&entry, lit_table, lit_table_size,
588 sizeof (property_table_entry), property_table_compare))
595 /* Look through the relocs for a section during the first phase, and
596 calculate needed space in the dynamic reloc sections. */
599 elf_xtensa_check_relocs (abfd, info, sec, relocs)
601 struct bfd_link_info *info;
603 const Elf_Internal_Rela *relocs;
605 Elf_Internal_Shdr *symtab_hdr;
606 struct elf_link_hash_entry **sym_hashes;
607 const Elf_Internal_Rela *rel;
608 const Elf_Internal_Rela *rel_end;
609 property_table_entry *lit_table;
612 if (info->relocateable)
615 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
616 sym_hashes = elf_sym_hashes (abfd);
618 ltblsize = xtensa_read_table_entries (abfd, sec, &lit_table,
619 XTENSA_LIT_SEC_NAME);
623 rel_end = relocs + sec->reloc_count;
624 for (rel = relocs; rel < rel_end; rel++)
627 unsigned long r_symndx;
628 struct elf_link_hash_entry *h;
630 r_symndx = ELF32_R_SYM (rel->r_info);
631 r_type = ELF32_R_TYPE (rel->r_info);
633 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
635 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
636 bfd_archive_filename (abfd),
641 if (r_symndx < symtab_hdr->sh_info)
645 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
646 while (h->root.type == bfd_link_hash_indirect
647 || h->root.type == bfd_link_hash_warning)
648 h = (struct elf_link_hash_entry *) h->root.u.i.link;
657 if ((sec->flags & SEC_ALLOC) != 0)
659 if ((sec->flags & SEC_READONLY) != 0
660 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
661 sec->vma + rel->r_offset))
662 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
664 if (h->got.refcount <= 0)
667 h->got.refcount += 1;
672 /* If this relocation is against a local symbol, then it's
673 exactly the same as a normal local GOT entry. */
677 if ((sec->flags & SEC_ALLOC) != 0)
679 if ((sec->flags & SEC_READONLY) != 0
680 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
681 sec->vma + rel->r_offset))
682 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
684 if (h->plt.refcount <= 0)
686 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
690 h->plt.refcount += 1;
692 /* Keep track of the total PLT relocation count even if we
693 don't yet know whether the dynamic sections will be
695 plt_reloc_count += 1;
697 if (elf_hash_table (info)->dynamic_sections_created)
699 if (!add_extra_plt_sections (elf_hash_table (info)->dynobj,
707 if ((sec->flags & SEC_ALLOC) != 0)
709 bfd_signed_vma *local_got_refcounts;
711 /* This is a global offset table entry for a local symbol. */
712 local_got_refcounts = elf_local_got_refcounts (abfd);
713 if (local_got_refcounts == NULL)
717 size = symtab_hdr->sh_info;
718 size *= sizeof (bfd_signed_vma);
719 local_got_refcounts = ((bfd_signed_vma *)
720 bfd_zalloc (abfd, size));
721 if (local_got_refcounts == NULL)
723 elf_local_got_refcounts (abfd) = local_got_refcounts;
725 local_got_refcounts[r_symndx] += 1;
727 /* If the relocation is not inside the GOT, the DF_TEXTREL
728 flag needs to be set. */
730 && (sec->flags & SEC_READONLY) != 0
731 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
732 sec->vma + rel->r_offset))
733 info->flags |= DF_TEXTREL;
740 case R_XTENSA_ASM_EXPAND:
741 case R_XTENSA_ASM_SIMPLIFY:
742 /* Nothing to do for these. */
745 case R_XTENSA_GNU_VTINHERIT:
746 /* This relocation describes the C++ object vtable hierarchy.
747 Reconstruct it for later use during GC. */
748 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
752 case R_XTENSA_GNU_VTENTRY:
753 /* This relocation describes which C++ vtable entries are actually
754 used. Record for later use during GC. */
755 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
770 elf_xtensa_hide_symbol (info, h, force_local)
771 struct bfd_link_info *info;
772 struct elf_link_hash_entry *h;
773 bfd_boolean force_local;
775 /* For a shared link, move the plt refcount to the got refcount to leave
776 space for RELATIVE relocs. */
777 elf_xtensa_make_sym_local (info, h);
779 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
784 elf_xtensa_copy_indirect_symbol (bed, dir, ind)
785 struct elf_backend_data *bed;
786 struct elf_link_hash_entry *dir, *ind;
788 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
790 /* The standard function doesn't copy the NEEDS_PLT flag. */
791 dir->elf_link_hash_flags |=
792 (ind->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT);
796 /* Return the section that should be marked against GC for a given
800 elf_xtensa_gc_mark_hook (sec, info, rel, h, sym)
802 struct bfd_link_info *info ATTRIBUTE_UNUSED;
803 Elf_Internal_Rela *rel;
804 struct elf_link_hash_entry *h;
805 Elf_Internal_Sym *sym;
809 switch (ELF32_R_TYPE (rel->r_info))
811 case R_XTENSA_GNU_VTINHERIT:
812 case R_XTENSA_GNU_VTENTRY:
816 switch (h->root.type)
818 case bfd_link_hash_defined:
819 case bfd_link_hash_defweak:
820 return h->root.u.def.section;
822 case bfd_link_hash_common:
823 return h->root.u.c.p->section;
831 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
836 /* Update the GOT & PLT entry reference counts
837 for the section being removed. */
840 elf_xtensa_gc_sweep_hook (abfd, info, sec, relocs)
842 struct bfd_link_info *info ATTRIBUTE_UNUSED;
844 const Elf_Internal_Rela *relocs;
846 Elf_Internal_Shdr *symtab_hdr;
847 struct elf_link_hash_entry **sym_hashes;
848 bfd_signed_vma *local_got_refcounts;
849 const Elf_Internal_Rela *rel, *relend;
851 if ((sec->flags & SEC_ALLOC) == 0)
854 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
855 sym_hashes = elf_sym_hashes (abfd);
856 local_got_refcounts = elf_local_got_refcounts (abfd);
858 relend = relocs + sec->reloc_count;
859 for (rel = relocs; rel < relend; rel++)
861 unsigned long r_symndx;
863 struct elf_link_hash_entry *h = NULL;
865 r_symndx = ELF32_R_SYM (rel->r_info);
866 if (r_symndx >= symtab_hdr->sh_info)
867 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
869 r_type = ELF32_R_TYPE (rel->r_info);
875 if (h->got.refcount > 0)
882 if (h->plt.refcount > 0)
887 if (local_got_refcounts[r_symndx] > 0)
888 local_got_refcounts[r_symndx] -= 1;
900 /* Create all the dynamic sections. */
903 elf_xtensa_create_dynamic_sections (dynobj, info)
905 struct bfd_link_info *info;
910 /* First do all the standard stuff. */
911 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
914 /* Create any extra PLT sections in case check_relocs has already
915 been called on all the non-dynamic input files. */
916 if (!add_extra_plt_sections (dynobj, plt_reloc_count))
919 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
920 | SEC_LINKER_CREATED | SEC_READONLY);
922 /* Mark the ".got.plt" section READONLY. */
923 s = bfd_get_section_by_name (dynobj, ".got.plt");
925 || ! bfd_set_section_flags (dynobj, s, flags))
928 /* Create ".rela.got". */
929 s = bfd_make_section (dynobj, ".rela.got");
931 || ! bfd_set_section_flags (dynobj, s, flags)
932 || ! bfd_set_section_alignment (dynobj, s, 2))
935 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
936 s = bfd_make_section (dynobj, ".xt.lit.plt");
938 || ! bfd_set_section_flags (dynobj, s, flags)
939 || ! bfd_set_section_alignment (dynobj, s, 2))
947 add_extra_plt_sections (dynobj, count)
953 /* Iterate over all chunks except 0 which uses the standard ".plt" and
954 ".got.plt" sections. */
955 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
961 /* Stop when we find a section has already been created. */
962 if (elf_xtensa_get_plt_section (dynobj, chunk))
965 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
966 | SEC_LINKER_CREATED | SEC_READONLY);
968 sname = (char *) bfd_malloc (10);
969 sprintf (sname, ".plt.%u", chunk);
970 s = bfd_make_section (dynobj, sname);
972 || ! bfd_set_section_flags (dynobj, s, flags | SEC_CODE)
973 || ! bfd_set_section_alignment (dynobj, s, 2))
976 sname = (char *) bfd_malloc (14);
977 sprintf (sname, ".got.plt.%u", chunk);
978 s = bfd_make_section (dynobj, sname);
980 || ! bfd_set_section_flags (dynobj, s, flags)
981 || ! bfd_set_section_alignment (dynobj, s, 2))
989 /* Adjust a symbol defined by a dynamic object and referenced by a
990 regular object. The current definition is in some section of the
991 dynamic object, but we're not including those sections. We have to
992 change the definition to something the rest of the link can
996 elf_xtensa_adjust_dynamic_symbol (info, h)
997 struct bfd_link_info *info ATTRIBUTE_UNUSED;
998 struct elf_link_hash_entry *h;
1000 /* If this is a weak symbol, and there is a real definition, the
1001 processor independent code will have arranged for us to see the
1002 real definition first, and we can just use the same value. */
1003 if (h->weakdef != NULL)
1005 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1006 || h->weakdef->root.type == bfd_link_hash_defweak);
1007 h->root.u.def.section = h->weakdef->root.u.def.section;
1008 h->root.u.def.value = h->weakdef->root.u.def.value;
1012 /* This is a reference to a symbol defined by a dynamic object. The
1013 reference must go through the GOT, so there's no need for COPY relocs,
1021 elf_xtensa_make_sym_local (info, h)
1022 struct bfd_link_info *info;
1023 struct elf_link_hash_entry *h;
1027 if (h->plt.refcount > 0)
1029 /* Will use RELATIVE relocs instead of JMP_SLOT relocs. */
1030 if (h->got.refcount < 0)
1031 h->got.refcount = 0;
1032 h->got.refcount += h->plt.refcount;
1033 h->plt.refcount = 0;
1038 /* Don't need any dynamic relocations at all. */
1039 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1040 h->plt.refcount = 0;
1041 h->got.refcount = 0;
1047 elf_xtensa_fix_refcounts (h, arg)
1048 struct elf_link_hash_entry *h;
1051 struct bfd_link_info *info = (struct bfd_link_info *) arg;
1053 if (h->root.type == bfd_link_hash_warning)
1054 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1056 if (! xtensa_elf_dynamic_symbol_p (info, h))
1057 elf_xtensa_make_sym_local (info, h);
1059 /* If the symbol has a relocation outside the GOT, set the
1061 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) != 0)
1062 info->flags |= DF_TEXTREL;
1069 elf_xtensa_allocate_plt_size (h, arg)
1070 struct elf_link_hash_entry *h;
1073 asection *srelplt = (asection *) arg;
1075 if (h->root.type == bfd_link_hash_warning)
1076 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1078 if (h->plt.refcount > 0)
1079 srelplt->_raw_size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1086 elf_xtensa_allocate_got_size (h, arg)
1087 struct elf_link_hash_entry *h;
1090 asection *srelgot = (asection *) arg;
1092 if (h->root.type == bfd_link_hash_warning)
1093 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1095 if (h->got.refcount > 0)
1096 srelgot->_raw_size += (h->got.refcount * sizeof (Elf32_External_Rela));
1103 elf_xtensa_allocate_local_got_size (info, srelgot)
1104 struct bfd_link_info *info;
1109 for (i = info->input_bfds; i; i = i->link_next)
1111 bfd_signed_vma *local_got_refcounts;
1112 bfd_size_type j, cnt;
1113 Elf_Internal_Shdr *symtab_hdr;
1115 local_got_refcounts = elf_local_got_refcounts (i);
1116 if (!local_got_refcounts)
1119 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1120 cnt = symtab_hdr->sh_info;
1122 for (j = 0; j < cnt; ++j)
1124 if (local_got_refcounts[j] > 0)
1125 srelgot->_raw_size += (local_got_refcounts[j]
1126 * sizeof (Elf32_External_Rela));
1132 /* Set the sizes of the dynamic sections. */
1135 elf_xtensa_size_dynamic_sections (output_bfd, info)
1136 bfd *output_bfd ATTRIBUTE_UNUSED;
1137 struct bfd_link_info *info;
1140 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl;
1141 bfd_boolean relplt, relgot;
1142 int plt_entries, plt_chunks, chunk;
1148 dynobj = elf_hash_table (info)->dynobj;
1152 if (elf_hash_table (info)->dynamic_sections_created)
1154 /* Set the contents of the .interp section to the interpreter. */
1157 s = bfd_get_section_by_name (dynobj, ".interp");
1160 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1161 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1164 /* Allocate room for one word in ".got". */
1165 s = bfd_get_section_by_name (dynobj, ".got");
1170 /* Adjust refcounts for symbols that we now know are not "dynamic". */
1171 elf_link_hash_traverse (elf_hash_table (info),
1172 elf_xtensa_fix_refcounts,
1175 /* Allocate space in ".rela.got" for literals that reference
1177 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1178 if (srelgot == NULL)
1180 elf_link_hash_traverse (elf_hash_table (info),
1181 elf_xtensa_allocate_got_size,
1184 /* If we are generating a shared object, we also need space in
1185 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1186 reference local symbols. */
1188 elf_xtensa_allocate_local_got_size (info, srelgot);
1190 /* Allocate space in ".rela.plt" for literals that have PLT entries. */
1191 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1192 if (srelplt == NULL)
1194 elf_link_hash_traverse (elf_hash_table (info),
1195 elf_xtensa_allocate_plt_size,
1198 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1199 each PLT entry, we need the PLT code plus a 4-byte literal.
1200 For each chunk of ".plt", we also need two more 4-byte
1201 literals, two corresponding entries in ".rela.got", and an
1202 8-byte entry in ".xt.lit.plt". */
1203 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
1204 if (spltlittbl == NULL)
1207 plt_entries = srelplt->_raw_size / sizeof (Elf32_External_Rela);
1209 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1211 /* Iterate over all the PLT chunks, including any extra sections
1212 created earlier because the initial count of PLT relocations
1213 was an overestimate. */
1215 (splt = elf_xtensa_get_plt_section (dynobj, chunk)) != NULL;
1220 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1221 if (sgotplt == NULL)
1224 if (chunk < plt_chunks - 1)
1225 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1226 else if (chunk == plt_chunks - 1)
1227 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1231 if (chunk_entries != 0)
1233 sgotplt->_raw_size = 4 * (chunk_entries + 2);
1234 splt->_raw_size = PLT_ENTRY_SIZE * chunk_entries;
1235 srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela);
1236 spltlittbl->_raw_size += 8;
1240 sgotplt->_raw_size = 0;
1241 splt->_raw_size = 0;
1246 /* Allocate memory for dynamic sections. */
1249 for (s = dynobj->sections; s != NULL; s = s->next)
1254 if ((s->flags & SEC_LINKER_CREATED) == 0)
1257 /* It's OK to base decisions on the section name, because none
1258 of the dynobj section names depend upon the input files. */
1259 name = bfd_get_section_name (dynobj, s);
1263 if (strncmp (name, ".rela", 5) == 0)
1265 if (strcmp (name, ".rela.plt") == 0)
1267 else if (strcmp (name, ".rela.got") == 0)
1270 /* We use the reloc_count field as a counter if we need
1271 to copy relocs into the output file. */
1274 else if (strncmp (name, ".plt.", 5) == 0
1275 || strncmp (name, ".got.plt.", 9) == 0)
1277 if (s->_raw_size == 0)
1279 /* If we don't need this section, strip it from the output
1280 file. We must create the ".plt*" and ".got.plt*"
1281 sections in create_dynamic_sections and/or check_relocs
1282 based on a conservative estimate of the PLT relocation
1283 count, because the sections must be created before the
1284 linker maps input sections to output sections. The
1285 linker does that before size_dynamic_sections, where we
1286 compute the exact size of the PLT, so there may be more
1287 of these sections than are actually needed. */
1291 else if (strcmp (name, ".got") != 0
1292 && strcmp (name, ".plt") != 0
1293 && strcmp (name, ".got.plt") != 0
1294 && strcmp (name, ".xt.lit.plt") != 0)
1296 /* It's not one of our sections, so don't allocate space. */
1301 _bfd_strip_section_from_output (info, s);
1304 /* Allocate memory for the section contents. */
1305 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1306 if (s->contents == NULL && s->_raw_size != 0)
1311 if (elf_hash_table (info)->dynamic_sections_created)
1313 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1314 known until finish_dynamic_sections, but we need to get the relocs
1315 in place before they are sorted. */
1316 if (srelgot == NULL)
1318 for (chunk = 0; chunk < plt_chunks; chunk++)
1320 Elf_Internal_Rela irela;
1324 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1327 loc = (srelgot->contents
1328 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1329 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1330 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1331 loc + sizeof (Elf32_External_Rela));
1332 srelgot->reloc_count += 2;
1335 /* Add some entries to the .dynamic section. We fill in the
1336 values later, in elf_xtensa_finish_dynamic_sections, but we
1337 must add the entries now so that we get the correct size for
1338 the .dynamic section. The DT_DEBUG entry is filled in by the
1339 dynamic linker and used by the debugger. */
1340 #define add_dynamic_entry(TAG, VAL) \
1341 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1345 if (!add_dynamic_entry (DT_DEBUG, 0))
1351 if (!add_dynamic_entry (DT_PLTGOT, 0)
1352 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1353 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1354 || !add_dynamic_entry (DT_JMPREL, 0))
1360 if (!add_dynamic_entry (DT_RELA, 0)
1361 || !add_dynamic_entry (DT_RELASZ, 0)
1362 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1366 if ((info->flags & DF_TEXTREL) != 0)
1368 if (!add_dynamic_entry (DT_TEXTREL, 0))
1372 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1373 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1376 #undef add_dynamic_entry
1382 /* Remove any PT_LOAD segments with no allocated sections. Prior to
1383 binutils 2.13, this function used to remove the non-SEC_ALLOC
1384 sections from PT_LOAD segments, but that task has now been moved
1385 into elf.c. We still need this function to remove any empty
1386 segments that result, but there's nothing Xtensa-specific about
1387 this and it probably ought to be moved into elf.c as well. */
1390 elf_xtensa_modify_segment_map (abfd)
1393 struct elf_segment_map **m_p;
1395 m_p = &elf_tdata (abfd)->segment_map;
1396 while (*m_p != NULL)
1398 if ((*m_p)->p_type == PT_LOAD && (*m_p)->count == 0)
1399 *m_p = (*m_p)->next;
1401 m_p = &(*m_p)->next;
1407 /* Perform the specified relocation. The instruction at (contents + address)
1408 is modified to set one operand to represent the value in "relocation". The
1409 operand position is determined by the relocation type recorded in the
1412 #define CALL_SEGMENT_BITS (30)
1413 #define CALL_SEGMENT_SIZE (1<<CALL_SEGMENT_BITS)
1415 static bfd_reloc_status_type
1416 elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
1417 contents, address, is_weak_undef, error_message)
1418 reloc_howto_type *howto;
1420 asection *input_section;
1424 bfd_boolean is_weak_undef;
1425 char **error_message;
1427 xtensa_opcode opcode;
1428 xtensa_operand operand;
1429 xtensa_encode_result encode_result;
1430 xtensa_isa isa = xtensa_default_isa;
1431 xtensa_insnbuf ibuff;
1432 bfd_vma self_address;
1436 switch (howto->type)
1439 return bfd_reloc_ok;
1441 case R_XTENSA_ASM_EXPAND:
1444 /* Check for windowed CALL across a 1GB boundary. */
1445 xtensa_opcode opcode =
1446 get_expanded_call_opcode (contents + address,
1447 input_section->_raw_size - address);
1448 if (is_windowed_call_opcode (opcode))
1450 self_address = (input_section->output_section->vma
1451 + input_section->output_offset
1453 if ((self_address >> CALL_SEGMENT_BITS) !=
1454 (relocation >> CALL_SEGMENT_BITS))
1456 *error_message = "windowed longcall crosses 1GB boundary; "
1458 return bfd_reloc_dangerous;
1462 return bfd_reloc_ok;
1464 case R_XTENSA_ASM_SIMPLIFY:
1466 /* Convert the L32R/CALLX to CALL. */
1467 bfd_reloc_status_type retval =
1468 elf_xtensa_do_asm_simplify (contents, address,
1469 input_section->_raw_size);
1470 if (retval != bfd_reloc_ok)
1473 /* The CALL needs to be relocated. Continue below for that part. */
1475 howto = &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
1483 x = bfd_get_32 (abfd, contents + address);
1485 bfd_put_32 (abfd, x, contents + address);
1487 return bfd_reloc_ok;
1490 /* Read the instruction into a buffer and decode the opcode. */
1491 ibuff = xtensa_insnbuf_alloc (isa);
1492 xtensa_insnbuf_from_chars (isa, ibuff, contents + address);
1493 opcode = xtensa_decode_insn (isa, ibuff);
1495 /* Determine which operand is being relocated. */
1496 if (opcode == XTENSA_UNDEFINED)
1498 *error_message = "cannot decode instruction";
1499 return bfd_reloc_dangerous;
1502 if (howto->type < R_XTENSA_OP0 || howto->type > R_XTENSA_OP2)
1504 *error_message = "unexpected relocation";
1505 return bfd_reloc_dangerous;
1508 opnd = howto->type - R_XTENSA_OP0;
1510 /* Calculate the PC address for this instruction. */
1511 if (!howto->pc_relative)
1513 *error_message = "expected PC-relative relocation";
1514 return bfd_reloc_dangerous;
1517 self_address = (input_section->output_section->vma
1518 + input_section->output_offset
1521 /* Apply the relocation. */
1522 operand = xtensa_get_operand (isa, opcode, opnd);
1523 newval = xtensa_operand_do_reloc (operand, relocation, self_address);
1524 encode_result = xtensa_operand_encode (operand, &newval);
1525 xtensa_operand_set_field (operand, ibuff, newval);
1527 /* Write the modified instruction back out of the buffer. */
1528 xtensa_insnbuf_to_chars (isa, ibuff, contents + address);
1531 if (encode_result != xtensa_encode_result_ok)
1533 char *message = build_encoding_error_message (opcode, encode_result);
1534 *error_message = message;
1535 return bfd_reloc_dangerous;
1538 /* Final check for call. */
1539 if (is_direct_call_opcode (opcode)
1540 && is_windowed_call_opcode (opcode))
1542 if ((self_address >> CALL_SEGMENT_BITS) !=
1543 (relocation >> CALL_SEGMENT_BITS))
1545 *error_message = "windowed call crosses 1GB boundary; "
1547 return bfd_reloc_dangerous;
1551 return bfd_reloc_ok;
1556 vsprint_msg VPARAMS ((const char *origmsg, const char *fmt, int arglen, ...))
1558 /* To reduce the size of the memory leak,
1559 we only use a single message buffer. */
1560 static bfd_size_type alloc_size = 0;
1561 static char *message = NULL;
1562 bfd_size_type orig_len, len = 0;
1563 bfd_boolean is_append;
1565 VA_OPEN (ap, arglen);
1566 VA_FIXEDARG (ap, const char *, origmsg);
1568 is_append = (origmsg == message);
1570 orig_len = strlen (origmsg);
1571 len = orig_len + strlen (fmt) + arglen + 20;
1572 if (len > alloc_size)
1574 message = (char *) bfd_realloc (message, len);
1578 memcpy (message, origmsg, orig_len);
1579 vsprintf (message + orig_len, fmt, ap);
1586 build_encoding_error_message (opcode, encode_result)
1587 xtensa_opcode opcode;
1588 xtensa_encode_result encode_result;
1590 const char *opname = xtensa_opcode_name (xtensa_default_isa, opcode);
1591 const char *msg = NULL;
1593 switch (encode_result)
1595 case xtensa_encode_result_ok:
1596 msg = "unexpected valid encoding";
1598 case xtensa_encode_result_align:
1599 msg = "misaligned encoding";
1601 case xtensa_encode_result_not_in_table:
1602 msg = "encoding not in lookup table";
1604 case xtensa_encode_result_too_low:
1605 msg = "encoding out of range: too low";
1607 case xtensa_encode_result_too_high:
1608 msg = "encoding out of range: too high";
1610 case xtensa_encode_result_not_ok:
1612 msg = "could not encode";
1616 if (is_direct_call_opcode (opcode)
1617 && (encode_result == xtensa_encode_result_too_low
1618 || encode_result == xtensa_encode_result_too_high))
1620 msg = "direct call out of range";
1622 else if (opcode == get_l32r_opcode ())
1624 /* L32Rs have the strange interaction with encoding in that they
1625 have an unsigned immediate field, so libisa returns "too high"
1626 when the absolute value is out of range and never returns "too
1627 low", but I leave the "too low" message in case anything
1629 if (encode_result == xtensa_encode_result_too_low)
1630 msg = "literal out of range";
1631 else if (encode_result == xtensa_encode_result_too_high)
1632 msg = "literal placed after use";
1635 return vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
1639 /* This function is registered as the "special_function" in the
1640 Xtensa howto for handling simplify operations.
1641 bfd_perform_relocation / bfd_install_relocation use it to
1642 perform (install) the specified relocation. Since this replaces the code
1643 in bfd_perform_relocation, it is basically an Xtensa-specific,
1644 stripped-down version of bfd_perform_relocation. */
1646 static bfd_reloc_status_type
1647 bfd_elf_xtensa_reloc (abfd, reloc_entry, symbol, data, input_section,
1648 output_bfd, error_message)
1650 arelent *reloc_entry;
1653 asection *input_section;
1655 char **error_message;
1658 bfd_reloc_status_type flag;
1659 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1660 bfd_vma output_base = 0;
1661 reloc_howto_type *howto = reloc_entry->howto;
1662 asection *reloc_target_output_section;
1663 bfd_boolean is_weak_undef;
1665 /* ELF relocs are against symbols. If we are producing relocateable
1666 output, and the reloc is against an external symbol, the resulting
1667 reloc will also be against the same symbol. In such a case, we
1668 don't want to change anything about the way the reloc is handled,
1669 since it will all be done at final link time. This test is similar
1670 to what bfd_elf_generic_reloc does except that it lets relocs with
1671 howto->partial_inplace go through even if the addend is non-zero.
1672 (The real problem is that partial_inplace is set for XTENSA_32
1673 relocs to begin with, but that's a long story and there's little we
1674 can do about it now....) */
1676 if (output_bfd != (bfd *) NULL
1677 && (symbol->flags & BSF_SECTION_SYM) == 0)
1679 reloc_entry->address += input_section->output_offset;
1680 return bfd_reloc_ok;
1683 /* Is the address of the relocation really within the section? */
1684 if (reloc_entry->address > (input_section->_cooked_size
1685 / bfd_octets_per_byte (abfd)))
1686 return bfd_reloc_outofrange;
1688 /* Work out which section the relocation is targetted at and the
1689 initial relocation command value. */
1691 /* Get symbol value. (Common symbols are special.) */
1692 if (bfd_is_com_section (symbol->section))
1695 relocation = symbol->value;
1697 reloc_target_output_section = symbol->section->output_section;
1699 /* Convert input-section-relative symbol value to absolute. */
1700 if ((output_bfd && !howto->partial_inplace)
1701 || reloc_target_output_section == NULL)
1704 output_base = reloc_target_output_section->vma;
1706 relocation += output_base + symbol->section->output_offset;
1708 /* Add in supplied addend. */
1709 relocation += reloc_entry->addend;
1711 /* Here the variable relocation holds the final address of the
1712 symbol we are relocating against, plus any addend. */
1715 if (!howto->partial_inplace)
1717 /* This is a partial relocation, and we want to apply the relocation
1718 to the reloc entry rather than the raw data. Everything except
1719 relocations against section symbols has already been handled
1722 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
1723 reloc_entry->addend = relocation;
1724 reloc_entry->address += input_section->output_offset;
1725 return bfd_reloc_ok;
1729 reloc_entry->address += input_section->output_offset;
1730 reloc_entry->addend = 0;
1734 is_weak_undef = (bfd_is_und_section (symbol->section)
1735 && (symbol->flags & BSF_WEAK) != 0);
1736 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
1737 (bfd_byte *) data, (bfd_vma) octets,
1738 is_weak_undef, error_message);
1740 if (flag == bfd_reloc_dangerous)
1742 /* Add the symbol name to the error message. */
1743 if (! *error_message)
1744 *error_message = "";
1745 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
1746 strlen (symbol->name) + 17,
1747 symbol->name, reloc_entry->addend);
1754 /* Set up an entry in the procedure linkage table. */
1757 elf_xtensa_create_plt_entry (dynobj, output_bfd, reloc_index)
1760 unsigned reloc_index;
1762 asection *splt, *sgotplt;
1763 bfd_vma plt_base, got_base;
1764 bfd_vma code_offset, lit_offset;
1767 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
1768 splt = elf_xtensa_get_plt_section (dynobj, chunk);
1769 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1770 BFD_ASSERT (splt != NULL && sgotplt != NULL);
1772 plt_base = splt->output_section->vma + splt->output_offset;
1773 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1775 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
1776 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
1778 /* Fill in the literal entry. This is the offset of the dynamic
1779 relocation entry. */
1780 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
1781 sgotplt->contents + lit_offset);
1783 /* Fill in the entry in the procedure linkage table. */
1784 memcpy (splt->contents + code_offset,
1785 (bfd_big_endian (output_bfd)
1786 ? elf_xtensa_be_plt_entry
1787 : elf_xtensa_le_plt_entry),
1789 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
1790 plt_base + code_offset + 3),
1791 splt->contents + code_offset + 4);
1792 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
1793 plt_base + code_offset + 6),
1794 splt->contents + code_offset + 7);
1795 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
1796 plt_base + code_offset + 9),
1797 splt->contents + code_offset + 10);
1799 return plt_base + code_offset;
1804 xtensa_elf_dynamic_symbol_p (info, h)
1805 struct bfd_link_info *info;
1806 struct elf_link_hash_entry *h;
1811 while (h->root.type == bfd_link_hash_indirect
1812 || h->root.type == bfd_link_hash_warning)
1813 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1815 if (h->dynindx == -1)
1818 if (h->root.type == bfd_link_hash_undefweak
1819 || h->root.type == bfd_link_hash_defweak)
1822 switch (ELF_ST_VISIBILITY (h->other))
1830 if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
1835 if ((info->shared && !info->symbolic)
1836 || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1843 /* Relocate an Xtensa ELF section. This is invoked by the linker for
1844 both relocateable and final links. */
1847 elf_xtensa_relocate_section (output_bfd, info, input_bfd,
1848 input_section, contents, relocs,
1849 local_syms, local_sections)
1851 struct bfd_link_info *info;
1853 asection *input_section;
1855 Elf_Internal_Rela *relocs;
1856 Elf_Internal_Sym *local_syms;
1857 asection **local_sections;
1859 Elf_Internal_Shdr *symtab_hdr;
1860 Elf_Internal_Rela *rel;
1861 Elf_Internal_Rela *relend;
1862 struct elf_link_hash_entry **sym_hashes;
1863 asection *srelgot, *srelplt;
1865 char *error_message = NULL;
1867 if (xtensa_default_isa == NULL)
1870 dynobj = elf_hash_table (info)->dynobj;
1871 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1872 sym_hashes = elf_sym_hashes (input_bfd);
1878 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
1879 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1883 relend = relocs + input_section->reloc_count;
1884 for (; rel < relend; rel++)
1887 reloc_howto_type *howto;
1888 unsigned long r_symndx;
1889 struct elf_link_hash_entry *h;
1890 Elf_Internal_Sym *sym;
1893 bfd_reloc_status_type r;
1894 bfd_boolean is_weak_undef;
1895 bfd_boolean unresolved_reloc;
1898 r_type = ELF32_R_TYPE (rel->r_info);
1899 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
1900 || r_type == (int) R_XTENSA_GNU_VTENTRY)
1903 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
1905 bfd_set_error (bfd_error_bad_value);
1908 howto = &elf_howto_table[r_type];
1910 r_symndx = ELF32_R_SYM (rel->r_info);
1912 if (info->relocateable)
1914 /* This is a relocateable link.
1915 1) If the reloc is against a section symbol, adjust
1916 according to the output section.
1917 2) If there is a new target for this relocation,
1918 the new target will be in the same output section.
1919 We adjust the relocation by the output section
1922 if (relaxing_section)
1924 /* Check if this references a section in another input file. */
1925 do_fix_for_relocateable_link (rel, input_bfd, input_section);
1926 r_type = ELF32_R_TYPE (rel->r_info);
1929 if (r_type == R_XTENSA_ASM_SIMPLIFY)
1931 /* Convert ASM_SIMPLIFY into the simpler relocation
1932 so that they never escape a relaxing link. */
1933 contract_asm_expansion (contents, input_section->_raw_size, rel);
1934 r_type = ELF32_R_TYPE (rel->r_info);
1937 /* This is a relocateable link, so we don't have to change
1938 anything unless the reloc is against a section symbol,
1939 in which case we have to adjust according to where the
1940 section symbol winds up in the output section. */
1941 if (r_symndx < symtab_hdr->sh_info)
1943 sym = local_syms + r_symndx;
1944 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1946 sec = local_sections[r_symndx];
1947 rel->r_addend += sec->output_offset + sym->st_value;
1951 /* If there is an addend with a partial_inplace howto,
1952 then move the addend to the contents. This is a hack
1953 to work around problems with DWARF in relocateable links
1954 with some previous version of BFD. Now we can't easily get
1955 rid of the hack without breaking backward compatibility.... */
1958 howto = &elf_howto_table[r_type];
1959 if (howto->partial_inplace)
1961 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
1962 rel->r_addend, contents,
1963 rel->r_offset, FALSE,
1965 if (r != bfd_reloc_ok)
1967 if (!((*info->callbacks->reloc_dangerous)
1968 (info, error_message, input_bfd, input_section,
1976 /* Done with work for relocateable link; continue with next reloc. */
1980 /* This is a final link. */
1985 is_weak_undef = FALSE;
1986 unresolved_reloc = FALSE;
1989 if (howto->partial_inplace)
1991 /* Because R_XTENSA_32 was made partial_inplace to fix some
1992 problems with DWARF info in partial links, there may be
1993 an addend stored in the contents. Take it out of there
1994 and move it back into the addend field of the reloc. */
1995 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
1996 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
1999 if (r_symndx < symtab_hdr->sh_info)
2001 sym = local_syms + r_symndx;
2002 sec = local_sections[r_symndx];
2003 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
2007 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2009 while (h->root.type == bfd_link_hash_indirect
2010 || h->root.type == bfd_link_hash_warning)
2011 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2014 if (h->root.type == bfd_link_hash_defined
2015 || h->root.type == bfd_link_hash_defweak)
2017 sec = h->root.u.def.section;
2019 if (sec->output_section == NULL)
2020 /* Set a flag that will be cleared later if we find a
2021 relocation value for this symbol. output_section
2022 is typically NULL for symbols satisfied by a shared
2024 unresolved_reloc = TRUE;
2026 relocation = (h->root.u.def.value
2027 + sec->output_section->vma
2028 + sec->output_offset);
2030 else if (h->root.type == bfd_link_hash_undefweak)
2031 is_weak_undef = TRUE;
2032 else if (info->shared
2033 && !info->no_undefined
2034 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2038 if (! ((*info->callbacks->undefined_symbol)
2039 (info, h->root.root.string, input_bfd,
2040 input_section, rel->r_offset,
2041 (!info->shared || info->no_undefined
2042 || ELF_ST_VISIBILITY (h->other)))))
2048 if (relaxing_section)
2050 /* Check if this references a section in another input file. */
2051 do_fix_for_final_link (rel, input_section, &relocation);
2053 /* Update some already cached values. */
2054 r_type = ELF32_R_TYPE (rel->r_info);
2055 howto = &elf_howto_table[r_type];
2058 /* Sanity check the address. */
2059 if (rel->r_offset >= input_section->_raw_size
2060 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2062 bfd_set_error (bfd_error_bad_value);
2066 /* Generate dynamic relocations. */
2067 if (elf_hash_table (info)->dynamic_sections_created)
2069 bfd_boolean dynamic_symbol = xtensa_elf_dynamic_symbol_p (info, h);
2071 if (dynamic_symbol && (r_type == R_XTENSA_OP0
2072 || r_type == R_XTENSA_OP1
2073 || r_type == R_XTENSA_OP2))
2075 /* This is an error. The symbol's real value won't be known
2076 until runtime and it's likely to be out of range anyway. */
2077 const char *name = h->root.root.string;
2078 error_message = vsprint_msg ("invalid relocation for dynamic "
2080 strlen (name) + 2, name);
2081 if (!((*info->callbacks->reloc_dangerous)
2082 (info, error_message, input_bfd, input_section,
2086 else if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
2087 && (input_section->flags & SEC_ALLOC) != 0
2088 && (dynamic_symbol || info->shared))
2090 Elf_Internal_Rela outrel;
2094 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2099 BFD_ASSERT (srel != NULL);
2102 _bfd_elf_section_offset (output_bfd, info,
2103 input_section, rel->r_offset);
2105 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2106 memset (&outrel, 0, sizeof outrel);
2109 outrel.r_offset = (input_section->output_section->vma
2110 + input_section->output_offset);
2114 outrel.r_addend = rel->r_addend;
2117 if (r_type == R_XTENSA_32)
2120 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2123 else /* r_type == R_XTENSA_PLT */
2126 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2128 /* Create the PLT entry and set the initial
2129 contents of the literal entry to the address of
2132 elf_xtensa_create_plt_entry (dynobj, output_bfd,
2135 unresolved_reloc = FALSE;
2139 /* Generate a RELATIVE relocation. */
2140 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2141 outrel.r_addend = 0;
2145 loc = (srel->contents
2146 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2147 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2148 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2149 <= srel->_cooked_size);
2153 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2154 because such sections are not SEC_ALLOC and thus ld.so will
2155 not process them. */
2156 if (unresolved_reloc
2157 && !((input_section->flags & SEC_DEBUGGING) != 0
2158 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2159 (*_bfd_error_handler)
2160 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2161 bfd_archive_filename (input_bfd),
2162 bfd_get_section_name (input_bfd, input_section),
2163 (long) rel->r_offset,
2164 h->root.root.string);
2166 /* There's no point in calling bfd_perform_relocation here.
2167 Just go directly to our "special function". */
2168 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2169 relocation + rel->r_addend,
2170 contents, rel->r_offset, is_weak_undef,
2173 if (r != bfd_reloc_ok && !warned)
2177 BFD_ASSERT (r == bfd_reloc_dangerous);
2178 BFD_ASSERT (error_message != (char *) NULL);
2181 name = h->root.root.string;
2184 name = bfd_elf_string_from_elf_section
2185 (input_bfd, symtab_hdr->sh_link, sym->st_name);
2186 if (name && *name == '\0')
2187 name = bfd_section_name (input_bfd, sec);
2190 error_message = vsprint_msg (error_message, ": %s",
2191 strlen (name), name);
2192 if (!((*info->callbacks->reloc_dangerous)
2193 (info, error_message, input_bfd, input_section,
2203 /* Finish up dynamic symbol handling. There's not much to do here since
2204 the PLT and GOT entries are all set up by relocate_section. */
2207 elf_xtensa_finish_dynamic_symbol (output_bfd, info, h, sym)
2208 bfd *output_bfd ATTRIBUTE_UNUSED;
2209 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2210 struct elf_link_hash_entry *h;
2211 Elf_Internal_Sym *sym;
2213 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
2214 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2216 /* Mark the symbol as undefined, rather than as defined in
2217 the .plt section. Leave the value alone. */
2218 sym->st_shndx = SHN_UNDEF;
2221 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2222 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2223 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2224 sym->st_shndx = SHN_ABS;
2230 /* Combine adjacent literal table entries in the output. Adjacent
2231 entries within each input section may have been removed during
2232 relaxation, but we repeat the process here, even though it's too late
2233 to shrink the output section, because it's important to minimize the
2234 number of literal table entries to reduce the start-up work for the
2235 runtime linker. Returns the number of remaining table entries or -1
2239 elf_xtensa_combine_prop_entries (output_bfd, secname)
2241 const char *secname;
2245 property_table_entry *table;
2246 bfd_size_type section_size;
2250 sec = bfd_get_section_by_name (output_bfd, secname);
2254 section_size = (sec->_cooked_size != 0 ? sec->_cooked_size : sec->_raw_size);
2255 BFD_ASSERT (section_size % 8 == 0);
2256 num = section_size / 8;
2258 contents = (bfd_byte *) bfd_malloc (section_size);
2259 table = (property_table_entry *)
2260 bfd_malloc (num * sizeof (property_table_entry));
2261 if (contents == 0 || table == 0)
2264 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
2265 propagates to the output section, where it doesn't really apply and
2266 where it breaks the following call to bfd_get_section_contents. */
2267 sec->flags &= ~SEC_IN_MEMORY;
2269 if (! bfd_get_section_contents (output_bfd, sec, contents, 0, section_size))
2272 /* There should never be any relocations left at this point, so this
2273 is quite a bit easier than what is done during relaxation. */
2275 /* Copy the raw contents into a property table array and sort it. */
2277 for (n = 0; n < num; n++)
2279 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
2280 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
2283 qsort (table, num, sizeof (property_table_entry), property_table_compare);
2285 for (n = 0; n < num; n++)
2287 bfd_boolean remove = FALSE;
2289 if (table[n].size == 0)
2292 (table[n-1].address + table[n-1].size == table[n].address))
2294 table[n-1].size += table[n].size;
2300 for (m = n; m < num - 1; m++)
2302 table[m].address = table[m+1].address;
2303 table[m].size = table[m+1].size;
2311 /* Copy the data back to the raw contents. */
2313 for (n = 0; n < num; n++)
2315 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
2316 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
2320 /* Clear the removed bytes. */
2321 if ((bfd_size_type) (num * 8) < section_size)
2323 memset (&contents[num * 8], 0, section_size - num * 8);
2324 sec->_cooked_size = num * 8;
2327 if (! bfd_set_section_contents (output_bfd, sec, contents, 0, section_size))
2335 /* Finish up the dynamic sections. */
2338 elf_xtensa_finish_dynamic_sections (output_bfd, info)
2340 struct bfd_link_info *info;
2343 asection *sdyn, *srelplt, *sgot;
2344 Elf32_External_Dyn *dyncon, *dynconend;
2345 int num_xtlit_entries;
2347 if (! elf_hash_table (info)->dynamic_sections_created)
2350 dynobj = elf_hash_table (info)->dynobj;
2351 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2352 BFD_ASSERT (sdyn != NULL);
2354 /* Set the first entry in the global offset table to the address of
2355 the dynamic section. */
2356 sgot = bfd_get_section_by_name (dynobj, ".got");
2359 BFD_ASSERT (sgot->_raw_size == 4);
2361 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2363 bfd_put_32 (output_bfd,
2364 sdyn->output_section->vma + sdyn->output_offset,
2368 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
2369 if (srelplt != NULL && srelplt->_raw_size != 0)
2371 asection *sgotplt, *srelgot, *spltlittbl;
2372 int chunk, plt_chunks, plt_entries;
2373 Elf_Internal_Rela irela;
2375 unsigned rtld_reloc;
2377 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
2378 BFD_ASSERT (srelgot != NULL);
2380 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
2381 BFD_ASSERT (spltlittbl != NULL);
2383 /* Find the first XTENSA_RTLD relocation. Presumably the rest
2384 of them follow immediately after.... */
2385 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
2387 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2388 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2389 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
2392 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
2394 plt_entries = (srelplt->_raw_size / sizeof (Elf32_External_Rela));
2396 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
2398 for (chunk = 0; chunk < plt_chunks; chunk++)
2400 int chunk_entries = 0;
2402 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
2403 BFD_ASSERT (sgotplt != NULL);
2405 /* Emit special RTLD relocations for the first two entries in
2406 each chunk of the .got.plt section. */
2408 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2409 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2410 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2411 irela.r_offset = (sgotplt->output_section->vma
2412 + sgotplt->output_offset);
2413 irela.r_addend = 1; /* tell rtld to set value to resolver function */
2414 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2416 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2418 /* Next literal immediately follows the first. */
2419 loc += sizeof (Elf32_External_Rela);
2420 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2421 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2422 irela.r_offset = (sgotplt->output_section->vma
2423 + sgotplt->output_offset + 4);
2424 /* Tell rtld to set value to object's link map. */
2426 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2428 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2430 /* Fill in the literal table. */
2431 if (chunk < plt_chunks - 1)
2432 chunk_entries = PLT_ENTRIES_PER_CHUNK;
2434 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
2436 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->_cooked_size);
2437 bfd_put_32 (output_bfd,
2438 sgotplt->output_section->vma + sgotplt->output_offset,
2439 spltlittbl->contents + (chunk * 8) + 0);
2440 bfd_put_32 (output_bfd,
2441 8 + (chunk_entries * 4),
2442 spltlittbl->contents + (chunk * 8) + 4);
2445 /* All the dynamic relocations have been emitted at this point.
2446 Make sure the relocation sections are the correct size. */
2447 if (srelgot->_cooked_size != (sizeof (Elf32_External_Rela)
2448 * srelgot->reloc_count)
2449 || srelplt->_cooked_size != (sizeof (Elf32_External_Rela)
2450 * srelplt->reloc_count))
2453 /* The .xt.lit.plt section has just been modified. This must
2454 happen before the code below which combines adjacent literal
2455 table entries, and the .xt.lit.plt contents have to be forced to
2457 if (! bfd_set_section_contents (output_bfd,
2458 spltlittbl->output_section,
2459 spltlittbl->contents,
2460 spltlittbl->output_offset,
2461 spltlittbl->_raw_size))
2463 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
2464 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
2467 /* Combine adjacent literal table entries. */
2468 BFD_ASSERT (! info->relocateable);
2469 num_xtlit_entries = elf_xtensa_combine_prop_entries (output_bfd, ".xt.lit");
2470 if (num_xtlit_entries < 0)
2473 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2474 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2475 for (; dyncon < dynconend; dyncon++)
2477 Elf_Internal_Dyn dyn;
2481 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2488 case DT_XTENSA_GOT_LOC_SZ:
2489 s = bfd_get_section_by_name (output_bfd, ".xt.lit");
2491 dyn.d_un.d_val = num_xtlit_entries;
2494 case DT_XTENSA_GOT_LOC_OFF:
2503 s = bfd_get_section_by_name (output_bfd, name);
2505 dyn.d_un.d_ptr = s->vma;
2509 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2511 dyn.d_un.d_val = (s->_cooked_size ? s->_cooked_size : s->_raw_size);
2515 /* Adjust RELASZ to not include JMPREL. This matches what
2516 glibc expects and what is done for several other ELF
2517 targets (e.g., i386, alpha), but the "correct" behavior
2518 seems to be unresolved. Since the linker script arranges
2519 for .rela.plt to follow all other relocation sections, we
2520 don't have to worry about changing the DT_RELA entry. */
2521 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2525 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
2530 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2537 /* Functions for dealing with the e_flags field. */
2539 /* Merge backend specific data from an object file to the output
2540 object file when linking. */
2543 elf_xtensa_merge_private_bfd_data (ibfd, obfd)
2547 unsigned out_mach, in_mach;
2548 flagword out_flag, in_flag;
2550 /* Check if we have the same endianess. */
2551 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
2554 /* Don't even pretend to support mixed-format linking. */
2555 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2556 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2559 out_flag = elf_elfheader (obfd)->e_flags;
2560 in_flag = elf_elfheader (ibfd)->e_flags;
2562 out_mach = out_flag & EF_XTENSA_MACH;
2563 in_mach = in_flag & EF_XTENSA_MACH;
2564 if (out_mach != in_mach)
2566 (*_bfd_error_handler)
2567 ("%s: incompatible machine type. Output is 0x%x. Input is 0x%x\n",
2568 bfd_archive_filename (ibfd), out_mach, in_mach);
2569 bfd_set_error (bfd_error_wrong_format);
2573 if (! elf_flags_init (obfd))
2575 elf_flags_init (obfd) = TRUE;
2576 elf_elfheader (obfd)->e_flags = in_flag;
2578 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2579 && bfd_get_arch_info (obfd)->the_default)
2580 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2581 bfd_get_mach (ibfd));
2586 if ((out_flag & EF_XTENSA_XT_INSN) !=
2587 (in_flag & EF_XTENSA_XT_INSN))
2588 elf_elfheader(obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
2590 if ((out_flag & EF_XTENSA_XT_LIT) !=
2591 (in_flag & EF_XTENSA_XT_LIT))
2592 elf_elfheader(obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
2599 elf_xtensa_set_private_flags (abfd, flags)
2603 BFD_ASSERT (!elf_flags_init (abfd)
2604 || elf_elfheader (abfd)->e_flags == flags);
2606 elf_elfheader (abfd)->e_flags |= flags;
2607 elf_flags_init (abfd) = TRUE;
2614 elf_xtensa_get_private_bfd_flags (abfd)
2617 return elf_elfheader (abfd)->e_flags;
2622 elf_xtensa_print_private_bfd_data (abfd, farg)
2626 FILE *f = (FILE *) farg;
2627 flagword e_flags = elf_elfheader (abfd)->e_flags;
2629 fprintf (f, "\nXtensa header:\n");
2630 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
2631 fprintf (f, "\nMachine = Base\n");
2633 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
2635 fprintf (f, "Insn tables = %s\n",
2636 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
2638 fprintf (f, "Literal tables = %s\n",
2639 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
2641 return _bfd_elf_print_private_bfd_data (abfd, farg);
2645 /* Set the right machine number for an Xtensa ELF file. */
2648 elf_xtensa_object_p (abfd)
2652 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
2657 mach = bfd_mach_xtensa;
2663 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
2668 /* The final processing done just before writing out an Xtensa ELF object
2669 file. This gets the Xtensa architecture right based on the machine
2673 elf_xtensa_final_write_processing (abfd, linker)
2675 bfd_boolean linker ATTRIBUTE_UNUSED;
2680 switch (mach = bfd_get_mach (abfd))
2682 case bfd_mach_xtensa:
2683 val = E_XTENSA_MACH;
2689 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
2690 elf_elfheader (abfd)->e_flags |= val;
2694 static enum elf_reloc_type_class
2695 elf_xtensa_reloc_type_class (rela)
2696 const Elf_Internal_Rela *rela;
2698 switch ((int) ELF32_R_TYPE (rela->r_info))
2700 case R_XTENSA_RELATIVE:
2701 return reloc_class_relative;
2702 case R_XTENSA_JMP_SLOT:
2703 return reloc_class_plt;
2705 return reloc_class_normal;
2711 elf_xtensa_discard_info_for_section (abfd, cookie, info, sec)
2713 struct elf_reloc_cookie *cookie;
2714 struct bfd_link_info *info;
2718 bfd_vma section_size;
2719 bfd_vma offset, actual_offset;
2720 size_t removed_bytes = 0;
2722 section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size);
2723 if (section_size == 0 || section_size % 8 != 0)
2726 if (sec->output_section
2727 && bfd_is_abs_section (sec->output_section))
2730 contents = retrieve_contents (abfd, sec, info->keep_memory);
2734 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
2737 release_contents (sec, contents);
2741 cookie->rel = cookie->rels;
2742 cookie->relend = cookie->rels + sec->reloc_count;
2744 for (offset = 0; offset < section_size; offset += 8)
2746 actual_offset = offset - removed_bytes;
2748 /* The ...symbol_deleted_p function will skip over relocs but it
2749 won't adjust their offsets, so do that here. */
2750 while (cookie->rel < cookie->relend
2751 && cookie->rel->r_offset < offset)
2753 cookie->rel->r_offset -= removed_bytes;
2757 while (cookie->rel < cookie->relend
2758 && cookie->rel->r_offset == offset)
2760 if (_bfd_elf32_reloc_symbol_deleted_p (offset, cookie))
2762 /* Remove the table entry. (If the reloc type is NONE, then
2763 the entry has already been merged with another and deleted
2764 during relaxation.) */
2765 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
2767 /* Shift the contents up. */
2768 if (offset + 8 < section_size)
2769 memmove (&contents[actual_offset],
2770 &contents[actual_offset+8],
2771 section_size - offset - 8);
2775 /* Remove this relocation. */
2776 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
2779 /* Adjust the relocation offset for previous removals. This
2780 should not be done before calling ...symbol_deleted_p
2781 because it might mess up the offset comparisons there.
2782 Make sure the offset doesn't underflow in the case where
2783 the first entry is removed. */
2784 if (cookie->rel->r_offset >= removed_bytes)
2785 cookie->rel->r_offset -= removed_bytes;
2787 cookie->rel->r_offset = 0;
2793 if (removed_bytes != 0)
2795 /* Adjust any remaining relocs (shouldn't be any). */
2796 for (; cookie->rel < cookie->relend; cookie->rel++)
2798 if (cookie->rel->r_offset >= removed_bytes)
2799 cookie->rel->r_offset -= removed_bytes;
2801 cookie->rel->r_offset = 0;
2804 /* Clear the removed bytes. */
2805 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
2807 pin_contents (sec, contents);
2808 pin_internal_relocs (sec, cookie->rels);
2810 sec->_cooked_size = section_size - removed_bytes;
2811 /* Also shrink _raw_size. See comments in relax_property_section. */
2812 sec->_raw_size = sec->_cooked_size;
2816 release_contents (sec, contents);
2817 release_internal_relocs (sec, cookie->rels);
2820 return (removed_bytes != 0);
2825 elf_xtensa_discard_info (abfd, cookie, info)
2827 struct elf_reloc_cookie *cookie;
2828 struct bfd_link_info *info;
2831 bfd_boolean changed = FALSE;
2833 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2835 if (xtensa_is_property_section (sec))
2837 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
2847 elf_xtensa_ignore_discarded_relocs (sec)
2850 return xtensa_is_property_section (sec);
2854 /* Support for core dump NOTE sections. */
2857 elf_xtensa_grok_prstatus (abfd, note)
2859 Elf_Internal_Note *note;
2862 unsigned int raw_size;
2864 /* The size for Xtensa is variable, so don't try to recognize the format
2865 based on the size. Just assume this is GNU/Linux. */
2868 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2871 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
2875 raw_size = note->descsz - offset - 4;
2877 /* Make a ".reg/999" section. */
2878 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2879 raw_size, note->descpos + offset);
2884 elf_xtensa_grok_psinfo (abfd, note)
2886 Elf_Internal_Note *note;
2888 switch (note->descsz)
2893 case 128: /* GNU/Linux elf_prpsinfo */
2894 elf_tdata (abfd)->core_program
2895 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
2896 elf_tdata (abfd)->core_command
2897 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
2900 /* Note that for some reason, a spurious space is tacked
2901 onto the end of the args in some (at least one anyway)
2902 implementations, so strip it off if it exists. */
2905 char *command = elf_tdata (abfd)->core_command;
2906 int n = strlen (command);
2908 if (0 < n && command[n - 1] == ' ')
2909 command[n - 1] = '\0';
2916 /* Generic Xtensa configurability stuff. */
2918 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
2919 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
2920 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
2921 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
2922 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
2923 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
2924 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
2925 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
2928 init_call_opcodes ()
2930 if (callx0_op == XTENSA_UNDEFINED)
2932 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
2933 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
2934 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
2935 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
2936 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
2937 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
2938 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
2939 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
2945 is_indirect_call_opcode (opcode)
2946 xtensa_opcode opcode;
2948 init_call_opcodes ();
2949 return (opcode == callx0_op
2950 || opcode == callx4_op
2951 || opcode == callx8_op
2952 || opcode == callx12_op);
2957 is_direct_call_opcode (opcode)
2958 xtensa_opcode opcode;
2960 init_call_opcodes ();
2961 return (opcode == call0_op
2962 || opcode == call4_op
2963 || opcode == call8_op
2964 || opcode == call12_op);
2969 is_windowed_call_opcode (opcode)
2970 xtensa_opcode opcode;
2972 init_call_opcodes ();
2973 return (opcode == call4_op
2974 || opcode == call8_op
2975 || opcode == call12_op
2976 || opcode == callx4_op
2977 || opcode == callx8_op
2978 || opcode == callx12_op);
2982 static xtensa_opcode
2983 get_l32r_opcode (void)
2985 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
2986 if (l32r_opcode == XTENSA_UNDEFINED)
2988 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
2989 BFD_ASSERT (l32r_opcode != XTENSA_UNDEFINED);
2996 l32r_offset (addr, pc)
3002 offset = addr - ((pc+3) & -4);
3003 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3004 offset = (signed int) offset >> 2;
3005 BFD_ASSERT ((signed int) offset >> 16 == -1);
3010 /* Get the operand number for a PC-relative relocation.
3011 If the relocation is not a PC-relative one, return (-1). */
3014 get_relocation_opnd (irel)
3015 Elf_Internal_Rela *irel;
3017 if (ELF32_R_TYPE (irel->r_info) < R_XTENSA_OP0
3018 || ELF32_R_TYPE (irel->r_info) >= R_XTENSA_max)
3020 return ELF32_R_TYPE (irel->r_info) - R_XTENSA_OP0;
3024 /* Get the opcode for a relocation. */
3026 static xtensa_opcode
3027 get_relocation_opcode (sec, contents, irel)
3030 Elf_Internal_Rela *irel;
3032 static xtensa_insnbuf ibuff = NULL;
3033 xtensa_isa isa = xtensa_default_isa;
3035 if (get_relocation_opnd (irel) == -1)
3036 return XTENSA_UNDEFINED;
3038 if (contents == NULL)
3039 return XTENSA_UNDEFINED;
3041 if (sec->_raw_size <= irel->r_offset)
3042 return XTENSA_UNDEFINED;
3045 ibuff = xtensa_insnbuf_alloc (isa);
3047 /* Decode the instruction. */
3048 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset]);
3049 return xtensa_decode_insn (isa, ibuff);
3054 is_l32r_relocation (sec, contents, irel)
3057 Elf_Internal_Rela *irel;
3059 xtensa_opcode opcode;
3061 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_OP1)
3064 opcode = get_relocation_opcode (sec, contents, irel);
3065 return (opcode == get_l32r_opcode ());
3069 /* Code for transforming CALLs at link-time. */
3071 static bfd_reloc_status_type
3072 elf_xtensa_do_asm_simplify (contents, address, content_length)
3075 bfd_vma content_length;
3077 static xtensa_insnbuf insnbuf = NULL;
3078 xtensa_opcode opcode;
3079 xtensa_operand operand;
3080 xtensa_opcode direct_call_opcode;
3081 xtensa_isa isa = xtensa_default_isa;
3082 bfd_byte *chbuf = contents + address;
3085 if (insnbuf == NULL)
3086 insnbuf = xtensa_insnbuf_alloc (isa);
3088 if (content_length < address)
3090 (*_bfd_error_handler)
3091 ("Attempt to convert L32R/CALLX to CALL failed\n");
3092 return bfd_reloc_other;
3095 opcode = get_expanded_call_opcode (chbuf, content_length - address);
3096 direct_call_opcode = swap_callx_for_call_opcode (opcode);
3097 if (direct_call_opcode == XTENSA_UNDEFINED)
3099 (*_bfd_error_handler)
3100 ("Attempt to convert L32R/CALLX to CALL failed\n");
3101 return bfd_reloc_other;
3104 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
3105 opcode = xtensa_opcode_lookup (isa, "or");
3106 xtensa_encode_insn (isa, opcode, insnbuf);
3107 for (opn = 0; opn < 3; opn++)
3109 operand = xtensa_get_operand (isa, opcode, opn);
3110 xtensa_operand_set_field (operand, insnbuf, 1);
3112 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf);
3114 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
3115 xtensa_encode_insn (isa, direct_call_opcode, insnbuf);
3116 operand = xtensa_get_operand (isa, opcode, 0);
3117 xtensa_operand_set_field (operand, insnbuf, 0);
3118 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3);
3120 return bfd_reloc_ok;
3124 static bfd_reloc_status_type
3125 contract_asm_expansion (contents, content_length, irel)
3127 bfd_vma content_length;
3128 Elf_Internal_Rela *irel;
3130 bfd_reloc_status_type retval =
3131 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length);
3133 if (retval != bfd_reloc_ok)
3136 /* Update the irel->r_offset field so that the right immediate and
3137 the right instruction are modified during the relocation. */
3138 irel->r_offset += 3;
3139 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_OP0);
3140 return bfd_reloc_ok;
3144 static xtensa_opcode
3145 swap_callx_for_call_opcode (opcode)
3146 xtensa_opcode opcode;
3148 init_call_opcodes ();
3150 if (opcode == callx0_op) return call0_op;
3151 if (opcode == callx4_op) return call4_op;
3152 if (opcode == callx8_op) return call8_op;
3153 if (opcode == callx12_op) return call12_op;
3155 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
3156 return XTENSA_UNDEFINED;
3160 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" sequence, and
3161 if so, return the CALLX opcode. If not, return XTENSA_UNDEFINED. */
3163 #define L32R_TARGET_REG_OPERAND 0
3164 #define CALLN_SOURCE_OPERAND 0
3166 static xtensa_opcode
3167 get_expanded_call_opcode (buf, bufsize)
3171 static xtensa_insnbuf insnbuf = NULL;
3172 xtensa_opcode opcode;
3173 xtensa_operand operand;
3174 xtensa_isa isa = xtensa_default_isa;
3175 uint32 regno, call_regno;
3177 /* Buffer must be at least 6 bytes. */
3179 return XTENSA_UNDEFINED;
3181 if (insnbuf == NULL)
3182 insnbuf = xtensa_insnbuf_alloc (isa);
3184 xtensa_insnbuf_from_chars (isa, insnbuf, buf);
3185 opcode = xtensa_decode_insn (isa, insnbuf);
3187 if (opcode != get_l32r_opcode ())
3188 return XTENSA_UNDEFINED;
3190 operand = xtensa_get_operand (isa, opcode, L32R_TARGET_REG_OPERAND);
3191 regno = xtensa_operand_decode
3192 (operand, xtensa_operand_get_field (operand, insnbuf));
3194 /* Next instruction should be an CALLXn with operand 0 == regno. */
3195 xtensa_insnbuf_from_chars (isa, insnbuf,
3196 buf + xtensa_insn_length (isa, opcode));
3197 opcode = xtensa_decode_insn (isa, insnbuf);
3199 if (!is_indirect_call_opcode (opcode))
3200 return XTENSA_UNDEFINED;
3202 operand = xtensa_get_operand (isa, opcode, CALLN_SOURCE_OPERAND);
3203 call_regno = xtensa_operand_decode
3204 (operand, xtensa_operand_get_field (operand, insnbuf));
3205 if (call_regno != regno)
3206 return XTENSA_UNDEFINED;
3212 /* Data structures used during relaxation. */
3214 /* r_reloc: relocation values. */
3216 /* Through the relaxation process, we need to keep track of the values
3217 that will result from evaluating relocations. The standard ELF
3218 relocation structure is not sufficient for this purpose because we're
3219 operating on multiple input files at once, so we need to know which
3220 input file a relocation refers to. The r_reloc structure thus
3221 records both the input file (bfd) and ELF relocation.
3223 For efficiency, an r_reloc also contains a "target_offset" field to
3224 cache the target-section-relative offset value that is represented by
3227 typedef struct r_reloc_struct r_reloc;
3229 struct r_reloc_struct
3232 Elf_Internal_Rela rela;
3233 bfd_vma target_offset;
3236 static bfd_boolean r_reloc_is_const
3237 PARAMS ((const r_reloc *));
3238 static void r_reloc_init
3239 PARAMS ((r_reloc *, bfd *, Elf_Internal_Rela *));
3240 static bfd_vma r_reloc_get_target_offset
3241 PARAMS ((const r_reloc *));
3242 static asection *r_reloc_get_section
3243 PARAMS ((const r_reloc *));
3244 static bfd_boolean r_reloc_is_defined
3245 PARAMS ((const r_reloc *));
3246 static struct elf_link_hash_entry *r_reloc_get_hash_entry
3247 PARAMS ((const r_reloc *));
3250 /* The r_reloc structure is included by value in literal_value, but not
3251 every literal_value has an associated relocation -- some are simple
3252 constants. In such cases, we set all the fields in the r_reloc
3253 struct to zero. The r_reloc_is_const function should be used to
3254 detect this case. */
3257 r_reloc_is_const (r_rel)
3258 const r_reloc *r_rel;
3260 return (r_rel->abfd == NULL);
3265 r_reloc_init (r_rel, abfd, irel)
3268 Elf_Internal_Rela *irel;
3272 r_rel->rela = *irel;
3274 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
3277 memset (r_rel, 0, sizeof (r_reloc));
3282 r_reloc_get_target_offset (r_rel)
3283 const r_reloc *r_rel;
3285 bfd_vma target_offset;
3286 unsigned long r_symndx;
3288 BFD_ASSERT (!r_reloc_is_const (r_rel));
3289 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3290 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
3291 return (target_offset + r_rel->rela.r_addend);
3295 static struct elf_link_hash_entry *
3296 r_reloc_get_hash_entry (r_rel)
3297 const r_reloc *r_rel;
3299 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3300 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
3305 r_reloc_get_section (r_rel)
3306 const r_reloc *r_rel;
3308 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3309 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
3314 r_reloc_is_defined (r_rel)
3315 const r_reloc *r_rel;
3317 asection *sec = r_reloc_get_section (r_rel);
3318 if (sec == bfd_abs_section_ptr
3319 || sec == bfd_com_section_ptr
3320 || sec == bfd_und_section_ptr)
3326 /* source_reloc: relocations that reference literal sections. */
3328 /* To determine whether literals can be coalesced, we need to first
3329 record all the relocations that reference the literals. The
3330 source_reloc structure below is used for this purpose. The
3331 source_reloc entries are kept in a per-literal-section array, sorted
3332 by offset within the literal section (i.e., target offset).
3334 The source_sec and r_rel.rela.r_offset fields identify the source of
3335 the relocation. The r_rel field records the relocation value, i.e.,
3336 the offset of the literal being referenced. The opnd field is needed
3337 to determine the range of the immediate field to which the relocation
3338 applies, so we can determine whether another literal with the same
3339 value is within range. The is_null field is true when the relocation
3340 is being removed (e.g., when an L32R is being removed due to a CALLX
3341 that is converted to a direct CALL). */
3343 typedef struct source_reloc_struct source_reloc;
3345 struct source_reloc_struct
3347 asection *source_sec;
3349 xtensa_operand opnd;
3350 bfd_boolean is_null;
3354 static void init_source_reloc
3355 PARAMS ((source_reloc *, asection *, const r_reloc *, xtensa_operand));
3356 static source_reloc *find_source_reloc
3357 PARAMS ((source_reloc *, int, asection *, Elf_Internal_Rela *));
3358 static int source_reloc_compare
3359 PARAMS ((const PTR, const PTR));
3363 init_source_reloc (reloc, source_sec, r_rel, opnd)
3364 source_reloc *reloc;
3365 asection *source_sec;
3366 const r_reloc *r_rel;
3367 xtensa_operand opnd;
3369 reloc->source_sec = source_sec;
3370 reloc->r_rel = *r_rel;
3372 reloc->is_null = FALSE;
3376 /* Find the source_reloc for a particular source offset and relocation
3377 type. Note that the array is sorted by _target_ offset, so this is
3378 just a linear search. */
3380 static source_reloc *
3381 find_source_reloc (src_relocs, src_count, sec, irel)
3382 source_reloc *src_relocs;
3385 Elf_Internal_Rela *irel;
3389 for (i = 0; i < src_count; i++)
3391 if (src_relocs[i].source_sec == sec
3392 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
3393 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
3394 == ELF32_R_TYPE (irel->r_info)))
3395 return &src_relocs[i];
3403 source_reloc_compare (ap, bp)
3407 const source_reloc *a = (const source_reloc *) ap;
3408 const source_reloc *b = (const source_reloc *) bp;
3410 return (a->r_rel.target_offset - b->r_rel.target_offset);
3414 /* Literal values and value hash tables. */
3416 /* Literals with the same value can be coalesced. The literal_value
3417 structure records the value of a literal: the "r_rel" field holds the
3418 information from the relocation on the literal (if there is one) and
3419 the "value" field holds the contents of the literal word itself.
3421 The value_map structure records a literal value along with the
3422 location of a literal holding that value. The value_map hash table
3423 is indexed by the literal value, so that we can quickly check if a
3424 particular literal value has been seen before and is thus a candidate
3427 typedef struct literal_value_struct literal_value;
3428 typedef struct value_map_struct value_map;
3429 typedef struct value_map_hash_table_struct value_map_hash_table;
3431 struct literal_value_struct
3434 unsigned long value;
3437 struct value_map_struct
3439 literal_value val; /* The literal value. */
3440 r_reloc loc; /* Location of the literal. */
3444 struct value_map_hash_table_struct
3446 unsigned bucket_count;
3447 value_map **buckets;
3452 static bfd_boolean is_same_value
3453 PARAMS ((const literal_value *, const literal_value *));
3454 static value_map_hash_table *value_map_hash_table_init
3456 static unsigned hash_literal_value
3457 PARAMS ((const literal_value *));
3458 static unsigned hash_bfd_vma
3460 static value_map *get_cached_value
3461 PARAMS ((value_map_hash_table *, const literal_value *));
3462 static value_map *add_value_map
3463 PARAMS ((value_map_hash_table *, const literal_value *, const r_reloc *));
3467 is_same_value (src1, src2)
3468 const literal_value *src1;
3469 const literal_value *src2;
3471 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
3474 if (r_reloc_is_const (&src1->r_rel))
3475 return (src1->value == src2->value);
3477 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
3478 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
3481 if (r_reloc_get_target_offset (&src1->r_rel)
3482 != r_reloc_get_target_offset (&src2->r_rel))
3485 if (src1->value != src2->value)
3488 /* Now check for the same section and the same elf_hash. */
3489 if (r_reloc_is_defined (&src1->r_rel))
3491 if (r_reloc_get_section (&src1->r_rel)
3492 != r_reloc_get_section (&src2->r_rel))
3497 if (r_reloc_get_hash_entry (&src1->r_rel)
3498 != r_reloc_get_hash_entry (&src2->r_rel))
3501 if (r_reloc_get_hash_entry (&src1->r_rel) == 0)
3509 /* Must be power of 2. */
3510 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
3512 static value_map_hash_table *
3513 value_map_hash_table_init ()
3515 value_map_hash_table *values;
3517 values = (value_map_hash_table *)
3518 bfd_malloc (sizeof (value_map_hash_table));
3520 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
3522 values->buckets = (value_map **)
3523 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
3533 return (val >> 2) + (val >> 10);
3538 hash_literal_value (src)
3539 const literal_value *src;
3542 if (r_reloc_is_const (&src->r_rel))
3543 return hash_bfd_vma (src->value);
3545 hash_val = (hash_bfd_vma (r_reloc_get_target_offset (&src->r_rel))
3546 + hash_bfd_vma (src->value));
3548 /* Now check for the same section and the same elf_hash. */
3549 if (r_reloc_is_defined (&src->r_rel))
3550 hash_val += hash_bfd_vma ((bfd_vma) r_reloc_get_section (&src->r_rel));
3552 hash_val += hash_bfd_vma ((bfd_vma) r_reloc_get_hash_entry (&src->r_rel));
3558 /* Check if the specified literal_value has been seen before. */
3561 get_cached_value (map, val)
3562 value_map_hash_table *map;
3563 const literal_value *val;
3569 idx = hash_literal_value (val);
3570 idx = idx & (map->bucket_count - 1);
3571 bucket = map->buckets[idx];
3572 for (map_e = bucket; map_e; map_e = map_e->next)
3574 if (is_same_value (&map_e->val, val))
3581 /* Record a new literal value. It is illegal to call this if VALUE
3582 already has an entry here. */
3585 add_value_map (map, val, loc)
3586 value_map_hash_table *map;
3587 const literal_value *val;
3590 value_map **bucket_p;
3593 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
3595 BFD_ASSERT (get_cached_value (map, val) == NULL);
3599 idx = hash_literal_value (val);
3600 idx = idx & (map->bucket_count - 1);
3601 bucket_p = &map->buckets[idx];
3603 val_e->next = *bucket_p;
3606 /* FIXME: consider resizing the hash table if we get too many entries */
3612 /* Lists of literals being coalesced or removed. */
3614 /* In the usual case, the literal identified by "from" is being
3615 coalesced with another literal identified by "to". If the literal is
3616 unused and is being removed altogether, "to.abfd" will be NULL.
3617 The removed_literal entries are kept on a per-section list, sorted
3618 by the "from" offset field. */
3620 typedef struct removed_literal_struct removed_literal;
3621 typedef struct removed_literal_list_struct removed_literal_list;
3623 struct removed_literal_struct
3627 removed_literal *next;
3630 struct removed_literal_list_struct
3632 removed_literal *head;
3633 removed_literal *tail;
3637 static void add_removed_literal
3638 PARAMS ((removed_literal_list *, const r_reloc *, const r_reloc *));
3639 static removed_literal *find_removed_literal
3640 PARAMS ((removed_literal_list *, bfd_vma));
3641 static bfd_vma offset_with_removed_literals
3642 PARAMS ((removed_literal_list *, bfd_vma));
3645 /* Record that the literal at "from" is being removed. If "to" is not
3646 NULL, the "from" literal is being coalesced with the "to" literal. */
3649 add_removed_literal (removed_list, from, to)
3650 removed_literal_list *removed_list;
3651 const r_reloc *from;
3654 removed_literal *r, *new_r, *next_r;
3656 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
3658 new_r->from = *from;
3662 new_r->to.abfd = NULL;
3665 r = removed_list->head;
3668 removed_list->head = new_r;
3669 removed_list->tail = new_r;
3671 /* Special check for common case of append. */
3672 else if (removed_list->tail->from.target_offset < from->target_offset)
3674 removed_list->tail->next = new_r;
3675 removed_list->tail = new_r;
3679 while (r->from.target_offset < from->target_offset
3686 new_r->next = next_r;
3688 removed_list->tail = new_r;
3693 /* Check if the list of removed literals contains an entry for the
3694 given address. Return the entry if found. */
3696 static removed_literal *
3697 find_removed_literal (removed_list, addr)
3698 removed_literal_list *removed_list;
3701 removed_literal *r = removed_list->head;
3702 while (r && r->from.target_offset < addr)
3704 if (r && r->from.target_offset == addr)
3710 /* Adjust an offset in a section to compensate for literals that are
3711 being removed. Search the list of removed literals and subtract
3712 4 bytes for every removed literal prior to the given address. */
3715 offset_with_removed_literals (removed_list, addr)
3716 removed_literal_list *removed_list;
3719 removed_literal *r = removed_list->head;
3720 unsigned num_bytes = 0;
3725 while (r && r->from.target_offset <= addr)
3730 if (num_bytes > addr)
3732 return (addr - num_bytes);
3736 /* Coalescing literals may require a relocation to refer to a section in
3737 a different input file, but the standard relocation information
3738 cannot express that. Instead, the reloc_bfd_fix structures are used
3739 to "fix" the relocations that refer to sections in other input files.
3740 These structures are kept on per-section lists. The "src_type" field
3741 records the relocation type in case there are multiple relocations on
3742 the same location. FIXME: This is ugly; an alternative might be to
3743 add new symbols with the "owner" field to some other input file. */
3745 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
3747 struct reloc_bfd_fix_struct
3751 unsigned src_type; /* Relocation type. */
3754 asection *target_sec;
3755 bfd_vma target_offset;
3757 reloc_bfd_fix *next;
3761 static reloc_bfd_fix *reloc_bfd_fix_init
3762 PARAMS ((asection *, bfd_vma, unsigned, bfd *, asection *, bfd_vma));
3763 static reloc_bfd_fix *get_bfd_fix
3764 PARAMS ((reloc_bfd_fix *, asection *, bfd_vma, unsigned));
3767 static reloc_bfd_fix *
3768 reloc_bfd_fix_init (src_sec, src_offset, src_type,
3769 target_abfd, target_sec, target_offset)
3774 asection *target_sec;
3775 bfd_vma target_offset;
3779 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
3780 fix->src_sec = src_sec;
3781 fix->src_offset = src_offset;
3782 fix->src_type = src_type;
3783 fix->target_abfd = target_abfd;
3784 fix->target_sec = target_sec;
3785 fix->target_offset = target_offset;
3791 static reloc_bfd_fix *
3792 get_bfd_fix (fix_list, sec, offset, type)
3793 reloc_bfd_fix *fix_list;
3800 for (r = fix_list; r != NULL; r = r->next)
3802 if (r->src_sec == sec
3803 && r->src_offset == offset
3804 && r->src_type == type)
3811 /* Per-section data for relaxation. */
3813 struct xtensa_relax_info_struct
3815 bfd_boolean is_relaxable_literal_section;
3816 int visited; /* Number of times visited. */
3818 source_reloc *src_relocs; /* Array[src_count]. */
3820 int src_next; /* Next src_relocs entry to assign. */
3822 removed_literal_list removed_list;
3824 reloc_bfd_fix *fix_list;
3827 struct elf_xtensa_section_data
3829 struct bfd_elf_section_data elf;
3830 xtensa_relax_info relax_info;
3833 static void init_xtensa_relax_info
3834 PARAMS ((asection *));
3835 static xtensa_relax_info *get_xtensa_relax_info
3836 PARAMS ((asection *));
3838 PARAMS ((asection *, reloc_bfd_fix *));
3842 elf_xtensa_new_section_hook (abfd, sec)
3846 struct elf_xtensa_section_data *sdata;
3847 bfd_size_type amt = sizeof (*sdata);
3849 sdata = (struct elf_xtensa_section_data *) bfd_zalloc (abfd, amt);
3852 sec->used_by_bfd = (PTR) sdata;
3854 return _bfd_elf_new_section_hook (abfd, sec);
3859 init_xtensa_relax_info (sec)
3862 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
3864 relax_info->is_relaxable_literal_section = FALSE;
3865 relax_info->visited = 0;
3867 relax_info->src_relocs = NULL;
3868 relax_info->src_count = 0;
3869 relax_info->src_next = 0;
3871 relax_info->removed_list.head = NULL;
3872 relax_info->removed_list.tail = NULL;
3874 relax_info->fix_list = NULL;
3878 static xtensa_relax_info *
3879 get_xtensa_relax_info (sec)
3882 struct elf_xtensa_section_data *section_data;
3884 /* No info available if no section or if it is an output section. */
3885 if (!sec || sec == sec->output_section)
3888 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
3889 return §ion_data->relax_info;
3894 add_fix (src_sec, fix)
3898 xtensa_relax_info *relax_info;
3900 relax_info = get_xtensa_relax_info (src_sec);
3901 fix->next = relax_info->fix_list;
3902 relax_info->fix_list = fix;
3906 /* Access to internal relocations, section contents and symbols. */
3908 /* During relaxation, we need to modify relocations, section contents,
3909 and symbol definitions, and we need to keep the original values from
3910 being reloaded from the input files, i.e., we need to "pin" the
3911 modified values in memory. We also want to continue to observe the
3912 setting of the "keep-memory" flag. The following functions wrap the
3913 standard BFD functions to take care of this for us. */
3915 static Elf_Internal_Rela *
3916 retrieve_internal_relocs (abfd, sec, keep_memory)
3919 bfd_boolean keep_memory;
3921 Elf_Internal_Rela *internal_relocs;
3923 if ((sec->flags & SEC_LINKER_CREATED) != 0)
3926 internal_relocs = elf_section_data (sec)->relocs;
3927 if (internal_relocs == NULL)
3928 internal_relocs = (_bfd_elf_link_read_relocs
3929 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
3931 return internal_relocs;
3936 pin_internal_relocs (sec, internal_relocs)
3938 Elf_Internal_Rela *internal_relocs;
3940 elf_section_data (sec)->relocs = internal_relocs;
3945 release_internal_relocs (sec, internal_relocs)
3947 Elf_Internal_Rela *internal_relocs;
3950 && elf_section_data (sec)->relocs != internal_relocs)
3951 free (internal_relocs);
3956 retrieve_contents (abfd, sec, keep_memory)
3959 bfd_boolean keep_memory;
3963 contents = elf_section_data (sec)->this_hdr.contents;
3965 if (contents == NULL && sec->_raw_size != 0)
3967 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
3968 if (contents != NULL)
3970 if (! bfd_get_section_contents (abfd, sec, contents,
3971 (file_ptr) 0, sec->_raw_size))
3977 elf_section_data (sec)->this_hdr.contents = contents;
3985 pin_contents (sec, contents)
3989 elf_section_data (sec)->this_hdr.contents = contents;
3994 release_contents (sec, contents)
3999 elf_section_data (sec)->this_hdr.contents != contents)
4004 static Elf_Internal_Sym *
4005 retrieve_local_syms (input_bfd)
4008 Elf_Internal_Shdr *symtab_hdr;
4009 Elf_Internal_Sym *isymbuf;
4012 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4013 locsymcount = symtab_hdr->sh_info;
4015 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4016 if (isymbuf == NULL && locsymcount != 0)
4017 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
4020 /* Save the symbols for this input file so they won't be read again. */
4021 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
4022 symtab_hdr->contents = (unsigned char *) isymbuf;
4028 /* Code for link-time relaxation. */
4030 /* Local helper functions. */
4031 static bfd_boolean analyze_relocations
4032 PARAMS ((struct bfd_link_info *));
4033 static bfd_boolean find_relaxable_sections
4034 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
4035 static bfd_boolean collect_source_relocs
4036 PARAMS ((bfd *, asection *, struct bfd_link_info *));
4037 static bfd_boolean is_resolvable_asm_expansion
4038 PARAMS ((bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
4039 struct bfd_link_info *, bfd_boolean *));
4040 static bfd_boolean remove_literals
4041 PARAMS ((bfd *, asection *, struct bfd_link_info *, value_map_hash_table *));
4042 static bfd_boolean relax_section
4043 PARAMS ((bfd *, asection *, struct bfd_link_info *));
4044 static bfd_boolean relax_property_section
4045 PARAMS ((bfd *, asection *, struct bfd_link_info *));
4046 static bfd_boolean relax_section_symbols
4047 PARAMS ((bfd *, asection *));
4048 static bfd_boolean relocations_reach
4049 PARAMS ((source_reloc *, int, const r_reloc *));
4050 static void translate_reloc
4051 PARAMS ((const r_reloc *, r_reloc *));
4052 static Elf_Internal_Rela *get_irel_at_offset
4053 PARAMS ((asection *, Elf_Internal_Rela *, bfd_vma));
4054 static Elf_Internal_Rela *find_associated_l32r_irel
4055 PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *,
4056 Elf_Internal_Rela *));
4057 static void shrink_dynamic_reloc_sections
4058 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *));
4062 elf_xtensa_relax_section (abfd, sec, link_info, again)
4065 struct bfd_link_info *link_info;
4068 static value_map_hash_table *values = NULL;
4069 xtensa_relax_info *relax_info;
4073 /* Do some overall initialization for relaxation. */
4074 values = value_map_hash_table_init ();
4075 relaxing_section = TRUE;
4076 if (!analyze_relocations (link_info))
4081 /* Don't mess with linker-created sections. */
4082 if ((sec->flags & SEC_LINKER_CREATED) != 0)
4085 relax_info = get_xtensa_relax_info (sec);
4086 BFD_ASSERT (relax_info != NULL);
4088 switch (relax_info->visited)
4091 /* Note: It would be nice to fold this pass into
4092 analyze_relocations, but it is important for this step that the
4093 sections be examined in link order. */
4094 if (!remove_literals (abfd, sec, link_info, values))
4100 if (!relax_section (abfd, sec, link_info))
4106 if (!relax_section_symbols (abfd, sec))
4111 relax_info->visited++;
4115 /* Initialization for relaxation. */
4117 /* This function is called once at the start of relaxation. It scans
4118 all the input sections and marks the ones that are relaxable (i.e.,
4119 literal sections with L32R relocations against them). It then
4120 collect source_reloc information for all the relocations against
4121 those relaxable sections. */
4124 analyze_relocations (link_info)
4125 struct bfd_link_info *link_info;
4129 bfd_boolean is_relaxable = FALSE;
4131 /* Initialize the per-section relaxation info. */
4132 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4133 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4135 init_xtensa_relax_info (sec);
4138 /* Mark relaxable sections (and count relocations against each one). */
4139 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4140 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4142 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
4146 /* Bail out if there are no relaxable sections. */
4150 /* Allocate space for source_relocs. */
4151 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4152 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4154 xtensa_relax_info *relax_info;
4156 relax_info = get_xtensa_relax_info (sec);
4157 if (relax_info->is_relaxable_literal_section)
4159 relax_info->src_relocs = (source_reloc *)
4160 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
4164 /* Collect info on relocations against each relaxable section. */
4165 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4166 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4168 if (!collect_source_relocs (abfd, sec, link_info))
4176 /* Find all the literal sections that might be relaxed. The motivation
4177 for this pass is that collect_source_relocs() needs to record _all_
4178 the relocations that target each relaxable section. That is
4179 expensive and unnecessary unless the target section is actually going
4180 to be relaxed. This pass identifies all such sections by checking if
4181 they have L32Rs pointing to them. In the process, the total number
4182 of relocations targetting each section is also counted so that we
4183 know how much space to allocate for source_relocs against each
4184 relaxable literal section. */
4187 find_relaxable_sections (abfd, sec, link_info, is_relaxable_p)
4190 struct bfd_link_info *link_info;
4191 bfd_boolean *is_relaxable_p;
4193 Elf_Internal_Rela *internal_relocs;
4195 bfd_boolean ok = TRUE;
4198 internal_relocs = retrieve_internal_relocs (abfd, sec,
4199 link_info->keep_memory);
4200 if (internal_relocs == NULL)
4203 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4204 if (contents == NULL && sec->_raw_size != 0)
4210 for (i = 0; i < sec->reloc_count; i++)
4212 Elf_Internal_Rela *irel = &internal_relocs[i];
4214 asection *target_sec;
4215 xtensa_relax_info *target_relax_info;
4217 r_reloc_init (&r_rel, abfd, irel);
4219 target_sec = r_reloc_get_section (&r_rel);
4220 target_relax_info = get_xtensa_relax_info (target_sec);
4221 if (!target_relax_info)
4224 /* Count relocations against the target section. */
4225 target_relax_info->src_count++;
4227 if (is_literal_section (target_sec)
4228 && is_l32r_relocation (sec, contents, irel)
4229 && r_reloc_is_defined (&r_rel))
4231 /* Mark the target section as relaxable. */
4232 target_relax_info->is_relaxable_literal_section = TRUE;
4233 *is_relaxable_p = TRUE;
4238 release_contents (sec, contents);
4239 release_internal_relocs (sec, internal_relocs);
4244 /* Record _all_ the relocations that point to relaxable literal
4245 sections, and get rid of ASM_EXPAND relocs by either converting them
4246 to ASM_SIMPLIFY or by removing them. */
4249 collect_source_relocs (abfd, sec, link_info)
4252 struct bfd_link_info *link_info;
4254 Elf_Internal_Rela *internal_relocs;
4256 bfd_boolean ok = TRUE;
4259 internal_relocs = retrieve_internal_relocs (abfd, sec,
4260 link_info->keep_memory);
4261 if (internal_relocs == NULL)
4264 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4265 if (contents == NULL && sec->_raw_size != 0)
4271 /* Record relocations against relaxable literal sections. */
4272 for (i = 0; i < sec->reloc_count; i++)
4274 Elf_Internal_Rela *irel = &internal_relocs[i];
4276 asection *target_sec;
4277 xtensa_relax_info *target_relax_info;
4279 r_reloc_init (&r_rel, abfd, irel);
4281 target_sec = r_reloc_get_section (&r_rel);
4282 target_relax_info = get_xtensa_relax_info (target_sec);
4284 if (target_relax_info
4285 && target_relax_info->is_relaxable_literal_section)
4287 xtensa_opcode opcode;
4288 xtensa_operand opnd;
4289 source_reloc *s_reloc;
4292 src_next = target_relax_info->src_next++;
4293 s_reloc = &target_relax_info->src_relocs[src_next];
4295 opcode = get_relocation_opcode (sec, contents, irel);
4296 if (opcode == XTENSA_UNDEFINED)
4299 opnd = xtensa_get_operand (xtensa_default_isa, opcode,
4300 get_relocation_opnd (irel));
4302 init_source_reloc (s_reloc, sec, &r_rel, opnd);
4306 /* Now get rid of ASM_EXPAND relocations. At this point, the
4307 src_relocs array for the target literal section may still be
4308 incomplete, but it must at least contain the entries for the L32R
4309 relocations associated with ASM_EXPANDs because they were just
4310 added in the preceding loop over the relocations. */
4312 for (i = 0; i < sec->reloc_count; i++)
4314 Elf_Internal_Rela *irel = &internal_relocs[i];
4315 bfd_boolean is_reachable;
4317 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
4323 Elf_Internal_Rela *l32r_irel;
4325 asection *target_sec;
4326 xtensa_relax_info *target_relax_info;
4328 /* Mark the source_reloc for the L32R so that it will be
4329 removed in remove_literals(), along with the associated
4331 l32r_irel = find_associated_l32r_irel (sec, contents,
4332 irel, internal_relocs);
4333 if (l32r_irel == NULL)
4336 r_reloc_init (&r_rel, abfd, l32r_irel);
4338 target_sec = r_reloc_get_section (&r_rel);
4339 target_relax_info = get_xtensa_relax_info (target_sec);
4341 if (target_relax_info
4342 && target_relax_info->is_relaxable_literal_section)
4344 source_reloc *s_reloc;
4346 /* Search the source_relocs for the entry corresponding to
4347 the l32r_irel. Note: The src_relocs array is not yet
4348 sorted, but it wouldn't matter anyway because we're
4349 searching by source offset instead of target offset. */
4350 s_reloc = find_source_reloc (target_relax_info->src_relocs,
4351 target_relax_info->src_next,
4353 BFD_ASSERT (s_reloc);
4354 s_reloc->is_null = TRUE;
4357 /* Convert this reloc to ASM_SIMPLIFY. */
4358 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4359 R_XTENSA_ASM_SIMPLIFY);
4360 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4362 pin_internal_relocs (sec, internal_relocs);
4366 /* It is resolvable but doesn't reach. We resolve now
4367 by eliminating the relocation -- the call will remain
4368 expanded into L32R/CALLX. */
4369 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4370 pin_internal_relocs (sec, internal_relocs);
4375 release_contents (sec, contents);
4376 release_internal_relocs (sec, internal_relocs);
4381 /* Return TRUE if the asm expansion can be resolved. Generally it can
4382 be resolved on a final link or when a partial link locates it in the
4383 same section as the target. Set "is_reachable" flag if the target of
4384 the call is within the range of a direct call, given the current VMA
4385 for this section and the target section. */
4388 is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
4393 Elf_Internal_Rela *irel;
4394 struct bfd_link_info *link_info;
4395 bfd_boolean *is_reachable_p;
4397 asection *target_sec;
4398 bfd_vma target_offset;
4400 xtensa_opcode opcode, direct_call_opcode;
4401 bfd_vma self_address;
4402 bfd_vma dest_address;
4404 *is_reachable_p = FALSE;
4406 if (contents == NULL)
4409 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
4412 opcode = get_expanded_call_opcode (contents + irel->r_offset,
4413 sec->_raw_size - irel->r_offset);
4415 direct_call_opcode = swap_callx_for_call_opcode (opcode);
4416 if (direct_call_opcode == XTENSA_UNDEFINED)
4419 /* Check and see that the target resolves. */
4420 r_reloc_init (&r_rel, abfd, irel);
4421 if (!r_reloc_is_defined (&r_rel))
4424 target_sec = r_reloc_get_section (&r_rel);
4425 target_offset = r_reloc_get_target_offset (&r_rel);
4427 /* If the target is in a shared library, then it doesn't reach. This
4428 isn't supposed to come up because the compiler should never generate
4429 non-PIC calls on systems that use shared libraries, but the linker
4430 shouldn't crash regardless. */
4431 if (!target_sec->output_section)
4434 /* For relocateable sections, we can only simplify when the output
4435 section of the target is the same as the output section of the
4437 if (link_info->relocateable
4438 && (target_sec->output_section != sec->output_section))
4441 self_address = (sec->output_section->vma
4442 + sec->output_offset + irel->r_offset + 3);
4443 dest_address = (target_sec->output_section->vma
4444 + target_sec->output_offset + target_offset);
4446 *is_reachable_p = pcrel_reloc_fits
4447 (xtensa_get_operand (xtensa_default_isa, direct_call_opcode, 0),
4448 self_address, dest_address);
4450 if ((self_address >> CALL_SEGMENT_BITS) !=
4451 (dest_address >> CALL_SEGMENT_BITS))
4458 static Elf_Internal_Rela *
4459 find_associated_l32r_irel (sec, contents, other_irel, internal_relocs)
4462 Elf_Internal_Rela *other_irel;
4463 Elf_Internal_Rela *internal_relocs;
4467 for (i = 0; i < sec->reloc_count; i++)
4469 Elf_Internal_Rela *irel = &internal_relocs[i];
4471 if (irel == other_irel)
4473 if (irel->r_offset != other_irel->r_offset)
4475 if (is_l32r_relocation (sec, contents, irel))
4482 /* First relaxation pass. */
4484 /* If the section is relaxable (i.e., a literal section), check each
4485 literal to see if it has the same value as another literal that has
4486 already been seen, either in the current section or a previous one.
4487 If so, add an entry to the per-section list of removed literals. The
4488 actual changes are deferred until the next pass. */
4491 remove_literals (abfd, sec, link_info, values)
4494 struct bfd_link_info *link_info;
4495 value_map_hash_table *values;
4497 xtensa_relax_info *relax_info;
4499 Elf_Internal_Rela *internal_relocs;
4500 source_reloc *src_relocs;
4501 bfd_boolean ok = TRUE;
4504 /* Do nothing if it is not a relaxable literal section. */
4505 relax_info = get_xtensa_relax_info (sec);
4506 BFD_ASSERT (relax_info);
4508 if (!relax_info->is_relaxable_literal_section)
4511 internal_relocs = retrieve_internal_relocs (abfd, sec,
4512 link_info->keep_memory);
4514 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4515 if (contents == NULL && sec->_raw_size != 0)
4521 /* Sort the source_relocs by target offset. */
4522 src_relocs = relax_info->src_relocs;
4523 qsort (src_relocs, relax_info->src_count,
4524 sizeof (source_reloc), source_reloc_compare);
4526 for (i = 0; i < relax_info->src_count; i++)
4529 Elf_Internal_Rela *irel = NULL;
4533 rel = &src_relocs[i];
4534 irel = get_irel_at_offset (sec, internal_relocs,
4535 rel->r_rel.target_offset);
4537 /* If the target_offset for this relocation is the same as the
4538 previous relocation, then we've already considered whether the
4539 literal can be coalesced. Skip to the next one.... */
4540 if (i != 0 && (src_relocs[i-1].r_rel.target_offset
4541 == rel->r_rel.target_offset))
4544 /* Check if the relocation was from an L32R that is being removed
4545 because a CALLX was converted to a direct CALL, and check if
4546 there are no other relocations to the literal. */
4548 && (i == relax_info->src_count - 1
4549 || (src_relocs[i+1].r_rel.target_offset
4550 != rel->r_rel.target_offset)))
4552 /* Mark the unused literal so that it will be removed. */
4553 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
4555 /* Zero out the relocation on this literal location. */
4558 if (elf_hash_table (link_info)->dynamic_sections_created)
4559 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
4561 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4567 /* Find the literal value. */
4568 r_reloc_init (&val.r_rel, abfd, irel);
4569 BFD_ASSERT (rel->r_rel.target_offset < sec->_raw_size);
4570 val.value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
4572 /* Check if we've seen another literal with the same value. */
4573 val_map = get_cached_value (values, &val);
4574 if (val_map != NULL)
4576 /* First check that THIS and all the other relocs to this
4577 literal will FIT if we move them to the new address. */
4579 if (relocations_reach (rel, relax_info->src_count - i,
4582 /* Mark that the literal will be coalesced. */
4583 add_removed_literal (&relax_info->removed_list,
4584 &rel->r_rel, &val_map->loc);
4588 /* Relocations do not reach -- do not remove this literal. */
4589 val_map->loc = rel->r_rel;
4594 /* This is the first time we've seen this literal value. */
4595 BFD_ASSERT (sec == r_reloc_get_section (&rel->r_rel));
4596 add_value_map (values, &val, &rel->r_rel);
4601 release_contents (sec, contents);
4602 release_internal_relocs (sec, internal_relocs);
4607 /* Check if the original relocations (presumably on L32R instructions)
4608 identified by reloc[0..N] can be changed to reference the literal
4609 identified by r_rel. If r_rel is out of range for any of the
4610 original relocations, then we don't want to coalesce the original
4611 literal with the one at r_rel. We only check reloc[0..N], where the
4612 offsets are all the same as for reloc[0] (i.e., they're all
4613 referencing the same literal) and where N is also bounded by the
4614 number of remaining entries in the "reloc" array. The "reloc" array
4615 is sorted by target offset so we know all the entries for the same
4616 literal will be contiguous. */
4619 relocations_reach (reloc, remaining_relocs, r_rel)
4620 source_reloc *reloc;
4621 int remaining_relocs;
4622 const r_reloc *r_rel;
4624 bfd_vma from_offset, source_address, dest_address;
4628 if (!r_reloc_is_defined (r_rel))
4631 sec = r_reloc_get_section (r_rel);
4632 from_offset = reloc[0].r_rel.target_offset;
4634 for (i = 0; i < remaining_relocs; i++)
4636 if (reloc[i].r_rel.target_offset != from_offset)
4639 /* Ignore relocations that have been removed. */
4640 if (reloc[i].is_null)
4643 /* The original and new output section for these must be the same
4644 in order to coalesce. */
4645 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
4646 != sec->output_section)
4649 /* A NULL operand means it is not a PC-relative relocation, so
4650 the literal can be moved anywhere. */
4653 /* Otherwise, check to see that it fits. */
4654 source_address = (reloc[i].source_sec->output_section->vma
4655 + reloc[i].source_sec->output_offset
4656 + reloc[i].r_rel.rela.r_offset);
4657 dest_address = (sec->output_section->vma
4658 + sec->output_offset
4659 + r_rel->target_offset);
4661 if (!pcrel_reloc_fits (reloc[i].opnd, source_address, dest_address))
4670 /* WARNING: linear search here. If the relocation are in order by
4671 address, we can use a faster binary search. ALSO, we assume that
4672 there is only 1 non-NONE relocation per address. */
4674 static Elf_Internal_Rela *
4675 get_irel_at_offset (sec, internal_relocs, offset)
4677 Elf_Internal_Rela *internal_relocs;
4681 if (!internal_relocs)
4683 for (i = 0; i < sec->reloc_count; i++)
4685 Elf_Internal_Rela *irel = &internal_relocs[i];
4686 if (irel->r_offset == offset
4687 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
4694 /* Second relaxation pass. */
4696 /* Modify all of the relocations to point to the right spot, and if this
4697 is a relaxable section, delete the unwanted literals and fix the
4701 relax_section (abfd, sec, link_info)
4704 struct bfd_link_info *link_info;
4706 Elf_Internal_Rela *internal_relocs;
4707 xtensa_relax_info *relax_info;
4709 bfd_boolean ok = TRUE;
4712 relax_info = get_xtensa_relax_info (sec);
4713 BFD_ASSERT (relax_info);
4715 /* Handle property sections (e.g., literal tables) specially. */
4716 if (xtensa_is_property_section (sec))
4718 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
4719 return relax_property_section (abfd, sec, link_info);
4722 internal_relocs = retrieve_internal_relocs (abfd, sec,
4723 link_info->keep_memory);
4724 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4725 if (contents == NULL && sec->_raw_size != 0)
4731 if (internal_relocs)
4733 for (i = 0; i < sec->reloc_count; i++)
4735 Elf_Internal_Rela *irel;
4736 xtensa_relax_info *target_relax_info;
4737 bfd_vma source_offset;
4740 asection *target_sec;
4742 /* Locally change the source address.
4743 Translate the target to the new target address.
4744 If it points to this section and has been removed,
4748 irel = &internal_relocs[i];
4749 source_offset = irel->r_offset;
4751 r_type = ELF32_R_TYPE (irel->r_info);
4752 r_reloc_init (&r_rel, abfd, irel);
4754 if (relax_info->is_relaxable_literal_section)
4756 if (r_type != R_XTENSA_NONE
4757 && find_removed_literal (&relax_info->removed_list,
4760 /* Remove this relocation. */
4761 if (elf_hash_table (link_info)->dynamic_sections_created)
4762 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
4763 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4764 irel->r_offset = offset_with_removed_literals
4765 (&relax_info->removed_list, irel->r_offset);
4769 offset_with_removed_literals (&relax_info->removed_list,
4771 irel->r_offset = source_offset;
4774 target_sec = r_reloc_get_section (&r_rel);
4775 target_relax_info = get_xtensa_relax_info (target_sec);
4777 if (target_relax_info
4778 && target_relax_info->is_relaxable_literal_section)
4783 translate_reloc (&r_rel, &new_rel);
4785 /* FIXME: If the relocation still references a section in
4786 the same input file, the relocation should be modified
4787 directly instead of adding a "fix" record. */
4789 fix = reloc_bfd_fix_init (sec, source_offset, r_type, 0,
4790 r_reloc_get_section (&new_rel),
4791 new_rel.target_offset);
4795 pin_internal_relocs (sec, internal_relocs);
4799 if (relax_info->is_relaxable_literal_section)
4801 /* Walk through the contents and delete literals that are not needed
4804 unsigned long size = sec->_cooked_size;
4805 unsigned long removed = 0;
4807 removed_literal *reloc = relax_info->removed_list.head;
4808 for (; reloc; reloc = reloc->next)
4810 unsigned long upper = sec->_raw_size;
4811 bfd_vma start = reloc->from.target_offset + 4;
4813 upper = reloc->next->from.target_offset;
4814 if (upper - start != 0)
4816 BFD_ASSERT (start <= upper);
4817 memmove (contents + start - removed - 4,
4820 pin_contents (sec, contents);
4826 /* Change the section size. */
4827 sec->_cooked_size = size;
4828 /* Also shrink _raw_size. (The code in relocate_section that
4829 checks that relocations are within the section must use
4830 _raw_size because of the way the stabs sections are relaxed;
4831 shrinking _raw_size means that these checks will not be
4832 unnecessarily lax.) */
4833 sec->_raw_size = size;
4837 release_internal_relocs (sec, internal_relocs);
4838 release_contents (sec, contents);
4843 /* Fix up a relocation to take account of removed literals. */
4846 translate_reloc (orig_rel, new_rel)
4847 const r_reloc *orig_rel;
4851 xtensa_relax_info *relax_info;
4852 removed_literal *removed;
4853 unsigned long new_offset;
4855 *new_rel = *orig_rel;
4857 if (!r_reloc_is_defined (orig_rel))
4859 sec = r_reloc_get_section (orig_rel);
4861 relax_info = get_xtensa_relax_info (sec);
4862 BFD_ASSERT (relax_info);
4864 if (!relax_info->is_relaxable_literal_section)
4867 /* Check if the original relocation is against a literal being removed. */
4868 removed = find_removed_literal (&relax_info->removed_list,
4869 orig_rel->target_offset);
4874 /* The fact that there is still a relocation to this literal indicates
4875 that the literal is being coalesced, not simply removed. */
4876 BFD_ASSERT (removed->to.abfd != NULL);
4878 /* This was moved to some other address (possibly in another section). */
4879 *new_rel = removed->to;
4880 new_sec = r_reloc_get_section (new_rel);
4884 relax_info = get_xtensa_relax_info (sec);
4885 if (!relax_info || !relax_info->is_relaxable_literal_section)
4890 /* ...and the target address may have been moved within its section. */
4891 new_offset = offset_with_removed_literals (&relax_info->removed_list,
4892 new_rel->target_offset);
4894 /* Modify the offset and addend. */
4895 new_rel->target_offset = new_offset;
4896 new_rel->rela.r_addend += (new_offset - new_rel->target_offset);
4900 /* For dynamic links, there may be a dynamic relocation for each
4901 literal. The number of dynamic relocations must be computed in
4902 size_dynamic_sections, which occurs before relaxation. When a
4903 literal is removed, this function checks if there is a corresponding
4904 dynamic relocation and shrinks the size of the appropriate dynamic
4905 relocation section accordingly. At this point, the contents of the
4906 dynamic relocation sections have not yet been filled in, so there's
4907 nothing else that needs to be done. */
4910 shrink_dynamic_reloc_sections (info, abfd, input_section, rel)
4911 struct bfd_link_info *info;
4913 asection *input_section;
4914 Elf_Internal_Rela *rel;
4916 Elf_Internal_Shdr *symtab_hdr;
4917 struct elf_link_hash_entry **sym_hashes;
4918 unsigned long r_symndx;
4920 struct elf_link_hash_entry *h;
4921 bfd_boolean dynamic_symbol;
4923 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4924 sym_hashes = elf_sym_hashes (abfd);
4926 r_type = ELF32_R_TYPE (rel->r_info);
4927 r_symndx = ELF32_R_SYM (rel->r_info);
4929 if (r_symndx < symtab_hdr->sh_info)
4932 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4934 dynamic_symbol = xtensa_elf_dynamic_symbol_p (info, h);
4936 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
4937 && (input_section->flags & SEC_ALLOC) != 0
4938 && (dynamic_symbol || info->shared))
4941 const char *srel_name;
4943 bfd_boolean is_plt = FALSE;
4945 dynobj = elf_hash_table (info)->dynobj;
4946 BFD_ASSERT (dynobj != NULL);
4948 if (dynamic_symbol && r_type == R_XTENSA_PLT)
4950 srel_name = ".rela.plt";
4954 srel_name = ".rela.got";
4956 /* Reduce size of the .rela.* section by one reloc. */
4957 srel = bfd_get_section_by_name (dynobj, srel_name);
4958 BFD_ASSERT (srel != NULL);
4959 BFD_ASSERT (srel->_cooked_size >= sizeof (Elf32_External_Rela));
4960 srel->_cooked_size -= sizeof (Elf32_External_Rela);
4962 /* Also shrink _raw_size. (This seems wrong but other bfd code seems
4963 to assume that linker-created sections will never be relaxed and
4964 hence _raw_size must always equal _cooked_size.) */
4965 srel->_raw_size = srel->_cooked_size;
4969 asection *splt, *sgotplt, *srelgot;
4970 int reloc_index, chunk;
4972 /* Find the PLT reloc index of the entry being removed. This
4973 is computed from the size of ".rela.plt". It is needed to
4974 figure out which PLT chunk to resize. Usually "last index
4975 = size - 1" since the index starts at zero, but in this
4976 context, the size has just been decremented so there's no
4977 need to subtract one. */
4978 reloc_index = srel->_cooked_size / sizeof (Elf32_External_Rela);
4980 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
4981 splt = elf_xtensa_get_plt_section (dynobj, chunk);
4982 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
4983 BFD_ASSERT (splt != NULL && sgotplt != NULL);
4985 /* Check if an entire PLT chunk has just been eliminated. */
4986 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
4988 /* The two magic GOT entries for that chunk can go away. */
4989 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4990 BFD_ASSERT (srelgot != NULL);
4991 srelgot->reloc_count -= 2;
4992 srelgot->_cooked_size -= 2 * sizeof (Elf32_External_Rela);
4993 /* Shrink _raw_size (see comment above). */
4994 srelgot->_raw_size = srelgot->_cooked_size;
4996 sgotplt->_cooked_size -= 8;
4998 /* There should be only one entry left (and it will be
5000 BFD_ASSERT (sgotplt->_cooked_size == 4);
5001 BFD_ASSERT (splt->_cooked_size == PLT_ENTRY_SIZE);
5004 BFD_ASSERT (sgotplt->_cooked_size >= 4);
5005 BFD_ASSERT (splt->_cooked_size >= PLT_ENTRY_SIZE);
5007 sgotplt->_cooked_size -= 4;
5008 splt->_cooked_size -= PLT_ENTRY_SIZE;
5010 /* Shrink _raw_sizes (see comment above). */
5011 sgotplt->_raw_size = sgotplt->_cooked_size;
5012 splt->_raw_size = splt->_cooked_size;
5018 /* This is similar to relax_section except that when a target is moved,
5019 we shift addresses up. We also need to modify the size. This
5020 algorithm does NOT allow for relocations into the middle of the
5021 property sections. */
5024 relax_property_section (abfd, sec, link_info)
5027 struct bfd_link_info *link_info;
5029 Elf_Internal_Rela *internal_relocs;
5032 bfd_boolean ok = TRUE;
5034 internal_relocs = retrieve_internal_relocs (abfd, sec,
5035 link_info->keep_memory);
5036 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5037 if (contents == NULL && sec->_raw_size != 0)
5043 if (internal_relocs)
5045 for (i = 0; i < sec->reloc_count; i++)
5047 Elf_Internal_Rela *irel;
5048 xtensa_relax_info *target_relax_info;
5051 asection *target_sec;
5053 /* Locally change the source address.
5054 Translate the target to the new target address.
5055 If it points to this section and has been removed, MOVE IT.
5056 Also, don't forget to modify the associated SIZE at
5059 irel = &internal_relocs[i];
5060 r_type = ELF32_R_TYPE (irel->r_info);
5061 if (r_type == R_XTENSA_NONE)
5064 r_reloc_init (&r_rel, abfd, irel);
5066 target_sec = r_reloc_get_section (&r_rel);
5067 target_relax_info = get_xtensa_relax_info (target_sec);
5069 if (target_relax_info
5070 && target_relax_info->is_relaxable_literal_section)
5072 /* Translate the relocation's destination. */
5074 bfd_vma new_end_offset;
5076 long old_size, new_size;
5079 offset_with_removed_literals (&target_relax_info->removed_list,
5080 r_rel.target_offset);
5082 /* Assert that we are not out of bounds. */
5083 size_p = &contents[irel->r_offset + 4];
5084 old_size = bfd_get_32 (abfd, &contents[irel->r_offset + 4]);
5087 offset_with_removed_literals (&target_relax_info->removed_list,
5088 r_rel.target_offset + old_size);
5090 new_size = new_end_offset - new_offset;
5091 if (new_size != old_size)
5093 bfd_put_32 (abfd, new_size, size_p);
5094 pin_contents (sec, contents);
5097 if (new_offset != r_rel.target_offset)
5099 bfd_vma diff = new_offset - r_rel.target_offset;
5100 irel->r_addend += diff;
5101 pin_internal_relocs (sec, internal_relocs);
5107 /* Combine adjacent property table entries. This is also done in
5108 finish_dynamic_sections() but at that point it's too late to
5109 reclaim the space in the output section, so we do this twice. */
5111 if (internal_relocs)
5113 Elf_Internal_Rela *last_irel = NULL;
5114 int removed_bytes = 0;
5115 bfd_vma offset, last_irel_offset;
5116 bfd_vma section_size;
5118 /* Walk over memory and irels at the same time.
5119 This REQUIRES that the internal_relocs be sorted by offset. */
5120 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
5121 internal_reloc_compare);
5122 nexti = 0; /* Index into internal_relocs. */
5124 pin_internal_relocs (sec, internal_relocs);
5125 pin_contents (sec, contents);
5127 last_irel_offset = (bfd_vma) -1;
5128 section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size);
5129 BFD_ASSERT (section_size % 8 == 0);
5131 for (offset = 0; offset < section_size; offset += 8)
5133 Elf_Internal_Rela *irel, *next_irel;
5134 bfd_vma bytes_to_remove, size, actual_offset;
5135 bfd_boolean remove_this_irel;
5140 /* Find the next two relocations (if there are that many left),
5141 skipping over any R_XTENSA_NONE relocs. On entry, "nexti" is
5142 the starting reloc index. After these two loops, "i"
5143 is the index of the first non-NONE reloc past that starting
5144 index, and "nexti" is the index for the next non-NONE reloc
5147 for (i = nexti; i < sec->reloc_count; i++)
5149 if (ELF32_R_TYPE (internal_relocs[i].r_info) != R_XTENSA_NONE)
5151 irel = &internal_relocs[i];
5154 internal_relocs[i].r_offset -= removed_bytes;
5157 for (nexti = i + 1; nexti < sec->reloc_count; nexti++)
5159 if (ELF32_R_TYPE (internal_relocs[nexti].r_info)
5162 next_irel = &internal_relocs[nexti];
5165 internal_relocs[nexti].r_offset -= removed_bytes;
5168 remove_this_irel = FALSE;
5169 bytes_to_remove = 0;
5170 actual_offset = offset - removed_bytes;
5171 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
5173 /* Check that the irels are sorted by offset,
5174 with only one per address. */
5175 BFD_ASSERT (!irel || (int) irel->r_offset > (int) last_irel_offset);
5176 BFD_ASSERT (!next_irel || next_irel->r_offset > irel->r_offset);
5178 /* Make sure there isn't a reloc on the size field. */
5179 if (irel && irel->r_offset == offset + 4)
5181 irel->r_offset -= removed_bytes;
5182 last_irel_offset = irel->r_offset;
5184 else if (next_irel && next_irel->r_offset == offset + 4)
5187 irel->r_offset -= removed_bytes;
5188 next_irel->r_offset -= removed_bytes;
5189 last_irel_offset = next_irel->r_offset;
5193 /* Always remove entries with zero size. */
5194 bytes_to_remove = 8;
5195 if (irel && irel->r_offset == offset)
5197 remove_this_irel = TRUE;
5199 irel->r_offset -= removed_bytes;
5200 last_irel_offset = irel->r_offset;
5203 else if (irel && irel->r_offset == offset)
5205 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32)
5210 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
5211 bfd_vma old_address =
5212 (last_irel->r_addend
5213 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
5214 bfd_vma new_address =
5216 + bfd_get_32 (abfd, &contents[actual_offset]));
5218 if ((ELF32_R_SYM (irel->r_info) ==
5219 ELF32_R_SYM (last_irel->r_info))
5220 && (old_address + old_size == new_address))
5222 /* fix the old size */
5223 bfd_put_32 (abfd, old_size + size,
5224 &contents[last_irel->r_offset + 4]);
5225 bytes_to_remove = 8;
5226 remove_this_irel = TRUE;
5235 irel->r_offset -= removed_bytes;
5236 last_irel_offset = irel->r_offset;
5239 if (remove_this_irel)
5241 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
5242 irel->r_offset -= bytes_to_remove;
5245 if (bytes_to_remove != 0)
5247 removed_bytes += bytes_to_remove;
5248 if (offset + 8 < section_size)
5249 memmove (&contents[actual_offset],
5250 &contents[actual_offset+8],
5251 section_size - offset - 8);
5257 /* Clear the removed bytes. */
5258 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
5260 sec->_cooked_size = section_size - removed_bytes;
5261 /* Also shrink _raw_size. (The code in relocate_section that
5262 checks that relocations are within the section must use
5263 _raw_size because of the way the stabs sections are
5264 relaxed; shrinking _raw_size means that these checks will
5265 not be unnecessarily lax.) */
5266 sec->_raw_size = sec->_cooked_size;
5271 release_internal_relocs (sec, internal_relocs);
5272 release_contents (sec, contents);
5277 /* Third relaxation pass. */
5279 /* Change symbol values to account for removed literals. */
5282 relax_section_symbols (abfd, sec)
5286 xtensa_relax_info *relax_info;
5287 unsigned int sec_shndx;
5288 Elf_Internal_Shdr *symtab_hdr;
5289 Elf_Internal_Sym *isymbuf;
5290 unsigned i, num_syms, num_locals;
5292 relax_info = get_xtensa_relax_info (sec);
5293 BFD_ASSERT (relax_info);
5295 if (!relax_info->is_relaxable_literal_section)
5298 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5300 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5301 isymbuf = retrieve_local_syms (abfd);
5303 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
5304 num_locals = symtab_hdr->sh_info;
5306 /* Adjust the local symbols defined in this section. */
5307 for (i = 0; i < num_locals; i++)
5309 Elf_Internal_Sym *isym = &isymbuf[i];
5311 if (isym->st_shndx == sec_shndx)
5313 bfd_vma new_address = offset_with_removed_literals
5314 (&relax_info->removed_list, isym->st_value);
5315 if (new_address != isym->st_value)
5316 isym->st_value = new_address;
5320 /* Now adjust the global symbols defined in this section. */
5321 for (i = 0; i < (num_syms - num_locals); i++)
5323 struct elf_link_hash_entry *sym_hash;
5325 sym_hash = elf_sym_hashes (abfd)[i];
5327 if (sym_hash->root.type == bfd_link_hash_warning)
5328 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
5330 if ((sym_hash->root.type == bfd_link_hash_defined
5331 || sym_hash->root.type == bfd_link_hash_defweak)
5332 && sym_hash->root.u.def.section == sec)
5334 bfd_vma new_address = offset_with_removed_literals
5335 (&relax_info->removed_list, sym_hash->root.u.def.value);
5336 if (new_address != sym_hash->root.u.def.value)
5337 sym_hash->root.u.def.value = new_address;
5345 /* "Fix" handling functions, called while performing relocations. */
5348 do_fix_for_relocateable_link (rel, input_bfd, input_section)
5349 Elf_Internal_Rela *rel;
5351 asection *input_section;
5354 asection *sec, *old_sec;
5356 int r_type = ELF32_R_TYPE (rel->r_info);
5357 reloc_bfd_fix *fix_list;
5360 if (r_type == R_XTENSA_NONE)
5363 fix_list = (get_xtensa_relax_info (input_section))->fix_list;
5364 if (fix_list == NULL)
5367 fix = get_bfd_fix (fix_list, input_section, rel->r_offset, r_type);
5371 r_reloc_init (&r_rel, input_bfd, rel);
5372 old_sec = r_reloc_get_section (&r_rel);
5373 old_offset = r_reloc_get_target_offset (&r_rel);
5375 if (old_sec == NULL || !r_reloc_is_defined (&r_rel))
5377 BFD_ASSERT (r_type == R_XTENSA_ASM_EXPAND);
5378 /* Leave it be. Resolution will happen in a later stage. */
5382 sec = fix->target_sec;
5383 rel->r_addend += ((sec->output_offset + fix->target_offset)
5384 - (old_sec->output_offset + old_offset));
5390 do_fix_for_final_link (rel, input_section, relocationp)
5391 Elf_Internal_Rela *rel;
5392 asection *input_section;
5393 bfd_vma *relocationp;
5396 int r_type = ELF32_R_TYPE (rel->r_info);
5397 reloc_bfd_fix *fix_list;
5400 if (r_type == R_XTENSA_NONE)
5403 fix_list = (get_xtensa_relax_info (input_section))->fix_list;
5404 if (fix_list == NULL)
5407 fix = get_bfd_fix (fix_list, input_section, rel->r_offset, r_type);
5411 sec = fix->target_sec;
5412 *relocationp = (sec->output_section->vma
5413 + sec->output_offset
5414 + fix->target_offset - rel->r_addend);
5418 /* Miscellaneous utility functions.... */
5421 elf_xtensa_get_plt_section (dynobj, chunk)
5428 return bfd_get_section_by_name (dynobj, ".plt");
5430 sprintf (plt_name, ".plt.%u", chunk);
5431 return bfd_get_section_by_name (dynobj, plt_name);
5436 elf_xtensa_get_gotplt_section (dynobj, chunk)
5443 return bfd_get_section_by_name (dynobj, ".got.plt");
5445 sprintf (got_name, ".got.plt.%u", chunk);
5446 return bfd_get_section_by_name (dynobj, got_name);
5450 /* Get the input section for a given symbol index.
5452 . a section symbol, return the section;
5453 . a common symbol, return the common section;
5454 . an undefined symbol, return the undefined section;
5455 . an indirect symbol, follow the links;
5456 . an absolute value, return the absolute section. */
5459 get_elf_r_symndx_section (abfd, r_symndx)
5461 unsigned long r_symndx;
5463 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5464 asection *target_sec = NULL;
5465 if (r_symndx < symtab_hdr->sh_info)
5467 Elf_Internal_Sym *isymbuf;
5468 unsigned int section_index;
5470 isymbuf = retrieve_local_syms (abfd);
5471 section_index = isymbuf[r_symndx].st_shndx;
5473 if (section_index == SHN_UNDEF)
5474 target_sec = bfd_und_section_ptr;
5475 else if (section_index > 0 && section_index < SHN_LORESERVE)
5476 target_sec = bfd_section_from_elf_index (abfd, section_index);
5477 else if (section_index == SHN_ABS)
5478 target_sec = bfd_abs_section_ptr;
5479 else if (section_index == SHN_COMMON)
5480 target_sec = bfd_com_section_ptr;
5487 unsigned long indx = r_symndx - symtab_hdr->sh_info;
5488 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
5490 while (h->root.type == bfd_link_hash_indirect
5491 || h->root.type == bfd_link_hash_warning)
5492 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5494 switch (h->root.type)
5496 case bfd_link_hash_defined:
5497 case bfd_link_hash_defweak:
5498 target_sec = h->root.u.def.section;
5500 case bfd_link_hash_common:
5501 target_sec = bfd_com_section_ptr;
5503 case bfd_link_hash_undefined:
5504 case bfd_link_hash_undefweak:
5505 target_sec = bfd_und_section_ptr;
5507 default: /* New indirect warning. */
5508 target_sec = bfd_und_section_ptr;
5516 static struct elf_link_hash_entry *
5517 get_elf_r_symndx_hash_entry (abfd, r_symndx)
5519 unsigned long r_symndx;
5522 struct elf_link_hash_entry *h;
5523 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5525 if (r_symndx < symtab_hdr->sh_info)
5528 indx = r_symndx - symtab_hdr->sh_info;
5529 h = elf_sym_hashes (abfd)[indx];
5530 while (h->root.type == bfd_link_hash_indirect
5531 || h->root.type == bfd_link_hash_warning)
5532 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5537 /* Get the section-relative offset for a symbol number. */
5540 get_elf_r_symndx_offset (abfd, r_symndx)
5542 unsigned long r_symndx;
5544 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5547 if (r_symndx < symtab_hdr->sh_info)
5549 Elf_Internal_Sym *isymbuf;
5550 isymbuf = retrieve_local_syms (abfd);
5551 offset = isymbuf[r_symndx].st_value;
5555 unsigned long indx = r_symndx - symtab_hdr->sh_info;
5556 struct elf_link_hash_entry *h =
5557 elf_sym_hashes (abfd)[indx];
5559 while (h->root.type == bfd_link_hash_indirect
5560 || h->root.type == bfd_link_hash_warning)
5561 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5562 if (h->root.type == bfd_link_hash_defined
5563 || h->root.type == bfd_link_hash_defweak)
5564 offset = h->root.u.def.value;
5571 pcrel_reloc_fits (opnd, self_address, dest_address)
5572 xtensa_operand opnd;
5573 bfd_vma self_address;
5574 bfd_vma dest_address;
5576 uint32 new_address =
5577 xtensa_operand_do_reloc (opnd, dest_address, self_address);
5578 return (xtensa_operand_encode (opnd, &new_address)
5579 == xtensa_encode_result_ok);
5584 xtensa_is_property_section (sec)
5587 static int len = sizeof (".gnu.linkonce.t.") - 1;
5589 return (strcmp (".xt.insn", sec->name) == 0
5590 || strcmp (".xt.lit", sec->name) == 0
5591 || strncmp (".gnu.linkonce.x.", sec->name, len) == 0
5592 || strncmp (".gnu.linkonce.p.", sec->name, len) == 0);
5597 is_literal_section (sec)
5600 /* FIXME: the current definition of this leaves a lot to be desired.... */
5601 if (sec == NULL || sec->name == NULL)
5603 return (strstr (sec->name, "literal") != NULL);
5608 internal_reloc_compare (ap, bp)
5612 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
5613 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
5615 return (a->r_offset - b->r_offset);
5620 get_is_linkonce_section (abfd, sec)
5621 bfd *abfd ATTRIBUTE_UNUSED;
5624 flagword flags, link_once_flags;
5625 bfd_boolean is_linkonce = FALSE;;
5627 flags = bfd_get_section_flags (abfd, sec);
5628 link_once_flags = (flags & SEC_LINK_ONCE);
5629 if (link_once_flags != 0)
5632 /* In order for this to be useful to the assembler
5633 before the linkonce flag is set we need to
5634 check for the GNU extension name. */
5636 strncmp (sec->name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
5644 xtensa_get_property_section_name (abfd, sec, base_name)
5647 const char * base_name;
5649 char *table_sec_name = NULL;
5650 bfd_boolean is_linkonce;
5652 is_linkonce = get_is_linkonce_section (abfd, sec);
5656 table_sec_name = strdup (base_name);
5660 static size_t prefix_len = sizeof (".gnu.linkonce.t.") - 1;
5661 size_t len = strlen (sec->name) + 1;
5662 char repl_char = '\0';
5663 const char *segname = sec->name;
5665 if (strncmp (segname, ".gnu.linkonce.t.", prefix_len) == 0)
5667 if (strcmp (base_name, ".xt.insn") == 0)
5669 else if (strcmp (base_name, ".xt.lit") == 0)
5673 if (repl_char != '\0')
5675 char *name = (char *) bfd_malloc (len);
5676 memcpy (name, sec->name, len);
5677 name[prefix_len - 2] = repl_char;
5678 table_sec_name = name;
5682 size_t base_len = strlen (base_name) + 1;
5683 char *name = (char *) bfd_malloc (len + base_len);
5684 memcpy (name, sec->name, len - 1);
5685 memcpy (name + len - 1, base_name, base_len);
5686 table_sec_name = name;
5690 return table_sec_name;
5694 /* Other functions called directly by the linker. */
5697 xtensa_callback_required_dependence (abfd, sec, link_info, callback, closure)
5700 struct bfd_link_info *link_info;
5701 deps_callback_t callback;
5704 Elf_Internal_Rela *internal_relocs;
5707 bfd_boolean ok = TRUE;
5709 /* ".plt*" sections have no explicit relocations but they contain L32R
5710 instructions that reference the corresponding ".got.plt*" sections. */
5711 if ((sec->flags & SEC_LINKER_CREATED) != 0
5712 && strncmp (sec->name, ".plt", 4) == 0)
5716 /* Find the corresponding ".got.plt*" section. */
5717 if (sec->name[4] == '\0')
5718 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
5724 BFD_ASSERT (sec->name[4] == '.');
5725 chunk = strtol (&sec->name[5], NULL, 10);
5727 sprintf (got_name, ".got.plt.%u", chunk);
5728 sgotplt = bfd_get_section_by_name (sec->owner, got_name);
5730 BFD_ASSERT (sgotplt);
5732 /* Assume worst-case offsets: L32R at the very end of the ".plt"
5733 section referencing a literal at the very beginning of
5734 ".got.plt". This is very close to the real dependence, anyway. */
5735 (*callback) (sec, sec->_raw_size, sgotplt, 0, closure);
5738 internal_relocs = retrieve_internal_relocs (abfd, sec,
5739 link_info->keep_memory);
5740 if (internal_relocs == NULL
5741 || sec->reloc_count == 0)
5744 /* Cache the contents for the duration of this scan. */
5745 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5746 if (contents == NULL && sec->_raw_size != 0)
5752 if (xtensa_default_isa == NULL)
5755 for (i = 0; i < sec->reloc_count; i++)
5757 Elf_Internal_Rela *irel = &internal_relocs[i];
5758 if (is_l32r_relocation (sec, contents, irel))
5761 asection *target_sec;
5762 bfd_vma target_offset;
5764 r_reloc_init (&l32r_rel, abfd, irel);
5767 /* L32Rs must be local to the input file. */
5768 if (r_reloc_is_defined (&l32r_rel))
5770 target_sec = r_reloc_get_section (&l32r_rel);
5771 target_offset = r_reloc_get_target_offset (&l32r_rel);
5773 (*callback) (sec, irel->r_offset, target_sec, target_offset,
5779 release_internal_relocs (sec, internal_relocs);
5780 release_contents (sec, contents);
5786 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
5787 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
5788 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
5789 #define TARGET_BIG_NAME "elf32-xtensa-be"
5790 #define ELF_ARCH bfd_arch_xtensa
5792 /* The new EM_XTENSA value will be recognized beginning in the Xtensa T1040
5793 release. However, we still have to generate files with the EM_XTENSA_OLD
5794 value so that pre-T1040 tools can read the files. As soon as we stop
5795 caring about pre-T1040 tools, the following two values should be
5796 swapped. At the same time, any other code that uses EM_XTENSA_OLD
5797 (e.g., prep_headers() in elf.c) should be changed to use EM_XTENSA. */
5798 #define ELF_MACHINE_CODE EM_XTENSA_OLD
5799 #define ELF_MACHINE_ALT1 EM_XTENSA
5802 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
5803 #else /* !XCHAL_HAVE_MMU */
5804 #define ELF_MAXPAGESIZE 1
5805 #endif /* !XCHAL_HAVE_MMU */
5806 #endif /* ELF_ARCH */
5808 #define elf_backend_can_gc_sections 1
5809 #define elf_backend_can_refcount 1
5810 #define elf_backend_plt_readonly 1
5811 #define elf_backend_got_header_size 4
5812 #define elf_backend_want_dynbss 0
5813 #define elf_backend_want_got_plt 1
5815 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
5817 #define bfd_elf32_bfd_final_link bfd_elf32_bfd_final_link
5818 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
5819 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
5820 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
5821 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
5822 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
5823 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
5825 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
5826 #define elf_backend_check_relocs elf_xtensa_check_relocs
5827 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
5828 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
5829 #define elf_backend_discard_info elf_xtensa_discard_info
5830 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
5831 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
5832 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
5833 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
5834 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
5835 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
5836 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
5837 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
5838 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
5839 #define elf_backend_modify_segment_map elf_xtensa_modify_segment_map
5840 #define elf_backend_object_p elf_xtensa_object_p
5841 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
5842 #define elf_backend_relocate_section elf_xtensa_relocate_section
5843 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
5845 #include "elf32-target.h"