1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 3 of the
10 License, or (at your option) any later version.
12 This program is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
31 #include "elf/xtensa.h"
32 #include "xtensa-isa.h"
33 #include "xtensa-config.h"
35 #define XTENSA_NO_NOP_REMOVAL 0
37 /* Local helper functions. */
39 static bfd_boolean add_extra_plt_sections (struct bfd_link_info *, int);
40 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
41 static bfd_reloc_status_type bfd_elf_xtensa_reloc
42 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
43 static bfd_boolean do_fix_for_relocatable_link
44 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *);
45 static void do_fix_for_final_link
46 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *, bfd_vma *);
48 /* Local functions to handle Xtensa configurability. */
50 static bfd_boolean is_indirect_call_opcode (xtensa_opcode);
51 static bfd_boolean is_direct_call_opcode (xtensa_opcode);
52 static bfd_boolean is_windowed_call_opcode (xtensa_opcode);
53 static xtensa_opcode get_const16_opcode (void);
54 static xtensa_opcode get_l32r_opcode (void);
55 static bfd_vma l32r_offset (bfd_vma, bfd_vma);
56 static int get_relocation_opnd (xtensa_opcode, int);
57 static int get_relocation_slot (int);
58 static xtensa_opcode get_relocation_opcode
59 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
60 static bfd_boolean is_l32r_relocation
61 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
62 static bfd_boolean is_alt_relocation (int);
63 static bfd_boolean is_operand_relocation (int);
64 static bfd_size_type insn_decode_len
65 (bfd_byte *, bfd_size_type, bfd_size_type);
66 static xtensa_opcode insn_decode_opcode
67 (bfd_byte *, bfd_size_type, bfd_size_type, int);
68 static bfd_boolean check_branch_target_aligned
69 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
70 static bfd_boolean check_loop_aligned
71 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
72 static bfd_boolean check_branch_target_aligned_address (bfd_vma, int);
73 static bfd_size_type get_asm_simplify_size
74 (bfd_byte *, bfd_size_type, bfd_size_type);
76 /* Functions for link-time code simplifications. */
78 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
79 (bfd_byte *, bfd_vma, bfd_vma, char **);
80 static bfd_reloc_status_type contract_asm_expansion
81 (bfd_byte *, bfd_vma, Elf_Internal_Rela *, char **);
82 static xtensa_opcode swap_callx_for_call_opcode (xtensa_opcode);
83 static xtensa_opcode get_expanded_call_opcode (bfd_byte *, int, bfd_boolean *);
85 /* Access to internal relocations, section contents and symbols. */
87 static Elf_Internal_Rela *retrieve_internal_relocs
88 (bfd *, asection *, bfd_boolean);
89 static void pin_internal_relocs (asection *, Elf_Internal_Rela *);
90 static void release_internal_relocs (asection *, Elf_Internal_Rela *);
91 static bfd_byte *retrieve_contents (bfd *, asection *, bfd_boolean);
92 static void pin_contents (asection *, bfd_byte *);
93 static void release_contents (asection *, bfd_byte *);
94 static Elf_Internal_Sym *retrieve_local_syms (bfd *);
96 /* Miscellaneous utility functions. */
98 static asection *elf_xtensa_get_plt_section (struct bfd_link_info *, int);
99 static asection *elf_xtensa_get_gotplt_section (struct bfd_link_info *, int);
100 static asection *get_elf_r_symndx_section (bfd *, unsigned long);
101 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
102 (bfd *, unsigned long);
103 static bfd_vma get_elf_r_symndx_offset (bfd *, unsigned long);
104 static bfd_boolean is_reloc_sym_weak (bfd *, Elf_Internal_Rela *);
105 static bfd_boolean pcrel_reloc_fits (xtensa_opcode, int, bfd_vma, bfd_vma);
106 static bfd_boolean xtensa_is_property_section (asection *);
107 static bfd_boolean xtensa_is_insntable_section (asection *);
108 static bfd_boolean xtensa_is_littable_section (asection *);
109 static bfd_boolean xtensa_is_proptable_section (asection *);
110 static int internal_reloc_compare (const void *, const void *);
111 static int internal_reloc_matches (const void *, const void *);
112 static asection *xtensa_get_property_section (asection *, const char *);
113 extern asection *xtensa_make_property_section (asection *, const char *);
114 static flagword xtensa_get_property_predef_flags (asection *);
116 /* Other functions called directly by the linker. */
118 typedef void (*deps_callback_t)
119 (asection *, bfd_vma, asection *, bfd_vma, void *);
120 extern bfd_boolean xtensa_callback_required_dependence
121 (bfd *, asection *, struct bfd_link_info *, deps_callback_t, void *);
124 /* Globally visible flag for choosing size optimization of NOP removal
125 instead of branch-target-aware minimization for NOP removal.
126 When nonzero, narrow all instructions and remove all NOPs possible
127 around longcall expansions. */
129 int elf32xtensa_size_opt;
132 /* The "new_section_hook" is used to set up a per-section
133 "xtensa_relax_info" data structure with additional information used
134 during relaxation. */
136 typedef struct xtensa_relax_info_struct xtensa_relax_info;
139 /* The GNU tools do not easily allow extending interfaces to pass around
140 the pointer to the Xtensa ISA information, so instead we add a global
141 variable here (in BFD) that can be used by any of the tools that need
144 xtensa_isa xtensa_default_isa;
147 /* When this is true, relocations may have been modified to refer to
148 symbols from other input files. The per-section list of "fix"
149 records needs to be checked when resolving relocations. */
151 static bfd_boolean relaxing_section = FALSE;
153 /* When this is true, during final links, literals that cannot be
154 coalesced and their relocations may be moved to other sections. */
156 int elf32xtensa_no_literal_movement = 1;
159 static reloc_howto_type elf_howto_table[] =
161 HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
162 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
164 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
165 bfd_elf_xtensa_reloc, "R_XTENSA_32",
166 TRUE, 0xffffffff, 0xffffffff, FALSE),
168 /* Replace a 32-bit value with a value from the runtime linker (only
169 used by linker-generated stub functions). The r_addend value is
170 special: 1 means to substitute a pointer to the runtime linker's
171 dynamic resolver function; 2 means to substitute the link map for
172 the shared object. */
173 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
174 NULL, "R_XTENSA_RTLD", FALSE, 0, 0, FALSE),
176 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
177 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
178 FALSE, 0, 0xffffffff, FALSE),
179 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
180 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
181 FALSE, 0, 0xffffffff, FALSE),
182 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
183 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
184 FALSE, 0, 0xffffffff, FALSE),
185 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
186 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
187 FALSE, 0, 0xffffffff, FALSE),
191 /* Old relocations for backward compatibility. */
192 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
193 bfd_elf_xtensa_reloc, "R_XTENSA_OP0", FALSE, 0, 0, TRUE),
194 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
195 bfd_elf_xtensa_reloc, "R_XTENSA_OP1", FALSE, 0, 0, TRUE),
196 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
197 bfd_elf_xtensa_reloc, "R_XTENSA_OP2", FALSE, 0, 0, TRUE),
199 /* Assembly auto-expansion. */
200 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
201 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND", FALSE, 0, 0, TRUE),
202 /* Relax assembly auto-expansion. */
203 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
204 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY", FALSE, 0, 0, TRUE),
208 HOWTO (R_XTENSA_32_PCREL, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
209 bfd_elf_xtensa_reloc, "R_XTENSA_32_PCREL",
210 FALSE, 0, 0xffffffff, TRUE),
212 /* GNU extension to record C++ vtable hierarchy. */
213 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
214 NULL, "R_XTENSA_GNU_VTINHERIT",
216 /* GNU extension to record C++ vtable member usage. */
217 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
218 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
221 /* Relocations for supporting difference of symbols. */
222 HOWTO (R_XTENSA_DIFF8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
223 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF8", FALSE, 0, 0xff, FALSE),
224 HOWTO (R_XTENSA_DIFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
225 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF16", FALSE, 0, 0xffff, FALSE),
226 HOWTO (R_XTENSA_DIFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
227 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF32", FALSE, 0, 0xffffffff, FALSE),
229 /* General immediate operand relocations. */
230 HOWTO (R_XTENSA_SLOT0_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
231 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_OP", FALSE, 0, 0, TRUE),
232 HOWTO (R_XTENSA_SLOT1_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
233 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_OP", FALSE, 0, 0, TRUE),
234 HOWTO (R_XTENSA_SLOT2_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
235 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_OP", FALSE, 0, 0, TRUE),
236 HOWTO (R_XTENSA_SLOT3_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
237 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_OP", FALSE, 0, 0, TRUE),
238 HOWTO (R_XTENSA_SLOT4_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
239 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_OP", FALSE, 0, 0, TRUE),
240 HOWTO (R_XTENSA_SLOT5_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
241 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_OP", FALSE, 0, 0, TRUE),
242 HOWTO (R_XTENSA_SLOT6_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
243 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_OP", FALSE, 0, 0, TRUE),
244 HOWTO (R_XTENSA_SLOT7_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
245 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_OP", FALSE, 0, 0, TRUE),
246 HOWTO (R_XTENSA_SLOT8_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
247 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_OP", FALSE, 0, 0, TRUE),
248 HOWTO (R_XTENSA_SLOT9_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
249 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_OP", FALSE, 0, 0, TRUE),
250 HOWTO (R_XTENSA_SLOT10_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
251 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_OP", FALSE, 0, 0, TRUE),
252 HOWTO (R_XTENSA_SLOT11_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
253 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_OP", FALSE, 0, 0, TRUE),
254 HOWTO (R_XTENSA_SLOT12_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
255 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_OP", FALSE, 0, 0, TRUE),
256 HOWTO (R_XTENSA_SLOT13_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
257 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_OP", FALSE, 0, 0, TRUE),
258 HOWTO (R_XTENSA_SLOT14_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
259 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_OP", FALSE, 0, 0, TRUE),
261 /* "Alternate" relocations. The meaning of these is opcode-specific. */
262 HOWTO (R_XTENSA_SLOT0_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
263 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_ALT", FALSE, 0, 0, TRUE),
264 HOWTO (R_XTENSA_SLOT1_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
265 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_ALT", FALSE, 0, 0, TRUE),
266 HOWTO (R_XTENSA_SLOT2_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
267 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_ALT", FALSE, 0, 0, TRUE),
268 HOWTO (R_XTENSA_SLOT3_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
269 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_ALT", FALSE, 0, 0, TRUE),
270 HOWTO (R_XTENSA_SLOT4_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
271 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_ALT", FALSE, 0, 0, TRUE),
272 HOWTO (R_XTENSA_SLOT5_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
273 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_ALT", FALSE, 0, 0, TRUE),
274 HOWTO (R_XTENSA_SLOT6_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
275 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_ALT", FALSE, 0, 0, TRUE),
276 HOWTO (R_XTENSA_SLOT7_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
277 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_ALT", FALSE, 0, 0, TRUE),
278 HOWTO (R_XTENSA_SLOT8_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
279 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_ALT", FALSE, 0, 0, TRUE),
280 HOWTO (R_XTENSA_SLOT9_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
281 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_ALT", FALSE, 0, 0, TRUE),
282 HOWTO (R_XTENSA_SLOT10_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
283 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_ALT", FALSE, 0, 0, TRUE),
284 HOWTO (R_XTENSA_SLOT11_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
285 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_ALT", FALSE, 0, 0, TRUE),
286 HOWTO (R_XTENSA_SLOT12_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
287 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_ALT", FALSE, 0, 0, TRUE),
288 HOWTO (R_XTENSA_SLOT13_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
289 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_ALT", FALSE, 0, 0, TRUE),
290 HOWTO (R_XTENSA_SLOT14_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
291 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_ALT", FALSE, 0, 0, TRUE),
293 /* TLS relocations. */
294 HOWTO (R_XTENSA_TLSDESC_FN, 0, 2, 32, FALSE, 0, complain_overflow_dont,
295 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_FN",
296 FALSE, 0, 0xffffffff, FALSE),
297 HOWTO (R_XTENSA_TLSDESC_ARG, 0, 2, 32, FALSE, 0, complain_overflow_dont,
298 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_ARG",
299 FALSE, 0, 0xffffffff, FALSE),
300 HOWTO (R_XTENSA_TLS_DTPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
301 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_DTPOFF",
302 FALSE, 0, 0xffffffff, FALSE),
303 HOWTO (R_XTENSA_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
304 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_TPOFF",
305 FALSE, 0, 0xffffffff, FALSE),
306 HOWTO (R_XTENSA_TLS_FUNC, 0, 0, 0, FALSE, 0, complain_overflow_dont,
307 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_FUNC",
309 HOWTO (R_XTENSA_TLS_ARG, 0, 0, 0, FALSE, 0, complain_overflow_dont,
310 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_ARG",
312 HOWTO (R_XTENSA_TLS_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
313 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_CALL",
319 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
324 static reloc_howto_type *
325 elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
326 bfd_reloc_code_real_type code)
331 TRACE ("BFD_RELOC_NONE");
332 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
335 TRACE ("BFD_RELOC_32");
336 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
338 case BFD_RELOC_32_PCREL:
339 TRACE ("BFD_RELOC_32_PCREL");
340 return &elf_howto_table[(unsigned) R_XTENSA_32_PCREL ];
342 case BFD_RELOC_XTENSA_DIFF8:
343 TRACE ("BFD_RELOC_XTENSA_DIFF8");
344 return &elf_howto_table[(unsigned) R_XTENSA_DIFF8 ];
346 case BFD_RELOC_XTENSA_DIFF16:
347 TRACE ("BFD_RELOC_XTENSA_DIFF16");
348 return &elf_howto_table[(unsigned) R_XTENSA_DIFF16 ];
350 case BFD_RELOC_XTENSA_DIFF32:
351 TRACE ("BFD_RELOC_XTENSA_DIFF32");
352 return &elf_howto_table[(unsigned) R_XTENSA_DIFF32 ];
354 case BFD_RELOC_XTENSA_RTLD:
355 TRACE ("BFD_RELOC_XTENSA_RTLD");
356 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
358 case BFD_RELOC_XTENSA_GLOB_DAT:
359 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
360 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
362 case BFD_RELOC_XTENSA_JMP_SLOT:
363 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
364 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
366 case BFD_RELOC_XTENSA_RELATIVE:
367 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
368 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
370 case BFD_RELOC_XTENSA_PLT:
371 TRACE ("BFD_RELOC_XTENSA_PLT");
372 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
374 case BFD_RELOC_XTENSA_OP0:
375 TRACE ("BFD_RELOC_XTENSA_OP0");
376 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
378 case BFD_RELOC_XTENSA_OP1:
379 TRACE ("BFD_RELOC_XTENSA_OP1");
380 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
382 case BFD_RELOC_XTENSA_OP2:
383 TRACE ("BFD_RELOC_XTENSA_OP2");
384 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
386 case BFD_RELOC_XTENSA_ASM_EXPAND:
387 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
388 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
390 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
391 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
392 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
394 case BFD_RELOC_VTABLE_INHERIT:
395 TRACE ("BFD_RELOC_VTABLE_INHERIT");
396 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
398 case BFD_RELOC_VTABLE_ENTRY:
399 TRACE ("BFD_RELOC_VTABLE_ENTRY");
400 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
402 case BFD_RELOC_XTENSA_TLSDESC_FN:
403 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
404 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_FN ];
406 case BFD_RELOC_XTENSA_TLSDESC_ARG:
407 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
408 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_ARG ];
410 case BFD_RELOC_XTENSA_TLS_DTPOFF:
411 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
412 return &elf_howto_table[(unsigned) R_XTENSA_TLS_DTPOFF ];
414 case BFD_RELOC_XTENSA_TLS_TPOFF:
415 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
416 return &elf_howto_table[(unsigned) R_XTENSA_TLS_TPOFF ];
418 case BFD_RELOC_XTENSA_TLS_FUNC:
419 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
420 return &elf_howto_table[(unsigned) R_XTENSA_TLS_FUNC ];
422 case BFD_RELOC_XTENSA_TLS_ARG:
423 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
424 return &elf_howto_table[(unsigned) R_XTENSA_TLS_ARG ];
426 case BFD_RELOC_XTENSA_TLS_CALL:
427 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
428 return &elf_howto_table[(unsigned) R_XTENSA_TLS_CALL ];
431 if (code >= BFD_RELOC_XTENSA_SLOT0_OP
432 && code <= BFD_RELOC_XTENSA_SLOT14_OP)
434 unsigned n = (R_XTENSA_SLOT0_OP +
435 (code - BFD_RELOC_XTENSA_SLOT0_OP));
436 return &elf_howto_table[n];
439 if (code >= BFD_RELOC_XTENSA_SLOT0_ALT
440 && code <= BFD_RELOC_XTENSA_SLOT14_ALT)
442 unsigned n = (R_XTENSA_SLOT0_ALT +
443 (code - BFD_RELOC_XTENSA_SLOT0_ALT));
444 return &elf_howto_table[n];
454 static reloc_howto_type *
455 elf_xtensa_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
460 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
461 if (elf_howto_table[i].name != NULL
462 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
463 return &elf_howto_table[i];
469 /* Given an ELF "rela" relocation, find the corresponding howto and record
470 it in the BFD internal arelent representation of the relocation. */
473 elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
475 Elf_Internal_Rela *dst)
477 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
479 BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max);
480 cache_ptr->howto = &elf_howto_table[r_type];
484 /* Functions for the Xtensa ELF linker. */
486 /* The name of the dynamic interpreter. This is put in the .interp
489 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
491 /* The size in bytes of an entry in the procedure linkage table.
492 (This does _not_ include the space for the literals associated with
495 #define PLT_ENTRY_SIZE 16
497 /* For _really_ large PLTs, we may need to alternate between literals
498 and code to keep the literals within the 256K range of the L32R
499 instructions in the code. It's unlikely that anyone would ever need
500 such a big PLT, but an arbitrary limit on the PLT size would be bad.
501 Thus, we split the PLT into chunks. Since there's very little
502 overhead (2 extra literals) for each chunk, the chunk size is kept
503 small so that the code for handling multiple chunks get used and
504 tested regularly. With 254 entries, there are 1K of literals for
505 each chunk, and that seems like a nice round number. */
507 #define PLT_ENTRIES_PER_CHUNK 254
509 /* PLT entries are actually used as stub functions for lazy symbol
510 resolution. Once the symbol is resolved, the stub function is never
511 invoked. Note: the 32-byte frame size used here cannot be changed
512 without a corresponding change in the runtime linker. */
514 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
516 0x6c, 0x10, 0x04, /* entry sp, 32 */
517 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
518 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
519 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
520 0x0a, 0x80, 0x00, /* jx a8 */
524 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
526 0x36, 0x41, 0x00, /* entry sp, 32 */
527 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
528 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
529 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
530 0xa0, 0x08, 0x00, /* jx a8 */
534 /* The size of the thread control block. */
537 struct elf_xtensa_link_hash_entry
539 struct elf_link_hash_entry elf;
541 bfd_signed_vma tlsfunc_refcount;
543 #define GOT_UNKNOWN 0
545 #define GOT_TLS_GD 2 /* global or local dynamic */
546 #define GOT_TLS_IE 4 /* initial or local exec */
547 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
548 unsigned char tls_type;
551 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
553 struct elf_xtensa_obj_tdata
555 struct elf_obj_tdata root;
557 /* tls_type for each local got entry. */
558 char *local_got_tls_type;
560 bfd_signed_vma *local_tlsfunc_refcounts;
563 #define elf_xtensa_tdata(abfd) \
564 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
566 #define elf_xtensa_local_got_tls_type(abfd) \
567 (elf_xtensa_tdata (abfd)->local_got_tls_type)
569 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
570 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
572 #define is_xtensa_elf(bfd) \
573 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
574 && elf_tdata (bfd) != NULL \
575 && elf_object_id (bfd) == XTENSA_ELF_TDATA)
578 elf_xtensa_mkobject (bfd *abfd)
580 return bfd_elf_allocate_object (abfd, sizeof (struct elf_xtensa_obj_tdata),
584 /* Xtensa ELF linker hash table. */
586 struct elf_xtensa_link_hash_table
588 struct elf_link_hash_table elf;
590 /* Short-cuts to get to dynamic linker sections. */
597 asection *spltlittbl;
599 /* Total count of PLT relocations seen during check_relocs.
600 The actual PLT code must be split into multiple sections and all
601 the sections have to be created before size_dynamic_sections,
602 where we figure out the exact number of PLT entries that will be
603 needed. It is OK if this count is an overestimate, e.g., some
604 relocations may be removed by GC. */
607 struct elf_xtensa_link_hash_entry *tlsbase;
610 /* Get the Xtensa ELF linker hash table from a link_info structure. */
612 #define elf_xtensa_hash_table(p) \
613 ((struct elf_xtensa_link_hash_table *) ((p)->hash))
615 /* Create an entry in an Xtensa ELF linker hash table. */
617 static struct bfd_hash_entry *
618 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry *entry,
619 struct bfd_hash_table *table,
622 /* Allocate the structure if it has not already been allocated by a
626 entry = bfd_hash_allocate (table,
627 sizeof (struct elf_xtensa_link_hash_entry));
632 /* Call the allocation method of the superclass. */
633 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
636 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (entry);
637 eh->tlsfunc_refcount = 0;
638 eh->tls_type = GOT_UNKNOWN;
644 /* Create an Xtensa ELF linker hash table. */
646 static struct bfd_link_hash_table *
647 elf_xtensa_link_hash_table_create (bfd *abfd)
649 struct elf_link_hash_entry *tlsbase;
650 struct elf_xtensa_link_hash_table *ret;
651 bfd_size_type amt = sizeof (struct elf_xtensa_link_hash_table);
653 ret = bfd_malloc (amt);
657 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
658 elf_xtensa_link_hash_newfunc,
659 sizeof (struct elf_xtensa_link_hash_entry)))
671 ret->spltlittbl = NULL;
673 ret->plt_reloc_count = 0;
675 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
677 tlsbase = elf_link_hash_lookup (&ret->elf, "_TLS_MODULE_BASE_",
679 tlsbase->root.type = bfd_link_hash_new;
680 tlsbase->root.u.undef.abfd = NULL;
681 tlsbase->non_elf = 0;
682 ret->tlsbase = elf_xtensa_hash_entry (tlsbase);
683 ret->tlsbase->tls_type = GOT_UNKNOWN;
685 return &ret->elf.root;
688 /* Copy the extra info we tack onto an elf_link_hash_entry. */
691 elf_xtensa_copy_indirect_symbol (struct bfd_link_info *info,
692 struct elf_link_hash_entry *dir,
693 struct elf_link_hash_entry *ind)
695 struct elf_xtensa_link_hash_entry *edir, *eind;
697 edir = elf_xtensa_hash_entry (dir);
698 eind = elf_xtensa_hash_entry (ind);
700 if (ind->root.type == bfd_link_hash_indirect)
702 edir->tlsfunc_refcount += eind->tlsfunc_refcount;
703 eind->tlsfunc_refcount = 0;
705 if (dir->got.refcount <= 0)
707 edir->tls_type = eind->tls_type;
708 eind->tls_type = GOT_UNKNOWN;
712 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
715 static inline bfd_boolean
716 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry *h,
717 struct bfd_link_info *info)
719 /* Check if we should do dynamic things to this symbol. The
720 "ignore_protected" argument need not be set, because Xtensa code
721 does not require special handling of STV_PROTECTED to make function
722 pointer comparisons work properly. The PLT addresses are never
723 used for function pointers. */
725 return _bfd_elf_dynamic_symbol_p (h, info, 0);
730 property_table_compare (const void *ap, const void *bp)
732 const property_table_entry *a = (const property_table_entry *) ap;
733 const property_table_entry *b = (const property_table_entry *) bp;
735 if (a->address == b->address)
737 if (a->size != b->size)
738 return (a->size - b->size);
740 if ((a->flags & XTENSA_PROP_ALIGN) != (b->flags & XTENSA_PROP_ALIGN))
741 return ((b->flags & XTENSA_PROP_ALIGN)
742 - (a->flags & XTENSA_PROP_ALIGN));
744 if ((a->flags & XTENSA_PROP_ALIGN)
745 && (GET_XTENSA_PROP_ALIGNMENT (a->flags)
746 != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
747 return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
748 - GET_XTENSA_PROP_ALIGNMENT (b->flags));
750 if ((a->flags & XTENSA_PROP_UNREACHABLE)
751 != (b->flags & XTENSA_PROP_UNREACHABLE))
752 return ((b->flags & XTENSA_PROP_UNREACHABLE)
753 - (a->flags & XTENSA_PROP_UNREACHABLE));
755 return (a->flags - b->flags);
758 return (a->address - b->address);
763 property_table_matches (const void *ap, const void *bp)
765 const property_table_entry *a = (const property_table_entry *) ap;
766 const property_table_entry *b = (const property_table_entry *) bp;
768 /* Check if one entry overlaps with the other. */
769 if ((b->address >= a->address && b->address < (a->address + a->size))
770 || (a->address >= b->address && a->address < (b->address + b->size)))
773 return (a->address - b->address);
777 /* Get the literal table or property table entries for the given
778 section. Sets TABLE_P and returns the number of entries. On
779 error, returns a negative value. */
782 xtensa_read_table_entries (bfd *abfd,
784 property_table_entry **table_p,
785 const char *sec_name,
786 bfd_boolean output_addr)
788 asection *table_section;
789 bfd_size_type table_size = 0;
790 bfd_byte *table_data;
791 property_table_entry *blocks;
792 int blk, block_count;
793 bfd_size_type num_records;
794 Elf_Internal_Rela *internal_relocs, *irel, *rel_end;
795 bfd_vma section_addr, off;
796 flagword predef_flags;
797 bfd_size_type table_entry_size, section_limit;
800 || !(section->flags & SEC_ALLOC)
801 || (section->flags & SEC_DEBUGGING))
807 table_section = xtensa_get_property_section (section, sec_name);
809 table_size = table_section->size;
817 predef_flags = xtensa_get_property_predef_flags (table_section);
818 table_entry_size = 12;
820 table_entry_size -= 4;
822 num_records = table_size / table_entry_size;
823 table_data = retrieve_contents (abfd, table_section, TRUE);
824 blocks = (property_table_entry *)
825 bfd_malloc (num_records * sizeof (property_table_entry));
829 section_addr = section->output_section->vma + section->output_offset;
831 section_addr = section->vma;
833 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
834 if (internal_relocs && !table_section->reloc_done)
836 qsort (internal_relocs, table_section->reloc_count,
837 sizeof (Elf_Internal_Rela), internal_reloc_compare);
838 irel = internal_relocs;
843 section_limit = bfd_get_section_limit (abfd, section);
844 rel_end = internal_relocs + table_section->reloc_count;
846 for (off = 0; off < table_size; off += table_entry_size)
848 bfd_vma address = bfd_get_32 (abfd, table_data + off);
850 /* Skip any relocations before the current offset. This should help
851 avoid confusion caused by unexpected relocations for the preceding
854 (irel->r_offset < off
855 || (irel->r_offset == off
856 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_NONE)))
863 if (irel && irel->r_offset == off)
866 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
867 BFD_ASSERT (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32);
869 if (get_elf_r_symndx_section (abfd, r_symndx) != section)
872 sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
873 BFD_ASSERT (sym_off == 0);
874 address += (section_addr + sym_off + irel->r_addend);
878 if (address < section_addr
879 || address >= section_addr + section_limit)
883 blocks[block_count].address = address;
884 blocks[block_count].size = bfd_get_32 (abfd, table_data + off + 4);
886 blocks[block_count].flags = predef_flags;
888 blocks[block_count].flags = bfd_get_32 (abfd, table_data + off + 8);
892 release_contents (table_section, table_data);
893 release_internal_relocs (table_section, internal_relocs);
897 /* Now sort them into address order for easy reference. */
898 qsort (blocks, block_count, sizeof (property_table_entry),
899 property_table_compare);
901 /* Check that the table contents are valid. Problems may occur,
902 for example, if an unrelocated object file is stripped. */
903 for (blk = 1; blk < block_count; blk++)
905 /* The only circumstance where two entries may legitimately
906 have the same address is when one of them is a zero-size
907 placeholder to mark a place where fill can be inserted.
908 The zero-size entry should come first. */
909 if (blocks[blk - 1].address == blocks[blk].address &&
910 blocks[blk - 1].size != 0)
912 (*_bfd_error_handler) (_("%B(%A): invalid property table"),
914 bfd_set_error (bfd_error_bad_value);
926 static property_table_entry *
927 elf_xtensa_find_property_entry (property_table_entry *property_table,
928 int property_table_size,
931 property_table_entry entry;
932 property_table_entry *rv;
934 if (property_table_size == 0)
937 entry.address = addr;
941 rv = bsearch (&entry, property_table, property_table_size,
942 sizeof (property_table_entry), property_table_matches);
948 elf_xtensa_in_literal_pool (property_table_entry *lit_table,
952 if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
959 /* Look through the relocs for a section during the first phase, and
960 calculate needed space in the dynamic reloc sections. */
963 elf_xtensa_check_relocs (bfd *abfd,
964 struct bfd_link_info *info,
966 const Elf_Internal_Rela *relocs)
968 struct elf_xtensa_link_hash_table *htab;
969 Elf_Internal_Shdr *symtab_hdr;
970 struct elf_link_hash_entry **sym_hashes;
971 const Elf_Internal_Rela *rel;
972 const Elf_Internal_Rela *rel_end;
974 if (info->relocatable || (sec->flags & SEC_ALLOC) == 0)
977 BFD_ASSERT (is_xtensa_elf (abfd));
979 htab = elf_xtensa_hash_table (info);
980 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
981 sym_hashes = elf_sym_hashes (abfd);
983 rel_end = relocs + sec->reloc_count;
984 for (rel = relocs; rel < rel_end; rel++)
987 unsigned long r_symndx;
988 struct elf_link_hash_entry *h = NULL;
989 struct elf_xtensa_link_hash_entry *eh;
990 int tls_type, old_tls_type;
991 bfd_boolean is_got = FALSE;
992 bfd_boolean is_plt = FALSE;
993 bfd_boolean is_tlsfunc = FALSE;
995 r_symndx = ELF32_R_SYM (rel->r_info);
996 r_type = ELF32_R_TYPE (rel->r_info);
998 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1000 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1005 if (r_symndx >= symtab_hdr->sh_info)
1007 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1008 while (h->root.type == bfd_link_hash_indirect
1009 || h->root.type == bfd_link_hash_warning)
1010 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1012 eh = elf_xtensa_hash_entry (h);
1016 case R_XTENSA_TLSDESC_FN:
1019 tls_type = GOT_TLS_GD;
1024 tls_type = GOT_TLS_IE;
1027 case R_XTENSA_TLSDESC_ARG:
1030 tls_type = GOT_TLS_GD;
1035 tls_type = GOT_TLS_IE;
1036 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1041 case R_XTENSA_TLS_DTPOFF:
1043 tls_type = GOT_TLS_GD;
1045 tls_type = GOT_TLS_IE;
1048 case R_XTENSA_TLS_TPOFF:
1049 tls_type = GOT_TLS_IE;
1051 info->flags |= DF_STATIC_TLS;
1052 if (info->shared || h)
1057 tls_type = GOT_NORMAL;
1062 tls_type = GOT_NORMAL;
1066 case R_XTENSA_GNU_VTINHERIT:
1067 /* This relocation describes the C++ object vtable hierarchy.
1068 Reconstruct it for later use during GC. */
1069 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1073 case R_XTENSA_GNU_VTENTRY:
1074 /* This relocation describes which C++ vtable entries are actually
1075 used. Record for later use during GC. */
1076 BFD_ASSERT (h != NULL);
1078 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1083 /* Nothing to do for any other relocations. */
1091 if (h->plt.refcount <= 0)
1094 h->plt.refcount = 1;
1097 h->plt.refcount += 1;
1099 /* Keep track of the total PLT relocation count even if we
1100 don't yet know whether the dynamic sections will be
1102 htab->plt_reloc_count += 1;
1104 if (elf_hash_table (info)->dynamic_sections_created)
1106 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1112 if (h->got.refcount <= 0)
1113 h->got.refcount = 1;
1115 h->got.refcount += 1;
1119 eh->tlsfunc_refcount += 1;
1121 old_tls_type = eh->tls_type;
1125 /* Allocate storage the first time. */
1126 if (elf_local_got_refcounts (abfd) == NULL)
1128 bfd_size_type size = symtab_hdr->sh_info;
1131 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1134 elf_local_got_refcounts (abfd) = (bfd_signed_vma *) mem;
1136 mem = bfd_zalloc (abfd, size);
1139 elf_xtensa_local_got_tls_type (abfd) = (char *) mem;
1141 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1144 elf_xtensa_local_tlsfunc_refcounts (abfd)
1145 = (bfd_signed_vma *) mem;
1148 /* This is a global offset table entry for a local symbol. */
1149 if (is_got || is_plt)
1150 elf_local_got_refcounts (abfd) [r_symndx] += 1;
1153 elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx] += 1;
1155 old_tls_type = elf_xtensa_local_got_tls_type (abfd) [r_symndx];
1158 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1159 tls_type |= old_tls_type;
1160 /* If a TLS symbol is accessed using IE at least once,
1161 there is no point to use a dynamic model for it. */
1162 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1163 && ((old_tls_type & GOT_TLS_GD) == 0
1164 || (tls_type & GOT_TLS_IE) == 0))
1166 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_GD))
1167 tls_type = old_tls_type;
1168 else if ((old_tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_GD))
1169 tls_type |= old_tls_type;
1172 (*_bfd_error_handler)
1173 (_("%B: `%s' accessed both as normal and thread local symbol"),
1175 h ? h->root.root.string : "<local>");
1180 if (old_tls_type != tls_type)
1183 eh->tls_type = tls_type;
1185 elf_xtensa_local_got_tls_type (abfd) [r_symndx] = tls_type;
1194 elf_xtensa_make_sym_local (struct bfd_link_info *info,
1195 struct elf_link_hash_entry *h)
1199 if (h->plt.refcount > 0)
1201 /* For shared objects, there's no need for PLT entries for local
1202 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1203 if (h->got.refcount < 0)
1204 h->got.refcount = 0;
1205 h->got.refcount += h->plt.refcount;
1206 h->plt.refcount = 0;
1211 /* Don't need any dynamic relocations at all. */
1212 h->plt.refcount = 0;
1213 h->got.refcount = 0;
1219 elf_xtensa_hide_symbol (struct bfd_link_info *info,
1220 struct elf_link_hash_entry *h,
1221 bfd_boolean force_local)
1223 /* For a shared link, move the plt refcount to the got refcount to leave
1224 space for RELATIVE relocs. */
1225 elf_xtensa_make_sym_local (info, h);
1227 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
1231 /* Return the section that should be marked against GC for a given
1235 elf_xtensa_gc_mark_hook (asection *sec,
1236 struct bfd_link_info *info,
1237 Elf_Internal_Rela *rel,
1238 struct elf_link_hash_entry *h,
1239 Elf_Internal_Sym *sym)
1241 /* Property sections are marked "KEEP" in the linker scripts, but they
1242 should not cause other sections to be marked. (This approach relies
1243 on elf_xtensa_discard_info to remove property table entries that
1244 describe discarded sections. Alternatively, it might be more
1245 efficient to avoid using "KEEP" in the linker scripts and instead use
1246 the gc_mark_extra_sections hook to mark only the property sections
1247 that describe marked sections. That alternative does not work well
1248 with the current property table sections, which do not correspond
1249 one-to-one with the sections they describe, but that should be fixed
1251 if (xtensa_is_property_section (sec))
1255 switch (ELF32_R_TYPE (rel->r_info))
1257 case R_XTENSA_GNU_VTINHERIT:
1258 case R_XTENSA_GNU_VTENTRY:
1262 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1266 /* Update the GOT & PLT entry reference counts
1267 for the section being removed. */
1270 elf_xtensa_gc_sweep_hook (bfd *abfd,
1271 struct bfd_link_info *info,
1273 const Elf_Internal_Rela *relocs)
1275 Elf_Internal_Shdr *symtab_hdr;
1276 struct elf_link_hash_entry **sym_hashes;
1277 const Elf_Internal_Rela *rel, *relend;
1278 struct elf_xtensa_link_hash_table *htab;
1280 htab = elf_xtensa_hash_table (info);
1282 if (info->relocatable)
1285 if ((sec->flags & SEC_ALLOC) == 0)
1288 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1289 sym_hashes = elf_sym_hashes (abfd);
1291 relend = relocs + sec->reloc_count;
1292 for (rel = relocs; rel < relend; rel++)
1294 unsigned long r_symndx;
1295 unsigned int r_type;
1296 struct elf_link_hash_entry *h = NULL;
1297 struct elf_xtensa_link_hash_entry *eh;
1298 bfd_boolean is_got = FALSE;
1299 bfd_boolean is_plt = FALSE;
1300 bfd_boolean is_tlsfunc = FALSE;
1302 r_symndx = ELF32_R_SYM (rel->r_info);
1303 if (r_symndx >= symtab_hdr->sh_info)
1305 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1306 while (h->root.type == bfd_link_hash_indirect
1307 || h->root.type == bfd_link_hash_warning)
1308 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1310 eh = elf_xtensa_hash_entry (h);
1312 r_type = ELF32_R_TYPE (rel->r_info);
1315 case R_XTENSA_TLSDESC_FN:
1323 case R_XTENSA_TLSDESC_ARG:
1328 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1333 case R_XTENSA_TLS_TPOFF:
1334 if (info->shared || h)
1354 if (h->plt.refcount > 0)
1359 if (h->got.refcount > 0)
1364 if (eh->tlsfunc_refcount > 0)
1365 eh->tlsfunc_refcount--;
1370 if (is_got || is_plt)
1372 bfd_signed_vma *got_refcount
1373 = &elf_local_got_refcounts (abfd) [r_symndx];
1374 if (*got_refcount > 0)
1379 bfd_signed_vma *tlsfunc_refcount
1380 = &elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx];
1381 if (*tlsfunc_refcount > 0)
1382 *tlsfunc_refcount -= 1;
1391 /* Create all the dynamic sections. */
1394 elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1396 struct elf_xtensa_link_hash_table *htab;
1397 flagword flags, noalloc_flags;
1399 htab = elf_xtensa_hash_table (info);
1401 /* First do all the standard stuff. */
1402 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
1404 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1405 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1406 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1407 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1408 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1410 /* Create any extra PLT sections in case check_relocs has already
1411 been called on all the non-dynamic input files. */
1412 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1415 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
1416 | SEC_LINKER_CREATED | SEC_READONLY);
1417 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
1419 /* Mark the ".got.plt" section READONLY. */
1420 if (htab->sgotplt == NULL
1421 || ! bfd_set_section_flags (dynobj, htab->sgotplt, flags))
1424 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1425 htab->sgotloc = bfd_make_section_with_flags (dynobj, ".got.loc", flags);
1426 if (htab->sgotloc == NULL
1427 || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
1430 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1431 htab->spltlittbl = bfd_make_section_with_flags (dynobj, ".xt.lit.plt",
1433 if (htab->spltlittbl == NULL
1434 || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
1442 add_extra_plt_sections (struct bfd_link_info *info, int count)
1444 bfd *dynobj = elf_hash_table (info)->dynobj;
1447 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1448 ".got.plt" sections. */
1449 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1455 /* Stop when we find a section has already been created. */
1456 if (elf_xtensa_get_plt_section (info, chunk))
1459 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1460 | SEC_LINKER_CREATED | SEC_READONLY);
1462 sname = (char *) bfd_malloc (10);
1463 sprintf (sname, ".plt.%u", chunk);
1464 s = bfd_make_section_with_flags (dynobj, sname, flags | SEC_CODE);
1466 || ! bfd_set_section_alignment (dynobj, s, 2))
1469 sname = (char *) bfd_malloc (14);
1470 sprintf (sname, ".got.plt.%u", chunk);
1471 s = bfd_make_section_with_flags (dynobj, sname, flags);
1473 || ! bfd_set_section_alignment (dynobj, s, 2))
1481 /* Adjust a symbol defined by a dynamic object and referenced by a
1482 regular object. The current definition is in some section of the
1483 dynamic object, but we're not including those sections. We have to
1484 change the definition to something the rest of the link can
1488 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1489 struct elf_link_hash_entry *h)
1491 /* If this is a weak symbol, and there is a real definition, the
1492 processor independent code will have arranged for us to see the
1493 real definition first, and we can just use the same value. */
1496 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1497 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1498 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1499 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1503 /* This is a reference to a symbol defined by a dynamic object. The
1504 reference must go through the GOT, so there's no need for COPY relocs,
1512 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry *h, void *arg)
1514 struct bfd_link_info *info;
1515 struct elf_xtensa_link_hash_table *htab;
1516 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (h);
1518 if (h->root.type == bfd_link_hash_indirect)
1521 if (h->root.type == bfd_link_hash_warning)
1522 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1524 info = (struct bfd_link_info *) arg;
1525 htab = elf_xtensa_hash_table (info);
1527 /* If we saw any use of an IE model for this symbol, we can then optimize
1528 away GOT entries for any TLSDESC_FN relocs. */
1529 if ((eh->tls_type & GOT_TLS_IE) != 0)
1531 BFD_ASSERT (h->got.refcount >= eh->tlsfunc_refcount);
1532 h->got.refcount -= eh->tlsfunc_refcount;
1535 if (! elf_xtensa_dynamic_symbol_p (h, info))
1536 elf_xtensa_make_sym_local (info, h);
1538 if (h->plt.refcount > 0)
1539 htab->srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1541 if (h->got.refcount > 0)
1542 htab->srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
1549 elf_xtensa_allocate_local_got_size (struct bfd_link_info *info)
1551 struct elf_xtensa_link_hash_table *htab;
1554 htab = elf_xtensa_hash_table (info);
1556 for (i = info->input_bfds; i; i = i->link_next)
1558 bfd_signed_vma *local_got_refcounts;
1559 bfd_size_type j, cnt;
1560 Elf_Internal_Shdr *symtab_hdr;
1562 local_got_refcounts = elf_local_got_refcounts (i);
1563 if (!local_got_refcounts)
1566 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1567 cnt = symtab_hdr->sh_info;
1569 for (j = 0; j < cnt; ++j)
1571 /* If we saw any use of an IE model for this symbol, we can
1572 then optimize away GOT entries for any TLSDESC_FN relocs. */
1573 if ((elf_xtensa_local_got_tls_type (i) [j] & GOT_TLS_IE) != 0)
1575 bfd_signed_vma *tlsfunc_refcount
1576 = &elf_xtensa_local_tlsfunc_refcounts (i) [j];
1577 BFD_ASSERT (local_got_refcounts[j] >= *tlsfunc_refcount);
1578 local_got_refcounts[j] -= *tlsfunc_refcount;
1581 if (local_got_refcounts[j] > 0)
1582 htab->srelgot->size += (local_got_refcounts[j]
1583 * sizeof (Elf32_External_Rela));
1589 /* Set the sizes of the dynamic sections. */
1592 elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1593 struct bfd_link_info *info)
1595 struct elf_xtensa_link_hash_table *htab;
1597 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1598 bfd_boolean relplt, relgot;
1599 int plt_entries, plt_chunks, chunk;
1604 htab = elf_xtensa_hash_table (info);
1605 dynobj = elf_hash_table (info)->dynobj;
1608 srelgot = htab->srelgot;
1609 srelplt = htab->srelplt;
1611 if (elf_hash_table (info)->dynamic_sections_created)
1613 BFD_ASSERT (htab->srelgot != NULL
1614 && htab->srelplt != NULL
1615 && htab->sgot != NULL
1616 && htab->spltlittbl != NULL
1617 && htab->sgotloc != NULL);
1619 /* Set the contents of the .interp section to the interpreter. */
1620 if (info->executable)
1622 s = bfd_get_section_by_name (dynobj, ".interp");
1625 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1626 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1629 /* Allocate room for one word in ".got". */
1630 htab->sgot->size = 4;
1632 /* Allocate space in ".rela.got" for literals that reference global
1633 symbols and space in ".rela.plt" for literals that have PLT
1635 elf_link_hash_traverse (elf_hash_table (info),
1636 elf_xtensa_allocate_dynrelocs,
1639 /* If we are generating a shared object, we also need space in
1640 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1641 reference local symbols. */
1643 elf_xtensa_allocate_local_got_size (info);
1645 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1646 each PLT entry, we need the PLT code plus a 4-byte literal.
1647 For each chunk of ".plt", we also need two more 4-byte
1648 literals, two corresponding entries in ".rela.got", and an
1649 8-byte entry in ".xt.lit.plt". */
1650 spltlittbl = htab->spltlittbl;
1651 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
1653 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1655 /* Iterate over all the PLT chunks, including any extra sections
1656 created earlier because the initial count of PLT relocations
1657 was an overestimate. */
1659 (splt = elf_xtensa_get_plt_section (info, chunk)) != NULL;
1664 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
1665 BFD_ASSERT (sgotplt != NULL);
1667 if (chunk < plt_chunks - 1)
1668 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1669 else if (chunk == plt_chunks - 1)
1670 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1674 if (chunk_entries != 0)
1676 sgotplt->size = 4 * (chunk_entries + 2);
1677 splt->size = PLT_ENTRY_SIZE * chunk_entries;
1678 srelgot->size += 2 * sizeof (Elf32_External_Rela);
1679 spltlittbl->size += 8;
1688 /* Allocate space in ".got.loc" to match the total size of all the
1690 sgotloc = htab->sgotloc;
1691 sgotloc->size = spltlittbl->size;
1692 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1694 if (abfd->flags & DYNAMIC)
1696 for (s = abfd->sections; s != NULL; s = s->next)
1698 if (! elf_discarded_section (s)
1699 && xtensa_is_littable_section (s)
1701 sgotloc->size += s->size;
1706 /* Allocate memory for dynamic sections. */
1709 for (s = dynobj->sections; s != NULL; s = s->next)
1713 if ((s->flags & SEC_LINKER_CREATED) == 0)
1716 /* It's OK to base decisions on the section name, because none
1717 of the dynobj section names depend upon the input files. */
1718 name = bfd_get_section_name (dynobj, s);
1720 if (CONST_STRNEQ (name, ".rela"))
1724 if (strcmp (name, ".rela.plt") == 0)
1726 else if (strcmp (name, ".rela.got") == 0)
1729 /* We use the reloc_count field as a counter if we need
1730 to copy relocs into the output file. */
1734 else if (! CONST_STRNEQ (name, ".plt.")
1735 && ! CONST_STRNEQ (name, ".got.plt.")
1736 && strcmp (name, ".got") != 0
1737 && strcmp (name, ".plt") != 0
1738 && strcmp (name, ".got.plt") != 0
1739 && strcmp (name, ".xt.lit.plt") != 0
1740 && strcmp (name, ".got.loc") != 0)
1742 /* It's not one of our sections, so don't allocate space. */
1748 /* If we don't need this section, strip it from the output
1749 file. We must create the ".plt*" and ".got.plt*"
1750 sections in create_dynamic_sections and/or check_relocs
1751 based on a conservative estimate of the PLT relocation
1752 count, because the sections must be created before the
1753 linker maps input sections to output sections. The
1754 linker does that before size_dynamic_sections, where we
1755 compute the exact size of the PLT, so there may be more
1756 of these sections than are actually needed. */
1757 s->flags |= SEC_EXCLUDE;
1759 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
1761 /* Allocate memory for the section contents. */
1762 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1763 if (s->contents == NULL)
1768 if (elf_hash_table (info)->dynamic_sections_created)
1770 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1771 known until finish_dynamic_sections, but we need to get the relocs
1772 in place before they are sorted. */
1773 for (chunk = 0; chunk < plt_chunks; chunk++)
1775 Elf_Internal_Rela irela;
1779 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1782 loc = (srelgot->contents
1783 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1784 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1785 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1786 loc + sizeof (Elf32_External_Rela));
1787 srelgot->reloc_count += 2;
1790 /* Add some entries to the .dynamic section. We fill in the
1791 values later, in elf_xtensa_finish_dynamic_sections, but we
1792 must add the entries now so that we get the correct size for
1793 the .dynamic section. The DT_DEBUG entry is filled in by the
1794 dynamic linker and used by the debugger. */
1795 #define add_dynamic_entry(TAG, VAL) \
1796 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1798 if (info->executable)
1800 if (!add_dynamic_entry (DT_DEBUG, 0))
1806 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1807 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1808 || !add_dynamic_entry (DT_JMPREL, 0))
1814 if (!add_dynamic_entry (DT_RELA, 0)
1815 || !add_dynamic_entry (DT_RELASZ, 0)
1816 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1820 if (!add_dynamic_entry (DT_PLTGOT, 0)
1821 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1822 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1825 #undef add_dynamic_entry
1831 elf_xtensa_always_size_sections (bfd *output_bfd,
1832 struct bfd_link_info *info)
1834 struct elf_xtensa_link_hash_table *htab;
1837 htab = elf_xtensa_hash_table (info);
1838 tls_sec = htab->elf.tls_sec;
1840 if (tls_sec && (htab->tlsbase->tls_type & GOT_TLS_ANY) != 0)
1842 struct elf_link_hash_entry *tlsbase = &htab->tlsbase->elf;
1843 struct bfd_link_hash_entry *bh = &tlsbase->root;
1844 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
1846 tlsbase->type = STT_TLS;
1847 if (!(_bfd_generic_link_add_one_symbol
1848 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1849 tls_sec, 0, NULL, FALSE,
1850 bed->collect, &bh)))
1852 tlsbase->def_regular = 1;
1853 tlsbase->other = STV_HIDDEN;
1854 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1861 /* Return the base VMA address which should be subtracted from real addresses
1862 when resolving @dtpoff relocation.
1863 This is PT_TLS segment p_vaddr. */
1866 dtpoff_base (struct bfd_link_info *info)
1868 /* If tls_sec is NULL, we should have signalled an error already. */
1869 if (elf_hash_table (info)->tls_sec == NULL)
1871 return elf_hash_table (info)->tls_sec->vma;
1874 /* Return the relocation value for @tpoff relocation
1875 if STT_TLS virtual address is ADDRESS. */
1878 tpoff (struct bfd_link_info *info, bfd_vma address)
1880 struct elf_link_hash_table *htab = elf_hash_table (info);
1883 /* If tls_sec is NULL, we should have signalled an error already. */
1884 if (htab->tls_sec == NULL)
1886 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
1887 return address - htab->tls_sec->vma + base;
1890 /* Perform the specified relocation. The instruction at (contents + address)
1891 is modified to set one operand to represent the value in "relocation". The
1892 operand position is determined by the relocation type recorded in the
1895 #define CALL_SEGMENT_BITS (30)
1896 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1898 static bfd_reloc_status_type
1899 elf_xtensa_do_reloc (reloc_howto_type *howto,
1901 asection *input_section,
1905 bfd_boolean is_weak_undef,
1906 char **error_message)
1909 xtensa_opcode opcode;
1910 xtensa_isa isa = xtensa_default_isa;
1911 static xtensa_insnbuf ibuff = NULL;
1912 static xtensa_insnbuf sbuff = NULL;
1913 bfd_vma self_address;
1914 bfd_size_type input_size;
1920 ibuff = xtensa_insnbuf_alloc (isa);
1921 sbuff = xtensa_insnbuf_alloc (isa);
1924 input_size = bfd_get_section_limit (abfd, input_section);
1926 /* Calculate the PC address for this instruction. */
1927 self_address = (input_section->output_section->vma
1928 + input_section->output_offset
1931 switch (howto->type)
1934 case R_XTENSA_DIFF8:
1935 case R_XTENSA_DIFF16:
1936 case R_XTENSA_DIFF32:
1937 case R_XTENSA_TLS_FUNC:
1938 case R_XTENSA_TLS_ARG:
1939 case R_XTENSA_TLS_CALL:
1940 return bfd_reloc_ok;
1942 case R_XTENSA_ASM_EXPAND:
1945 /* Check for windowed CALL across a 1GB boundary. */
1946 xtensa_opcode opcode =
1947 get_expanded_call_opcode (contents + address,
1948 input_size - address, 0);
1949 if (is_windowed_call_opcode (opcode))
1951 if ((self_address >> CALL_SEGMENT_BITS)
1952 != (relocation >> CALL_SEGMENT_BITS))
1954 *error_message = "windowed longcall crosses 1GB boundary; "
1956 return bfd_reloc_dangerous;
1960 return bfd_reloc_ok;
1962 case R_XTENSA_ASM_SIMPLIFY:
1964 /* Convert the L32R/CALLX to CALL. */
1965 bfd_reloc_status_type retval =
1966 elf_xtensa_do_asm_simplify (contents, address, input_size,
1968 if (retval != bfd_reloc_ok)
1969 return bfd_reloc_dangerous;
1971 /* The CALL needs to be relocated. Continue below for that part. */
1974 howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
1981 x = bfd_get_32 (abfd, contents + address);
1983 bfd_put_32 (abfd, x, contents + address);
1985 return bfd_reloc_ok;
1987 case R_XTENSA_32_PCREL:
1988 bfd_put_32 (abfd, relocation - self_address, contents + address);
1989 return bfd_reloc_ok;
1992 case R_XTENSA_TLSDESC_FN:
1993 case R_XTENSA_TLSDESC_ARG:
1994 case R_XTENSA_TLS_DTPOFF:
1995 case R_XTENSA_TLS_TPOFF:
1996 bfd_put_32 (abfd, relocation, contents + address);
1997 return bfd_reloc_ok;
2000 /* Only instruction slot-specific relocations handled below.... */
2001 slot = get_relocation_slot (howto->type);
2002 if (slot == XTENSA_UNDEFINED)
2004 *error_message = "unexpected relocation";
2005 return bfd_reloc_dangerous;
2008 /* Read the instruction into a buffer and decode the opcode. */
2009 xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
2010 input_size - address);
2011 fmt = xtensa_format_decode (isa, ibuff);
2012 if (fmt == XTENSA_UNDEFINED)
2014 *error_message = "cannot decode instruction format";
2015 return bfd_reloc_dangerous;
2018 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
2020 opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
2021 if (opcode == XTENSA_UNDEFINED)
2023 *error_message = "cannot decode instruction opcode";
2024 return bfd_reloc_dangerous;
2027 /* Check for opcode-specific "alternate" relocations. */
2028 if (is_alt_relocation (howto->type))
2030 if (opcode == get_l32r_opcode ())
2032 /* Handle the special-case of non-PC-relative L32R instructions. */
2033 bfd *output_bfd = input_section->output_section->owner;
2034 asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
2037 *error_message = "relocation references missing .lit4 section";
2038 return bfd_reloc_dangerous;
2040 self_address = ((lit4_sec->vma & ~0xfff)
2041 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2042 newval = relocation;
2045 else if (opcode == get_const16_opcode ())
2047 /* ALT used for high 16 bits. */
2048 newval = relocation >> 16;
2053 /* No other "alternate" relocations currently defined. */
2054 *error_message = "unexpected relocation";
2055 return bfd_reloc_dangerous;
2058 else /* Not an "alternate" relocation.... */
2060 if (opcode == get_const16_opcode ())
2062 newval = relocation & 0xffff;
2067 /* ...normal PC-relative relocation.... */
2069 /* Determine which operand is being relocated. */
2070 opnd = get_relocation_opnd (opcode, howto->type);
2071 if (opnd == XTENSA_UNDEFINED)
2073 *error_message = "unexpected relocation";
2074 return bfd_reloc_dangerous;
2077 if (!howto->pc_relative)
2079 *error_message = "expected PC-relative relocation";
2080 return bfd_reloc_dangerous;
2083 newval = relocation;
2087 /* Apply the relocation. */
2088 if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
2089 || xtensa_operand_encode (isa, opcode, opnd, &newval)
2090 || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
2093 const char *opname = xtensa_opcode_name (isa, opcode);
2096 msg = "cannot encode";
2097 if (is_direct_call_opcode (opcode))
2099 if ((relocation & 0x3) != 0)
2100 msg = "misaligned call target";
2102 msg = "call target out of range";
2104 else if (opcode == get_l32r_opcode ())
2106 if ((relocation & 0x3) != 0)
2107 msg = "misaligned literal target";
2108 else if (is_alt_relocation (howto->type))
2109 msg = "literal target out of range (too many literals)";
2110 else if (self_address > relocation)
2111 msg = "literal target out of range (try using text-section-literals)";
2113 msg = "literal placed after use";
2116 *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
2117 return bfd_reloc_dangerous;
2120 /* Check for calls across 1GB boundaries. */
2121 if (is_direct_call_opcode (opcode)
2122 && is_windowed_call_opcode (opcode))
2124 if ((self_address >> CALL_SEGMENT_BITS)
2125 != (relocation >> CALL_SEGMENT_BITS))
2128 "windowed call crosses 1GB boundary; return may fail";
2129 return bfd_reloc_dangerous;
2133 /* Write the modified instruction back out of the buffer. */
2134 xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
2135 xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
2136 input_size - address);
2137 return bfd_reloc_ok;
2142 vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
2144 /* To reduce the size of the memory leak,
2145 we only use a single message buffer. */
2146 static bfd_size_type alloc_size = 0;
2147 static char *message = NULL;
2148 bfd_size_type orig_len, len = 0;
2149 bfd_boolean is_append;
2151 VA_OPEN (ap, arglen);
2152 VA_FIXEDARG (ap, const char *, origmsg);
2154 is_append = (origmsg == message);
2156 orig_len = strlen (origmsg);
2157 len = orig_len + strlen (fmt) + arglen + 20;
2158 if (len > alloc_size)
2160 message = (char *) bfd_realloc_or_free (message, len);
2163 if (message != NULL)
2166 memcpy (message, origmsg, orig_len);
2167 vsprintf (message + orig_len, fmt, ap);
2174 /* This function is registered as the "special_function" in the
2175 Xtensa howto for handling simplify operations.
2176 bfd_perform_relocation / bfd_install_relocation use it to
2177 perform (install) the specified relocation. Since this replaces the code
2178 in bfd_perform_relocation, it is basically an Xtensa-specific,
2179 stripped-down version of bfd_perform_relocation. */
2181 static bfd_reloc_status_type
2182 bfd_elf_xtensa_reloc (bfd *abfd,
2183 arelent *reloc_entry,
2186 asection *input_section,
2188 char **error_message)
2191 bfd_reloc_status_type flag;
2192 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2193 bfd_vma output_base = 0;
2194 reloc_howto_type *howto = reloc_entry->howto;
2195 asection *reloc_target_output_section;
2196 bfd_boolean is_weak_undef;
2198 if (!xtensa_default_isa)
2199 xtensa_default_isa = xtensa_isa_init (0, 0);
2201 /* ELF relocs are against symbols. If we are producing relocatable
2202 output, and the reloc is against an external symbol, the resulting
2203 reloc will also be against the same symbol. In such a case, we
2204 don't want to change anything about the way the reloc is handled,
2205 since it will all be done at final link time. This test is similar
2206 to what bfd_elf_generic_reloc does except that it lets relocs with
2207 howto->partial_inplace go through even if the addend is non-zero.
2208 (The real problem is that partial_inplace is set for XTENSA_32
2209 relocs to begin with, but that's a long story and there's little we
2210 can do about it now....) */
2212 if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
2214 reloc_entry->address += input_section->output_offset;
2215 return bfd_reloc_ok;
2218 /* Is the address of the relocation really within the section? */
2219 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2220 return bfd_reloc_outofrange;
2222 /* Work out which section the relocation is targeted at and the
2223 initial relocation command value. */
2225 /* Get symbol value. (Common symbols are special.) */
2226 if (bfd_is_com_section (symbol->section))
2229 relocation = symbol->value;
2231 reloc_target_output_section = symbol->section->output_section;
2233 /* Convert input-section-relative symbol value to absolute. */
2234 if ((output_bfd && !howto->partial_inplace)
2235 || reloc_target_output_section == NULL)
2238 output_base = reloc_target_output_section->vma;
2240 relocation += output_base + symbol->section->output_offset;
2242 /* Add in supplied addend. */
2243 relocation += reloc_entry->addend;
2245 /* Here the variable relocation holds the final address of the
2246 symbol we are relocating against, plus any addend. */
2249 if (!howto->partial_inplace)
2251 /* This is a partial relocation, and we want to apply the relocation
2252 to the reloc entry rather than the raw data. Everything except
2253 relocations against section symbols has already been handled
2256 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
2257 reloc_entry->addend = relocation;
2258 reloc_entry->address += input_section->output_offset;
2259 return bfd_reloc_ok;
2263 reloc_entry->address += input_section->output_offset;
2264 reloc_entry->addend = 0;
2268 is_weak_undef = (bfd_is_und_section (symbol->section)
2269 && (symbol->flags & BSF_WEAK) != 0);
2270 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
2271 (bfd_byte *) data, (bfd_vma) octets,
2272 is_weak_undef, error_message);
2274 if (flag == bfd_reloc_dangerous)
2276 /* Add the symbol name to the error message. */
2277 if (! *error_message)
2278 *error_message = "";
2279 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
2280 strlen (symbol->name) + 17,
2282 (unsigned long) reloc_entry->addend);
2289 /* Set up an entry in the procedure linkage table. */
2292 elf_xtensa_create_plt_entry (struct bfd_link_info *info,
2294 unsigned reloc_index)
2296 asection *splt, *sgotplt;
2297 bfd_vma plt_base, got_base;
2298 bfd_vma code_offset, lit_offset;
2301 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
2302 splt = elf_xtensa_get_plt_section (info, chunk);
2303 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
2304 BFD_ASSERT (splt != NULL && sgotplt != NULL);
2306 plt_base = splt->output_section->vma + splt->output_offset;
2307 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
2309 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
2310 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
2312 /* Fill in the literal entry. This is the offset of the dynamic
2313 relocation entry. */
2314 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
2315 sgotplt->contents + lit_offset);
2317 /* Fill in the entry in the procedure linkage table. */
2318 memcpy (splt->contents + code_offset,
2319 (bfd_big_endian (output_bfd)
2320 ? elf_xtensa_be_plt_entry
2321 : elf_xtensa_le_plt_entry),
2323 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
2324 plt_base + code_offset + 3),
2325 splt->contents + code_offset + 4);
2326 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
2327 plt_base + code_offset + 6),
2328 splt->contents + code_offset + 7);
2329 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
2330 plt_base + code_offset + 9),
2331 splt->contents + code_offset + 10);
2333 return plt_base + code_offset;
2337 static bfd_boolean get_indirect_call_dest_reg (xtensa_opcode, unsigned *);
2340 replace_tls_insn (Elf_Internal_Rela *rel,
2342 asection *input_section,
2344 bfd_boolean is_ld_model,
2345 char **error_message)
2347 static xtensa_insnbuf ibuff = NULL;
2348 static xtensa_insnbuf sbuff = NULL;
2349 xtensa_isa isa = xtensa_default_isa;
2351 xtensa_opcode old_op, new_op;
2352 bfd_size_type input_size;
2354 unsigned dest_reg, src_reg;
2358 ibuff = xtensa_insnbuf_alloc (isa);
2359 sbuff = xtensa_insnbuf_alloc (isa);
2362 input_size = bfd_get_section_limit (abfd, input_section);
2364 /* Read the instruction into a buffer and decode the opcode. */
2365 xtensa_insnbuf_from_chars (isa, ibuff, contents + rel->r_offset,
2366 input_size - rel->r_offset);
2367 fmt = xtensa_format_decode (isa, ibuff);
2368 if (fmt == XTENSA_UNDEFINED)
2370 *error_message = "cannot decode instruction format";
2374 BFD_ASSERT (xtensa_format_num_slots (isa, fmt) == 1);
2375 xtensa_format_get_slot (isa, fmt, 0, ibuff, sbuff);
2377 old_op = xtensa_opcode_decode (isa, fmt, 0, sbuff);
2378 if (old_op == XTENSA_UNDEFINED)
2380 *error_message = "cannot decode instruction opcode";
2384 r_type = ELF32_R_TYPE (rel->r_info);
2387 case R_XTENSA_TLS_FUNC:
2388 case R_XTENSA_TLS_ARG:
2389 if (old_op != get_l32r_opcode ()
2390 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2391 sbuff, &dest_reg) != 0)
2393 *error_message = "cannot extract L32R destination for TLS access";
2398 case R_XTENSA_TLS_CALL:
2399 if (! get_indirect_call_dest_reg (old_op, &dest_reg)
2400 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2401 sbuff, &src_reg) != 0)
2403 *error_message = "cannot extract CALLXn operands for TLS access";
2416 case R_XTENSA_TLS_FUNC:
2417 case R_XTENSA_TLS_ARG:
2418 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2419 versions of Xtensa). */
2420 new_op = xtensa_opcode_lookup (isa, "nop");
2421 if (new_op == XTENSA_UNDEFINED)
2423 new_op = xtensa_opcode_lookup (isa, "or");
2424 if (new_op == XTENSA_UNDEFINED
2425 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2426 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2428 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2430 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2433 *error_message = "cannot encode OR for TLS access";
2439 if (xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0)
2441 *error_message = "cannot encode NOP for TLS access";
2447 case R_XTENSA_TLS_CALL:
2448 /* Read THREADPTR into the CALLX's return value register. */
2449 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2450 if (new_op == XTENSA_UNDEFINED
2451 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2452 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2453 sbuff, dest_reg + 2) != 0)
2455 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2465 case R_XTENSA_TLS_FUNC:
2466 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2467 if (new_op == XTENSA_UNDEFINED
2468 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2469 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2470 sbuff, dest_reg) != 0)
2472 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2477 case R_XTENSA_TLS_ARG:
2478 /* Nothing to do. Keep the original L32R instruction. */
2481 case R_XTENSA_TLS_CALL:
2482 /* Add the CALLX's src register (holding the THREADPTR value)
2483 to the first argument register (holding the offset) and put
2484 the result in the CALLX's return value register. */
2485 new_op = xtensa_opcode_lookup (isa, "add");
2486 if (new_op == XTENSA_UNDEFINED
2487 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2488 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2489 sbuff, dest_reg + 2) != 0
2490 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2491 sbuff, dest_reg + 2) != 0
2492 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2493 sbuff, src_reg) != 0)
2495 *error_message = "cannot encode ADD for TLS access";
2502 xtensa_format_set_slot (isa, fmt, 0, ibuff, sbuff);
2503 xtensa_insnbuf_to_chars (isa, ibuff, contents + rel->r_offset,
2504 input_size - rel->r_offset);
2510 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2511 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2512 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2513 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2514 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2515 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2516 || (R_TYPE) == R_XTENSA_TLS_ARG \
2517 || (R_TYPE) == R_XTENSA_TLS_CALL)
2519 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2520 both relocatable and final links. */
2523 elf_xtensa_relocate_section (bfd *output_bfd,
2524 struct bfd_link_info *info,
2526 asection *input_section,
2528 Elf_Internal_Rela *relocs,
2529 Elf_Internal_Sym *local_syms,
2530 asection **local_sections)
2532 struct elf_xtensa_link_hash_table *htab;
2533 Elf_Internal_Shdr *symtab_hdr;
2534 Elf_Internal_Rela *rel;
2535 Elf_Internal_Rela *relend;
2536 struct elf_link_hash_entry **sym_hashes;
2537 property_table_entry *lit_table = 0;
2539 char *local_got_tls_types;
2540 char *error_message = NULL;
2541 bfd_size_type input_size;
2544 if (!xtensa_default_isa)
2545 xtensa_default_isa = xtensa_isa_init (0, 0);
2547 BFD_ASSERT (is_xtensa_elf (input_bfd));
2549 htab = elf_xtensa_hash_table (info);
2550 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2551 sym_hashes = elf_sym_hashes (input_bfd);
2552 local_got_tls_types = elf_xtensa_local_got_tls_type (input_bfd);
2554 if (elf_hash_table (info)->dynamic_sections_created)
2556 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
2557 &lit_table, XTENSA_LIT_SEC_NAME,
2563 input_size = bfd_get_section_limit (input_bfd, input_section);
2566 relend = relocs + input_section->reloc_count;
2567 for (; rel < relend; rel++)
2570 reloc_howto_type *howto;
2571 unsigned long r_symndx;
2572 struct elf_link_hash_entry *h;
2573 Elf_Internal_Sym *sym;
2578 bfd_reloc_status_type r;
2579 bfd_boolean is_weak_undef;
2580 bfd_boolean unresolved_reloc;
2582 bfd_boolean dynamic_symbol;
2584 r_type = ELF32_R_TYPE (rel->r_info);
2585 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2586 || r_type == (int) R_XTENSA_GNU_VTENTRY)
2589 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2591 bfd_set_error (bfd_error_bad_value);
2594 howto = &elf_howto_table[r_type];
2596 r_symndx = ELF32_R_SYM (rel->r_info);
2601 is_weak_undef = FALSE;
2602 unresolved_reloc = FALSE;
2605 if (howto->partial_inplace && !info->relocatable)
2607 /* Because R_XTENSA_32 was made partial_inplace to fix some
2608 problems with DWARF info in partial links, there may be
2609 an addend stored in the contents. Take it out of there
2610 and move it back into the addend field of the reloc. */
2611 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2612 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2615 if (r_symndx < symtab_hdr->sh_info)
2617 sym = local_syms + r_symndx;
2618 sym_type = ELF32_ST_TYPE (sym->st_info);
2619 sec = local_sections[r_symndx];
2620 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2624 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2625 r_symndx, symtab_hdr, sym_hashes,
2627 unresolved_reloc, warned);
2630 && !unresolved_reloc
2631 && h->root.type == bfd_link_hash_undefweak)
2632 is_weak_undef = TRUE;
2637 if (sec != NULL && elf_discarded_section (sec))
2639 /* For relocs against symbols from removed linkonce sections,
2640 or sections discarded by a linker script, we just want the
2641 section contents zeroed. Avoid any special processing. */
2642 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2648 if (info->relocatable)
2650 /* This is a relocatable link.
2651 1) If the reloc is against a section symbol, adjust
2652 according to the output section.
2653 2) If there is a new target for this relocation,
2654 the new target will be in the same output section.
2655 We adjust the relocation by the output section
2658 if (relaxing_section)
2660 /* Check if this references a section in another input file. */
2661 if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2666 if (r_type == R_XTENSA_ASM_SIMPLIFY)
2668 char *error_message = NULL;
2669 /* Convert ASM_SIMPLIFY into the simpler relocation
2670 so that they never escape a relaxing link. */
2671 r = contract_asm_expansion (contents, input_size, rel,
2673 if (r != bfd_reloc_ok)
2675 if (!((*info->callbacks->reloc_dangerous)
2676 (info, error_message, input_bfd, input_section,
2680 r_type = ELF32_R_TYPE (rel->r_info);
2683 /* This is a relocatable link, so we don't have to change
2684 anything unless the reloc is against a section symbol,
2685 in which case we have to adjust according to where the
2686 section symbol winds up in the output section. */
2687 if (r_symndx < symtab_hdr->sh_info)
2689 sym = local_syms + r_symndx;
2690 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2692 sec = local_sections[r_symndx];
2693 rel->r_addend += sec->output_offset + sym->st_value;
2697 /* If there is an addend with a partial_inplace howto,
2698 then move the addend to the contents. This is a hack
2699 to work around problems with DWARF in relocatable links
2700 with some previous version of BFD. Now we can't easily get
2701 rid of the hack without breaking backward compatibility.... */
2704 howto = &elf_howto_table[r_type];
2705 if (howto->partial_inplace)
2707 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2708 rel->r_addend, contents,
2709 rel->r_offset, FALSE,
2711 if (r != bfd_reloc_ok)
2713 if (!((*info->callbacks->reloc_dangerous)
2714 (info, error_message, input_bfd, input_section,
2722 /* Done with work for relocatable link; continue with next reloc. */
2726 /* This is a final link. */
2728 if (relaxing_section)
2730 /* Check if this references a section in another input file. */
2731 do_fix_for_final_link (rel, input_bfd, input_section, contents,
2735 /* Sanity check the address. */
2736 if (rel->r_offset >= input_size
2737 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2739 (*_bfd_error_handler)
2740 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2741 input_bfd, input_section, rel->r_offset, input_size);
2742 bfd_set_error (bfd_error_bad_value);
2747 name = h->root.root.string;
2750 name = (bfd_elf_string_from_elf_section
2751 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2752 if (name == NULL || *name == '\0')
2753 name = bfd_section_name (input_bfd, sec);
2757 && r_type != R_XTENSA_NONE
2759 || h->root.type == bfd_link_hash_defined
2760 || h->root.type == bfd_link_hash_defweak)
2761 && IS_XTENSA_TLS_RELOC (r_type) != (sym_type == STT_TLS))
2763 (*_bfd_error_handler)
2764 ((sym_type == STT_TLS
2765 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
2766 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
2769 (long) rel->r_offset,
2774 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
2776 tls_type = GOT_UNKNOWN;
2778 tls_type = elf_xtensa_hash_entry (h)->tls_type;
2779 else if (local_got_tls_types)
2780 tls_type = local_got_tls_types [r_symndx];
2786 if (elf_hash_table (info)->dynamic_sections_created
2787 && (input_section->flags & SEC_ALLOC) != 0
2788 && (dynamic_symbol || info->shared))
2790 Elf_Internal_Rela outrel;
2794 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2795 srel = htab->srelplt;
2797 srel = htab->srelgot;
2799 BFD_ASSERT (srel != NULL);
2802 _bfd_elf_section_offset (output_bfd, info,
2803 input_section, rel->r_offset);
2805 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2806 memset (&outrel, 0, sizeof outrel);
2809 outrel.r_offset += (input_section->output_section->vma
2810 + input_section->output_offset);
2812 /* Complain if the relocation is in a read-only section
2813 and not in a literal pool. */
2814 if ((input_section->flags & SEC_READONLY) != 0
2815 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
2819 _("dynamic relocation in read-only section");
2820 if (!((*info->callbacks->reloc_dangerous)
2821 (info, error_message, input_bfd, input_section,
2828 outrel.r_addend = rel->r_addend;
2831 if (r_type == R_XTENSA_32)
2834 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2837 else /* r_type == R_XTENSA_PLT */
2840 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2842 /* Create the PLT entry and set the initial
2843 contents of the literal entry to the address of
2846 elf_xtensa_create_plt_entry (info, output_bfd,
2849 unresolved_reloc = FALSE;
2853 /* Generate a RELATIVE relocation. */
2854 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2855 outrel.r_addend = 0;
2859 loc = (srel->contents
2860 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2861 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2862 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2865 else if (r_type == R_XTENSA_ASM_EXPAND && dynamic_symbol)
2867 /* This should only happen for non-PIC code, which is not
2868 supposed to be used on systems with dynamic linking.
2869 Just ignore these relocations. */
2874 case R_XTENSA_TLS_TPOFF:
2875 /* Switch to LE model for local symbols in an executable. */
2876 if (! info->shared && ! dynamic_symbol)
2878 relocation = tpoff (info, relocation);
2883 case R_XTENSA_TLSDESC_FN:
2884 case R_XTENSA_TLSDESC_ARG:
2886 if (r_type == R_XTENSA_TLSDESC_FN)
2888 if (! info->shared || (tls_type & GOT_TLS_IE) != 0)
2889 r_type = R_XTENSA_NONE;
2891 else if (r_type == R_XTENSA_TLSDESC_ARG)
2895 if ((tls_type & GOT_TLS_IE) != 0)
2896 r_type = R_XTENSA_TLS_TPOFF;
2900 r_type = R_XTENSA_TLS_TPOFF;
2901 if (! dynamic_symbol)
2903 relocation = tpoff (info, relocation);
2909 if (r_type == R_XTENSA_NONE)
2910 /* Nothing to do here; skip to the next reloc. */
2913 if (! elf_hash_table (info)->dynamic_sections_created)
2916 _("TLS relocation invalid without dynamic sections");
2917 if (!((*info->callbacks->reloc_dangerous)
2918 (info, error_message, input_bfd, input_section,
2924 Elf_Internal_Rela outrel;
2926 asection *srel = htab->srelgot;
2929 outrel.r_offset = (input_section->output_section->vma
2930 + input_section->output_offset
2933 /* Complain if the relocation is in a read-only section
2934 and not in a literal pool. */
2935 if ((input_section->flags & SEC_READONLY) != 0
2936 && ! elf_xtensa_in_literal_pool (lit_table, ltblsize,
2940 _("dynamic relocation in read-only section");
2941 if (!((*info->callbacks->reloc_dangerous)
2942 (info, error_message, input_bfd, input_section,
2947 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2949 outrel.r_addend = relocation - dtpoff_base (info);
2951 outrel.r_addend = 0;
2954 outrel.r_info = ELF32_R_INFO (indx, r_type);
2956 unresolved_reloc = FALSE;
2959 loc = (srel->contents
2960 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2961 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2962 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2968 case R_XTENSA_TLS_DTPOFF:
2970 /* Switch from LD model to LE model. */
2971 relocation = tpoff (info, relocation);
2973 relocation -= dtpoff_base (info);
2976 case R_XTENSA_TLS_FUNC:
2977 case R_XTENSA_TLS_ARG:
2978 case R_XTENSA_TLS_CALL:
2979 /* Check if optimizing to IE or LE model. */
2980 if ((tls_type & GOT_TLS_IE) != 0)
2982 bfd_boolean is_ld_model =
2983 (h && elf_xtensa_hash_entry (h) == htab->tlsbase);
2984 if (! replace_tls_insn (rel, input_bfd, input_section, contents,
2985 is_ld_model, &error_message))
2987 if (!((*info->callbacks->reloc_dangerous)
2988 (info, error_message, input_bfd, input_section,
2993 if (r_type != R_XTENSA_TLS_ARG || is_ld_model)
2995 /* Skip subsequent relocations on the same instruction. */
2996 while (rel + 1 < relend && rel[1].r_offset == rel->r_offset)
3003 if (elf_hash_table (info)->dynamic_sections_created
3004 && dynamic_symbol && (is_operand_relocation (r_type)
3005 || r_type == R_XTENSA_32_PCREL))
3008 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3009 strlen (name) + 2, name);
3010 if (!((*info->callbacks->reloc_dangerous)
3011 (info, error_message, input_bfd, input_section,
3019 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3020 because such sections are not SEC_ALLOC and thus ld.so will
3021 not process them. */
3022 if (unresolved_reloc
3023 && !((input_section->flags & SEC_DEBUGGING) != 0
3026 (*_bfd_error_handler)
3027 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3030 (long) rel->r_offset,
3036 /* TLS optimizations may have changed r_type; update "howto". */
3037 howto = &elf_howto_table[r_type];
3039 /* There's no point in calling bfd_perform_relocation here.
3040 Just go directly to our "special function". */
3041 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
3042 relocation + rel->r_addend,
3043 contents, rel->r_offset, is_weak_undef,
3046 if (r != bfd_reloc_ok && !warned)
3048 BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
3049 BFD_ASSERT (error_message != NULL);
3051 if (rel->r_addend == 0)
3052 error_message = vsprint_msg (error_message, ": %s",
3053 strlen (name) + 2, name);
3055 error_message = vsprint_msg (error_message, ": (%s+0x%x)",
3057 name, (int) rel->r_addend);
3059 if (!((*info->callbacks->reloc_dangerous)
3060 (info, error_message, input_bfd, input_section,
3069 input_section->reloc_done = TRUE;
3075 /* Finish up dynamic symbol handling. There's not much to do here since
3076 the PLT and GOT entries are all set up by relocate_section. */
3079 elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
3080 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3081 struct elf_link_hash_entry *h,
3082 Elf_Internal_Sym *sym)
3084 if (h->needs_plt && !h->def_regular)
3086 /* Mark the symbol as undefined, rather than as defined in
3087 the .plt section. Leave the value alone. */
3088 sym->st_shndx = SHN_UNDEF;
3089 /* If the symbol is weak, we do need to clear the value.
3090 Otherwise, the PLT entry would provide a definition for
3091 the symbol even if the symbol wasn't defined anywhere,
3092 and so the symbol would never be NULL. */
3093 if (!h->ref_regular_nonweak)
3097 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3098 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3099 || h == elf_hash_table (info)->hgot)
3100 sym->st_shndx = SHN_ABS;
3106 /* Combine adjacent literal table entries in the output. Adjacent
3107 entries within each input section may have been removed during
3108 relaxation, but we repeat the process here, even though it's too late
3109 to shrink the output section, because it's important to minimize the
3110 number of literal table entries to reduce the start-up work for the
3111 runtime linker. Returns the number of remaining table entries or -1
3115 elf_xtensa_combine_prop_entries (bfd *output_bfd,
3120 property_table_entry *table;
3121 bfd_size_type section_size, sgotloc_size;
3125 section_size = sxtlit->size;
3126 BFD_ASSERT (section_size % 8 == 0);
3127 num = section_size / 8;
3129 sgotloc_size = sgotloc->size;
3130 if (sgotloc_size != section_size)
3132 (*_bfd_error_handler)
3133 (_("internal inconsistency in size of .got.loc section"));
3137 table = bfd_malloc (num * sizeof (property_table_entry));
3141 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3142 propagates to the output section, where it doesn't really apply and
3143 where it breaks the following call to bfd_malloc_and_get_section. */
3144 sxtlit->flags &= ~SEC_IN_MEMORY;
3146 if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
3154 /* There should never be any relocations left at this point, so this
3155 is quite a bit easier than what is done during relaxation. */
3157 /* Copy the raw contents into a property table array and sort it. */
3159 for (n = 0; n < num; n++)
3161 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
3162 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
3165 qsort (table, num, sizeof (property_table_entry), property_table_compare);
3167 for (n = 0; n < num; n++)
3169 bfd_boolean remove = FALSE;
3171 if (table[n].size == 0)
3174 (table[n-1].address + table[n-1].size == table[n].address))
3176 table[n-1].size += table[n].size;
3182 for (m = n; m < num - 1; m++)
3184 table[m].address = table[m+1].address;
3185 table[m].size = table[m+1].size;
3193 /* Copy the data back to the raw contents. */
3195 for (n = 0; n < num; n++)
3197 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
3198 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
3202 /* Clear the removed bytes. */
3203 if ((bfd_size_type) (num * 8) < section_size)
3204 memset (&contents[num * 8], 0, section_size - num * 8);
3206 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
3210 /* Copy the contents to ".got.loc". */
3211 memcpy (sgotloc->contents, contents, section_size);
3219 /* Finish up the dynamic sections. */
3222 elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
3223 struct bfd_link_info *info)
3225 struct elf_xtensa_link_hash_table *htab;
3227 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
3228 Elf32_External_Dyn *dyncon, *dynconend;
3229 int num_xtlit_entries = 0;
3231 if (! elf_hash_table (info)->dynamic_sections_created)
3234 htab = elf_xtensa_hash_table (info);
3235 dynobj = elf_hash_table (info)->dynobj;
3236 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3237 BFD_ASSERT (sdyn != NULL);
3239 /* Set the first entry in the global offset table to the address of
3240 the dynamic section. */
3244 BFD_ASSERT (sgot->size == 4);
3246 bfd_put_32 (output_bfd, 0, sgot->contents);
3248 bfd_put_32 (output_bfd,
3249 sdyn->output_section->vma + sdyn->output_offset,
3253 srelplt = htab->srelplt;
3254 if (srelplt && srelplt->size != 0)
3256 asection *sgotplt, *srelgot, *spltlittbl;
3257 int chunk, plt_chunks, plt_entries;
3258 Elf_Internal_Rela irela;
3260 unsigned rtld_reloc;
3262 srelgot = htab->srelgot;
3263 spltlittbl = htab->spltlittbl;
3264 BFD_ASSERT (srelgot != NULL && spltlittbl != NULL);
3266 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3267 of them follow immediately after.... */
3268 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
3270 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3271 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3272 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
3275 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
3277 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
3279 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
3281 for (chunk = 0; chunk < plt_chunks; chunk++)
3283 int chunk_entries = 0;
3285 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
3286 BFD_ASSERT (sgotplt != NULL);
3288 /* Emit special RTLD relocations for the first two entries in
3289 each chunk of the .got.plt section. */
3291 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3292 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3293 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3294 irela.r_offset = (sgotplt->output_section->vma
3295 + sgotplt->output_offset);
3296 irela.r_addend = 1; /* tell rtld to set value to resolver function */
3297 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3299 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3301 /* Next literal immediately follows the first. */
3302 loc += sizeof (Elf32_External_Rela);
3303 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3304 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3305 irela.r_offset = (sgotplt->output_section->vma
3306 + sgotplt->output_offset + 4);
3307 /* Tell rtld to set value to object's link map. */
3309 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3311 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3313 /* Fill in the literal table. */
3314 if (chunk < plt_chunks - 1)
3315 chunk_entries = PLT_ENTRIES_PER_CHUNK;
3317 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
3319 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
3320 bfd_put_32 (output_bfd,
3321 sgotplt->output_section->vma + sgotplt->output_offset,
3322 spltlittbl->contents + (chunk * 8) + 0);
3323 bfd_put_32 (output_bfd,
3324 8 + (chunk_entries * 4),
3325 spltlittbl->contents + (chunk * 8) + 4);
3328 /* All the dynamic relocations have been emitted at this point.
3329 Make sure the relocation sections are the correct size. */
3330 if (srelgot->size != (sizeof (Elf32_External_Rela)
3331 * srelgot->reloc_count)
3332 || srelplt->size != (sizeof (Elf32_External_Rela)
3333 * srelplt->reloc_count))
3336 /* The .xt.lit.plt section has just been modified. This must
3337 happen before the code below which combines adjacent literal
3338 table entries, and the .xt.lit.plt contents have to be forced to
3340 if (! bfd_set_section_contents (output_bfd,
3341 spltlittbl->output_section,
3342 spltlittbl->contents,
3343 spltlittbl->output_offset,
3346 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3347 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
3350 /* Combine adjacent literal table entries. */
3351 BFD_ASSERT (! info->relocatable);
3352 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
3353 sgotloc = htab->sgotloc;
3354 BFD_ASSERT (sgotloc);
3358 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
3359 if (num_xtlit_entries < 0)
3363 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3364 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3365 for (; dyncon < dynconend; dyncon++)
3367 Elf_Internal_Dyn dyn;
3369 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3376 case DT_XTENSA_GOT_LOC_SZ:
3377 dyn.d_un.d_val = num_xtlit_entries;
3380 case DT_XTENSA_GOT_LOC_OFF:
3381 dyn.d_un.d_ptr = htab->sgotloc->output_section->vma;
3385 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3389 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3393 dyn.d_un.d_val = htab->srelplt->output_section->size;
3397 /* Adjust RELASZ to not include JMPREL. This matches what
3398 glibc expects and what is done for several other ELF
3399 targets (e.g., i386, alpha), but the "correct" behavior
3400 seems to be unresolved. Since the linker script arranges
3401 for .rela.plt to follow all other relocation sections, we
3402 don't have to worry about changing the DT_RELA entry. */
3404 dyn.d_un.d_val -= htab->srelplt->output_section->size;
3408 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3415 /* Functions for dealing with the e_flags field. */
3417 /* Merge backend specific data from an object file to the output
3418 object file when linking. */
3421 elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3423 unsigned out_mach, in_mach;
3424 flagword out_flag, in_flag;
3426 /* Check if we have the same endianess. */
3427 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
3430 /* Don't even pretend to support mixed-format linking. */
3431 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3432 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3435 out_flag = elf_elfheader (obfd)->e_flags;
3436 in_flag = elf_elfheader (ibfd)->e_flags;
3438 out_mach = out_flag & EF_XTENSA_MACH;
3439 in_mach = in_flag & EF_XTENSA_MACH;
3440 if (out_mach != in_mach)
3442 (*_bfd_error_handler)
3443 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
3444 ibfd, out_mach, in_mach);
3445 bfd_set_error (bfd_error_wrong_format);
3449 if (! elf_flags_init (obfd))
3451 elf_flags_init (obfd) = TRUE;
3452 elf_elfheader (obfd)->e_flags = in_flag;
3454 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3455 && bfd_get_arch_info (obfd)->the_default)
3456 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3457 bfd_get_mach (ibfd));
3462 if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
3463 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
3465 if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
3466 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
3473 elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
3475 BFD_ASSERT (!elf_flags_init (abfd)
3476 || elf_elfheader (abfd)->e_flags == flags);
3478 elf_elfheader (abfd)->e_flags |= flags;
3479 elf_flags_init (abfd) = TRUE;
3486 elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
3488 FILE *f = (FILE *) farg;
3489 flagword e_flags = elf_elfheader (abfd)->e_flags;
3491 fprintf (f, "\nXtensa header:\n");
3492 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
3493 fprintf (f, "\nMachine = Base\n");
3495 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
3497 fprintf (f, "Insn tables = %s\n",
3498 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
3500 fprintf (f, "Literal tables = %s\n",
3501 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
3503 return _bfd_elf_print_private_bfd_data (abfd, farg);
3507 /* Set the right machine number for an Xtensa ELF file. */
3510 elf_xtensa_object_p (bfd *abfd)
3513 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
3518 mach = bfd_mach_xtensa;
3524 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
3529 /* The final processing done just before writing out an Xtensa ELF object
3530 file. This gets the Xtensa architecture right based on the machine
3534 elf_xtensa_final_write_processing (bfd *abfd,
3535 bfd_boolean linker ATTRIBUTE_UNUSED)
3540 switch (mach = bfd_get_mach (abfd))
3542 case bfd_mach_xtensa:
3543 val = E_XTENSA_MACH;
3549 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
3550 elf_elfheader (abfd)->e_flags |= val;
3554 static enum elf_reloc_type_class
3555 elf_xtensa_reloc_type_class (const Elf_Internal_Rela *rela)
3557 switch ((int) ELF32_R_TYPE (rela->r_info))
3559 case R_XTENSA_RELATIVE:
3560 return reloc_class_relative;
3561 case R_XTENSA_JMP_SLOT:
3562 return reloc_class_plt;
3564 return reloc_class_normal;
3570 elf_xtensa_discard_info_for_section (bfd *abfd,
3571 struct elf_reloc_cookie *cookie,
3572 struct bfd_link_info *info,
3576 bfd_vma offset, actual_offset;
3577 bfd_size_type removed_bytes = 0;
3578 bfd_size_type entry_size;
3580 if (sec->output_section
3581 && bfd_is_abs_section (sec->output_section))
3584 if (xtensa_is_proptable_section (sec))
3589 if (sec->size == 0 || sec->size % entry_size != 0)
3592 contents = retrieve_contents (abfd, sec, info->keep_memory);
3596 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
3599 release_contents (sec, contents);
3603 /* Sort the relocations. They should already be in order when
3604 relaxation is enabled, but it might not be. */
3605 qsort (cookie->rels, sec->reloc_count, sizeof (Elf_Internal_Rela),
3606 internal_reloc_compare);
3608 cookie->rel = cookie->rels;
3609 cookie->relend = cookie->rels + sec->reloc_count;
3611 for (offset = 0; offset < sec->size; offset += entry_size)
3613 actual_offset = offset - removed_bytes;
3615 /* The ...symbol_deleted_p function will skip over relocs but it
3616 won't adjust their offsets, so do that here. */
3617 while (cookie->rel < cookie->relend
3618 && cookie->rel->r_offset < offset)
3620 cookie->rel->r_offset -= removed_bytes;
3624 while (cookie->rel < cookie->relend
3625 && cookie->rel->r_offset == offset)
3627 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
3629 /* Remove the table entry. (If the reloc type is NONE, then
3630 the entry has already been merged with another and deleted
3631 during relaxation.) */
3632 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
3634 /* Shift the contents up. */
3635 if (offset + entry_size < sec->size)
3636 memmove (&contents[actual_offset],
3637 &contents[actual_offset + entry_size],
3638 sec->size - offset - entry_size);
3639 removed_bytes += entry_size;
3642 /* Remove this relocation. */
3643 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3646 /* Adjust the relocation offset for previous removals. This
3647 should not be done before calling ...symbol_deleted_p
3648 because it might mess up the offset comparisons there.
3649 Make sure the offset doesn't underflow in the case where
3650 the first entry is removed. */
3651 if (cookie->rel->r_offset >= removed_bytes)
3652 cookie->rel->r_offset -= removed_bytes;
3654 cookie->rel->r_offset = 0;
3660 if (removed_bytes != 0)
3662 /* Adjust any remaining relocs (shouldn't be any). */
3663 for (; cookie->rel < cookie->relend; cookie->rel++)
3665 if (cookie->rel->r_offset >= removed_bytes)
3666 cookie->rel->r_offset -= removed_bytes;
3668 cookie->rel->r_offset = 0;
3671 /* Clear the removed bytes. */
3672 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
3674 pin_contents (sec, contents);
3675 pin_internal_relocs (sec, cookie->rels);
3678 if (sec->rawsize == 0)
3679 sec->rawsize = sec->size;
3680 sec->size -= removed_bytes;
3682 if (xtensa_is_littable_section (sec))
3684 asection *sgotloc = elf_xtensa_hash_table (info)->sgotloc;
3686 sgotloc->size -= removed_bytes;
3691 release_contents (sec, contents);
3692 release_internal_relocs (sec, cookie->rels);
3695 return (removed_bytes != 0);
3700 elf_xtensa_discard_info (bfd *abfd,
3701 struct elf_reloc_cookie *cookie,
3702 struct bfd_link_info *info)
3705 bfd_boolean changed = FALSE;
3707 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3709 if (xtensa_is_property_section (sec))
3711 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
3721 elf_xtensa_ignore_discarded_relocs (asection *sec)
3723 return xtensa_is_property_section (sec);
3728 elf_xtensa_action_discarded (asection *sec)
3730 if (strcmp (".xt_except_table", sec->name) == 0)
3733 if (strcmp (".xt_except_desc", sec->name) == 0)
3736 return _bfd_elf_default_action_discarded (sec);
3740 /* Support for core dump NOTE sections. */
3743 elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3748 /* The size for Xtensa is variable, so don't try to recognize the format
3749 based on the size. Just assume this is GNU/Linux. */
3752 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3755 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
3759 size = note->descsz - offset - 4;
3761 /* Make a ".reg/999" section. */
3762 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3763 size, note->descpos + offset);
3768 elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3770 switch (note->descsz)
3775 case 128: /* GNU/Linux elf_prpsinfo */
3776 elf_tdata (abfd)->core_program
3777 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3778 elf_tdata (abfd)->core_command
3779 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3782 /* Note that for some reason, a spurious space is tacked
3783 onto the end of the args in some (at least one anyway)
3784 implementations, so strip it off if it exists. */
3787 char *command = elf_tdata (abfd)->core_command;
3788 int n = strlen (command);
3790 if (0 < n && command[n - 1] == ' ')
3791 command[n - 1] = '\0';
3798 /* Generic Xtensa configurability stuff. */
3800 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3801 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3802 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3803 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3804 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3805 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3806 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3807 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3810 init_call_opcodes (void)
3812 if (callx0_op == XTENSA_UNDEFINED)
3814 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3815 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3816 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3817 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3818 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3819 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3820 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3821 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3827 is_indirect_call_opcode (xtensa_opcode opcode)
3829 init_call_opcodes ();
3830 return (opcode == callx0_op
3831 || opcode == callx4_op
3832 || opcode == callx8_op
3833 || opcode == callx12_op);
3838 is_direct_call_opcode (xtensa_opcode opcode)
3840 init_call_opcodes ();
3841 return (opcode == call0_op
3842 || opcode == call4_op
3843 || opcode == call8_op
3844 || opcode == call12_op);
3849 is_windowed_call_opcode (xtensa_opcode opcode)
3851 init_call_opcodes ();
3852 return (opcode == call4_op
3853 || opcode == call8_op
3854 || opcode == call12_op
3855 || opcode == callx4_op
3856 || opcode == callx8_op
3857 || opcode == callx12_op);
3862 get_indirect_call_dest_reg (xtensa_opcode opcode, unsigned *pdst)
3864 unsigned dst = (unsigned) -1;
3866 init_call_opcodes ();
3867 if (opcode == callx0_op)
3869 else if (opcode == callx4_op)
3871 else if (opcode == callx8_op)
3873 else if (opcode == callx12_op)
3876 if (dst == (unsigned) -1)
3884 static xtensa_opcode
3885 get_const16_opcode (void)
3887 static bfd_boolean done_lookup = FALSE;
3888 static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3891 const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3894 return const16_opcode;
3898 static xtensa_opcode
3899 get_l32r_opcode (void)
3901 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
3902 static bfd_boolean done_lookup = FALSE;
3906 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
3914 l32r_offset (bfd_vma addr, bfd_vma pc)
3918 offset = addr - ((pc+3) & -4);
3919 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3920 offset = (signed int) offset >> 2;
3921 BFD_ASSERT ((signed int) offset >> 16 == -1);
3927 get_relocation_opnd (xtensa_opcode opcode, int r_type)
3929 xtensa_isa isa = xtensa_default_isa;
3930 int last_immed, last_opnd, opi;
3932 if (opcode == XTENSA_UNDEFINED)
3933 return XTENSA_UNDEFINED;
3935 /* Find the last visible PC-relative immediate operand for the opcode.
3936 If there are no PC-relative immediates, then choose the last visible
3937 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3938 last_immed = XTENSA_UNDEFINED;
3939 last_opnd = xtensa_opcode_num_operands (isa, opcode);
3940 for (opi = last_opnd - 1; opi >= 0; opi--)
3942 if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
3944 if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
3949 if (last_immed == XTENSA_UNDEFINED
3950 && xtensa_operand_is_register (isa, opcode, opi) == 0)
3954 return XTENSA_UNDEFINED;
3956 /* If the operand number was specified in an old-style relocation,
3957 check for consistency with the operand computed above. */
3958 if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
3960 int reloc_opnd = r_type - R_XTENSA_OP0;
3961 if (reloc_opnd != last_immed)
3962 return XTENSA_UNDEFINED;
3970 get_relocation_slot (int r_type)
3980 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
3981 return r_type - R_XTENSA_SLOT0_OP;
3982 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
3983 return r_type - R_XTENSA_SLOT0_ALT;
3987 return XTENSA_UNDEFINED;
3991 /* Get the opcode for a relocation. */
3993 static xtensa_opcode
3994 get_relocation_opcode (bfd *abfd,
3997 Elf_Internal_Rela *irel)
3999 static xtensa_insnbuf ibuff = NULL;
4000 static xtensa_insnbuf sbuff = NULL;
4001 xtensa_isa isa = xtensa_default_isa;
4005 if (contents == NULL)
4006 return XTENSA_UNDEFINED;
4008 if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
4009 return XTENSA_UNDEFINED;
4013 ibuff = xtensa_insnbuf_alloc (isa);
4014 sbuff = xtensa_insnbuf_alloc (isa);
4017 /* Decode the instruction. */
4018 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
4019 sec->size - irel->r_offset);
4020 fmt = xtensa_format_decode (isa, ibuff);
4021 slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
4022 if (slot == XTENSA_UNDEFINED)
4023 return XTENSA_UNDEFINED;
4024 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
4025 return xtensa_opcode_decode (isa, fmt, slot, sbuff);
4030 is_l32r_relocation (bfd *abfd,
4033 Elf_Internal_Rela *irel)
4035 xtensa_opcode opcode;
4036 if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
4038 opcode = get_relocation_opcode (abfd, sec, contents, irel);
4039 return (opcode == get_l32r_opcode ());
4043 static bfd_size_type
4044 get_asm_simplify_size (bfd_byte *contents,
4045 bfd_size_type content_len,
4046 bfd_size_type offset)
4048 bfd_size_type insnlen, size = 0;
4050 /* Decode the size of the next two instructions. */
4051 insnlen = insn_decode_len (contents, content_len, offset);
4057 insnlen = insn_decode_len (contents, content_len, offset + size);
4067 is_alt_relocation (int r_type)
4069 return (r_type >= R_XTENSA_SLOT0_ALT
4070 && r_type <= R_XTENSA_SLOT14_ALT);
4075 is_operand_relocation (int r_type)
4085 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4087 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4096 #define MIN_INSN_LENGTH 2
4098 /* Return 0 if it fails to decode. */
4101 insn_decode_len (bfd_byte *contents,
4102 bfd_size_type content_len,
4103 bfd_size_type offset)
4106 xtensa_isa isa = xtensa_default_isa;
4108 static xtensa_insnbuf ibuff = NULL;
4110 if (offset + MIN_INSN_LENGTH > content_len)
4114 ibuff = xtensa_insnbuf_alloc (isa);
4115 xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
4116 content_len - offset);
4117 fmt = xtensa_format_decode (isa, ibuff);
4118 if (fmt == XTENSA_UNDEFINED)
4120 insn_len = xtensa_format_length (isa, fmt);
4121 if (insn_len == XTENSA_UNDEFINED)
4127 /* Decode the opcode for a single slot instruction.
4128 Return 0 if it fails to decode or the instruction is multi-slot. */
4131 insn_decode_opcode (bfd_byte *contents,
4132 bfd_size_type content_len,
4133 bfd_size_type offset,
4136 xtensa_isa isa = xtensa_default_isa;
4138 static xtensa_insnbuf insnbuf = NULL;
4139 static xtensa_insnbuf slotbuf = NULL;
4141 if (offset + MIN_INSN_LENGTH > content_len)
4142 return XTENSA_UNDEFINED;
4144 if (insnbuf == NULL)
4146 insnbuf = xtensa_insnbuf_alloc (isa);
4147 slotbuf = xtensa_insnbuf_alloc (isa);
4150 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4151 content_len - offset);
4152 fmt = xtensa_format_decode (isa, insnbuf);
4153 if (fmt == XTENSA_UNDEFINED)
4154 return XTENSA_UNDEFINED;
4156 if (slot >= xtensa_format_num_slots (isa, fmt))
4157 return XTENSA_UNDEFINED;
4159 xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4160 return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4164 /* The offset is the offset in the contents.
4165 The address is the address of that offset. */
4168 check_branch_target_aligned (bfd_byte *contents,
4169 bfd_size_type content_length,
4173 bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
4176 return check_branch_target_aligned_address (address, insn_len);
4181 check_loop_aligned (bfd_byte *contents,
4182 bfd_size_type content_length,
4186 bfd_size_type loop_len, insn_len;
4187 xtensa_opcode opcode;
4189 opcode = insn_decode_opcode (contents, content_length, offset, 0);
4190 if (opcode == XTENSA_UNDEFINED
4191 || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
4197 loop_len = insn_decode_len (contents, content_length, offset);
4198 insn_len = insn_decode_len (contents, content_length, offset + loop_len);
4199 if (loop_len == 0 || insn_len == 0)
4205 return check_branch_target_aligned_address (address + loop_len, insn_len);
4210 check_branch_target_aligned_address (bfd_vma addr, int len)
4213 return (addr % 8 == 0);
4214 return ((addr >> 2) == ((addr + len - 1) >> 2));
4218 /* Instruction widening and narrowing. */
4220 /* When FLIX is available we need to access certain instructions only
4221 when they are 16-bit or 24-bit instructions. This table caches
4222 information about such instructions by walking through all the
4223 opcodes and finding the smallest single-slot format into which each
4226 static xtensa_format *op_single_fmt_table = NULL;
4230 init_op_single_format_table (void)
4232 xtensa_isa isa = xtensa_default_isa;
4233 xtensa_insnbuf ibuf;
4234 xtensa_opcode opcode;
4238 if (op_single_fmt_table)
4241 ibuf = xtensa_insnbuf_alloc (isa);
4242 num_opcodes = xtensa_isa_num_opcodes (isa);
4244 op_single_fmt_table = (xtensa_format *)
4245 bfd_malloc (sizeof (xtensa_format) * num_opcodes);
4246 for (opcode = 0; opcode < num_opcodes; opcode++)
4248 op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
4249 for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
4251 if (xtensa_format_num_slots (isa, fmt) == 1
4252 && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
4254 xtensa_opcode old_fmt = op_single_fmt_table[opcode];
4255 int fmt_length = xtensa_format_length (isa, fmt);
4256 if (old_fmt == XTENSA_UNDEFINED
4257 || fmt_length < xtensa_format_length (isa, old_fmt))
4258 op_single_fmt_table[opcode] = fmt;
4262 xtensa_insnbuf_free (isa, ibuf);
4266 static xtensa_format
4267 get_single_format (xtensa_opcode opcode)
4269 init_op_single_format_table ();
4270 return op_single_fmt_table[opcode];
4274 /* For the set of narrowable instructions we do NOT include the
4275 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4276 involved during linker relaxation that may require these to
4277 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4278 requires special case code to ensure it only works when op1 == op2. */
4286 struct string_pair narrowable[] =
4289 { "addi", "addi.n" },
4290 { "addmi", "addi.n" },
4291 { "l32i", "l32i.n" },
4292 { "movi", "movi.n" },
4294 { "retw", "retw.n" },
4295 { "s32i", "s32i.n" },
4296 { "or", "mov.n" } /* special case only when op1 == op2 */
4299 struct string_pair widenable[] =
4302 { "addi", "addi.n" },
4303 { "addmi", "addi.n" },
4304 { "beqz", "beqz.n" },
4305 { "bnez", "bnez.n" },
4306 { "l32i", "l32i.n" },
4307 { "movi", "movi.n" },
4309 { "retw", "retw.n" },
4310 { "s32i", "s32i.n" },
4311 { "or", "mov.n" } /* special case only when op1 == op2 */
4315 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4316 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4317 return the instruction buffer holding the narrow instruction. Otherwise,
4318 return 0. The set of valid narrowing are specified by a string table
4319 but require some special case operand checks in some cases. */
4321 static xtensa_insnbuf
4322 can_narrow_instruction (xtensa_insnbuf slotbuf,
4324 xtensa_opcode opcode)
4326 xtensa_isa isa = xtensa_default_isa;
4327 xtensa_format o_fmt;
4330 static xtensa_insnbuf o_insnbuf = NULL;
4331 static xtensa_insnbuf o_slotbuf = NULL;
4333 if (o_insnbuf == NULL)
4335 o_insnbuf = xtensa_insnbuf_alloc (isa);
4336 o_slotbuf = xtensa_insnbuf_alloc (isa);
4339 for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
4341 bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
4343 if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
4345 uint32 value, newval;
4346 int i, operand_count, o_operand_count;
4347 xtensa_opcode o_opcode;
4349 /* Address does not matter in this case. We might need to
4350 fix it to handle branches/jumps. */
4351 bfd_vma self_address = 0;
4353 o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
4354 if (o_opcode == XTENSA_UNDEFINED)
4356 o_fmt = get_single_format (o_opcode);
4357 if (o_fmt == XTENSA_UNDEFINED)
4360 if (xtensa_format_length (isa, fmt) != 3
4361 || xtensa_format_length (isa, o_fmt) != 2)
4364 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4365 operand_count = xtensa_opcode_num_operands (isa, opcode);
4366 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4368 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4373 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4378 uint32 rawval0, rawval1, rawval2;
4380 if (o_operand_count + 1 != operand_count
4381 || xtensa_operand_get_field (isa, opcode, 0,
4382 fmt, 0, slotbuf, &rawval0) != 0
4383 || xtensa_operand_get_field (isa, opcode, 1,
4384 fmt, 0, slotbuf, &rawval1) != 0
4385 || xtensa_operand_get_field (isa, opcode, 2,
4386 fmt, 0, slotbuf, &rawval2) != 0
4387 || rawval1 != rawval2
4388 || rawval0 == rawval1 /* it is a nop */)
4392 for (i = 0; i < o_operand_count; ++i)
4394 if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
4396 || xtensa_operand_decode (isa, opcode, i, &value))
4399 /* PC-relative branches need adjustment, but
4400 the PC-rel operand will always have a relocation. */
4402 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4404 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4405 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4410 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4420 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4421 the action in-place directly into the contents and return TRUE. Otherwise,
4422 the return value is FALSE and the contents are not modified. */
4425 narrow_instruction (bfd_byte *contents,
4426 bfd_size_type content_length,
4427 bfd_size_type offset)
4429 xtensa_opcode opcode;
4430 bfd_size_type insn_len;
4431 xtensa_isa isa = xtensa_default_isa;
4433 xtensa_insnbuf o_insnbuf;
4435 static xtensa_insnbuf insnbuf = NULL;
4436 static xtensa_insnbuf slotbuf = NULL;
4438 if (insnbuf == NULL)
4440 insnbuf = xtensa_insnbuf_alloc (isa);
4441 slotbuf = xtensa_insnbuf_alloc (isa);
4444 BFD_ASSERT (offset < content_length);
4446 if (content_length < 2)
4449 /* We will hand-code a few of these for a little while.
4450 These have all been specified in the assembler aleady. */
4451 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4452 content_length - offset);
4453 fmt = xtensa_format_decode (isa, insnbuf);
4454 if (xtensa_format_num_slots (isa, fmt) != 1)
4457 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4460 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4461 if (opcode == XTENSA_UNDEFINED)
4463 insn_len = xtensa_format_length (isa, fmt);
4464 if (insn_len > content_length)
4467 o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
4470 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4471 content_length - offset);
4479 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4480 "density" instruction to a standard 3-byte instruction. If it is valid,
4481 return the instruction buffer holding the wide instruction. Otherwise,
4482 return 0. The set of valid widenings are specified by a string table
4483 but require some special case operand checks in some cases. */
4485 static xtensa_insnbuf
4486 can_widen_instruction (xtensa_insnbuf slotbuf,
4488 xtensa_opcode opcode)
4490 xtensa_isa isa = xtensa_default_isa;
4491 xtensa_format o_fmt;
4494 static xtensa_insnbuf o_insnbuf = NULL;
4495 static xtensa_insnbuf o_slotbuf = NULL;
4497 if (o_insnbuf == NULL)
4499 o_insnbuf = xtensa_insnbuf_alloc (isa);
4500 o_slotbuf = xtensa_insnbuf_alloc (isa);
4503 for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
4505 bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
4506 bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
4507 || strcmp ("bnez", widenable[opi].wide) == 0);
4509 if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
4511 uint32 value, newval;
4512 int i, operand_count, o_operand_count, check_operand_count;
4513 xtensa_opcode o_opcode;
4515 /* Address does not matter in this case. We might need to fix it
4516 to handle branches/jumps. */
4517 bfd_vma self_address = 0;
4519 o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
4520 if (o_opcode == XTENSA_UNDEFINED)
4522 o_fmt = get_single_format (o_opcode);
4523 if (o_fmt == XTENSA_UNDEFINED)
4526 if (xtensa_format_length (isa, fmt) != 2
4527 || xtensa_format_length (isa, o_fmt) != 3)
4530 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4531 operand_count = xtensa_opcode_num_operands (isa, opcode);
4532 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4533 check_operand_count = o_operand_count;
4535 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4540 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4545 uint32 rawval0, rawval1;
4547 if (o_operand_count != operand_count + 1
4548 || xtensa_operand_get_field (isa, opcode, 0,
4549 fmt, 0, slotbuf, &rawval0) != 0
4550 || xtensa_operand_get_field (isa, opcode, 1,
4551 fmt, 0, slotbuf, &rawval1) != 0
4552 || rawval0 == rawval1 /* it is a nop */)
4556 check_operand_count--;
4558 for (i = 0; i < check_operand_count; i++)
4561 if (is_or && i == o_operand_count - 1)
4563 if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
4565 || xtensa_operand_decode (isa, opcode, new_i, &value))
4568 /* PC-relative branches need adjustment, but
4569 the PC-rel operand will always have a relocation. */
4571 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4573 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4574 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4579 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4589 /* Attempt to widen an instruction. If the widening is valid, perform
4590 the action in-place directly into the contents and return TRUE. Otherwise,
4591 the return value is FALSE and the contents are not modified. */
4594 widen_instruction (bfd_byte *contents,
4595 bfd_size_type content_length,
4596 bfd_size_type offset)
4598 xtensa_opcode opcode;
4599 bfd_size_type insn_len;
4600 xtensa_isa isa = xtensa_default_isa;
4602 xtensa_insnbuf o_insnbuf;
4604 static xtensa_insnbuf insnbuf = NULL;
4605 static xtensa_insnbuf slotbuf = NULL;
4607 if (insnbuf == NULL)
4609 insnbuf = xtensa_insnbuf_alloc (isa);
4610 slotbuf = xtensa_insnbuf_alloc (isa);
4613 BFD_ASSERT (offset < content_length);
4615 if (content_length < 2)
4618 /* We will hand-code a few of these for a little while.
4619 These have all been specified in the assembler aleady. */
4620 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4621 content_length - offset);
4622 fmt = xtensa_format_decode (isa, insnbuf);
4623 if (xtensa_format_num_slots (isa, fmt) != 1)
4626 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4629 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4630 if (opcode == XTENSA_UNDEFINED)
4632 insn_len = xtensa_format_length (isa, fmt);
4633 if (insn_len > content_length)
4636 o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
4639 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4640 content_length - offset);
4647 /* Code for transforming CALLs at link-time. */
4649 static bfd_reloc_status_type
4650 elf_xtensa_do_asm_simplify (bfd_byte *contents,
4652 bfd_vma content_length,
4653 char **error_message)
4655 static xtensa_insnbuf insnbuf = NULL;
4656 static xtensa_insnbuf slotbuf = NULL;
4657 xtensa_format core_format = XTENSA_UNDEFINED;
4658 xtensa_opcode opcode;
4659 xtensa_opcode direct_call_opcode;
4660 xtensa_isa isa = xtensa_default_isa;
4661 bfd_byte *chbuf = contents + address;
4664 if (insnbuf == NULL)
4666 insnbuf = xtensa_insnbuf_alloc (isa);
4667 slotbuf = xtensa_insnbuf_alloc (isa);
4670 if (content_length < address)
4672 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4673 return bfd_reloc_other;
4676 opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
4677 direct_call_opcode = swap_callx_for_call_opcode (opcode);
4678 if (direct_call_opcode == XTENSA_UNDEFINED)
4680 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4681 return bfd_reloc_other;
4684 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4685 core_format = xtensa_format_lookup (isa, "x24");
4686 opcode = xtensa_opcode_lookup (isa, "or");
4687 xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
4688 for (opn = 0; opn < 3; opn++)
4691 xtensa_operand_encode (isa, opcode, opn, ®no);
4692 xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
4695 xtensa_format_encode (isa, core_format, insnbuf);
4696 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4697 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
4699 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4700 xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
4701 xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
4703 xtensa_format_encode (isa, core_format, insnbuf);
4704 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4705 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
4706 content_length - address - 3);
4708 return bfd_reloc_ok;
4712 static bfd_reloc_status_type
4713 contract_asm_expansion (bfd_byte *contents,
4714 bfd_vma content_length,
4715 Elf_Internal_Rela *irel,
4716 char **error_message)
4718 bfd_reloc_status_type retval =
4719 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
4722 if (retval != bfd_reloc_ok)
4723 return bfd_reloc_dangerous;
4725 /* Update the irel->r_offset field so that the right immediate and
4726 the right instruction are modified during the relocation. */
4727 irel->r_offset += 3;
4728 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
4729 return bfd_reloc_ok;
4733 static xtensa_opcode
4734 swap_callx_for_call_opcode (xtensa_opcode opcode)
4736 init_call_opcodes ();
4738 if (opcode == callx0_op) return call0_op;
4739 if (opcode == callx4_op) return call4_op;
4740 if (opcode == callx8_op) return call8_op;
4741 if (opcode == callx12_op) return call12_op;
4743 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4744 return XTENSA_UNDEFINED;
4748 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4749 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4750 If not, return XTENSA_UNDEFINED. */
4752 #define L32R_TARGET_REG_OPERAND 0
4753 #define CONST16_TARGET_REG_OPERAND 0
4754 #define CALLN_SOURCE_OPERAND 0
4756 static xtensa_opcode
4757 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
4759 static xtensa_insnbuf insnbuf = NULL;
4760 static xtensa_insnbuf slotbuf = NULL;
4762 xtensa_opcode opcode;
4763 xtensa_isa isa = xtensa_default_isa;
4764 uint32 regno, const16_regno, call_regno;
4767 if (insnbuf == NULL)
4769 insnbuf = xtensa_insnbuf_alloc (isa);
4770 slotbuf = xtensa_insnbuf_alloc (isa);
4773 xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4774 fmt = xtensa_format_decode (isa, insnbuf);
4775 if (fmt == XTENSA_UNDEFINED
4776 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4777 return XTENSA_UNDEFINED;
4779 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4780 if (opcode == XTENSA_UNDEFINED)
4781 return XTENSA_UNDEFINED;
4783 if (opcode == get_l32r_opcode ())
4786 *p_uses_l32r = TRUE;
4787 if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4788 fmt, 0, slotbuf, ®no)
4789 || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4791 return XTENSA_UNDEFINED;
4793 else if (opcode == get_const16_opcode ())
4796 *p_uses_l32r = FALSE;
4797 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4798 fmt, 0, slotbuf, ®no)
4799 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4801 return XTENSA_UNDEFINED;
4803 /* Check that the next instruction is also CONST16. */
4804 offset += xtensa_format_length (isa, fmt);
4805 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4806 fmt = xtensa_format_decode (isa, insnbuf);
4807 if (fmt == XTENSA_UNDEFINED
4808 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4809 return XTENSA_UNDEFINED;
4810 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4811 if (opcode != get_const16_opcode ())
4812 return XTENSA_UNDEFINED;
4814 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4815 fmt, 0, slotbuf, &const16_regno)
4816 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4818 || const16_regno != regno)
4819 return XTENSA_UNDEFINED;
4822 return XTENSA_UNDEFINED;
4824 /* Next instruction should be an CALLXn with operand 0 == regno. */
4825 offset += xtensa_format_length (isa, fmt);
4826 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4827 fmt = xtensa_format_decode (isa, insnbuf);
4828 if (fmt == XTENSA_UNDEFINED
4829 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4830 return XTENSA_UNDEFINED;
4831 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4832 if (opcode == XTENSA_UNDEFINED
4833 || !is_indirect_call_opcode (opcode))
4834 return XTENSA_UNDEFINED;
4836 if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4837 fmt, 0, slotbuf, &call_regno)
4838 || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4840 return XTENSA_UNDEFINED;
4842 if (call_regno != regno)
4843 return XTENSA_UNDEFINED;
4849 /* Data structures used during relaxation. */
4851 /* r_reloc: relocation values. */
4853 /* Through the relaxation process, we need to keep track of the values
4854 that will result from evaluating relocations. The standard ELF
4855 relocation structure is not sufficient for this purpose because we're
4856 operating on multiple input files at once, so we need to know which
4857 input file a relocation refers to. The r_reloc structure thus
4858 records both the input file (bfd) and ELF relocation.
4860 For efficiency, an r_reloc also contains a "target_offset" field to
4861 cache the target-section-relative offset value that is represented by
4864 The r_reloc also contains a virtual offset that allows multiple
4865 inserted literals to be placed at the same "address" with
4866 different offsets. */
4868 typedef struct r_reloc_struct r_reloc;
4870 struct r_reloc_struct
4873 Elf_Internal_Rela rela;
4874 bfd_vma target_offset;
4875 bfd_vma virtual_offset;
4879 /* The r_reloc structure is included by value in literal_value, but not
4880 every literal_value has an associated relocation -- some are simple
4881 constants. In such cases, we set all the fields in the r_reloc
4882 struct to zero. The r_reloc_is_const function should be used to
4883 detect this case. */
4886 r_reloc_is_const (const r_reloc *r_rel)
4888 return (r_rel->abfd == NULL);
4893 r_reloc_get_target_offset (const r_reloc *r_rel)
4895 bfd_vma target_offset;
4896 unsigned long r_symndx;
4898 BFD_ASSERT (!r_reloc_is_const (r_rel));
4899 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4900 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4901 return (target_offset + r_rel->rela.r_addend);
4905 static struct elf_link_hash_entry *
4906 r_reloc_get_hash_entry (const r_reloc *r_rel)
4908 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4909 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4914 r_reloc_get_section (const r_reloc *r_rel)
4916 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4917 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4922 r_reloc_is_defined (const r_reloc *r_rel)
4928 sec = r_reloc_get_section (r_rel);
4929 if (sec == bfd_abs_section_ptr
4930 || sec == bfd_com_section_ptr
4931 || sec == bfd_und_section_ptr)
4938 r_reloc_init (r_reloc *r_rel,
4940 Elf_Internal_Rela *irel,
4942 bfd_size_type content_length)
4945 reloc_howto_type *howto;
4949 r_rel->rela = *irel;
4951 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
4952 r_rel->virtual_offset = 0;
4953 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
4954 howto = &elf_howto_table[r_type];
4955 if (howto->partial_inplace)
4957 bfd_vma inplace_val;
4958 BFD_ASSERT (r_rel->rela.r_offset < content_length);
4960 inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
4961 r_rel->target_offset += inplace_val;
4965 memset (r_rel, 0, sizeof (r_reloc));
4972 print_r_reloc (FILE *fp, const r_reloc *r_rel)
4974 if (r_reloc_is_defined (r_rel))
4976 asection *sec = r_reloc_get_section (r_rel);
4977 fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
4979 else if (r_reloc_get_hash_entry (r_rel))
4980 fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
4982 fprintf (fp, " ?? + ");
4984 fprintf_vma (fp, r_rel->target_offset);
4985 if (r_rel->virtual_offset)
4987 fprintf (fp, " + ");
4988 fprintf_vma (fp, r_rel->virtual_offset);
4997 /* source_reloc: relocations that reference literals. */
4999 /* To determine whether literals can be coalesced, we need to first
5000 record all the relocations that reference the literals. The
5001 source_reloc structure below is used for this purpose. The
5002 source_reloc entries are kept in a per-literal-section array, sorted
5003 by offset within the literal section (i.e., target offset).
5005 The source_sec and r_rel.rela.r_offset fields identify the source of
5006 the relocation. The r_rel field records the relocation value, i.e.,
5007 the offset of the literal being referenced. The opnd field is needed
5008 to determine the range of the immediate field to which the relocation
5009 applies, so we can determine whether another literal with the same
5010 value is within range. The is_null field is true when the relocation
5011 is being removed (e.g., when an L32R is being removed due to a CALLX
5012 that is converted to a direct CALL). */
5014 typedef struct source_reloc_struct source_reloc;
5016 struct source_reloc_struct
5018 asection *source_sec;
5020 xtensa_opcode opcode;
5022 bfd_boolean is_null;
5023 bfd_boolean is_abs_literal;
5028 init_source_reloc (source_reloc *reloc,
5029 asection *source_sec,
5030 const r_reloc *r_rel,
5031 xtensa_opcode opcode,
5033 bfd_boolean is_abs_literal)
5035 reloc->source_sec = source_sec;
5036 reloc->r_rel = *r_rel;
5037 reloc->opcode = opcode;
5039 reloc->is_null = FALSE;
5040 reloc->is_abs_literal = is_abs_literal;
5044 /* Find the source_reloc for a particular source offset and relocation
5045 type. Note that the array is sorted by _target_ offset, so this is
5046 just a linear search. */
5048 static source_reloc *
5049 find_source_reloc (source_reloc *src_relocs,
5052 Elf_Internal_Rela *irel)
5056 for (i = 0; i < src_count; i++)
5058 if (src_relocs[i].source_sec == sec
5059 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
5060 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
5061 == ELF32_R_TYPE (irel->r_info)))
5062 return &src_relocs[i];
5070 source_reloc_compare (const void *ap, const void *bp)
5072 const source_reloc *a = (const source_reloc *) ap;
5073 const source_reloc *b = (const source_reloc *) bp;
5075 if (a->r_rel.target_offset != b->r_rel.target_offset)
5076 return (a->r_rel.target_offset - b->r_rel.target_offset);
5078 /* We don't need to sort on these criteria for correctness,
5079 but enforcing a more strict ordering prevents unstable qsort
5080 from behaving differently with different implementations.
5081 Without the code below we get correct but different results
5082 on Solaris 2.7 and 2.8. We would like to always produce the
5083 same results no matter the host. */
5085 if ((!a->is_null) - (!b->is_null))
5086 return ((!a->is_null) - (!b->is_null));
5087 return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
5091 /* Literal values and value hash tables. */
5093 /* Literals with the same value can be coalesced. The literal_value
5094 structure records the value of a literal: the "r_rel" field holds the
5095 information from the relocation on the literal (if there is one) and
5096 the "value" field holds the contents of the literal word itself.
5098 The value_map structure records a literal value along with the
5099 location of a literal holding that value. The value_map hash table
5100 is indexed by the literal value, so that we can quickly check if a
5101 particular literal value has been seen before and is thus a candidate
5104 typedef struct literal_value_struct literal_value;
5105 typedef struct value_map_struct value_map;
5106 typedef struct value_map_hash_table_struct value_map_hash_table;
5108 struct literal_value_struct
5111 unsigned long value;
5112 bfd_boolean is_abs_literal;
5115 struct value_map_struct
5117 literal_value val; /* The literal value. */
5118 r_reloc loc; /* Location of the literal. */
5122 struct value_map_hash_table_struct
5124 unsigned bucket_count;
5125 value_map **buckets;
5127 bfd_boolean has_last_loc;
5133 init_literal_value (literal_value *lit,
5134 const r_reloc *r_rel,
5135 unsigned long value,
5136 bfd_boolean is_abs_literal)
5138 lit->r_rel = *r_rel;
5140 lit->is_abs_literal = is_abs_literal;
5145 literal_value_equal (const literal_value *src1,
5146 const literal_value *src2,
5147 bfd_boolean final_static_link)
5149 struct elf_link_hash_entry *h1, *h2;
5151 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
5154 if (r_reloc_is_const (&src1->r_rel))
5155 return (src1->value == src2->value);
5157 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
5158 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
5161 if (src1->r_rel.target_offset != src2->r_rel.target_offset)
5164 if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
5167 if (src1->value != src2->value)
5170 /* Now check for the same section (if defined) or the same elf_hash
5171 (if undefined or weak). */
5172 h1 = r_reloc_get_hash_entry (&src1->r_rel);
5173 h2 = r_reloc_get_hash_entry (&src2->r_rel);
5174 if (r_reloc_is_defined (&src1->r_rel)
5175 && (final_static_link
5176 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
5177 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
5179 if (r_reloc_get_section (&src1->r_rel)
5180 != r_reloc_get_section (&src2->r_rel))
5185 /* Require that the hash entries (i.e., symbols) be identical. */
5186 if (h1 != h2 || h1 == 0)
5190 if (src1->is_abs_literal != src2->is_abs_literal)
5197 /* Must be power of 2. */
5198 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5200 static value_map_hash_table *
5201 value_map_hash_table_init (void)
5203 value_map_hash_table *values;
5205 values = (value_map_hash_table *)
5206 bfd_zmalloc (sizeof (value_map_hash_table));
5207 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
5209 values->buckets = (value_map **)
5210 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
5211 if (values->buckets == NULL)
5216 values->has_last_loc = FALSE;
5223 value_map_hash_table_delete (value_map_hash_table *table)
5225 free (table->buckets);
5231 hash_bfd_vma (bfd_vma val)
5233 return (val >> 2) + (val >> 10);
5238 literal_value_hash (const literal_value *src)
5242 hash_val = hash_bfd_vma (src->value);
5243 if (!r_reloc_is_const (&src->r_rel))
5247 hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
5248 hash_val += hash_bfd_vma (src->r_rel.target_offset);
5249 hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
5251 /* Now check for the same section and the same elf_hash. */
5252 if (r_reloc_is_defined (&src->r_rel))
5253 sec_or_hash = r_reloc_get_section (&src->r_rel);
5255 sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
5256 hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
5262 /* Check if the specified literal_value has been seen before. */
5265 value_map_get_cached_value (value_map_hash_table *map,
5266 const literal_value *val,
5267 bfd_boolean final_static_link)
5273 idx = literal_value_hash (val);
5274 idx = idx & (map->bucket_count - 1);
5275 bucket = map->buckets[idx];
5276 for (map_e = bucket; map_e; map_e = map_e->next)
5278 if (literal_value_equal (&map_e->val, val, final_static_link))
5285 /* Record a new literal value. It is illegal to call this if VALUE
5286 already has an entry here. */
5289 add_value_map (value_map_hash_table *map,
5290 const literal_value *val,
5292 bfd_boolean final_static_link)
5294 value_map **bucket_p;
5297 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
5300 bfd_set_error (bfd_error_no_memory);
5304 BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
5308 idx = literal_value_hash (val);
5309 idx = idx & (map->bucket_count - 1);
5310 bucket_p = &map->buckets[idx];
5312 val_e->next = *bucket_p;
5315 /* FIXME: Consider resizing the hash table if we get too many entries. */
5321 /* Lists of text actions (ta_) for narrowing, widening, longcall
5322 conversion, space fill, code & literal removal, etc. */
5324 /* The following text actions are generated:
5326 "ta_remove_insn" remove an instruction or instructions
5327 "ta_remove_longcall" convert longcall to call
5328 "ta_convert_longcall" convert longcall to nop/call
5329 "ta_narrow_insn" narrow a wide instruction
5330 "ta_widen" widen a narrow instruction
5331 "ta_fill" add fill or remove fill
5332 removed < 0 is a fill; branches to the fill address will be
5333 changed to address + fill size (e.g., address - removed)
5334 removed >= 0 branches to the fill address will stay unchanged
5335 "ta_remove_literal" remove a literal; this action is
5336 indicated when a literal is removed
5338 "ta_add_literal" insert a new literal; this action is
5339 indicated when a literal has been moved.
5340 It may use a virtual_offset because
5341 multiple literals can be placed at the
5344 For each of these text actions, we also record the number of bytes
5345 removed by performing the text action. In the case of a "ta_widen"
5346 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5348 typedef struct text_action_struct text_action;
5349 typedef struct text_action_list_struct text_action_list;
5350 typedef enum text_action_enum_t text_action_t;
5352 enum text_action_enum_t
5355 ta_remove_insn, /* removed = -size */
5356 ta_remove_longcall, /* removed = -size */
5357 ta_convert_longcall, /* removed = 0 */
5358 ta_narrow_insn, /* removed = -1 */
5359 ta_widen_insn, /* removed = +1 */
5360 ta_fill, /* removed = +size */
5366 /* Structure for a text action record. */
5367 struct text_action_struct
5369 text_action_t action;
5370 asection *sec; /* Optional */
5372 bfd_vma virtual_offset; /* Zero except for adding literals. */
5374 literal_value value; /* Only valid when adding literals. */
5380 /* List of all of the actions taken on a text section. */
5381 struct text_action_list_struct
5387 static text_action *
5388 find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
5392 /* It is not necessary to fill at the end of a section. */
5393 if (sec->size == offset)
5396 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
5398 text_action *t = *m_p;
5399 /* When the action is another fill at the same address,
5400 just increase the size. */
5401 if (t->offset == offset && t->action == ta_fill)
5409 compute_removed_action_diff (const text_action *ta,
5413 int removable_space)
5416 int current_removed = 0;
5419 current_removed = ta->removed_bytes;
5421 BFD_ASSERT (ta == NULL || ta->offset == offset);
5422 BFD_ASSERT (ta == NULL || ta->action == ta_fill);
5424 /* It is not necessary to fill at the end of a section. Clean this up. */
5425 if (sec->size == offset)
5426 new_removed = removable_space - 0;
5430 int added = -removed - current_removed;
5431 /* Ignore multiples of the section alignment. */
5432 added = ((1 << sec->alignment_power) - 1) & added;
5433 new_removed = (-added);
5435 /* Modify for removable. */
5436 space = removable_space - new_removed;
5437 new_removed = (removable_space
5438 - (((1 << sec->alignment_power) - 1) & space));
5440 return (new_removed - current_removed);
5445 adjust_fill_action (text_action *ta, int fill_diff)
5447 ta->removed_bytes += fill_diff;
5451 /* Add a modification action to the text. For the case of adding or
5452 removing space, modify any current fill and assume that
5453 "unreachable_space" bytes can be freely contracted. Note that a
5454 negative removed value is a fill. */
5457 text_action_add (text_action_list *l,
5458 text_action_t action,
5466 /* It is not necessary to fill at the end of a section. */
5467 if (action == ta_fill && sec->size == offset)
5470 /* It is not necessary to fill 0 bytes. */
5471 if (action == ta_fill && removed == 0)
5474 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
5476 text_action *t = *m_p;
5478 if (action == ta_fill)
5480 /* When the action is another fill at the same address,
5481 just increase the size. */
5482 if (t->offset == offset && t->action == ta_fill)
5484 t->removed_bytes += removed;
5487 /* Fills need to happen before widens so that we don't
5488 insert fill bytes into the instruction stream. */
5489 if (t->offset == offset && t->action == ta_widen_insn)
5494 /* Create a new record and fill it up. */
5495 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5496 ta->action = action;
5498 ta->offset = offset;
5499 ta->removed_bytes = removed;
5506 text_action_add_literal (text_action_list *l,
5507 text_action_t action,
5509 const literal_value *value,
5514 asection *sec = r_reloc_get_section (loc);
5515 bfd_vma offset = loc->target_offset;
5516 bfd_vma virtual_offset = loc->virtual_offset;
5518 BFD_ASSERT (action == ta_add_literal);
5520 for (m_p = &l->head; *m_p != NULL; m_p = &(*m_p)->next)
5522 if ((*m_p)->offset > offset
5523 && ((*m_p)->offset != offset
5524 || (*m_p)->virtual_offset > virtual_offset))
5528 /* Create a new record and fill it up. */
5529 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5530 ta->action = action;
5532 ta->offset = offset;
5533 ta->virtual_offset = virtual_offset;
5535 ta->removed_bytes = removed;
5541 /* Find the total offset adjustment for the relaxations specified by
5542 text_actions, beginning from a particular starting action. This is
5543 typically used from offset_with_removed_text to search an entire list of
5544 actions, but it may also be called directly when adjusting adjacent offsets
5545 so that each search may begin where the previous one left off. */
5548 removed_by_actions (text_action **p_start_action,
5550 bfd_boolean before_fill)
5555 r = *p_start_action;
5558 if (r->offset > offset)
5561 if (r->offset == offset
5562 && (before_fill || r->action != ta_fill || r->removed_bytes >= 0))
5565 removed += r->removed_bytes;
5570 *p_start_action = r;
5576 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
5578 text_action *r = action_list->head;
5579 return offset - removed_by_actions (&r, offset, FALSE);
5584 action_list_count (text_action_list *action_list)
5586 text_action *r = action_list->head;
5588 for (r = action_list->head; r != NULL; r = r->next)
5596 /* The find_insn_action routine will only find non-fill actions. */
5598 static text_action *
5599 find_insn_action (text_action_list *action_list, bfd_vma offset)
5602 for (t = action_list->head; t; t = t->next)
5604 if (t->offset == offset)
5611 case ta_remove_insn:
5612 case ta_remove_longcall:
5613 case ta_convert_longcall:
5614 case ta_narrow_insn:
5617 case ta_remove_literal:
5618 case ta_add_literal:
5631 print_action_list (FILE *fp, text_action_list *action_list)
5635 fprintf (fp, "Text Action\n");
5636 for (r = action_list->head; r != NULL; r = r->next)
5638 const char *t = "unknown";
5641 case ta_remove_insn:
5642 t = "remove_insn"; break;
5643 case ta_remove_longcall:
5644 t = "remove_longcall"; break;
5645 case ta_convert_longcall:
5646 t = "convert_longcall"; break;
5647 case ta_narrow_insn:
5648 t = "narrow_insn"; break;
5650 t = "widen_insn"; break;
5655 case ta_remove_literal:
5656 t = "remove_literal"; break;
5657 case ta_add_literal:
5658 t = "add_literal"; break;
5661 fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
5662 r->sec->owner->filename,
5663 r->sec->name, r->offset, t, r->removed_bytes);
5670 /* Lists of literals being coalesced or removed. */
5672 /* In the usual case, the literal identified by "from" is being
5673 coalesced with another literal identified by "to". If the literal is
5674 unused and is being removed altogether, "to.abfd" will be NULL.
5675 The removed_literal entries are kept on a per-section list, sorted
5676 by the "from" offset field. */
5678 typedef struct removed_literal_struct removed_literal;
5679 typedef struct removed_literal_list_struct removed_literal_list;
5681 struct removed_literal_struct
5685 removed_literal *next;
5688 struct removed_literal_list_struct
5690 removed_literal *head;
5691 removed_literal *tail;
5695 /* Record that the literal at "from" is being removed. If "to" is not
5696 NULL, the "from" literal is being coalesced with the "to" literal. */
5699 add_removed_literal (removed_literal_list *removed_list,
5700 const r_reloc *from,
5703 removed_literal *r, *new_r, *next_r;
5705 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
5707 new_r->from = *from;
5711 new_r->to.abfd = NULL;
5714 r = removed_list->head;
5717 removed_list->head = new_r;
5718 removed_list->tail = new_r;
5720 /* Special check for common case of append. */
5721 else if (removed_list->tail->from.target_offset < from->target_offset)
5723 removed_list->tail->next = new_r;
5724 removed_list->tail = new_r;
5728 while (r->from.target_offset < from->target_offset && r->next)
5734 new_r->next = next_r;
5736 removed_list->tail = new_r;
5741 /* Check if the list of removed literals contains an entry for the
5742 given address. Return the entry if found. */
5744 static removed_literal *
5745 find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
5747 removed_literal *r = removed_list->head;
5748 while (r && r->from.target_offset < addr)
5750 if (r && r->from.target_offset == addr)
5759 print_removed_literals (FILE *fp, removed_literal_list *removed_list)
5762 r = removed_list->head;
5764 fprintf (fp, "Removed Literals\n");
5765 for (; r != NULL; r = r->next)
5767 print_r_reloc (fp, &r->from);
5768 fprintf (fp, " => ");
5769 if (r->to.abfd == NULL)
5770 fprintf (fp, "REMOVED");
5772 print_r_reloc (fp, &r->to);
5780 /* Per-section data for relaxation. */
5782 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
5784 struct xtensa_relax_info_struct
5786 bfd_boolean is_relaxable_literal_section;
5787 bfd_boolean is_relaxable_asm_section;
5788 int visited; /* Number of times visited. */
5790 source_reloc *src_relocs; /* Array[src_count]. */
5792 int src_next; /* Next src_relocs entry to assign. */
5794 removed_literal_list removed_list;
5795 text_action_list action_list;
5797 reloc_bfd_fix *fix_list;
5798 reloc_bfd_fix *fix_array;
5799 unsigned fix_array_count;
5801 /* Support for expanding the reloc array that is stored
5802 in the section structure. If the relocations have been
5803 reallocated, the newly allocated relocations will be referenced
5804 here along with the actual size allocated. The relocation
5805 count will always be found in the section structure. */
5806 Elf_Internal_Rela *allocated_relocs;
5807 unsigned relocs_count;
5808 unsigned allocated_relocs_count;
5811 struct elf_xtensa_section_data
5813 struct bfd_elf_section_data elf;
5814 xtensa_relax_info relax_info;
5819 elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
5821 if (!sec->used_by_bfd)
5823 struct elf_xtensa_section_data *sdata;
5824 bfd_size_type amt = sizeof (*sdata);
5826 sdata = bfd_zalloc (abfd, amt);
5829 sec->used_by_bfd = sdata;
5832 return _bfd_elf_new_section_hook (abfd, sec);
5836 static xtensa_relax_info *
5837 get_xtensa_relax_info (asection *sec)
5839 struct elf_xtensa_section_data *section_data;
5841 /* No info available if no section or if it is an output section. */
5842 if (!sec || sec == sec->output_section)
5845 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
5846 return §ion_data->relax_info;
5851 init_xtensa_relax_info (asection *sec)
5853 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5855 relax_info->is_relaxable_literal_section = FALSE;
5856 relax_info->is_relaxable_asm_section = FALSE;
5857 relax_info->visited = 0;
5859 relax_info->src_relocs = NULL;
5860 relax_info->src_count = 0;
5861 relax_info->src_next = 0;
5863 relax_info->removed_list.head = NULL;
5864 relax_info->removed_list.tail = NULL;
5866 relax_info->action_list.head = NULL;
5868 relax_info->fix_list = NULL;
5869 relax_info->fix_array = NULL;
5870 relax_info->fix_array_count = 0;
5872 relax_info->allocated_relocs = NULL;
5873 relax_info->relocs_count = 0;
5874 relax_info->allocated_relocs_count = 0;
5878 /* Coalescing literals may require a relocation to refer to a section in
5879 a different input file, but the standard relocation information
5880 cannot express that. Instead, the reloc_bfd_fix structures are used
5881 to "fix" the relocations that refer to sections in other input files.
5882 These structures are kept on per-section lists. The "src_type" field
5883 records the relocation type in case there are multiple relocations on
5884 the same location. FIXME: This is ugly; an alternative might be to
5885 add new symbols with the "owner" field to some other input file. */
5887 struct reloc_bfd_fix_struct
5891 unsigned src_type; /* Relocation type. */
5893 asection *target_sec;
5894 bfd_vma target_offset;
5895 bfd_boolean translated;
5897 reloc_bfd_fix *next;
5901 static reloc_bfd_fix *
5902 reloc_bfd_fix_init (asection *src_sec,
5905 asection *target_sec,
5906 bfd_vma target_offset,
5907 bfd_boolean translated)
5911 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
5912 fix->src_sec = src_sec;
5913 fix->src_offset = src_offset;
5914 fix->src_type = src_type;
5915 fix->target_sec = target_sec;
5916 fix->target_offset = target_offset;
5917 fix->translated = translated;
5924 add_fix (asection *src_sec, reloc_bfd_fix *fix)
5926 xtensa_relax_info *relax_info;
5928 relax_info = get_xtensa_relax_info (src_sec);
5929 fix->next = relax_info->fix_list;
5930 relax_info->fix_list = fix;
5935 fix_compare (const void *ap, const void *bp)
5937 const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
5938 const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
5940 if (a->src_offset != b->src_offset)
5941 return (a->src_offset - b->src_offset);
5942 return (a->src_type - b->src_type);
5947 cache_fix_array (asection *sec)
5949 unsigned i, count = 0;
5951 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5953 if (relax_info == NULL)
5955 if (relax_info->fix_list == NULL)
5958 for (r = relax_info->fix_list; r != NULL; r = r->next)
5961 relax_info->fix_array =
5962 (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
5963 relax_info->fix_array_count = count;
5965 r = relax_info->fix_list;
5966 for (i = 0; i < count; i++, r = r->next)
5968 relax_info->fix_array[count - 1 - i] = *r;
5969 relax_info->fix_array[count - 1 - i].next = NULL;
5972 qsort (relax_info->fix_array, relax_info->fix_array_count,
5973 sizeof (reloc_bfd_fix), fix_compare);
5977 static reloc_bfd_fix *
5978 get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
5980 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5984 if (relax_info == NULL)
5986 if (relax_info->fix_list == NULL)
5989 if (relax_info->fix_array == NULL)
5990 cache_fix_array (sec);
5992 key.src_offset = offset;
5993 key.src_type = type;
5994 rv = bsearch (&key, relax_info->fix_array, relax_info->fix_array_count,
5995 sizeof (reloc_bfd_fix), fix_compare);
6000 /* Section caching. */
6002 typedef struct section_cache_struct section_cache_t;
6004 struct section_cache_struct
6008 bfd_byte *contents; /* Cache of the section contents. */
6009 bfd_size_type content_length;
6011 property_table_entry *ptbl; /* Cache of the section property table. */
6014 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6015 unsigned reloc_count;
6020 init_section_cache (section_cache_t *sec_cache)
6022 memset (sec_cache, 0, sizeof (*sec_cache));
6027 clear_section_cache (section_cache_t *sec_cache)
6031 release_contents (sec_cache->sec, sec_cache->contents);
6032 release_internal_relocs (sec_cache->sec, sec_cache->relocs);
6033 if (sec_cache->ptbl)
6034 free (sec_cache->ptbl);
6035 memset (sec_cache, 0, sizeof (sec_cache));
6041 section_cache_section (section_cache_t *sec_cache,
6043 struct bfd_link_info *link_info)
6046 property_table_entry *prop_table = NULL;
6048 bfd_byte *contents = NULL;
6049 Elf_Internal_Rela *internal_relocs = NULL;
6050 bfd_size_type sec_size;
6054 if (sec == sec_cache->sec)
6058 sec_size = bfd_get_section_limit (abfd, sec);
6060 /* Get the contents. */
6061 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6062 if (contents == NULL && sec_size != 0)
6065 /* Get the relocations. */
6066 internal_relocs = retrieve_internal_relocs (abfd, sec,
6067 link_info->keep_memory);
6069 /* Get the entry table. */
6070 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6071 XTENSA_PROP_SEC_NAME, FALSE);
6075 /* Fill in the new section cache. */
6076 clear_section_cache (sec_cache);
6077 memset (sec_cache, 0, sizeof (sec_cache));
6079 sec_cache->sec = sec;
6080 sec_cache->contents = contents;
6081 sec_cache->content_length = sec_size;
6082 sec_cache->relocs = internal_relocs;
6083 sec_cache->reloc_count = sec->reloc_count;
6084 sec_cache->pte_count = ptblsize;
6085 sec_cache->ptbl = prop_table;
6090 release_contents (sec, contents);
6091 release_internal_relocs (sec, internal_relocs);
6098 /* Extended basic blocks. */
6100 /* An ebb_struct represents an Extended Basic Block. Within this
6101 range, we guarantee that all instructions are decodable, the
6102 property table entries are contiguous, and no property table
6103 specifies a segment that cannot have instructions moved. This
6104 structure contains caches of the contents, property table and
6105 relocations for the specified section for easy use. The range is
6106 specified by ranges of indices for the byte offset, property table
6107 offsets and relocation offsets. These must be consistent. */
6109 typedef struct ebb_struct ebb_t;
6115 bfd_byte *contents; /* Cache of the section contents. */
6116 bfd_size_type content_length;
6118 property_table_entry *ptbl; /* Cache of the section property table. */
6121 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6122 unsigned reloc_count;
6124 bfd_vma start_offset; /* Offset in section. */
6125 unsigned start_ptbl_idx; /* Offset in the property table. */
6126 unsigned start_reloc_idx; /* Offset in the relocations. */
6129 unsigned end_ptbl_idx;
6130 unsigned end_reloc_idx;
6132 bfd_boolean ends_section; /* Is this the last ebb in a section? */
6134 /* The unreachable property table at the end of this set of blocks;
6135 NULL if the end is not an unreachable block. */
6136 property_table_entry *ends_unreachable;
6140 enum ebb_target_enum
6143 EBB_DESIRE_TGT_ALIGN,
6144 EBB_REQUIRE_TGT_ALIGN,
6145 EBB_REQUIRE_LOOP_ALIGN,
6150 /* proposed_action_struct is similar to the text_action_struct except
6151 that is represents a potential transformation, not one that will
6152 occur. We build a list of these for an extended basic block
6153 and use them to compute the actual actions desired. We must be
6154 careful that the entire set of actual actions we perform do not
6155 break any relocations that would fit if the actions were not
6158 typedef struct proposed_action_struct proposed_action;
6160 struct proposed_action_struct
6162 enum ebb_target_enum align_type; /* for the target alignment */
6163 bfd_vma alignment_pow;
6164 text_action_t action;
6167 bfd_boolean do_action; /* If false, then we will not perform the action. */
6171 /* The ebb_constraint_struct keeps a set of proposed actions for an
6172 extended basic block. */
6174 typedef struct ebb_constraint_struct ebb_constraint;
6176 struct ebb_constraint_struct
6179 bfd_boolean start_movable;
6181 /* Bytes of extra space at the beginning if movable. */
6182 int start_extra_space;
6184 enum ebb_target_enum start_align;
6186 bfd_boolean end_movable;
6188 /* Bytes of extra space at the end if movable. */
6189 int end_extra_space;
6191 unsigned action_count;
6192 unsigned action_allocated;
6194 /* Array of proposed actions. */
6195 proposed_action *actions;
6197 /* Action alignments -- one for each proposed action. */
6198 enum ebb_target_enum *action_aligns;
6203 init_ebb_constraint (ebb_constraint *c)
6205 memset (c, 0, sizeof (ebb_constraint));
6210 free_ebb_constraint (ebb_constraint *c)
6218 init_ebb (ebb_t *ebb,
6221 bfd_size_type content_length,
6222 property_table_entry *prop_table,
6224 Elf_Internal_Rela *internal_relocs,
6225 unsigned reloc_count)
6227 memset (ebb, 0, sizeof (ebb_t));
6229 ebb->contents = contents;
6230 ebb->content_length = content_length;
6231 ebb->ptbl = prop_table;
6232 ebb->pte_count = ptblsize;
6233 ebb->relocs = internal_relocs;
6234 ebb->reloc_count = reloc_count;
6235 ebb->start_offset = 0;
6236 ebb->end_offset = ebb->content_length - 1;
6237 ebb->start_ptbl_idx = 0;
6238 ebb->end_ptbl_idx = ptblsize;
6239 ebb->start_reloc_idx = 0;
6240 ebb->end_reloc_idx = reloc_count;
6244 /* Extend the ebb to all decodable contiguous sections. The algorithm
6245 for building a basic block around an instruction is to push it
6246 forward until we hit the end of a section, an unreachable block or
6247 a block that cannot be transformed. Then we push it backwards
6248 searching for similar conditions. */
6250 static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
6251 static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
6252 static bfd_size_type insn_block_decodable_len
6253 (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
6256 extend_ebb_bounds (ebb_t *ebb)
6258 if (!extend_ebb_bounds_forward (ebb))
6260 if (!extend_ebb_bounds_backward (ebb))
6267 extend_ebb_bounds_forward (ebb_t *ebb)
6269 property_table_entry *the_entry, *new_entry;
6271 the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6273 /* Stop when (1) we cannot decode an instruction, (2) we are at
6274 the end of the property tables, (3) we hit a non-contiguous property
6275 table entry, (4) we hit a NO_TRANSFORM region. */
6280 bfd_size_type insn_block_len;
6282 entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
6284 insn_block_decodable_len (ebb->contents, ebb->content_length,
6286 entry_end - ebb->end_offset);
6287 if (insn_block_len != (entry_end - ebb->end_offset))
6289 (*_bfd_error_handler)
6290 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6291 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6294 ebb->end_offset += insn_block_len;
6296 if (ebb->end_offset == ebb->sec->size)
6297 ebb->ends_section = TRUE;
6299 /* Update the reloc counter. */
6300 while (ebb->end_reloc_idx + 1 < ebb->reloc_count
6301 && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
6304 ebb->end_reloc_idx++;
6307 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6310 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6311 if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
6312 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6313 || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
6316 if (the_entry->address + the_entry->size != new_entry->address)
6319 the_entry = new_entry;
6320 ebb->end_ptbl_idx++;
6323 /* Quick check for an unreachable or end of file just at the end. */
6324 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6326 if (ebb->end_offset == ebb->content_length)
6327 ebb->ends_section = TRUE;
6331 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6332 if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
6333 && the_entry->address + the_entry->size == new_entry->address)
6334 ebb->ends_unreachable = new_entry;
6337 /* Any other ending requires exact alignment. */
6343 extend_ebb_bounds_backward (ebb_t *ebb)
6345 property_table_entry *the_entry, *new_entry;
6347 the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6349 /* Stop when (1) we cannot decode the instructions in the current entry.
6350 (2) we are at the beginning of the property tables, (3) we hit a
6351 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6355 bfd_vma block_begin;
6356 bfd_size_type insn_block_len;
6358 block_begin = the_entry->address - ebb->sec->vma;
6360 insn_block_decodable_len (ebb->contents, ebb->content_length,
6362 ebb->start_offset - block_begin);
6363 if (insn_block_len != ebb->start_offset - block_begin)
6365 (*_bfd_error_handler)
6366 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6367 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6370 ebb->start_offset -= insn_block_len;
6372 /* Update the reloc counter. */
6373 while (ebb->start_reloc_idx > 0
6374 && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
6375 >= ebb->start_offset))
6377 ebb->start_reloc_idx--;
6380 if (ebb->start_ptbl_idx == 0)
6383 new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
6384 if ((new_entry->flags & XTENSA_PROP_INSN) == 0
6385 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6386 || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
6388 if (new_entry->address + new_entry->size != the_entry->address)
6391 the_entry = new_entry;
6392 ebb->start_ptbl_idx--;
6398 static bfd_size_type
6399 insn_block_decodable_len (bfd_byte *contents,
6400 bfd_size_type content_len,
6401 bfd_vma block_offset,
6402 bfd_size_type block_len)
6404 bfd_vma offset = block_offset;
6406 while (offset < block_offset + block_len)
6408 bfd_size_type insn_len = 0;
6410 insn_len = insn_decode_len (contents, content_len, offset);
6412 return (offset - block_offset);
6415 return (offset - block_offset);
6420 ebb_propose_action (ebb_constraint *c,
6421 enum ebb_target_enum align_type,
6422 bfd_vma alignment_pow,
6423 text_action_t action,
6426 bfd_boolean do_action)
6428 proposed_action *act;
6430 if (c->action_allocated <= c->action_count)
6432 unsigned new_allocated, i;
6433 proposed_action *new_actions;
6435 new_allocated = (c->action_count + 2) * 2;
6436 new_actions = (proposed_action *)
6437 bfd_zmalloc (sizeof (proposed_action) * new_allocated);
6439 for (i = 0; i < c->action_count; i++)
6440 new_actions[i] = c->actions[i];
6443 c->actions = new_actions;
6444 c->action_allocated = new_allocated;
6447 act = &c->actions[c->action_count];
6448 act->align_type = align_type;
6449 act->alignment_pow = alignment_pow;
6450 act->action = action;
6451 act->offset = offset;
6452 act->removed_bytes = removed_bytes;
6453 act->do_action = do_action;
6459 /* Access to internal relocations, section contents and symbols. */
6461 /* During relaxation, we need to modify relocations, section contents,
6462 and symbol definitions, and we need to keep the original values from
6463 being reloaded from the input files, i.e., we need to "pin" the
6464 modified values in memory. We also want to continue to observe the
6465 setting of the "keep-memory" flag. The following functions wrap the
6466 standard BFD functions to take care of this for us. */
6468 static Elf_Internal_Rela *
6469 retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6471 Elf_Internal_Rela *internal_relocs;
6473 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6476 internal_relocs = elf_section_data (sec)->relocs;
6477 if (internal_relocs == NULL)
6478 internal_relocs = (_bfd_elf_link_read_relocs
6479 (abfd, sec, NULL, NULL, keep_memory));
6480 return internal_relocs;
6485 pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6487 elf_section_data (sec)->relocs = internal_relocs;
6492 release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6495 && elf_section_data (sec)->relocs != internal_relocs)
6496 free (internal_relocs);
6501 retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6504 bfd_size_type sec_size;
6506 sec_size = bfd_get_section_limit (abfd, sec);
6507 contents = elf_section_data (sec)->this_hdr.contents;
6509 if (contents == NULL && sec_size != 0)
6511 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
6518 elf_section_data (sec)->this_hdr.contents = contents;
6525 pin_contents (asection *sec, bfd_byte *contents)
6527 elf_section_data (sec)->this_hdr.contents = contents;
6532 release_contents (asection *sec, bfd_byte *contents)
6534 if (contents && elf_section_data (sec)->this_hdr.contents != contents)
6539 static Elf_Internal_Sym *
6540 retrieve_local_syms (bfd *input_bfd)
6542 Elf_Internal_Shdr *symtab_hdr;
6543 Elf_Internal_Sym *isymbuf;
6546 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6547 locsymcount = symtab_hdr->sh_info;
6549 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6550 if (isymbuf == NULL && locsymcount != 0)
6551 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
6554 /* Save the symbols for this input file so they won't be read again. */
6555 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
6556 symtab_hdr->contents = (unsigned char *) isymbuf;
6562 /* Code for link-time relaxation. */
6564 /* Initialization for relaxation: */
6565 static bfd_boolean analyze_relocations (struct bfd_link_info *);
6566 static bfd_boolean find_relaxable_sections
6567 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
6568 static bfd_boolean collect_source_relocs
6569 (bfd *, asection *, struct bfd_link_info *);
6570 static bfd_boolean is_resolvable_asm_expansion
6571 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
6573 static Elf_Internal_Rela *find_associated_l32r_irel
6574 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
6575 static bfd_boolean compute_text_actions
6576 (bfd *, asection *, struct bfd_link_info *);
6577 static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
6578 static bfd_boolean compute_ebb_actions (ebb_constraint *);
6579 static bfd_boolean check_section_ebb_pcrels_fit
6580 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, const ebb_constraint *,
6581 const xtensa_opcode *);
6582 static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
6583 static void text_action_add_proposed
6584 (text_action_list *, const ebb_constraint *, asection *);
6585 static int compute_fill_extra_space (property_table_entry *);
6588 static bfd_boolean compute_removed_literals
6589 (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
6590 static Elf_Internal_Rela *get_irel_at_offset
6591 (asection *, Elf_Internal_Rela *, bfd_vma);
6592 static bfd_boolean is_removable_literal
6593 (const source_reloc *, int, const source_reloc *, int, asection *,
6594 property_table_entry *, int);
6595 static bfd_boolean remove_dead_literal
6596 (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
6597 Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
6598 static bfd_boolean identify_literal_placement
6599 (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
6600 value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
6601 source_reloc *, property_table_entry *, int, section_cache_t *,
6603 static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
6604 static bfd_boolean coalesce_shared_literal
6605 (asection *, source_reloc *, property_table_entry *, int, value_map *);
6606 static bfd_boolean move_shared_literal
6607 (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
6608 int, const r_reloc *, const literal_value *, section_cache_t *);
6611 static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
6612 static bfd_boolean translate_section_fixes (asection *);
6613 static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
6614 static asection *translate_reloc (const r_reloc *, r_reloc *, asection *);
6615 static void shrink_dynamic_reloc_sections
6616 (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
6617 static bfd_boolean move_literal
6618 (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
6619 xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
6620 static bfd_boolean relax_property_section
6621 (bfd *, asection *, struct bfd_link_info *);
6624 static bfd_boolean relax_section_symbols (bfd *, asection *);
6628 elf_xtensa_relax_section (bfd *abfd,
6630 struct bfd_link_info *link_info,
6633 static value_map_hash_table *values = NULL;
6634 static bfd_boolean relocations_analyzed = FALSE;
6635 xtensa_relax_info *relax_info;
6637 if (link_info->relocatable)
6638 (*link_info->callbacks->einfo)
6639 (_("%P%F: --relax and -r may not be used together\n"));
6641 if (!relocations_analyzed)
6643 /* Do some overall initialization for relaxation. */
6644 values = value_map_hash_table_init ();
6647 relaxing_section = TRUE;
6648 if (!analyze_relocations (link_info))
6650 relocations_analyzed = TRUE;
6654 /* Don't mess with linker-created sections. */
6655 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6658 relax_info = get_xtensa_relax_info (sec);
6659 BFD_ASSERT (relax_info != NULL);
6661 switch (relax_info->visited)
6664 /* Note: It would be nice to fold this pass into
6665 analyze_relocations, but it is important for this step that the
6666 sections be examined in link order. */
6667 if (!compute_removed_literals (abfd, sec, link_info, values))
6674 value_map_hash_table_delete (values);
6676 if (!relax_section (abfd, sec, link_info))
6682 if (!relax_section_symbols (abfd, sec))
6687 relax_info->visited++;
6692 /* Initialization for relaxation. */
6694 /* This function is called once at the start of relaxation. It scans
6695 all the input sections and marks the ones that are relaxable (i.e.,
6696 literal sections with L32R relocations against them), and then
6697 collects source_reloc information for all the relocations against
6698 those relaxable sections. During this process, it also detects
6699 longcalls, i.e., calls relaxed by the assembler into indirect
6700 calls, that can be optimized back into direct calls. Within each
6701 extended basic block (ebb) containing an optimized longcall, it
6702 computes a set of "text actions" that can be performed to remove
6703 the L32R associated with the longcall while optionally preserving
6704 branch target alignments. */
6707 analyze_relocations (struct bfd_link_info *link_info)
6711 bfd_boolean is_relaxable = FALSE;
6713 /* Initialize the per-section relaxation info. */
6714 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6715 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6717 init_xtensa_relax_info (sec);
6720 /* Mark relaxable sections (and count relocations against each one). */
6721 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6722 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6724 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
6728 /* Bail out if there are no relaxable sections. */
6732 /* Allocate space for source_relocs. */
6733 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6734 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6736 xtensa_relax_info *relax_info;
6738 relax_info = get_xtensa_relax_info (sec);
6739 if (relax_info->is_relaxable_literal_section
6740 || relax_info->is_relaxable_asm_section)
6742 relax_info->src_relocs = (source_reloc *)
6743 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
6746 relax_info->src_count = 0;
6749 /* Collect info on relocations against each relaxable section. */
6750 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6751 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6753 if (!collect_source_relocs (abfd, sec, link_info))
6757 /* Compute the text actions. */
6758 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6759 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6761 if (!compute_text_actions (abfd, sec, link_info))
6769 /* Find all the sections that might be relaxed. The motivation for
6770 this pass is that collect_source_relocs() needs to record _all_ the
6771 relocations that target each relaxable section. That is expensive
6772 and unnecessary unless the target section is actually going to be
6773 relaxed. This pass identifies all such sections by checking if
6774 they have L32Rs pointing to them. In the process, the total number
6775 of relocations targeting each section is also counted so that we
6776 know how much space to allocate for source_relocs against each
6777 relaxable literal section. */
6780 find_relaxable_sections (bfd *abfd,
6782 struct bfd_link_info *link_info,
6783 bfd_boolean *is_relaxable_p)
6785 Elf_Internal_Rela *internal_relocs;
6787 bfd_boolean ok = TRUE;
6789 xtensa_relax_info *source_relax_info;
6790 bfd_boolean is_l32r_reloc;
6792 internal_relocs = retrieve_internal_relocs (abfd, sec,
6793 link_info->keep_memory);
6794 if (internal_relocs == NULL)
6797 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6798 if (contents == NULL && sec->size != 0)
6804 source_relax_info = get_xtensa_relax_info (sec);
6805 for (i = 0; i < sec->reloc_count; i++)
6807 Elf_Internal_Rela *irel = &internal_relocs[i];
6809 asection *target_sec;
6810 xtensa_relax_info *target_relax_info;
6812 /* If this section has not already been marked as "relaxable", and
6813 if it contains any ASM_EXPAND relocations (marking expanded
6814 longcalls) that can be optimized into direct calls, then mark
6815 the section as "relaxable". */
6816 if (source_relax_info
6817 && !source_relax_info->is_relaxable_asm_section
6818 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
6820 bfd_boolean is_reachable = FALSE;
6821 if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
6822 link_info, &is_reachable)
6825 source_relax_info->is_relaxable_asm_section = TRUE;
6826 *is_relaxable_p = TRUE;
6830 r_reloc_init (&r_rel, abfd, irel, contents,
6831 bfd_get_section_limit (abfd, sec));
6833 target_sec = r_reloc_get_section (&r_rel);
6834 target_relax_info = get_xtensa_relax_info (target_sec);
6835 if (!target_relax_info)
6838 /* Count PC-relative operand relocations against the target section.
6839 Note: The conditions tested here must match the conditions under
6840 which init_source_reloc is called in collect_source_relocs(). */
6841 is_l32r_reloc = FALSE;
6842 if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6844 xtensa_opcode opcode =
6845 get_relocation_opcode (abfd, sec, contents, irel);
6846 if (opcode != XTENSA_UNDEFINED)
6848 is_l32r_reloc = (opcode == get_l32r_opcode ());
6849 if (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
6851 target_relax_info->src_count++;
6855 if (is_l32r_reloc && r_reloc_is_defined (&r_rel))
6857 /* Mark the target section as relaxable. */
6858 target_relax_info->is_relaxable_literal_section = TRUE;
6859 *is_relaxable_p = TRUE;
6864 release_contents (sec, contents);
6865 release_internal_relocs (sec, internal_relocs);
6870 /* Record _all_ the relocations that point to relaxable sections, and
6871 get rid of ASM_EXPAND relocs by either converting them to
6872 ASM_SIMPLIFY or by removing them. */
6875 collect_source_relocs (bfd *abfd,
6877 struct bfd_link_info *link_info)
6879 Elf_Internal_Rela *internal_relocs;
6881 bfd_boolean ok = TRUE;
6883 bfd_size_type sec_size;
6885 internal_relocs = retrieve_internal_relocs (abfd, sec,
6886 link_info->keep_memory);
6887 if (internal_relocs == NULL)
6890 sec_size = bfd_get_section_limit (abfd, sec);
6891 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6892 if (contents == NULL && sec_size != 0)
6898 /* Record relocations against relaxable literal sections. */
6899 for (i = 0; i < sec->reloc_count; i++)
6901 Elf_Internal_Rela *irel = &internal_relocs[i];
6903 asection *target_sec;
6904 xtensa_relax_info *target_relax_info;
6906 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6908 target_sec = r_reloc_get_section (&r_rel);
6909 target_relax_info = get_xtensa_relax_info (target_sec);
6911 if (target_relax_info
6912 && (target_relax_info->is_relaxable_literal_section
6913 || target_relax_info->is_relaxable_asm_section))
6915 xtensa_opcode opcode = XTENSA_UNDEFINED;
6917 bfd_boolean is_abs_literal = FALSE;
6919 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
6921 /* None of the current alternate relocs are PC-relative,
6922 and only PC-relative relocs matter here. However, we
6923 still need to record the opcode for literal
6925 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6926 if (opcode == get_l32r_opcode ())
6928 is_abs_literal = TRUE;
6932 opcode = XTENSA_UNDEFINED;
6934 else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6936 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6937 opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
6940 if (opcode != XTENSA_UNDEFINED)
6942 int src_next = target_relax_info->src_next++;
6943 source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
6945 init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
6951 /* Now get rid of ASM_EXPAND relocations. At this point, the
6952 src_relocs array for the target literal section may still be
6953 incomplete, but it must at least contain the entries for the L32R
6954 relocations associated with ASM_EXPANDs because they were just
6955 added in the preceding loop over the relocations. */
6957 for (i = 0; i < sec->reloc_count; i++)
6959 Elf_Internal_Rela *irel = &internal_relocs[i];
6960 bfd_boolean is_reachable;
6962 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
6968 Elf_Internal_Rela *l32r_irel;
6970 asection *target_sec;
6971 xtensa_relax_info *target_relax_info;
6973 /* Mark the source_reloc for the L32R so that it will be
6974 removed in compute_removed_literals(), along with the
6975 associated literal. */
6976 l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
6977 irel, internal_relocs);
6978 if (l32r_irel == NULL)
6981 r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
6983 target_sec = r_reloc_get_section (&r_rel);
6984 target_relax_info = get_xtensa_relax_info (target_sec);
6986 if (target_relax_info
6987 && (target_relax_info->is_relaxable_literal_section
6988 || target_relax_info->is_relaxable_asm_section))
6990 source_reloc *s_reloc;
6992 /* Search the source_relocs for the entry corresponding to
6993 the l32r_irel. Note: The src_relocs array is not yet
6994 sorted, but it wouldn't matter anyway because we're
6995 searching by source offset instead of target offset. */
6996 s_reloc = find_source_reloc (target_relax_info->src_relocs,
6997 target_relax_info->src_next,
6999 BFD_ASSERT (s_reloc);
7000 s_reloc->is_null = TRUE;
7003 /* Convert this reloc to ASM_SIMPLIFY. */
7004 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7005 R_XTENSA_ASM_SIMPLIFY);
7006 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7008 pin_internal_relocs (sec, internal_relocs);
7012 /* It is resolvable but doesn't reach. We resolve now
7013 by eliminating the relocation -- the call will remain
7014 expanded into L32R/CALLX. */
7015 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7016 pin_internal_relocs (sec, internal_relocs);
7021 release_contents (sec, contents);
7022 release_internal_relocs (sec, internal_relocs);
7027 /* Return TRUE if the asm expansion can be resolved. Generally it can
7028 be resolved on a final link or when a partial link locates it in the
7029 same section as the target. Set "is_reachable" flag if the target of
7030 the call is within the range of a direct call, given the current VMA
7031 for this section and the target section. */
7034 is_resolvable_asm_expansion (bfd *abfd,
7037 Elf_Internal_Rela *irel,
7038 struct bfd_link_info *link_info,
7039 bfd_boolean *is_reachable_p)
7041 asection *target_sec;
7042 bfd_vma target_offset;
7044 xtensa_opcode opcode, direct_call_opcode;
7045 bfd_vma self_address;
7046 bfd_vma dest_address;
7047 bfd_boolean uses_l32r;
7048 bfd_size_type sec_size;
7050 *is_reachable_p = FALSE;
7052 if (contents == NULL)
7055 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
7058 sec_size = bfd_get_section_limit (abfd, sec);
7059 opcode = get_expanded_call_opcode (contents + irel->r_offset,
7060 sec_size - irel->r_offset, &uses_l32r);
7061 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7065 direct_call_opcode = swap_callx_for_call_opcode (opcode);
7066 if (direct_call_opcode == XTENSA_UNDEFINED)
7069 /* Check and see that the target resolves. */
7070 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7071 if (!r_reloc_is_defined (&r_rel))
7074 target_sec = r_reloc_get_section (&r_rel);
7075 target_offset = r_rel.target_offset;
7077 /* If the target is in a shared library, then it doesn't reach. This
7078 isn't supposed to come up because the compiler should never generate
7079 non-PIC calls on systems that use shared libraries, but the linker
7080 shouldn't crash regardless. */
7081 if (!target_sec->output_section)
7084 /* For relocatable sections, we can only simplify when the output
7085 section of the target is the same as the output section of the
7087 if (link_info->relocatable
7088 && (target_sec->output_section != sec->output_section
7089 || is_reloc_sym_weak (abfd, irel)))
7092 self_address = (sec->output_section->vma
7093 + sec->output_offset + irel->r_offset + 3);
7094 dest_address = (target_sec->output_section->vma
7095 + target_sec->output_offset + target_offset);
7097 *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
7098 self_address, dest_address);
7100 if ((self_address >> CALL_SEGMENT_BITS) !=
7101 (dest_address >> CALL_SEGMENT_BITS))
7108 static Elf_Internal_Rela *
7109 find_associated_l32r_irel (bfd *abfd,
7112 Elf_Internal_Rela *other_irel,
7113 Elf_Internal_Rela *internal_relocs)
7117 for (i = 0; i < sec->reloc_count; i++)
7119 Elf_Internal_Rela *irel = &internal_relocs[i];
7121 if (irel == other_irel)
7123 if (irel->r_offset != other_irel->r_offset)
7125 if (is_l32r_relocation (abfd, sec, contents, irel))
7133 static xtensa_opcode *
7134 build_reloc_opcodes (bfd *abfd,
7137 Elf_Internal_Rela *internal_relocs)
7140 xtensa_opcode *reloc_opcodes =
7141 (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
7142 for (i = 0; i < sec->reloc_count; i++)
7144 Elf_Internal_Rela *irel = &internal_relocs[i];
7145 reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
7147 return reloc_opcodes;
7151 /* The compute_text_actions function will build a list of potential
7152 transformation actions for code in the extended basic block of each
7153 longcall that is optimized to a direct call. From this list we
7154 generate a set of actions to actually perform that optimizes for
7155 space and, if not using size_opt, maintains branch target
7158 These actions to be performed are placed on a per-section list.
7159 The actual changes are performed by relax_section() in the second
7163 compute_text_actions (bfd *abfd,
7165 struct bfd_link_info *link_info)
7167 xtensa_opcode *reloc_opcodes = NULL;
7168 xtensa_relax_info *relax_info;
7170 Elf_Internal_Rela *internal_relocs;
7171 bfd_boolean ok = TRUE;
7173 property_table_entry *prop_table = 0;
7175 bfd_size_type sec_size;
7177 relax_info = get_xtensa_relax_info (sec);
7178 BFD_ASSERT (relax_info);
7179 BFD_ASSERT (relax_info->src_next == relax_info->src_count);
7181 /* Do nothing if the section contains no optimized longcalls. */
7182 if (!relax_info->is_relaxable_asm_section)
7185 internal_relocs = retrieve_internal_relocs (abfd, sec,
7186 link_info->keep_memory);
7188 if (internal_relocs)
7189 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7190 internal_reloc_compare);
7192 sec_size = bfd_get_section_limit (abfd, sec);
7193 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7194 if (contents == NULL && sec_size != 0)
7200 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7201 XTENSA_PROP_SEC_NAME, FALSE);
7208 for (i = 0; i < sec->reloc_count; i++)
7210 Elf_Internal_Rela *irel = &internal_relocs[i];
7212 property_table_entry *the_entry;
7215 ebb_constraint ebb_table;
7216 bfd_size_type simplify_size;
7218 if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
7220 r_offset = irel->r_offset;
7222 simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
7223 if (simplify_size == 0)
7225 (*_bfd_error_handler)
7226 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
7227 sec->owner, sec, r_offset);
7231 /* If the instruction table is not around, then don't do this
7233 the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7234 sec->vma + irel->r_offset);
7235 if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
7237 text_action_add (&relax_info->action_list,
7238 ta_convert_longcall, sec, r_offset,
7243 /* If the next longcall happens to be at the same address as an
7244 unreachable section of size 0, then skip forward. */
7245 ptbl_idx = the_entry - prop_table;
7246 while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
7247 && the_entry->size == 0
7248 && ptbl_idx + 1 < ptblsize
7249 && (prop_table[ptbl_idx + 1].address
7250 == prop_table[ptbl_idx].address))
7256 if (the_entry->flags & XTENSA_PROP_NO_TRANSFORM)
7257 /* NO_REORDER is OK */
7260 init_ebb_constraint (&ebb_table);
7261 ebb = &ebb_table.ebb;
7262 init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
7263 internal_relocs, sec->reloc_count);
7264 ebb->start_offset = r_offset + simplify_size;
7265 ebb->end_offset = r_offset + simplify_size;
7266 ebb->start_ptbl_idx = ptbl_idx;
7267 ebb->end_ptbl_idx = ptbl_idx;
7268 ebb->start_reloc_idx = i;
7269 ebb->end_reloc_idx = i;
7271 /* Precompute the opcode for each relocation. */
7272 if (reloc_opcodes == NULL)
7273 reloc_opcodes = build_reloc_opcodes (abfd, sec, contents,
7276 if (!extend_ebb_bounds (ebb)
7277 || !compute_ebb_proposed_actions (&ebb_table)
7278 || !compute_ebb_actions (&ebb_table)
7279 || !check_section_ebb_pcrels_fit (abfd, sec, contents,
7280 internal_relocs, &ebb_table,
7282 || !check_section_ebb_reduces (&ebb_table))
7284 /* If anything goes wrong or we get unlucky and something does
7285 not fit, with our plan because of expansion between
7286 critical branches, just convert to a NOP. */
7288 text_action_add (&relax_info->action_list,
7289 ta_convert_longcall, sec, r_offset, 0);
7290 i = ebb_table.ebb.end_reloc_idx;
7291 free_ebb_constraint (&ebb_table);
7295 text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
7297 /* Update the index so we do not go looking at the relocations
7298 we have already processed. */
7299 i = ebb_table.ebb.end_reloc_idx;
7300 free_ebb_constraint (&ebb_table);
7304 if (relax_info->action_list.head)
7305 print_action_list (stderr, &relax_info->action_list);
7309 release_contents (sec, contents);
7310 release_internal_relocs (sec, internal_relocs);
7314 free (reloc_opcodes);
7320 /* Do not widen an instruction if it is preceeded by a
7321 loop opcode. It might cause misalignment. */
7324 prev_instr_is_a_loop (bfd_byte *contents,
7325 bfd_size_type content_length,
7326 bfd_size_type offset)
7328 xtensa_opcode prev_opcode;
7332 prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
7333 return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
7337 /* Find all of the possible actions for an extended basic block. */
7340 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
7342 const ebb_t *ebb = &ebb_table->ebb;
7343 unsigned rel_idx = ebb->start_reloc_idx;
7344 property_table_entry *entry, *start_entry, *end_entry;
7346 xtensa_isa isa = xtensa_default_isa;
7348 static xtensa_insnbuf insnbuf = NULL;
7349 static xtensa_insnbuf slotbuf = NULL;
7351 if (insnbuf == NULL)
7353 insnbuf = xtensa_insnbuf_alloc (isa);
7354 slotbuf = xtensa_insnbuf_alloc (isa);
7357 start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
7358 end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
7360 for (entry = start_entry; entry <= end_entry; entry++)
7362 bfd_vma start_offset, end_offset;
7363 bfd_size_type insn_len;
7365 start_offset = entry->address - ebb->sec->vma;
7366 end_offset = entry->address + entry->size - ebb->sec->vma;
7368 if (entry == start_entry)
7369 start_offset = ebb->start_offset;
7370 if (entry == end_entry)
7371 end_offset = ebb->end_offset;
7372 offset = start_offset;
7374 if (offset == entry->address - ebb->sec->vma
7375 && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
7377 enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
7378 BFD_ASSERT (offset != end_offset);
7379 if (offset == end_offset)
7382 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
7387 if (check_branch_target_aligned_address (offset, insn_len))
7388 align_type = EBB_REQUIRE_TGT_ALIGN;
7390 ebb_propose_action (ebb_table, align_type, 0,
7391 ta_none, offset, 0, TRUE);
7394 while (offset != end_offset)
7396 Elf_Internal_Rela *irel;
7397 xtensa_opcode opcode;
7399 while (rel_idx < ebb->end_reloc_idx
7400 && (ebb->relocs[rel_idx].r_offset < offset
7401 || (ebb->relocs[rel_idx].r_offset == offset
7402 && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
7403 != R_XTENSA_ASM_SIMPLIFY))))
7406 /* Check for longcall. */
7407 irel = &ebb->relocs[rel_idx];
7408 if (irel->r_offset == offset
7409 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
7411 bfd_size_type simplify_size;
7413 simplify_size = get_asm_simplify_size (ebb->contents,
7414 ebb->content_length,
7416 if (simplify_size == 0)
7419 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7420 ta_convert_longcall, offset, 0, TRUE);
7422 offset += simplify_size;
7426 if (offset + MIN_INSN_LENGTH > ebb->content_length)
7428 xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
7429 ebb->content_length - offset);
7430 fmt = xtensa_format_decode (isa, insnbuf);
7431 if (fmt == XTENSA_UNDEFINED)
7433 insn_len = xtensa_format_length (isa, fmt);
7434 if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
7437 if (xtensa_format_num_slots (isa, fmt) != 1)
7443 xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7444 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7445 if (opcode == XTENSA_UNDEFINED)
7448 if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
7449 && (entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7450 && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
7452 /* Add an instruction narrow action. */
7453 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7454 ta_narrow_insn, offset, 0, FALSE);
7456 else if ((entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7457 && can_widen_instruction (slotbuf, fmt, opcode) != 0
7458 && ! prev_instr_is_a_loop (ebb->contents,
7459 ebb->content_length, offset))
7461 /* Add an instruction widen action. */
7462 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7463 ta_widen_insn, offset, 0, FALSE);
7465 else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
7467 /* Check for branch targets. */
7468 ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
7469 ta_none, offset, 0, TRUE);
7476 if (ebb->ends_unreachable)
7478 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7479 ta_fill, ebb->end_offset, 0, TRUE);
7485 (*_bfd_error_handler)
7486 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
7487 ebb->sec->owner, ebb->sec, offset);
7492 /* After all of the information has collected about the
7493 transformations possible in an EBB, compute the appropriate actions
7494 here in compute_ebb_actions. We still must check later to make
7495 sure that the actions do not break any relocations. The algorithm
7496 used here is pretty greedy. Basically, it removes as many no-ops
7497 as possible so that the end of the EBB has the same alignment
7498 characteristics as the original. First, it uses narrowing, then
7499 fill space at the end of the EBB, and finally widenings. If that
7500 does not work, it tries again with one fewer no-op removed. The
7501 optimization will only be performed if all of the branch targets
7502 that were aligned before transformation are also aligned after the
7505 When the size_opt flag is set, ignore the branch target alignments,
7506 narrow all wide instructions, and remove all no-ops unless the end
7507 of the EBB prevents it. */
7510 compute_ebb_actions (ebb_constraint *ebb_table)
7514 int removed_bytes = 0;
7515 ebb_t *ebb = &ebb_table->ebb;
7516 unsigned seg_idx_start = 0;
7517 unsigned seg_idx_end = 0;
7519 /* We perform this like the assembler relaxation algorithm: Start by
7520 assuming all instructions are narrow and all no-ops removed; then
7523 /* For each segment of this that has a solid constraint, check to
7524 see if there are any combinations that will keep the constraint.
7526 for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
7528 bfd_boolean requires_text_end_align = FALSE;
7529 unsigned longcall_count = 0;
7530 unsigned longcall_convert_count = 0;
7531 unsigned narrowable_count = 0;
7532 unsigned narrowable_convert_count = 0;
7533 unsigned widenable_count = 0;
7534 unsigned widenable_convert_count = 0;
7536 proposed_action *action = NULL;
7537 int align = (1 << ebb_table->ebb.sec->alignment_power);
7539 seg_idx_start = seg_idx_end;
7541 for (i = seg_idx_start; i < ebb_table->action_count; i++)
7543 action = &ebb_table->actions[i];
7544 if (action->action == ta_convert_longcall)
7546 if (action->action == ta_narrow_insn)
7548 if (action->action == ta_widen_insn)
7550 if (action->action == ta_fill)
7552 if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
7554 if (action->align_type == EBB_REQUIRE_TGT_ALIGN
7555 && !elf32xtensa_size_opt)
7560 if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
7561 requires_text_end_align = TRUE;
7563 if (elf32xtensa_size_opt && !requires_text_end_align
7564 && action->align_type != EBB_REQUIRE_LOOP_ALIGN
7565 && action->align_type != EBB_REQUIRE_TGT_ALIGN)
7567 longcall_convert_count = longcall_count;
7568 narrowable_convert_count = narrowable_count;
7569 widenable_convert_count = 0;
7573 /* There is a constraint. Convert the max number of longcalls. */
7574 narrowable_convert_count = 0;
7575 longcall_convert_count = 0;
7576 widenable_convert_count = 0;
7578 for (j = 0; j < longcall_count; j++)
7580 int removed = (longcall_count - j) * 3 & (align - 1);
7581 unsigned desire_narrow = (align - removed) & (align - 1);
7582 unsigned desire_widen = removed;
7583 if (desire_narrow <= narrowable_count)
7585 narrowable_convert_count = desire_narrow;
7586 narrowable_convert_count +=
7587 (align * ((narrowable_count - narrowable_convert_count)
7589 longcall_convert_count = (longcall_count - j);
7590 widenable_convert_count = 0;
7593 if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
7595 narrowable_convert_count = 0;
7596 longcall_convert_count = longcall_count - j;
7597 widenable_convert_count = desire_widen;
7603 /* Now the number of conversions are saved. Do them. */
7604 for (i = seg_idx_start; i < seg_idx_end; i++)
7606 action = &ebb_table->actions[i];
7607 switch (action->action)
7609 case ta_convert_longcall:
7610 if (longcall_convert_count != 0)
7612 action->action = ta_remove_longcall;
7613 action->do_action = TRUE;
7614 action->removed_bytes += 3;
7615 longcall_convert_count--;
7618 case ta_narrow_insn:
7619 if (narrowable_convert_count != 0)
7621 action->do_action = TRUE;
7622 action->removed_bytes += 1;
7623 narrowable_convert_count--;
7627 if (widenable_convert_count != 0)
7629 action->do_action = TRUE;
7630 action->removed_bytes -= 1;
7631 widenable_convert_count--;
7640 /* Now we move on to some local opts. Try to remove each of the
7641 remaining longcalls. */
7643 if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
7646 for (i = 0; i < ebb_table->action_count; i++)
7648 int old_removed_bytes = removed_bytes;
7649 proposed_action *action = &ebb_table->actions[i];
7651 if (action->do_action && action->action == ta_convert_longcall)
7653 bfd_boolean bad_alignment = FALSE;
7655 for (j = i + 1; j < ebb_table->action_count; j++)
7657 proposed_action *new_action = &ebb_table->actions[j];
7658 bfd_vma offset = new_action->offset;
7659 if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
7661 if (!check_branch_target_aligned
7662 (ebb_table->ebb.contents,
7663 ebb_table->ebb.content_length,
7664 offset, offset - removed_bytes))
7666 bad_alignment = TRUE;
7670 if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
7672 if (!check_loop_aligned (ebb_table->ebb.contents,
7673 ebb_table->ebb.content_length,
7675 offset - removed_bytes))
7677 bad_alignment = TRUE;
7681 if (new_action->action == ta_narrow_insn
7682 && !new_action->do_action
7683 && ebb_table->ebb.sec->alignment_power == 2)
7685 /* Narrow an instruction and we are done. */
7686 new_action->do_action = TRUE;
7687 new_action->removed_bytes += 1;
7688 bad_alignment = FALSE;
7691 if (new_action->action == ta_widen_insn
7692 && new_action->do_action
7693 && ebb_table->ebb.sec->alignment_power == 2)
7695 /* Narrow an instruction and we are done. */
7696 new_action->do_action = FALSE;
7697 new_action->removed_bytes += 1;
7698 bad_alignment = FALSE;
7701 if (new_action->do_action)
7702 removed_bytes += new_action->removed_bytes;
7706 action->removed_bytes += 3;
7707 action->action = ta_remove_longcall;
7708 action->do_action = TRUE;
7711 removed_bytes = old_removed_bytes;
7712 if (action->do_action)
7713 removed_bytes += action->removed_bytes;
7718 for (i = 0; i < ebb_table->action_count; ++i)
7720 proposed_action *action = &ebb_table->actions[i];
7721 if (action->do_action)
7722 removed_bytes += action->removed_bytes;
7725 if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
7726 && ebb->ends_unreachable)
7728 proposed_action *action;
7732 BFD_ASSERT (ebb_table->action_count != 0);
7733 action = &ebb_table->actions[ebb_table->action_count - 1];
7734 BFD_ASSERT (action->action == ta_fill);
7735 BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
7737 extra_space = compute_fill_extra_space (ebb->ends_unreachable);
7738 br = action->removed_bytes + removed_bytes + extra_space;
7739 br = br & ((1 << ebb->sec->alignment_power ) - 1);
7741 action->removed_bytes = extra_space - br;
7747 /* The xlate_map is a sorted array of address mappings designed to
7748 answer the offset_with_removed_text() query with a binary search instead
7749 of a linear search through the section's action_list. */
7751 typedef struct xlate_map_entry xlate_map_entry_t;
7752 typedef struct xlate_map xlate_map_t;
7754 struct xlate_map_entry
7756 unsigned orig_address;
7757 unsigned new_address;
7763 unsigned entry_count;
7764 xlate_map_entry_t *entry;
7769 xlate_compare (const void *a_v, const void *b_v)
7771 const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
7772 const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
7773 if (a->orig_address < b->orig_address)
7775 if (a->orig_address > (b->orig_address + b->size - 1))
7782 xlate_offset_with_removed_text (const xlate_map_t *map,
7783 text_action_list *action_list,
7786 xlate_map_entry_t tmp;
7788 xlate_map_entry_t *e;
7791 return offset_with_removed_text (action_list, offset);
7793 if (map->entry_count == 0)
7796 tmp.orig_address = offset;
7797 tmp.new_address = offset;
7800 r = bsearch (&offset, map->entry, map->entry_count,
7801 sizeof (xlate_map_entry_t), &xlate_compare);
7802 e = (xlate_map_entry_t *) r;
7804 BFD_ASSERT (e != NULL);
7807 return e->new_address - e->orig_address + offset;
7811 /* Build a binary searchable offset translation map from a section's
7814 static xlate_map_t *
7815 build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
7817 xlate_map_t *map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
7818 text_action_list *action_list = &relax_info->action_list;
7819 unsigned num_actions = 0;
7822 xlate_map_entry_t *current_entry;
7827 num_actions = action_list_count (action_list);
7828 map->entry = (xlate_map_entry_t *)
7829 bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
7830 if (map->entry == NULL)
7835 map->entry_count = 0;
7838 current_entry = &map->entry[0];
7840 current_entry->orig_address = 0;
7841 current_entry->new_address = 0;
7842 current_entry->size = 0;
7844 for (r = action_list->head; r != NULL; r = r->next)
7846 unsigned orig_size = 0;
7850 case ta_remove_insn:
7851 case ta_convert_longcall:
7852 case ta_remove_literal:
7853 case ta_add_literal:
7855 case ta_remove_longcall:
7858 case ta_narrow_insn:
7867 current_entry->size =
7868 r->offset + orig_size - current_entry->orig_address;
7869 if (current_entry->size != 0)
7874 current_entry->orig_address = r->offset + orig_size;
7875 removed += r->removed_bytes;
7876 current_entry->new_address = r->offset + orig_size - removed;
7877 current_entry->size = 0;
7880 current_entry->size = (bfd_get_section_limit (sec->owner, sec)
7881 - current_entry->orig_address);
7882 if (current_entry->size != 0)
7889 /* Free an offset translation map. */
7892 free_xlate_map (xlate_map_t *map)
7894 if (map && map->entry)
7901 /* Use check_section_ebb_pcrels_fit to make sure that all of the
7902 relocations in a section will fit if a proposed set of actions
7906 check_section_ebb_pcrels_fit (bfd *abfd,
7909 Elf_Internal_Rela *internal_relocs,
7910 const ebb_constraint *constraint,
7911 const xtensa_opcode *reloc_opcodes)
7914 Elf_Internal_Rela *irel;
7915 xlate_map_t *xmap = NULL;
7916 bfd_boolean ok = TRUE;
7917 xtensa_relax_info *relax_info;
7919 relax_info = get_xtensa_relax_info (sec);
7921 if (relax_info && sec->reloc_count > 100)
7923 xmap = build_xlate_map (sec, relax_info);
7924 /* NULL indicates out of memory, but the slow version
7925 can still be used. */
7928 for (i = 0; i < sec->reloc_count; i++)
7931 bfd_vma orig_self_offset, orig_target_offset;
7932 bfd_vma self_offset, target_offset;
7934 reloc_howto_type *howto;
7935 int self_removed_bytes, target_removed_bytes;
7937 irel = &internal_relocs[i];
7938 r_type = ELF32_R_TYPE (irel->r_info);
7940 howto = &elf_howto_table[r_type];
7941 /* We maintain the required invariant: PC-relative relocations
7942 that fit before linking must fit after linking. Thus we only
7943 need to deal with relocations to the same section that are
7945 if (r_type == R_XTENSA_ASM_SIMPLIFY
7946 || r_type == R_XTENSA_32_PCREL
7947 || !howto->pc_relative)
7950 r_reloc_init (&r_rel, abfd, irel, contents,
7951 bfd_get_section_limit (abfd, sec));
7953 if (r_reloc_get_section (&r_rel) != sec)
7956 orig_self_offset = irel->r_offset;
7957 orig_target_offset = r_rel.target_offset;
7959 self_offset = orig_self_offset;
7960 target_offset = orig_target_offset;
7965 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
7968 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
7969 orig_target_offset);
7972 self_removed_bytes = 0;
7973 target_removed_bytes = 0;
7975 for (j = 0; j < constraint->action_count; ++j)
7977 proposed_action *action = &constraint->actions[j];
7978 bfd_vma offset = action->offset;
7979 int removed_bytes = action->removed_bytes;
7980 if (offset < orig_self_offset
7981 || (offset == orig_self_offset && action->action == ta_fill
7982 && action->removed_bytes < 0))
7983 self_removed_bytes += removed_bytes;
7984 if (offset < orig_target_offset
7985 || (offset == orig_target_offset && action->action == ta_fill
7986 && action->removed_bytes < 0))
7987 target_removed_bytes += removed_bytes;
7989 self_offset -= self_removed_bytes;
7990 target_offset -= target_removed_bytes;
7992 /* Try to encode it. Get the operand and check. */
7993 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7995 /* None of the current alternate relocs are PC-relative,
7996 and only PC-relative relocs matter here. */
8000 xtensa_opcode opcode;
8004 opcode = reloc_opcodes[i];
8006 opcode = get_relocation_opcode (abfd, sec, contents, irel);
8007 if (opcode == XTENSA_UNDEFINED)
8013 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
8014 if (opnum == XTENSA_UNDEFINED)
8020 if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
8029 free_xlate_map (xmap);
8036 check_section_ebb_reduces (const ebb_constraint *constraint)
8041 for (i = 0; i < constraint->action_count; i++)
8043 const proposed_action *action = &constraint->actions[i];
8044 if (action->do_action)
8045 removed += action->removed_bytes;
8055 text_action_add_proposed (text_action_list *l,
8056 const ebb_constraint *ebb_table,
8061 for (i = 0; i < ebb_table->action_count; i++)
8063 proposed_action *action = &ebb_table->actions[i];
8065 if (!action->do_action)
8067 switch (action->action)
8069 case ta_remove_insn:
8070 case ta_remove_longcall:
8071 case ta_convert_longcall:
8072 case ta_narrow_insn:
8075 case ta_remove_literal:
8076 text_action_add (l, action->action, sec, action->offset,
8077 action->removed_bytes);
8090 compute_fill_extra_space (property_table_entry *entry)
8092 int fill_extra_space;
8097 if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
8100 fill_extra_space = entry->size;
8101 if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
8103 /* Fill bytes for alignment:
8104 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8105 int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
8106 int nsm = (1 << pow) - 1;
8107 bfd_vma addr = entry->address + entry->size;
8108 bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
8109 fill_extra_space += align_fill;
8111 return fill_extra_space;
8115 /* First relaxation pass. */
8117 /* If the section contains relaxable literals, check each literal to
8118 see if it has the same value as another literal that has already
8119 been seen, either in the current section or a previous one. If so,
8120 add an entry to the per-section list of removed literals. The
8121 actual changes are deferred until the next pass. */
8124 compute_removed_literals (bfd *abfd,
8126 struct bfd_link_info *link_info,
8127 value_map_hash_table *values)
8129 xtensa_relax_info *relax_info;
8131 Elf_Internal_Rela *internal_relocs;
8132 source_reloc *src_relocs, *rel;
8133 bfd_boolean ok = TRUE;
8134 property_table_entry *prop_table = NULL;
8137 bfd_boolean last_loc_is_prev = FALSE;
8138 bfd_vma last_target_offset = 0;
8139 section_cache_t target_sec_cache;
8140 bfd_size_type sec_size;
8142 init_section_cache (&target_sec_cache);
8144 /* Do nothing if it is not a relaxable literal section. */
8145 relax_info = get_xtensa_relax_info (sec);
8146 BFD_ASSERT (relax_info);
8147 if (!relax_info->is_relaxable_literal_section)
8150 internal_relocs = retrieve_internal_relocs (abfd, sec,
8151 link_info->keep_memory);
8153 sec_size = bfd_get_section_limit (abfd, sec);
8154 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8155 if (contents == NULL && sec_size != 0)
8161 /* Sort the source_relocs by target offset. */
8162 src_relocs = relax_info->src_relocs;
8163 qsort (src_relocs, relax_info->src_count,
8164 sizeof (source_reloc), source_reloc_compare);
8165 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8166 internal_reloc_compare);
8168 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
8169 XTENSA_PROP_SEC_NAME, FALSE);
8177 for (i = 0; i < relax_info->src_count; i++)
8179 Elf_Internal_Rela *irel = NULL;
8181 rel = &src_relocs[i];
8182 if (get_l32r_opcode () != rel->opcode)
8184 irel = get_irel_at_offset (sec, internal_relocs,
8185 rel->r_rel.target_offset);
8187 /* If the relocation on this is not a simple R_XTENSA_32 or
8188 R_XTENSA_PLT then do not consider it. This may happen when
8189 the difference of two symbols is used in a literal. */
8190 if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
8191 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
8194 /* If the target_offset for this relocation is the same as the
8195 previous relocation, then we've already considered whether the
8196 literal can be coalesced. Skip to the next one.... */
8197 if (i != 0 && prev_i != -1
8198 && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
8202 if (last_loc_is_prev &&
8203 last_target_offset + 4 != rel->r_rel.target_offset)
8204 last_loc_is_prev = FALSE;
8206 /* Check if the relocation was from an L32R that is being removed
8207 because a CALLX was converted to a direct CALL, and check if
8208 there are no other relocations to the literal. */
8209 if (is_removable_literal (rel, i, src_relocs, relax_info->src_count,
8210 sec, prop_table, ptblsize))
8212 if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
8213 irel, rel, prop_table, ptblsize))
8218 last_target_offset = rel->r_rel.target_offset;
8222 if (!identify_literal_placement (abfd, sec, contents, link_info,
8224 &last_loc_is_prev, irel,
8225 relax_info->src_count - i, rel,
8226 prop_table, ptblsize,
8227 &target_sec_cache, rel->is_abs_literal))
8232 last_target_offset = rel->r_rel.target_offset;
8236 print_removed_literals (stderr, &relax_info->removed_list);
8237 print_action_list (stderr, &relax_info->action_list);
8241 if (prop_table) free (prop_table);
8242 clear_section_cache (&target_sec_cache);
8244 release_contents (sec, contents);
8245 release_internal_relocs (sec, internal_relocs);
8250 static Elf_Internal_Rela *
8251 get_irel_at_offset (asection *sec,
8252 Elf_Internal_Rela *internal_relocs,
8256 Elf_Internal_Rela *irel;
8258 Elf_Internal_Rela key;
8260 if (!internal_relocs)
8263 key.r_offset = offset;
8264 irel = bsearch (&key, internal_relocs, sec->reloc_count,
8265 sizeof (Elf_Internal_Rela), internal_reloc_matches);
8269 /* bsearch does not guarantee which will be returned if there are
8270 multiple matches. We need the first that is not an alignment. */
8271 i = irel - internal_relocs;
8274 if (internal_relocs[i-1].r_offset != offset)
8278 for ( ; i < sec->reloc_count; i++)
8280 irel = &internal_relocs[i];
8281 r_type = ELF32_R_TYPE (irel->r_info);
8282 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
8291 is_removable_literal (const source_reloc *rel,
8293 const source_reloc *src_relocs,
8296 property_table_entry *prop_table,
8299 const source_reloc *curr_rel;
8300 property_table_entry *entry;
8305 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8306 sec->vma + rel->r_rel.target_offset);
8307 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8310 for (++i; i < src_count; ++i)
8312 curr_rel = &src_relocs[i];
8313 /* If all others have the same target offset.... */
8314 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
8317 if (!curr_rel->is_null
8318 && !xtensa_is_property_section (curr_rel->source_sec)
8319 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
8327 remove_dead_literal (bfd *abfd,
8329 struct bfd_link_info *link_info,
8330 Elf_Internal_Rela *internal_relocs,
8331 Elf_Internal_Rela *irel,
8333 property_table_entry *prop_table,
8336 property_table_entry *entry;
8337 xtensa_relax_info *relax_info;
8339 relax_info = get_xtensa_relax_info (sec);
8343 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8344 sec->vma + rel->r_rel.target_offset);
8346 /* Mark the unused literal so that it will be removed. */
8347 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
8349 text_action_add (&relax_info->action_list,
8350 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8352 /* If the section is 4-byte aligned, do not add fill. */
8353 if (sec->alignment_power > 2)
8355 int fill_extra_space;
8356 bfd_vma entry_sec_offset;
8358 property_table_entry *the_add_entry;
8362 entry_sec_offset = entry->address - sec->vma + entry->size;
8364 entry_sec_offset = rel->r_rel.target_offset + 4;
8366 /* If the literal range is at the end of the section,
8368 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8370 fill_extra_space = compute_fill_extra_space (the_add_entry);
8372 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8373 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8374 -4, fill_extra_space);
8376 adjust_fill_action (fa, removed_diff);
8378 text_action_add (&relax_info->action_list,
8379 ta_fill, sec, entry_sec_offset, removed_diff);
8382 /* Zero out the relocation on this literal location. */
8385 if (elf_hash_table (link_info)->dynamic_sections_created)
8386 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8388 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8389 pin_internal_relocs (sec, internal_relocs);
8392 /* Do not modify "last_loc_is_prev". */
8398 identify_literal_placement (bfd *abfd,
8401 struct bfd_link_info *link_info,
8402 value_map_hash_table *values,
8403 bfd_boolean *last_loc_is_prev_p,
8404 Elf_Internal_Rela *irel,
8405 int remaining_src_rels,
8407 property_table_entry *prop_table,
8409 section_cache_t *target_sec_cache,
8410 bfd_boolean is_abs_literal)
8414 xtensa_relax_info *relax_info;
8415 bfd_boolean literal_placed = FALSE;
8417 unsigned long value;
8418 bfd_boolean final_static_link;
8419 bfd_size_type sec_size;
8421 relax_info = get_xtensa_relax_info (sec);
8425 sec_size = bfd_get_section_limit (abfd, sec);
8428 (!link_info->relocatable
8429 && !elf_hash_table (link_info)->dynamic_sections_created);
8431 /* The placement algorithm first checks to see if the literal is
8432 already in the value map. If so and the value map is reachable
8433 from all uses, then the literal is moved to that location. If
8434 not, then we identify the last location where a fresh literal was
8435 placed. If the literal can be safely moved there, then we do so.
8436 If not, then we assume that the literal is not to move and leave
8437 the literal where it is, marking it as the last literal
8440 /* Find the literal value. */
8442 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8445 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
8446 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
8448 init_literal_value (&val, &r_rel, value, is_abs_literal);
8450 /* Check if we've seen another literal with the same value that
8451 is in the same output section. */
8452 val_map = value_map_get_cached_value (values, &val, final_static_link);
8455 && (r_reloc_get_section (&val_map->loc)->output_section
8456 == sec->output_section)
8457 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
8458 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
8460 /* No change to last_loc_is_prev. */
8461 literal_placed = TRUE;
8464 /* For relocatable links, do not try to move literals. To do it
8465 correctly might increase the number of relocations in an input
8466 section making the default relocatable linking fail. */
8467 if (!link_info->relocatable && !literal_placed
8468 && values->has_last_loc && !(*last_loc_is_prev_p))
8470 asection *target_sec = r_reloc_get_section (&values->last_loc);
8471 if (target_sec && target_sec->output_section == sec->output_section)
8473 /* Increment the virtual offset. */
8474 r_reloc try_loc = values->last_loc;
8475 try_loc.virtual_offset += 4;
8477 /* There is a last loc that was in the same output section. */
8478 if (relocations_reach (rel, remaining_src_rels, &try_loc)
8479 && move_shared_literal (sec, link_info, rel,
8480 prop_table, ptblsize,
8481 &try_loc, &val, target_sec_cache))
8483 values->last_loc.virtual_offset += 4;
8484 literal_placed = TRUE;
8486 val_map = add_value_map (values, &val, &try_loc,
8489 val_map->loc = try_loc;
8494 if (!literal_placed)
8496 /* Nothing worked, leave the literal alone but update the last loc. */
8497 values->has_last_loc = TRUE;
8498 values->last_loc = rel->r_rel;
8500 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
8502 val_map->loc = rel->r_rel;
8503 *last_loc_is_prev_p = TRUE;
8510 /* Check if the original relocations (presumably on L32R instructions)
8511 identified by reloc[0..N] can be changed to reference the literal
8512 identified by r_rel. If r_rel is out of range for any of the
8513 original relocations, then we don't want to coalesce the original
8514 literal with the one at r_rel. We only check reloc[0..N], where the
8515 offsets are all the same as for reloc[0] (i.e., they're all
8516 referencing the same literal) and where N is also bounded by the
8517 number of remaining entries in the "reloc" array. The "reloc" array
8518 is sorted by target offset so we know all the entries for the same
8519 literal will be contiguous. */
8522 relocations_reach (source_reloc *reloc,
8523 int remaining_relocs,
8524 const r_reloc *r_rel)
8526 bfd_vma from_offset, source_address, dest_address;
8530 if (!r_reloc_is_defined (r_rel))
8533 sec = r_reloc_get_section (r_rel);
8534 from_offset = reloc[0].r_rel.target_offset;
8536 for (i = 0; i < remaining_relocs; i++)
8538 if (reloc[i].r_rel.target_offset != from_offset)
8541 /* Ignore relocations that have been removed. */
8542 if (reloc[i].is_null)
8545 /* The original and new output section for these must be the same
8546 in order to coalesce. */
8547 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
8548 != sec->output_section)
8551 /* Absolute literals in the same output section can always be
8553 if (reloc[i].is_abs_literal)
8556 /* A literal with no PC-relative relocations can be moved anywhere. */
8557 if (reloc[i].opnd != -1)
8559 /* Otherwise, check to see that it fits. */
8560 source_address = (reloc[i].source_sec->output_section->vma
8561 + reloc[i].source_sec->output_offset
8562 + reloc[i].r_rel.rela.r_offset);
8563 dest_address = (sec->output_section->vma
8564 + sec->output_offset
8565 + r_rel->target_offset);
8567 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
8568 source_address, dest_address))
8577 /* Move a literal to another literal location because it is
8578 the same as the other literal value. */
8581 coalesce_shared_literal (asection *sec,
8583 property_table_entry *prop_table,
8587 property_table_entry *entry;
8589 property_table_entry *the_add_entry;
8591 xtensa_relax_info *relax_info;
8593 relax_info = get_xtensa_relax_info (sec);
8597 entry = elf_xtensa_find_property_entry
8598 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
8599 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8602 /* Mark that the literal will be coalesced. */
8603 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
8605 text_action_add (&relax_info->action_list,
8606 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8608 /* If the section is 4-byte aligned, do not add fill. */
8609 if (sec->alignment_power > 2)
8611 int fill_extra_space;
8612 bfd_vma entry_sec_offset;
8615 entry_sec_offset = entry->address - sec->vma + entry->size;
8617 entry_sec_offset = rel->r_rel.target_offset + 4;
8619 /* If the literal range is at the end of the section,
8621 fill_extra_space = 0;
8622 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8624 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8625 fill_extra_space = the_add_entry->size;
8627 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8628 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8629 -4, fill_extra_space);
8631 adjust_fill_action (fa, removed_diff);
8633 text_action_add (&relax_info->action_list,
8634 ta_fill, sec, entry_sec_offset, removed_diff);
8641 /* Move a literal to another location. This may actually increase the
8642 total amount of space used because of alignments so we need to do
8643 this carefully. Also, it may make a branch go out of range. */
8646 move_shared_literal (asection *sec,
8647 struct bfd_link_info *link_info,
8649 property_table_entry *prop_table,
8651 const r_reloc *target_loc,
8652 const literal_value *lit_value,
8653 section_cache_t *target_sec_cache)
8655 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
8656 text_action *fa, *target_fa;
8658 xtensa_relax_info *relax_info, *target_relax_info;
8659 asection *target_sec;
8661 ebb_constraint ebb_table;
8662 bfd_boolean relocs_fit;
8664 /* If this routine always returns FALSE, the literals that cannot be
8665 coalesced will not be moved. */
8666 if (elf32xtensa_no_literal_movement)
8669 relax_info = get_xtensa_relax_info (sec);
8673 target_sec = r_reloc_get_section (target_loc);
8674 target_relax_info = get_xtensa_relax_info (target_sec);
8676 /* Literals to undefined sections may not be moved because they
8677 must report an error. */
8678 if (bfd_is_und_section (target_sec))
8681 src_entry = elf_xtensa_find_property_entry
8682 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
8684 if (!section_cache_section (target_sec_cache, target_sec, link_info))
8687 target_entry = elf_xtensa_find_property_entry
8688 (target_sec_cache->ptbl, target_sec_cache->pte_count,
8689 target_sec->vma + target_loc->target_offset);
8694 /* Make sure that we have not broken any branches. */
8697 init_ebb_constraint (&ebb_table);
8698 ebb = &ebb_table.ebb;
8699 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
8700 target_sec_cache->content_length,
8701 target_sec_cache->ptbl, target_sec_cache->pte_count,
8702 target_sec_cache->relocs, target_sec_cache->reloc_count);
8704 /* Propose to add 4 bytes + worst-case alignment size increase to
8706 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
8707 ta_fill, target_loc->target_offset,
8708 -4 - (1 << target_sec->alignment_power), TRUE);
8710 /* Check all of the PC-relative relocations to make sure they still fit. */
8711 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
8712 target_sec_cache->contents,
8713 target_sec_cache->relocs,
8719 text_action_add_literal (&target_relax_info->action_list,
8720 ta_add_literal, target_loc, lit_value, -4);
8722 if (target_sec->alignment_power > 2 && target_entry != src_entry)
8724 /* May need to add or remove some fill to maintain alignment. */
8725 int fill_extra_space;
8726 bfd_vma entry_sec_offset;
8729 target_entry->address - target_sec->vma + target_entry->size;
8731 /* If the literal range is at the end of the section,
8733 fill_extra_space = 0;
8735 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
8736 target_sec_cache->pte_count,
8738 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8739 fill_extra_space = the_add_entry->size;
8741 target_fa = find_fill_action (&target_relax_info->action_list,
8742 target_sec, entry_sec_offset);
8743 removed_diff = compute_removed_action_diff (target_fa, target_sec,
8744 entry_sec_offset, 4,
8747 adjust_fill_action (target_fa, removed_diff);
8749 text_action_add (&target_relax_info->action_list,
8750 ta_fill, target_sec, entry_sec_offset, removed_diff);
8753 /* Mark that the literal will be moved to the new location. */
8754 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
8756 /* Remove the literal. */
8757 text_action_add (&relax_info->action_list,
8758 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8760 /* If the section is 4-byte aligned, do not add fill. */
8761 if (sec->alignment_power > 2 && target_entry != src_entry)
8763 int fill_extra_space;
8764 bfd_vma entry_sec_offset;
8767 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
8769 entry_sec_offset = rel->r_rel.target_offset+4;
8771 /* If the literal range is at the end of the section,
8773 fill_extra_space = 0;
8774 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8776 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8777 fill_extra_space = the_add_entry->size;
8779 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8780 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8781 -4, fill_extra_space);
8783 adjust_fill_action (fa, removed_diff);
8785 text_action_add (&relax_info->action_list,
8786 ta_fill, sec, entry_sec_offset, removed_diff);
8793 /* Second relaxation pass. */
8795 /* Modify all of the relocations to point to the right spot, and if this
8796 is a relaxable section, delete the unwanted literals and fix the
8800 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
8802 Elf_Internal_Rela *internal_relocs;
8803 xtensa_relax_info *relax_info;
8805 bfd_boolean ok = TRUE;
8807 bfd_boolean rv = FALSE;
8808 bfd_boolean virtual_action;
8809 bfd_size_type sec_size;
8811 sec_size = bfd_get_section_limit (abfd, sec);
8812 relax_info = get_xtensa_relax_info (sec);
8813 BFD_ASSERT (relax_info);
8815 /* First translate any of the fixes that have been added already. */
8816 translate_section_fixes (sec);
8818 /* Handle property sections (e.g., literal tables) specially. */
8819 if (xtensa_is_property_section (sec))
8821 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
8822 return relax_property_section (abfd, sec, link_info);
8825 internal_relocs = retrieve_internal_relocs (abfd, sec,
8826 link_info->keep_memory);
8827 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8828 if (contents == NULL && sec_size != 0)
8834 if (internal_relocs)
8836 for (i = 0; i < sec->reloc_count; i++)
8838 Elf_Internal_Rela *irel;
8839 xtensa_relax_info *target_relax_info;
8840 bfd_vma source_offset, old_source_offset;
8843 asection *target_sec;
8845 /* Locally change the source address.
8846 Translate the target to the new target address.
8847 If it points to this section and has been removed,
8851 irel = &internal_relocs[i];
8852 source_offset = irel->r_offset;
8853 old_source_offset = source_offset;
8855 r_type = ELF32_R_TYPE (irel->r_info);
8856 r_reloc_init (&r_rel, abfd, irel, contents,
8857 bfd_get_section_limit (abfd, sec));
8859 /* If this section could have changed then we may need to
8860 change the relocation's offset. */
8862 if (relax_info->is_relaxable_literal_section
8863 || relax_info->is_relaxable_asm_section)
8865 pin_internal_relocs (sec, internal_relocs);
8867 if (r_type != R_XTENSA_NONE
8868 && find_removed_literal (&relax_info->removed_list,
8871 /* Remove this relocation. */
8872 if (elf_hash_table (link_info)->dynamic_sections_created)
8873 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8874 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8875 irel->r_offset = offset_with_removed_text
8876 (&relax_info->action_list, irel->r_offset);
8880 if (r_type == R_XTENSA_ASM_SIMPLIFY)
8882 text_action *action =
8883 find_insn_action (&relax_info->action_list,
8885 if (action && (action->action == ta_convert_longcall
8886 || action->action == ta_remove_longcall))
8888 bfd_reloc_status_type retval;
8889 char *error_message = NULL;
8891 retval = contract_asm_expansion (contents, sec_size,
8892 irel, &error_message);
8893 if (retval != bfd_reloc_ok)
8895 (*link_info->callbacks->reloc_dangerous)
8896 (link_info, error_message, abfd, sec,
8900 /* Update the action so that the code that moves
8901 the contents will do the right thing. */
8902 if (action->action == ta_remove_longcall)
8903 action->action = ta_remove_insn;
8905 action->action = ta_none;
8906 /* Refresh the info in the r_rel. */
8907 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8908 r_type = ELF32_R_TYPE (irel->r_info);
8912 source_offset = offset_with_removed_text
8913 (&relax_info->action_list, irel->r_offset);
8914 irel->r_offset = source_offset;
8917 /* If the target section could have changed then
8918 we may need to change the relocation's target offset. */
8920 target_sec = r_reloc_get_section (&r_rel);
8922 /* For a reference to a discarded section from a DWARF section,
8923 i.e., where action_discarded is PRETEND, the symbol will
8924 eventually be modified to refer to the kept section (at least if
8925 the kept and discarded sections are the same size). Anticipate
8926 that here and adjust things accordingly. */
8927 if (! elf_xtensa_ignore_discarded_relocs (sec)
8928 && elf_xtensa_action_discarded (sec) == PRETEND
8929 && sec->sec_info_type != ELF_INFO_TYPE_STABS
8930 && target_sec != NULL
8931 && elf_discarded_section (target_sec))
8933 /* It would be natural to call _bfd_elf_check_kept_section
8934 here, but it's not exported from elflink.c. It's also a
8935 fairly expensive check. Adjusting the relocations to the
8936 discarded section is fairly harmless; it will only adjust
8937 some addends and difference values. If it turns out that
8938 _bfd_elf_check_kept_section fails later, it won't matter,
8939 so just compare the section names to find the right group
8941 asection *kept = target_sec->kept_section;
8944 if ((kept->flags & SEC_GROUP) != 0)
8946 asection *first = elf_next_in_group (kept);
8947 asection *s = first;
8952 if (strcmp (s->name, target_sec->name) == 0)
8957 s = elf_next_in_group (s);
8964 && ((target_sec->rawsize != 0
8965 ? target_sec->rawsize : target_sec->size)
8966 == (kept->rawsize != 0 ? kept->rawsize : kept->size)))
8970 target_relax_info = get_xtensa_relax_info (target_sec);
8971 if (target_relax_info
8972 && (target_relax_info->is_relaxable_literal_section
8973 || target_relax_info->is_relaxable_asm_section))
8976 target_sec = translate_reloc (&r_rel, &new_reloc, target_sec);
8978 if (r_type == R_XTENSA_DIFF8
8979 || r_type == R_XTENSA_DIFF16
8980 || r_type == R_XTENSA_DIFF32)
8982 bfd_vma diff_value = 0, new_end_offset, diff_mask = 0;
8984 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
8986 (*link_info->callbacks->reloc_dangerous)
8987 (link_info, _("invalid relocation address"),
8988 abfd, sec, old_source_offset);
8994 case R_XTENSA_DIFF8:
8996 bfd_get_8 (abfd, &contents[old_source_offset]);
8998 case R_XTENSA_DIFF16:
9000 bfd_get_16 (abfd, &contents[old_source_offset]);
9002 case R_XTENSA_DIFF32:
9004 bfd_get_32 (abfd, &contents[old_source_offset]);
9008 new_end_offset = offset_with_removed_text
9009 (&target_relax_info->action_list,
9010 r_rel.target_offset + diff_value);
9011 diff_value = new_end_offset - new_reloc.target_offset;
9015 case R_XTENSA_DIFF8:
9017 bfd_put_8 (abfd, diff_value,
9018 &contents[old_source_offset]);
9020 case R_XTENSA_DIFF16:
9022 bfd_put_16 (abfd, diff_value,
9023 &contents[old_source_offset]);
9025 case R_XTENSA_DIFF32:
9026 diff_mask = 0xffffffff;
9027 bfd_put_32 (abfd, diff_value,
9028 &contents[old_source_offset]);
9032 /* Check for overflow. */
9033 if ((diff_value & ~diff_mask) != 0)
9035 (*link_info->callbacks->reloc_dangerous)
9036 (link_info, _("overflow after relaxation"),
9037 abfd, sec, old_source_offset);
9041 pin_contents (sec, contents);
9044 /* If the relocation still references a section in the same
9045 input file, modify the relocation directly instead of
9046 adding a "fix" record. */
9047 if (target_sec->owner == abfd)
9049 unsigned r_symndx = ELF32_R_SYM (new_reloc.rela.r_info);
9050 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
9051 irel->r_addend = new_reloc.rela.r_addend;
9052 pin_internal_relocs (sec, internal_relocs);
9056 bfd_vma addend_displacement;
9059 addend_displacement =
9060 new_reloc.target_offset + new_reloc.virtual_offset;
9061 fix = reloc_bfd_fix_init (sec, source_offset, r_type,
9063 addend_displacement, TRUE);
9070 if ((relax_info->is_relaxable_literal_section
9071 || relax_info->is_relaxable_asm_section)
9072 && relax_info->action_list.head)
9074 /* Walk through the planned actions and build up a table
9075 of move, copy and fill records. Use the move, copy and
9076 fill records to perform the actions once. */
9079 bfd_size_type final_size, copy_size, orig_insn_size;
9080 bfd_byte *scratch = NULL;
9081 bfd_byte *dup_contents = NULL;
9082 bfd_size_type orig_size = sec->size;
9083 bfd_vma orig_dot = 0;
9084 bfd_vma orig_dot_copied = 0; /* Byte copied already from
9085 orig dot in physical memory. */
9086 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
9087 bfd_vma dup_dot = 0;
9089 text_action *action = relax_info->action_list.head;
9091 final_size = sec->size;
9092 for (action = relax_info->action_list.head; action;
9093 action = action->next)
9095 final_size -= action->removed_bytes;
9098 scratch = (bfd_byte *) bfd_zmalloc (final_size);
9099 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
9101 /* The dot is the current fill location. */
9103 print_action_list (stderr, &relax_info->action_list);
9106 for (action = relax_info->action_list.head; action;
9107 action = action->next)
9109 virtual_action = FALSE;
9110 if (action->offset > orig_dot)
9112 orig_dot += orig_dot_copied;
9113 orig_dot_copied = 0;
9115 /* Out of the virtual world. */
9118 if (action->offset > orig_dot)
9120 copy_size = action->offset - orig_dot;
9121 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9122 orig_dot += copy_size;
9123 dup_dot += copy_size;
9124 BFD_ASSERT (action->offset == orig_dot);
9126 else if (action->offset < orig_dot)
9128 if (action->action == ta_fill
9129 && action->offset - action->removed_bytes == orig_dot)
9131 /* This is OK because the fill only effects the dup_dot. */
9133 else if (action->action == ta_add_literal)
9135 /* TBD. Might need to handle this. */
9138 if (action->offset == orig_dot)
9140 if (action->virtual_offset > orig_dot_vo)
9142 if (orig_dot_vo == 0)
9144 /* Need to copy virtual_offset bytes. Probably four. */
9145 copy_size = action->virtual_offset - orig_dot_vo;
9146 memmove (&dup_contents[dup_dot],
9147 &contents[orig_dot], copy_size);
9148 orig_dot_copied = copy_size;
9149 dup_dot += copy_size;
9151 virtual_action = TRUE;
9154 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
9156 switch (action->action)
9158 case ta_remove_literal:
9159 case ta_remove_insn:
9160 BFD_ASSERT (action->removed_bytes >= 0);
9161 orig_dot += action->removed_bytes;
9164 case ta_narrow_insn:
9167 memmove (scratch, &contents[orig_dot], orig_insn_size);
9168 BFD_ASSERT (action->removed_bytes == 1);
9169 rv = narrow_instruction (scratch, final_size, 0);
9171 memmove (&dup_contents[dup_dot], scratch, copy_size);
9172 orig_dot += orig_insn_size;
9173 dup_dot += copy_size;
9177 if (action->removed_bytes >= 0)
9178 orig_dot += action->removed_bytes;
9181 /* Already zeroed in dup_contents. Just bump the
9183 dup_dot += (-action->removed_bytes);
9188 BFD_ASSERT (action->removed_bytes == 0);
9191 case ta_convert_longcall:
9192 case ta_remove_longcall:
9193 /* These will be removed or converted before we get here. */
9200 memmove (scratch, &contents[orig_dot], orig_insn_size);
9201 BFD_ASSERT (action->removed_bytes == -1);
9202 rv = widen_instruction (scratch, final_size, 0);
9204 memmove (&dup_contents[dup_dot], scratch, copy_size);
9205 orig_dot += orig_insn_size;
9206 dup_dot += copy_size;
9209 case ta_add_literal:
9212 BFD_ASSERT (action->removed_bytes == -4);
9213 /* TBD -- place the literal value here and insert
9215 memset (&dup_contents[dup_dot], 0, 4);
9216 pin_internal_relocs (sec, internal_relocs);
9217 pin_contents (sec, contents);
9219 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
9220 relax_info, &internal_relocs, &action->value))
9224 orig_dot_vo += copy_size;
9226 orig_dot += orig_insn_size;
9227 dup_dot += copy_size;
9231 /* Not implemented yet. */
9236 removed += action->removed_bytes;
9237 BFD_ASSERT (dup_dot <= final_size);
9238 BFD_ASSERT (orig_dot <= orig_size);
9241 orig_dot += orig_dot_copied;
9242 orig_dot_copied = 0;
9244 if (orig_dot != orig_size)
9246 copy_size = orig_size - orig_dot;
9247 BFD_ASSERT (orig_size > orig_dot);
9248 BFD_ASSERT (dup_dot + copy_size == final_size);
9249 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9250 orig_dot += copy_size;
9251 dup_dot += copy_size;
9253 BFD_ASSERT (orig_size == orig_dot);
9254 BFD_ASSERT (final_size == dup_dot);
9256 /* Move the dup_contents back. */
9257 if (final_size > orig_size)
9259 /* Contents need to be reallocated. Swap the dup_contents into
9261 sec->contents = dup_contents;
9263 contents = dup_contents;
9264 pin_contents (sec, contents);
9268 BFD_ASSERT (final_size <= orig_size);
9269 memset (contents, 0, orig_size);
9270 memcpy (contents, dup_contents, final_size);
9271 free (dup_contents);
9274 pin_contents (sec, contents);
9276 if (sec->rawsize == 0)
9277 sec->rawsize = sec->size;
9278 sec->size = final_size;
9282 release_internal_relocs (sec, internal_relocs);
9283 release_contents (sec, contents);
9289 translate_section_fixes (asection *sec)
9291 xtensa_relax_info *relax_info;
9294 relax_info = get_xtensa_relax_info (sec);
9298 for (r = relax_info->fix_list; r != NULL; r = r->next)
9299 if (!translate_reloc_bfd_fix (r))
9306 /* Translate a fix given the mapping in the relax info for the target
9307 section. If it has already been translated, no work is required. */
9310 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
9312 reloc_bfd_fix new_fix;
9314 xtensa_relax_info *relax_info;
9315 removed_literal *removed;
9316 bfd_vma new_offset, target_offset;
9318 if (fix->translated)
9321 sec = fix->target_sec;
9322 target_offset = fix->target_offset;
9324 relax_info = get_xtensa_relax_info (sec);
9327 fix->translated = TRUE;
9333 /* The fix does not need to be translated if the section cannot change. */
9334 if (!relax_info->is_relaxable_literal_section
9335 && !relax_info->is_relaxable_asm_section)
9337 fix->translated = TRUE;
9341 /* If the literal has been moved and this relocation was on an
9342 opcode, then the relocation should move to the new literal
9343 location. Otherwise, the relocation should move within the
9347 if (is_operand_relocation (fix->src_type))
9349 /* Check if the original relocation is against a literal being
9351 removed = find_removed_literal (&relax_info->removed_list,
9359 /* The fact that there is still a relocation to this literal indicates
9360 that the literal is being coalesced, not simply removed. */
9361 BFD_ASSERT (removed->to.abfd != NULL);
9363 /* This was moved to some other address (possibly another section). */
9364 new_sec = r_reloc_get_section (&removed->to);
9368 relax_info = get_xtensa_relax_info (sec);
9370 (!relax_info->is_relaxable_literal_section
9371 && !relax_info->is_relaxable_asm_section))
9373 target_offset = removed->to.target_offset;
9374 new_fix.target_sec = new_sec;
9375 new_fix.target_offset = target_offset;
9376 new_fix.translated = TRUE;
9381 target_offset = removed->to.target_offset;
9382 new_fix.target_sec = new_sec;
9385 /* The target address may have been moved within its section. */
9386 new_offset = offset_with_removed_text (&relax_info->action_list,
9389 new_fix.target_offset = new_offset;
9390 new_fix.target_offset = new_offset;
9391 new_fix.translated = TRUE;
9397 /* Fix up a relocation to take account of removed literals. */
9400 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec)
9402 xtensa_relax_info *relax_info;
9403 removed_literal *removed;
9404 bfd_vma target_offset, base_offset;
9407 *new_rel = *orig_rel;
9409 if (!r_reloc_is_defined (orig_rel))
9412 relax_info = get_xtensa_relax_info (sec);
9413 BFD_ASSERT (relax_info && (relax_info->is_relaxable_literal_section
9414 || relax_info->is_relaxable_asm_section));
9416 target_offset = orig_rel->target_offset;
9419 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
9421 /* Check if the original relocation is against a literal being
9423 removed = find_removed_literal (&relax_info->removed_list,
9426 if (removed && removed->to.abfd)
9430 /* The fact that there is still a relocation to this literal indicates
9431 that the literal is being coalesced, not simply removed. */
9432 BFD_ASSERT (removed->to.abfd != NULL);
9434 /* This was moved to some other address
9435 (possibly in another section). */
9436 *new_rel = removed->to;
9437 new_sec = r_reloc_get_section (new_rel);
9441 relax_info = get_xtensa_relax_info (sec);
9443 || (!relax_info->is_relaxable_literal_section
9444 && !relax_info->is_relaxable_asm_section))
9447 target_offset = new_rel->target_offset;
9450 /* Find the base offset of the reloc symbol, excluding any addend from the
9451 reloc or from the section contents (for a partial_inplace reloc). Then
9452 find the adjusted values of the offsets due to relaxation. The base
9453 offset is needed to determine the change to the reloc's addend; the reloc
9454 addend should not be adjusted due to relaxations located before the base
9457 base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend;
9458 act = relax_info->action_list.head;
9459 if (base_offset <= target_offset)
9461 int base_removed = removed_by_actions (&act, base_offset, FALSE);
9462 int addend_removed = removed_by_actions (&act, target_offset, FALSE);
9463 new_rel->target_offset = target_offset - base_removed - addend_removed;
9464 new_rel->rela.r_addend -= addend_removed;
9468 /* Handle a negative addend. The base offset comes first. */
9469 int tgt_removed = removed_by_actions (&act, target_offset, FALSE);
9470 int addend_removed = removed_by_actions (&act, base_offset, FALSE);
9471 new_rel->target_offset = target_offset - tgt_removed;
9472 new_rel->rela.r_addend += addend_removed;
9479 /* For dynamic links, there may be a dynamic relocation for each
9480 literal. The number of dynamic relocations must be computed in
9481 size_dynamic_sections, which occurs before relaxation. When a
9482 literal is removed, this function checks if there is a corresponding
9483 dynamic relocation and shrinks the size of the appropriate dynamic
9484 relocation section accordingly. At this point, the contents of the
9485 dynamic relocation sections have not yet been filled in, so there's
9486 nothing else that needs to be done. */
9489 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
9491 asection *input_section,
9492 Elf_Internal_Rela *rel)
9494 struct elf_xtensa_link_hash_table *htab;
9495 Elf_Internal_Shdr *symtab_hdr;
9496 struct elf_link_hash_entry **sym_hashes;
9497 unsigned long r_symndx;
9499 struct elf_link_hash_entry *h;
9500 bfd_boolean dynamic_symbol;
9502 htab = elf_xtensa_hash_table (info);
9503 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9504 sym_hashes = elf_sym_hashes (abfd);
9506 r_type = ELF32_R_TYPE (rel->r_info);
9507 r_symndx = ELF32_R_SYM (rel->r_info);
9509 if (r_symndx < symtab_hdr->sh_info)
9512 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9514 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
9516 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
9517 && (input_section->flags & SEC_ALLOC) != 0
9518 && (dynamic_symbol || info->shared))
9521 bfd_boolean is_plt = FALSE;
9523 if (dynamic_symbol && r_type == R_XTENSA_PLT)
9525 srel = htab->srelplt;
9529 srel = htab->srelgot;
9531 /* Reduce size of the .rela.* section by one reloc. */
9532 BFD_ASSERT (srel != NULL);
9533 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
9534 srel->size -= sizeof (Elf32_External_Rela);
9538 asection *splt, *sgotplt, *srelgot;
9539 int reloc_index, chunk;
9541 /* Find the PLT reloc index of the entry being removed. This
9542 is computed from the size of ".rela.plt". It is needed to
9543 figure out which PLT chunk to resize. Usually "last index
9544 = size - 1" since the index starts at zero, but in this
9545 context, the size has just been decremented so there's no
9546 need to subtract one. */
9547 reloc_index = srel->size / sizeof (Elf32_External_Rela);
9549 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
9550 splt = elf_xtensa_get_plt_section (info, chunk);
9551 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
9552 BFD_ASSERT (splt != NULL && sgotplt != NULL);
9554 /* Check if an entire PLT chunk has just been eliminated. */
9555 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
9557 /* The two magic GOT entries for that chunk can go away. */
9558 srelgot = htab->srelgot;
9559 BFD_ASSERT (srelgot != NULL);
9560 srelgot->reloc_count -= 2;
9561 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
9564 /* There should be only one entry left (and it will be
9566 BFD_ASSERT (sgotplt->size == 4);
9567 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
9570 BFD_ASSERT (sgotplt->size >= 4);
9571 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
9574 splt->size -= PLT_ENTRY_SIZE;
9580 /* Take an r_rel and move it to another section. This usually
9581 requires extending the interal_relocation array and pinning it. If
9582 the original r_rel is from the same BFD, we can complete this here.
9583 Otherwise, we add a fix record to let the final link fix the
9584 appropriate address. Contents and internal relocations for the
9585 section must be pinned after calling this routine. */
9588 move_literal (bfd *abfd,
9589 struct bfd_link_info *link_info,
9593 xtensa_relax_info *relax_info,
9594 Elf_Internal_Rela **internal_relocs_p,
9595 const literal_value *lit)
9597 Elf_Internal_Rela *new_relocs = NULL;
9598 size_t new_relocs_count = 0;
9599 Elf_Internal_Rela this_rela;
9600 const r_reloc *r_rel;
9602 r_rel = &lit->r_rel;
9603 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
9605 if (r_reloc_is_const (r_rel))
9606 bfd_put_32 (abfd, lit->value, contents + offset);
9611 asection *target_sec;
9615 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
9616 target_sec = r_reloc_get_section (r_rel);
9618 /* This is the difficult case. We have to create a fix up. */
9619 this_rela.r_offset = offset;
9620 this_rela.r_info = ELF32_R_INFO (0, r_type);
9621 this_rela.r_addend =
9622 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
9623 bfd_put_32 (abfd, lit->value, contents + offset);
9625 /* Currently, we cannot move relocations during a relocatable link. */
9626 BFD_ASSERT (!link_info->relocatable);
9627 fix = reloc_bfd_fix_init (sec, offset, r_type,
9628 r_reloc_get_section (r_rel),
9629 r_rel->target_offset + r_rel->virtual_offset,
9631 /* We also need to mark that relocations are needed here. */
9632 sec->flags |= SEC_RELOC;
9634 translate_reloc_bfd_fix (fix);
9635 /* This fix has not yet been translated. */
9638 /* Add the relocation. If we have already allocated our own
9639 space for the relocations and we have room for more, then use
9640 it. Otherwise, allocate new space and move the literals. */
9641 insert_at = sec->reloc_count;
9642 for (i = 0; i < sec->reloc_count; ++i)
9644 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
9651 if (*internal_relocs_p != relax_info->allocated_relocs
9652 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
9654 BFD_ASSERT (relax_info->allocated_relocs == NULL
9655 || sec->reloc_count == relax_info->relocs_count);
9657 if (relax_info->allocated_relocs_count == 0)
9658 new_relocs_count = (sec->reloc_count + 2) * 2;
9660 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
9662 new_relocs = (Elf_Internal_Rela *)
9663 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
9667 /* We could handle this more quickly by finding the split point. */
9669 memcpy (new_relocs, *internal_relocs_p,
9670 insert_at * sizeof (Elf_Internal_Rela));
9672 new_relocs[insert_at] = this_rela;
9674 if (insert_at != sec->reloc_count)
9675 memcpy (new_relocs + insert_at + 1,
9676 (*internal_relocs_p) + insert_at,
9677 (sec->reloc_count - insert_at)
9678 * sizeof (Elf_Internal_Rela));
9680 if (*internal_relocs_p != relax_info->allocated_relocs)
9682 /* The first time we re-allocate, we can only free the
9683 old relocs if they were allocated with bfd_malloc.
9684 This is not true when keep_memory is in effect. */
9685 if (!link_info->keep_memory)
9686 free (*internal_relocs_p);
9689 free (*internal_relocs_p);
9690 relax_info->allocated_relocs = new_relocs;
9691 relax_info->allocated_relocs_count = new_relocs_count;
9692 elf_section_data (sec)->relocs = new_relocs;
9694 relax_info->relocs_count = sec->reloc_count;
9695 *internal_relocs_p = new_relocs;
9699 if (insert_at != sec->reloc_count)
9702 for (idx = sec->reloc_count; idx > insert_at; idx--)
9703 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
9705 (*internal_relocs_p)[insert_at] = this_rela;
9707 if (relax_info->allocated_relocs)
9708 relax_info->relocs_count = sec->reloc_count;
9715 /* This is similar to relax_section except that when a target is moved,
9716 we shift addresses up. We also need to modify the size. This
9717 algorithm does NOT allow for relocations into the middle of the
9718 property sections. */
9721 relax_property_section (bfd *abfd,
9723 struct bfd_link_info *link_info)
9725 Elf_Internal_Rela *internal_relocs;
9728 bfd_boolean ok = TRUE;
9729 bfd_boolean is_full_prop_section;
9730 size_t last_zfill_target_offset = 0;
9731 asection *last_zfill_target_sec = NULL;
9732 bfd_size_type sec_size;
9733 bfd_size_type entry_size;
9735 sec_size = bfd_get_section_limit (abfd, sec);
9736 internal_relocs = retrieve_internal_relocs (abfd, sec,
9737 link_info->keep_memory);
9738 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9739 if (contents == NULL && sec_size != 0)
9745 is_full_prop_section = xtensa_is_proptable_section (sec);
9746 if (is_full_prop_section)
9751 if (internal_relocs)
9753 for (i = 0; i < sec->reloc_count; i++)
9755 Elf_Internal_Rela *irel;
9756 xtensa_relax_info *target_relax_info;
9758 asection *target_sec;
9760 bfd_byte *size_p, *flags_p;
9762 /* Locally change the source address.
9763 Translate the target to the new target address.
9764 If it points to this section and has been removed, MOVE IT.
9765 Also, don't forget to modify the associated SIZE at
9768 irel = &internal_relocs[i];
9769 r_type = ELF32_R_TYPE (irel->r_info);
9770 if (r_type == R_XTENSA_NONE)
9773 /* Find the literal value. */
9774 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
9775 size_p = &contents[irel->r_offset + 4];
9777 if (is_full_prop_section)
9778 flags_p = &contents[irel->r_offset + 8];
9779 BFD_ASSERT (irel->r_offset + entry_size <= sec_size);
9781 target_sec = r_reloc_get_section (&val.r_rel);
9782 target_relax_info = get_xtensa_relax_info (target_sec);
9784 if (target_relax_info
9785 && (target_relax_info->is_relaxable_literal_section
9786 || target_relax_info->is_relaxable_asm_section ))
9788 /* Translate the relocation's destination. */
9789 bfd_vma old_offset = val.r_rel.target_offset;
9791 long old_size, new_size;
9792 text_action *act = target_relax_info->action_list.head;
9793 new_offset = old_offset -
9794 removed_by_actions (&act, old_offset, FALSE);
9796 /* Assert that we are not out of bounds. */
9797 old_size = bfd_get_32 (abfd, size_p);
9798 new_size = old_size;
9802 /* Only the first zero-sized unreachable entry is
9803 allowed to expand. In this case the new offset
9804 should be the offset before the fill and the new
9805 size is the expansion size. For other zero-sized
9806 entries the resulting size should be zero with an
9807 offset before or after the fill address depending
9808 on whether the expanding unreachable entry
9810 if (last_zfill_target_sec == 0
9811 || last_zfill_target_sec != target_sec
9812 || last_zfill_target_offset != old_offset)
9814 bfd_vma new_end_offset = new_offset;
9816 /* Recompute the new_offset, but this time don't
9817 include any fill inserted by relaxation. */
9818 act = target_relax_info->action_list.head;
9819 new_offset = old_offset -
9820 removed_by_actions (&act, old_offset, TRUE);
9822 /* If it is not unreachable and we have not yet
9823 seen an unreachable at this address, place it
9824 before the fill address. */
9825 if (flags_p && (bfd_get_32 (abfd, flags_p)
9826 & XTENSA_PROP_UNREACHABLE) != 0)
9828 new_size = new_end_offset - new_offset;
9830 last_zfill_target_sec = target_sec;
9831 last_zfill_target_offset = old_offset;
9837 removed_by_actions (&act, old_offset + old_size, TRUE);
9839 if (new_size != old_size)
9841 bfd_put_32 (abfd, new_size, size_p);
9842 pin_contents (sec, contents);
9845 if (new_offset != old_offset)
9847 bfd_vma diff = new_offset - old_offset;
9848 irel->r_addend += diff;
9849 pin_internal_relocs (sec, internal_relocs);
9855 /* Combine adjacent property table entries. This is also done in
9856 finish_dynamic_sections() but at that point it's too late to
9857 reclaim the space in the output section, so we do this twice. */
9859 if (internal_relocs && (!link_info->relocatable
9860 || xtensa_is_littable_section (sec)))
9862 Elf_Internal_Rela *last_irel = NULL;
9863 Elf_Internal_Rela *irel, *next_rel, *rel_end;
9864 int removed_bytes = 0;
9866 flagword predef_flags;
9868 predef_flags = xtensa_get_property_predef_flags (sec);
9870 /* Walk over memory and relocations at the same time.
9871 This REQUIRES that the internal_relocs be sorted by offset. */
9872 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
9873 internal_reloc_compare);
9875 pin_internal_relocs (sec, internal_relocs);
9876 pin_contents (sec, contents);
9878 next_rel = internal_relocs;
9879 rel_end = internal_relocs + sec->reloc_count;
9881 BFD_ASSERT (sec->size % entry_size == 0);
9883 for (offset = 0; offset < sec->size; offset += entry_size)
9885 Elf_Internal_Rela *offset_rel, *extra_rel;
9886 bfd_vma bytes_to_remove, size, actual_offset;
9887 bfd_boolean remove_this_rel;
9890 /* Find the first relocation for the entry at the current offset.
9891 Adjust the offsets of any extra relocations for the previous
9896 for (irel = next_rel; irel < rel_end; irel++)
9898 if ((irel->r_offset == offset
9899 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9900 || irel->r_offset > offset)
9905 irel->r_offset -= removed_bytes;
9909 /* Find the next relocation (if there are any left). */
9913 for (irel = offset_rel + 1; irel < rel_end; irel++)
9915 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9923 /* Check if there are relocations on the current entry. There
9924 should usually be a relocation on the offset field. If there
9925 are relocations on the size or flags, then we can't optimize
9926 this entry. Also, find the next relocation to examine on the
9930 if (offset_rel->r_offset >= offset + entry_size)
9932 next_rel = offset_rel;
9933 /* There are no relocations on the current entry, but we
9934 might still be able to remove it if the size is zero. */
9937 else if (offset_rel->r_offset > offset
9939 && extra_rel->r_offset < offset + entry_size))
9941 /* There is a relocation on the size or flags, so we can't
9942 do anything with this entry. Continue with the next. */
9943 next_rel = offset_rel;
9948 BFD_ASSERT (offset_rel->r_offset == offset);
9949 offset_rel->r_offset -= removed_bytes;
9950 next_rel = offset_rel + 1;
9956 remove_this_rel = FALSE;
9957 bytes_to_remove = 0;
9958 actual_offset = offset - removed_bytes;
9959 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
9961 if (is_full_prop_section)
9962 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
9964 flags = predef_flags;
9967 && (flags & XTENSA_PROP_ALIGN) == 0
9968 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
9970 /* Always remove entries with zero size and no alignment. */
9971 bytes_to_remove = entry_size;
9973 remove_this_rel = TRUE;
9976 && ELF32_R_TYPE (offset_rel->r_info) == R_XTENSA_32)
9982 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
9983 bfd_vma old_address =
9984 (last_irel->r_addend
9985 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
9986 bfd_vma new_address =
9987 (offset_rel->r_addend
9988 + bfd_get_32 (abfd, &contents[actual_offset]));
9989 if (is_full_prop_section)
9990 old_flags = bfd_get_32
9991 (abfd, &contents[last_irel->r_offset + 8]);
9993 old_flags = predef_flags;
9995 if ((ELF32_R_SYM (offset_rel->r_info)
9996 == ELF32_R_SYM (last_irel->r_info))
9997 && old_address + old_size == new_address
9998 && old_flags == flags
9999 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
10000 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
10002 /* Fix the old size. */
10003 bfd_put_32 (abfd, old_size + size,
10004 &contents[last_irel->r_offset + 4]);
10005 bytes_to_remove = entry_size;
10006 remove_this_rel = TRUE;
10009 last_irel = offset_rel;
10012 last_irel = offset_rel;
10015 if (remove_this_rel)
10017 offset_rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
10018 offset_rel->r_offset = 0;
10021 if (bytes_to_remove != 0)
10023 removed_bytes += bytes_to_remove;
10024 if (offset + bytes_to_remove < sec->size)
10025 memmove (&contents[actual_offset],
10026 &contents[actual_offset + bytes_to_remove],
10027 sec->size - offset - bytes_to_remove);
10033 /* Fix up any extra relocations on the last entry. */
10034 for (irel = next_rel; irel < rel_end; irel++)
10035 irel->r_offset -= removed_bytes;
10037 /* Clear the removed bytes. */
10038 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
10040 if (sec->rawsize == 0)
10041 sec->rawsize = sec->size;
10042 sec->size -= removed_bytes;
10044 if (xtensa_is_littable_section (sec))
10046 asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
10048 sgotloc->size -= removed_bytes;
10054 release_internal_relocs (sec, internal_relocs);
10055 release_contents (sec, contents);
10060 /* Third relaxation pass. */
10062 /* Change symbol values to account for removed literals. */
10065 relax_section_symbols (bfd *abfd, asection *sec)
10067 xtensa_relax_info *relax_info;
10068 unsigned int sec_shndx;
10069 Elf_Internal_Shdr *symtab_hdr;
10070 Elf_Internal_Sym *isymbuf;
10071 unsigned i, num_syms, num_locals;
10073 relax_info = get_xtensa_relax_info (sec);
10074 BFD_ASSERT (relax_info);
10076 if (!relax_info->is_relaxable_literal_section
10077 && !relax_info->is_relaxable_asm_section)
10080 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
10082 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10083 isymbuf = retrieve_local_syms (abfd);
10085 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
10086 num_locals = symtab_hdr->sh_info;
10088 /* Adjust the local symbols defined in this section. */
10089 for (i = 0; i < num_locals; i++)
10091 Elf_Internal_Sym *isym = &isymbuf[i];
10093 if (isym->st_shndx == sec_shndx)
10095 text_action *act = relax_info->action_list.head;
10096 bfd_vma orig_addr = isym->st_value;
10098 isym->st_value -= removed_by_actions (&act, orig_addr, FALSE);
10100 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
10102 removed_by_actions (&act, orig_addr + isym->st_size, FALSE);
10106 /* Now adjust the global symbols defined in this section. */
10107 for (i = 0; i < (num_syms - num_locals); i++)
10109 struct elf_link_hash_entry *sym_hash;
10111 sym_hash = elf_sym_hashes (abfd)[i];
10113 if (sym_hash->root.type == bfd_link_hash_warning)
10114 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
10116 if ((sym_hash->root.type == bfd_link_hash_defined
10117 || sym_hash->root.type == bfd_link_hash_defweak)
10118 && sym_hash->root.u.def.section == sec)
10120 text_action *act = relax_info->action_list.head;
10121 bfd_vma orig_addr = sym_hash->root.u.def.value;
10123 sym_hash->root.u.def.value -=
10124 removed_by_actions (&act, orig_addr, FALSE);
10126 if (sym_hash->type == STT_FUNC)
10128 removed_by_actions (&act, orig_addr + sym_hash->size, FALSE);
10136 /* "Fix" handling functions, called while performing relocations. */
10139 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
10141 asection *input_section,
10142 bfd_byte *contents)
10145 asection *sec, *old_sec;
10146 bfd_vma old_offset;
10147 int r_type = ELF32_R_TYPE (rel->r_info);
10148 reloc_bfd_fix *fix;
10150 if (r_type == R_XTENSA_NONE)
10153 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10157 r_reloc_init (&r_rel, input_bfd, rel, contents,
10158 bfd_get_section_limit (input_bfd, input_section));
10159 old_sec = r_reloc_get_section (&r_rel);
10160 old_offset = r_rel.target_offset;
10162 if (!old_sec || !r_reloc_is_defined (&r_rel))
10164 if (r_type != R_XTENSA_ASM_EXPAND)
10166 (*_bfd_error_handler)
10167 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
10168 input_bfd, input_section, rel->r_offset,
10169 elf_howto_table[r_type].name);
10172 /* Leave it be. Resolution will happen in a later stage. */
10176 sec = fix->target_sec;
10177 rel->r_addend += ((sec->output_offset + fix->target_offset)
10178 - (old_sec->output_offset + old_offset));
10185 do_fix_for_final_link (Elf_Internal_Rela *rel,
10187 asection *input_section,
10188 bfd_byte *contents,
10189 bfd_vma *relocationp)
10192 int r_type = ELF32_R_TYPE (rel->r_info);
10193 reloc_bfd_fix *fix;
10194 bfd_vma fixup_diff;
10196 if (r_type == R_XTENSA_NONE)
10199 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10203 sec = fix->target_sec;
10205 fixup_diff = rel->r_addend;
10206 if (elf_howto_table[fix->src_type].partial_inplace)
10208 bfd_vma inplace_val;
10209 BFD_ASSERT (fix->src_offset
10210 < bfd_get_section_limit (input_bfd, input_section));
10211 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
10212 fixup_diff += inplace_val;
10215 *relocationp = (sec->output_section->vma
10216 + sec->output_offset
10217 + fix->target_offset - fixup_diff);
10221 /* Miscellaneous utility functions.... */
10224 elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
10226 struct elf_xtensa_link_hash_table *htab;
10232 htab = elf_xtensa_hash_table (info);
10236 dynobj = elf_hash_table (info)->dynobj;
10237 sprintf (plt_name, ".plt.%u", chunk);
10238 return bfd_get_section_by_name (dynobj, plt_name);
10243 elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
10245 struct elf_xtensa_link_hash_table *htab;
10251 htab = elf_xtensa_hash_table (info);
10252 return htab->sgotplt;
10255 dynobj = elf_hash_table (info)->dynobj;
10256 sprintf (got_name, ".got.plt.%u", chunk);
10257 return bfd_get_section_by_name (dynobj, got_name);
10261 /* Get the input section for a given symbol index.
10263 . a section symbol, return the section;
10264 . a common symbol, return the common section;
10265 . an undefined symbol, return the undefined section;
10266 . an indirect symbol, follow the links;
10267 . an absolute value, return the absolute section. */
10270 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
10272 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10273 asection *target_sec = NULL;
10274 if (r_symndx < symtab_hdr->sh_info)
10276 Elf_Internal_Sym *isymbuf;
10277 unsigned int section_index;
10279 isymbuf = retrieve_local_syms (abfd);
10280 section_index = isymbuf[r_symndx].st_shndx;
10282 if (section_index == SHN_UNDEF)
10283 target_sec = bfd_und_section_ptr;
10284 else if (section_index == SHN_ABS)
10285 target_sec = bfd_abs_section_ptr;
10286 else if (section_index == SHN_COMMON)
10287 target_sec = bfd_com_section_ptr;
10289 target_sec = bfd_section_from_elf_index (abfd, section_index);
10293 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10294 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
10296 while (h->root.type == bfd_link_hash_indirect
10297 || h->root.type == bfd_link_hash_warning)
10298 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10300 switch (h->root.type)
10302 case bfd_link_hash_defined:
10303 case bfd_link_hash_defweak:
10304 target_sec = h->root.u.def.section;
10306 case bfd_link_hash_common:
10307 target_sec = bfd_com_section_ptr;
10309 case bfd_link_hash_undefined:
10310 case bfd_link_hash_undefweak:
10311 target_sec = bfd_und_section_ptr;
10313 default: /* New indirect warning. */
10314 target_sec = bfd_und_section_ptr;
10322 static struct elf_link_hash_entry *
10323 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
10325 unsigned long indx;
10326 struct elf_link_hash_entry *h;
10327 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10329 if (r_symndx < symtab_hdr->sh_info)
10332 indx = r_symndx - symtab_hdr->sh_info;
10333 h = elf_sym_hashes (abfd)[indx];
10334 while (h->root.type == bfd_link_hash_indirect
10335 || h->root.type == bfd_link_hash_warning)
10336 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10341 /* Get the section-relative offset for a symbol number. */
10344 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
10346 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10347 bfd_vma offset = 0;
10349 if (r_symndx < symtab_hdr->sh_info)
10351 Elf_Internal_Sym *isymbuf;
10352 isymbuf = retrieve_local_syms (abfd);
10353 offset = isymbuf[r_symndx].st_value;
10357 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10358 struct elf_link_hash_entry *h =
10359 elf_sym_hashes (abfd)[indx];
10361 while (h->root.type == bfd_link_hash_indirect
10362 || h->root.type == bfd_link_hash_warning)
10363 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10364 if (h->root.type == bfd_link_hash_defined
10365 || h->root.type == bfd_link_hash_defweak)
10366 offset = h->root.u.def.value;
10373 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
10375 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
10376 struct elf_link_hash_entry *h;
10378 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
10379 if (h && h->root.type == bfd_link_hash_defweak)
10386 pcrel_reloc_fits (xtensa_opcode opc,
10388 bfd_vma self_address,
10389 bfd_vma dest_address)
10391 xtensa_isa isa = xtensa_default_isa;
10392 uint32 valp = dest_address;
10393 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
10394 || xtensa_operand_encode (isa, opc, opnd, &valp))
10401 xtensa_is_property_section (asection *sec)
10403 if (xtensa_is_insntable_section (sec)
10404 || xtensa_is_littable_section (sec)
10405 || xtensa_is_proptable_section (sec))
10413 xtensa_is_insntable_section (asection *sec)
10415 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
10416 || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
10424 xtensa_is_littable_section (asection *sec)
10426 if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
10427 || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
10435 xtensa_is_proptable_section (asection *sec)
10437 if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
10438 || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
10446 internal_reloc_compare (const void *ap, const void *bp)
10448 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10449 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10451 if (a->r_offset != b->r_offset)
10452 return (a->r_offset - b->r_offset);
10454 /* We don't need to sort on these criteria for correctness,
10455 but enforcing a more strict ordering prevents unstable qsort
10456 from behaving differently with different implementations.
10457 Without the code below we get correct but different results
10458 on Solaris 2.7 and 2.8. We would like to always produce the
10459 same results no matter the host. */
10461 if (a->r_info != b->r_info)
10462 return (a->r_info - b->r_info);
10464 return (a->r_addend - b->r_addend);
10469 internal_reloc_matches (const void *ap, const void *bp)
10471 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10472 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10474 /* Check if one entry overlaps with the other; this shouldn't happen
10475 except when searching for a match. */
10476 return (a->r_offset - b->r_offset);
10480 /* Predicate function used to look up a section in a particular group. */
10483 match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
10485 const char *gname = inf;
10486 const char *group_name = elf_group_name (sec);
10488 return (group_name == gname
10489 || (group_name != NULL
10491 && strcmp (group_name, gname) == 0));
10495 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
10498 xtensa_property_section_name (asection *sec, const char *base_name)
10500 const char *suffix, *group_name;
10501 char *prop_sec_name;
10503 group_name = elf_group_name (sec);
10506 suffix = strrchr (sec->name, '.');
10507 if (suffix == sec->name)
10509 prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
10510 + (suffix ? strlen (suffix) : 0));
10511 strcpy (prop_sec_name, base_name);
10513 strcat (prop_sec_name, suffix);
10515 else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
10517 char *linkonce_kind = 0;
10519 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
10520 linkonce_kind = "x.";
10521 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
10522 linkonce_kind = "p.";
10523 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
10524 linkonce_kind = "prop.";
10528 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
10529 + strlen (linkonce_kind) + 1);
10530 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
10531 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
10533 suffix = sec->name + linkonce_len;
10534 /* For backward compatibility, replace "t." instead of inserting
10535 the new linkonce_kind (but not for "prop" sections). */
10536 if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
10538 strcat (prop_sec_name + linkonce_len, suffix);
10541 prop_sec_name = strdup (base_name);
10543 return prop_sec_name;
10548 xtensa_get_property_section (asection *sec, const char *base_name)
10550 char *prop_sec_name;
10551 asection *prop_sec;
10553 prop_sec_name = xtensa_property_section_name (sec, base_name);
10554 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10555 match_section_group,
10556 (void *) elf_group_name (sec));
10557 free (prop_sec_name);
10563 xtensa_make_property_section (asection *sec, const char *base_name)
10565 char *prop_sec_name;
10566 asection *prop_sec;
10568 /* Check if the section already exists. */
10569 prop_sec_name = xtensa_property_section_name (sec, base_name);
10570 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10571 match_section_group,
10572 (void *) elf_group_name (sec));
10573 /* If not, create it. */
10576 flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
10577 flags |= (bfd_get_section_flags (sec->owner, sec)
10578 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
10580 prop_sec = bfd_make_section_anyway_with_flags
10581 (sec->owner, strdup (prop_sec_name), flags);
10585 elf_group_name (prop_sec) = elf_group_name (sec);
10588 free (prop_sec_name);
10594 xtensa_get_property_predef_flags (asection *sec)
10596 if (xtensa_is_insntable_section (sec))
10597 return (XTENSA_PROP_INSN
10598 | XTENSA_PROP_NO_TRANSFORM
10599 | XTENSA_PROP_INSN_NO_REORDER);
10601 if (xtensa_is_littable_section (sec))
10602 return (XTENSA_PROP_LITERAL
10603 | XTENSA_PROP_NO_TRANSFORM
10604 | XTENSA_PROP_INSN_NO_REORDER);
10610 /* Other functions called directly by the linker. */
10613 xtensa_callback_required_dependence (bfd *abfd,
10615 struct bfd_link_info *link_info,
10616 deps_callback_t callback,
10619 Elf_Internal_Rela *internal_relocs;
10620 bfd_byte *contents;
10622 bfd_boolean ok = TRUE;
10623 bfd_size_type sec_size;
10625 sec_size = bfd_get_section_limit (abfd, sec);
10627 /* ".plt*" sections have no explicit relocations but they contain L32R
10628 instructions that reference the corresponding ".got.plt*" sections. */
10629 if ((sec->flags & SEC_LINKER_CREATED) != 0
10630 && CONST_STRNEQ (sec->name, ".plt"))
10634 /* Find the corresponding ".got.plt*" section. */
10635 if (sec->name[4] == '\0')
10636 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
10642 BFD_ASSERT (sec->name[4] == '.');
10643 chunk = strtol (&sec->name[5], NULL, 10);
10645 sprintf (got_name, ".got.plt.%u", chunk);
10646 sgotplt = bfd_get_section_by_name (sec->owner, got_name);
10648 BFD_ASSERT (sgotplt);
10650 /* Assume worst-case offsets: L32R at the very end of the ".plt"
10651 section referencing a literal at the very beginning of
10652 ".got.plt". This is very close to the real dependence, anyway. */
10653 (*callback) (sec, sec_size, sgotplt, 0, closure);
10656 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
10657 when building uclibc, which runs "ld -b binary /dev/null". */
10658 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
10661 internal_relocs = retrieve_internal_relocs (abfd, sec,
10662 link_info->keep_memory);
10663 if (internal_relocs == NULL
10664 || sec->reloc_count == 0)
10667 /* Cache the contents for the duration of this scan. */
10668 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
10669 if (contents == NULL && sec_size != 0)
10675 if (!xtensa_default_isa)
10676 xtensa_default_isa = xtensa_isa_init (0, 0);
10678 for (i = 0; i < sec->reloc_count; i++)
10680 Elf_Internal_Rela *irel = &internal_relocs[i];
10681 if (is_l32r_relocation (abfd, sec, contents, irel))
10684 asection *target_sec;
10685 bfd_vma target_offset;
10687 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
10690 /* L32Rs must be local to the input file. */
10691 if (r_reloc_is_defined (&l32r_rel))
10693 target_sec = r_reloc_get_section (&l32r_rel);
10694 target_offset = l32r_rel.target_offset;
10696 (*callback) (sec, irel->r_offset, target_sec, target_offset,
10702 release_internal_relocs (sec, internal_relocs);
10703 release_contents (sec, contents);
10707 /* The default literal sections should always be marked as "code" (i.e.,
10708 SHF_EXECINSTR). This is particularly important for the Linux kernel
10709 module loader so that the literals are not placed after the text. */
10710 static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
10712 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10713 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10714 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10715 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 },
10716 { NULL, 0, 0, 0, 0 }
10720 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
10721 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
10722 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
10723 #define TARGET_BIG_NAME "elf32-xtensa-be"
10724 #define ELF_ARCH bfd_arch_xtensa
10726 #define ELF_MACHINE_CODE EM_XTENSA
10727 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
10730 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
10731 #else /* !XCHAL_HAVE_MMU */
10732 #define ELF_MAXPAGESIZE 1
10733 #endif /* !XCHAL_HAVE_MMU */
10734 #endif /* ELF_ARCH */
10736 #define elf_backend_can_gc_sections 1
10737 #define elf_backend_can_refcount 1
10738 #define elf_backend_plt_readonly 1
10739 #define elf_backend_got_header_size 4
10740 #define elf_backend_want_dynbss 0
10741 #define elf_backend_want_got_plt 1
10743 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
10745 #define bfd_elf32_mkobject elf_xtensa_mkobject
10747 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
10748 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
10749 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
10750 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
10751 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
10752 #define bfd_elf32_bfd_reloc_name_lookup \
10753 elf_xtensa_reloc_name_lookup
10754 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
10755 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
10757 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
10758 #define elf_backend_check_relocs elf_xtensa_check_relocs
10759 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
10760 #define elf_backend_discard_info elf_xtensa_discard_info
10761 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
10762 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
10763 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
10764 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
10765 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
10766 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
10767 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
10768 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
10769 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
10770 #define elf_backend_object_p elf_xtensa_object_p
10771 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
10772 #define elf_backend_relocate_section elf_xtensa_relocate_section
10773 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
10774 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
10775 #define elf_backend_omit_section_dynsym \
10776 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
10777 #define elf_backend_special_sections elf_xtensa_special_sections
10778 #define elf_backend_action_discarded elf_xtensa_action_discarded
10779 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
10781 #include "elf32-target.h"