1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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;
158 /* Rename one of the generic section flags to better document how it
160 /* Whether relocations have been processed. */
161 #define reloc_done sec_flg0
163 static reloc_howto_type elf_howto_table[] =
165 HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
166 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
168 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
169 bfd_elf_xtensa_reloc, "R_XTENSA_32",
170 TRUE, 0xffffffff, 0xffffffff, FALSE),
172 /* Replace a 32-bit value with a value from the runtime linker (only
173 used by linker-generated stub functions). The r_addend value is
174 special: 1 means to substitute a pointer to the runtime linker's
175 dynamic resolver function; 2 means to substitute the link map for
176 the shared object. */
177 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
178 NULL, "R_XTENSA_RTLD", FALSE, 0, 0, FALSE),
180 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
181 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
182 FALSE, 0, 0xffffffff, FALSE),
183 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
184 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
185 FALSE, 0, 0xffffffff, FALSE),
186 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
187 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
188 FALSE, 0, 0xffffffff, FALSE),
189 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
190 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
191 FALSE, 0, 0xffffffff, FALSE),
195 /* Old relocations for backward compatibility. */
196 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
197 bfd_elf_xtensa_reloc, "R_XTENSA_OP0", FALSE, 0, 0, TRUE),
198 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
199 bfd_elf_xtensa_reloc, "R_XTENSA_OP1", FALSE, 0, 0, TRUE),
200 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
201 bfd_elf_xtensa_reloc, "R_XTENSA_OP2", FALSE, 0, 0, TRUE),
203 /* Assembly auto-expansion. */
204 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
205 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND", FALSE, 0, 0, TRUE),
206 /* Relax assembly auto-expansion. */
207 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
208 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY", FALSE, 0, 0, TRUE),
212 HOWTO (R_XTENSA_32_PCREL, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
213 bfd_elf_xtensa_reloc, "R_XTENSA_32_PCREL",
214 FALSE, 0, 0xffffffff, TRUE),
216 /* GNU extension to record C++ vtable hierarchy. */
217 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
218 NULL, "R_XTENSA_GNU_VTINHERIT",
220 /* GNU extension to record C++ vtable member usage. */
221 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
222 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
225 /* Relocations for supporting difference of symbols. */
226 HOWTO (R_XTENSA_DIFF8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
227 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF8", FALSE, 0, 0xff, FALSE),
228 HOWTO (R_XTENSA_DIFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
229 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF16", FALSE, 0, 0xffff, FALSE),
230 HOWTO (R_XTENSA_DIFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
231 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF32", FALSE, 0, 0xffffffff, FALSE),
233 /* General immediate operand relocations. */
234 HOWTO (R_XTENSA_SLOT0_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
235 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_OP", FALSE, 0, 0, TRUE),
236 HOWTO (R_XTENSA_SLOT1_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
237 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_OP", FALSE, 0, 0, TRUE),
238 HOWTO (R_XTENSA_SLOT2_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
239 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_OP", FALSE, 0, 0, TRUE),
240 HOWTO (R_XTENSA_SLOT3_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
241 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_OP", FALSE, 0, 0, TRUE),
242 HOWTO (R_XTENSA_SLOT4_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
243 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_OP", FALSE, 0, 0, TRUE),
244 HOWTO (R_XTENSA_SLOT5_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
245 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_OP", FALSE, 0, 0, TRUE),
246 HOWTO (R_XTENSA_SLOT6_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
247 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_OP", FALSE, 0, 0, TRUE),
248 HOWTO (R_XTENSA_SLOT7_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
249 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_OP", FALSE, 0, 0, TRUE),
250 HOWTO (R_XTENSA_SLOT8_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
251 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_OP", FALSE, 0, 0, TRUE),
252 HOWTO (R_XTENSA_SLOT9_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
253 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_OP", FALSE, 0, 0, TRUE),
254 HOWTO (R_XTENSA_SLOT10_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
255 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_OP", FALSE, 0, 0, TRUE),
256 HOWTO (R_XTENSA_SLOT11_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
257 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_OP", FALSE, 0, 0, TRUE),
258 HOWTO (R_XTENSA_SLOT12_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
259 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_OP", FALSE, 0, 0, TRUE),
260 HOWTO (R_XTENSA_SLOT13_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
261 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_OP", FALSE, 0, 0, TRUE),
262 HOWTO (R_XTENSA_SLOT14_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
263 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_OP", FALSE, 0, 0, TRUE),
265 /* "Alternate" relocations. The meaning of these is opcode-specific. */
266 HOWTO (R_XTENSA_SLOT0_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
267 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_ALT", FALSE, 0, 0, TRUE),
268 HOWTO (R_XTENSA_SLOT1_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
269 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_ALT", FALSE, 0, 0, TRUE),
270 HOWTO (R_XTENSA_SLOT2_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
271 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_ALT", FALSE, 0, 0, TRUE),
272 HOWTO (R_XTENSA_SLOT3_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
273 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_ALT", FALSE, 0, 0, TRUE),
274 HOWTO (R_XTENSA_SLOT4_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
275 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_ALT", FALSE, 0, 0, TRUE),
276 HOWTO (R_XTENSA_SLOT5_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
277 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_ALT", FALSE, 0, 0, TRUE),
278 HOWTO (R_XTENSA_SLOT6_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
279 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_ALT", FALSE, 0, 0, TRUE),
280 HOWTO (R_XTENSA_SLOT7_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
281 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_ALT", FALSE, 0, 0, TRUE),
282 HOWTO (R_XTENSA_SLOT8_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
283 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_ALT", FALSE, 0, 0, TRUE),
284 HOWTO (R_XTENSA_SLOT9_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
285 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_ALT", FALSE, 0, 0, TRUE),
286 HOWTO (R_XTENSA_SLOT10_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
287 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_ALT", FALSE, 0, 0, TRUE),
288 HOWTO (R_XTENSA_SLOT11_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
289 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_ALT", FALSE, 0, 0, TRUE),
290 HOWTO (R_XTENSA_SLOT12_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
291 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_ALT", FALSE, 0, 0, TRUE),
292 HOWTO (R_XTENSA_SLOT13_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
293 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_ALT", FALSE, 0, 0, TRUE),
294 HOWTO (R_XTENSA_SLOT14_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
295 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_ALT", FALSE, 0, 0, TRUE),
297 /* TLS relocations. */
298 HOWTO (R_XTENSA_TLSDESC_FN, 0, 2, 32, FALSE, 0, complain_overflow_dont,
299 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_FN",
300 FALSE, 0, 0xffffffff, FALSE),
301 HOWTO (R_XTENSA_TLSDESC_ARG, 0, 2, 32, FALSE, 0, complain_overflow_dont,
302 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_ARG",
303 FALSE, 0, 0xffffffff, FALSE),
304 HOWTO (R_XTENSA_TLS_DTPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
305 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_DTPOFF",
306 FALSE, 0, 0xffffffff, FALSE),
307 HOWTO (R_XTENSA_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
308 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_TPOFF",
309 FALSE, 0, 0xffffffff, FALSE),
310 HOWTO (R_XTENSA_TLS_FUNC, 0, 0, 0, FALSE, 0, complain_overflow_dont,
311 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_FUNC",
313 HOWTO (R_XTENSA_TLS_ARG, 0, 0, 0, FALSE, 0, complain_overflow_dont,
314 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_ARG",
316 HOWTO (R_XTENSA_TLS_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
317 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_CALL",
323 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
328 static reloc_howto_type *
329 elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
330 bfd_reloc_code_real_type code)
335 TRACE ("BFD_RELOC_NONE");
336 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
339 TRACE ("BFD_RELOC_32");
340 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
342 case BFD_RELOC_32_PCREL:
343 TRACE ("BFD_RELOC_32_PCREL");
344 return &elf_howto_table[(unsigned) R_XTENSA_32_PCREL ];
346 case BFD_RELOC_XTENSA_DIFF8:
347 TRACE ("BFD_RELOC_XTENSA_DIFF8");
348 return &elf_howto_table[(unsigned) R_XTENSA_DIFF8 ];
350 case BFD_RELOC_XTENSA_DIFF16:
351 TRACE ("BFD_RELOC_XTENSA_DIFF16");
352 return &elf_howto_table[(unsigned) R_XTENSA_DIFF16 ];
354 case BFD_RELOC_XTENSA_DIFF32:
355 TRACE ("BFD_RELOC_XTENSA_DIFF32");
356 return &elf_howto_table[(unsigned) R_XTENSA_DIFF32 ];
358 case BFD_RELOC_XTENSA_RTLD:
359 TRACE ("BFD_RELOC_XTENSA_RTLD");
360 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
362 case BFD_RELOC_XTENSA_GLOB_DAT:
363 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
364 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
366 case BFD_RELOC_XTENSA_JMP_SLOT:
367 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
368 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
370 case BFD_RELOC_XTENSA_RELATIVE:
371 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
372 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
374 case BFD_RELOC_XTENSA_PLT:
375 TRACE ("BFD_RELOC_XTENSA_PLT");
376 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
378 case BFD_RELOC_XTENSA_OP0:
379 TRACE ("BFD_RELOC_XTENSA_OP0");
380 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
382 case BFD_RELOC_XTENSA_OP1:
383 TRACE ("BFD_RELOC_XTENSA_OP1");
384 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
386 case BFD_RELOC_XTENSA_OP2:
387 TRACE ("BFD_RELOC_XTENSA_OP2");
388 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
390 case BFD_RELOC_XTENSA_ASM_EXPAND:
391 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
392 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
394 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
395 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
396 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
398 case BFD_RELOC_VTABLE_INHERIT:
399 TRACE ("BFD_RELOC_VTABLE_INHERIT");
400 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
402 case BFD_RELOC_VTABLE_ENTRY:
403 TRACE ("BFD_RELOC_VTABLE_ENTRY");
404 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
406 case BFD_RELOC_XTENSA_TLSDESC_FN:
407 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
408 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_FN ];
410 case BFD_RELOC_XTENSA_TLSDESC_ARG:
411 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
412 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_ARG ];
414 case BFD_RELOC_XTENSA_TLS_DTPOFF:
415 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
416 return &elf_howto_table[(unsigned) R_XTENSA_TLS_DTPOFF ];
418 case BFD_RELOC_XTENSA_TLS_TPOFF:
419 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
420 return &elf_howto_table[(unsigned) R_XTENSA_TLS_TPOFF ];
422 case BFD_RELOC_XTENSA_TLS_FUNC:
423 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
424 return &elf_howto_table[(unsigned) R_XTENSA_TLS_FUNC ];
426 case BFD_RELOC_XTENSA_TLS_ARG:
427 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
428 return &elf_howto_table[(unsigned) R_XTENSA_TLS_ARG ];
430 case BFD_RELOC_XTENSA_TLS_CALL:
431 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
432 return &elf_howto_table[(unsigned) R_XTENSA_TLS_CALL ];
435 if (code >= BFD_RELOC_XTENSA_SLOT0_OP
436 && code <= BFD_RELOC_XTENSA_SLOT14_OP)
438 unsigned n = (R_XTENSA_SLOT0_OP +
439 (code - BFD_RELOC_XTENSA_SLOT0_OP));
440 return &elf_howto_table[n];
443 if (code >= BFD_RELOC_XTENSA_SLOT0_ALT
444 && code <= BFD_RELOC_XTENSA_SLOT14_ALT)
446 unsigned n = (R_XTENSA_SLOT0_ALT +
447 (code - BFD_RELOC_XTENSA_SLOT0_ALT));
448 return &elf_howto_table[n];
458 static reloc_howto_type *
459 elf_xtensa_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
464 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
465 if (elf_howto_table[i].name != NULL
466 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
467 return &elf_howto_table[i];
473 /* Given an ELF "rela" relocation, find the corresponding howto and record
474 it in the BFD internal arelent representation of the relocation. */
477 elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
479 Elf_Internal_Rela *dst)
481 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
483 BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max);
484 cache_ptr->howto = &elf_howto_table[r_type];
488 /* Functions for the Xtensa ELF linker. */
490 /* The name of the dynamic interpreter. This is put in the .interp
493 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
495 /* The size in bytes of an entry in the procedure linkage table.
496 (This does _not_ include the space for the literals associated with
499 #define PLT_ENTRY_SIZE 16
501 /* For _really_ large PLTs, we may need to alternate between literals
502 and code to keep the literals within the 256K range of the L32R
503 instructions in the code. It's unlikely that anyone would ever need
504 such a big PLT, but an arbitrary limit on the PLT size would be bad.
505 Thus, we split the PLT into chunks. Since there's very little
506 overhead (2 extra literals) for each chunk, the chunk size is kept
507 small so that the code for handling multiple chunks get used and
508 tested regularly. With 254 entries, there are 1K of literals for
509 each chunk, and that seems like a nice round number. */
511 #define PLT_ENTRIES_PER_CHUNK 254
513 /* PLT entries are actually used as stub functions for lazy symbol
514 resolution. Once the symbol is resolved, the stub function is never
515 invoked. Note: the 32-byte frame size used here cannot be changed
516 without a corresponding change in the runtime linker. */
518 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
520 0x6c, 0x10, 0x04, /* entry sp, 32 */
521 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
522 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
523 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
524 0x0a, 0x80, 0x00, /* jx a8 */
528 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
530 0x36, 0x41, 0x00, /* entry sp, 32 */
531 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
532 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
533 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
534 0xa0, 0x08, 0x00, /* jx a8 */
538 /* The size of the thread control block. */
541 struct elf_xtensa_link_hash_entry
543 struct elf_link_hash_entry elf;
545 bfd_signed_vma tlsfunc_refcount;
547 #define GOT_UNKNOWN 0
549 #define GOT_TLS_GD 2 /* global or local dynamic */
550 #define GOT_TLS_IE 4 /* initial or local exec */
551 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
552 unsigned char tls_type;
555 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
557 struct elf_xtensa_obj_tdata
559 struct elf_obj_tdata root;
561 /* tls_type for each local got entry. */
562 char *local_got_tls_type;
564 bfd_signed_vma *local_tlsfunc_refcounts;
567 #define elf_xtensa_tdata(abfd) \
568 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
570 #define elf_xtensa_local_got_tls_type(abfd) \
571 (elf_xtensa_tdata (abfd)->local_got_tls_type)
573 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
574 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
576 #define is_xtensa_elf(bfd) \
577 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
578 && elf_tdata (bfd) != NULL \
579 && elf_object_id (bfd) == XTENSA_ELF_DATA)
582 elf_xtensa_mkobject (bfd *abfd)
584 return bfd_elf_allocate_object (abfd, sizeof (struct elf_xtensa_obj_tdata),
588 /* Xtensa ELF linker hash table. */
590 struct elf_xtensa_link_hash_table
592 struct elf_link_hash_table elf;
594 /* Short-cuts to get to dynamic linker sections. */
601 asection *spltlittbl;
603 /* Total count of PLT relocations seen during check_relocs.
604 The actual PLT code must be split into multiple sections and all
605 the sections have to be created before size_dynamic_sections,
606 where we figure out the exact number of PLT entries that will be
607 needed. It is OK if this count is an overestimate, e.g., some
608 relocations may be removed by GC. */
611 struct elf_xtensa_link_hash_entry *tlsbase;
614 /* Get the Xtensa ELF linker hash table from a link_info structure. */
616 #define elf_xtensa_hash_table(p) \
617 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
618 == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
620 /* Create an entry in an Xtensa ELF linker hash table. */
622 static struct bfd_hash_entry *
623 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry *entry,
624 struct bfd_hash_table *table,
627 /* Allocate the structure if it has not already been allocated by a
631 entry = bfd_hash_allocate (table,
632 sizeof (struct elf_xtensa_link_hash_entry));
637 /* Call the allocation method of the superclass. */
638 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
641 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (entry);
642 eh->tlsfunc_refcount = 0;
643 eh->tls_type = GOT_UNKNOWN;
649 /* Create an Xtensa ELF linker hash table. */
651 static struct bfd_link_hash_table *
652 elf_xtensa_link_hash_table_create (bfd *abfd)
654 struct elf_link_hash_entry *tlsbase;
655 struct elf_xtensa_link_hash_table *ret;
656 bfd_size_type amt = sizeof (struct elf_xtensa_link_hash_table);
658 ret = bfd_malloc (amt);
662 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
663 elf_xtensa_link_hash_newfunc,
664 sizeof (struct elf_xtensa_link_hash_entry),
677 ret->spltlittbl = NULL;
679 ret->plt_reloc_count = 0;
681 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
683 tlsbase = elf_link_hash_lookup (&ret->elf, "_TLS_MODULE_BASE_",
685 tlsbase->root.type = bfd_link_hash_new;
686 tlsbase->root.u.undef.abfd = NULL;
687 tlsbase->non_elf = 0;
688 ret->tlsbase = elf_xtensa_hash_entry (tlsbase);
689 ret->tlsbase->tls_type = GOT_UNKNOWN;
691 return &ret->elf.root;
694 /* Copy the extra info we tack onto an elf_link_hash_entry. */
697 elf_xtensa_copy_indirect_symbol (struct bfd_link_info *info,
698 struct elf_link_hash_entry *dir,
699 struct elf_link_hash_entry *ind)
701 struct elf_xtensa_link_hash_entry *edir, *eind;
703 edir = elf_xtensa_hash_entry (dir);
704 eind = elf_xtensa_hash_entry (ind);
706 if (ind->root.type == bfd_link_hash_indirect)
708 edir->tlsfunc_refcount += eind->tlsfunc_refcount;
709 eind->tlsfunc_refcount = 0;
711 if (dir->got.refcount <= 0)
713 edir->tls_type = eind->tls_type;
714 eind->tls_type = GOT_UNKNOWN;
718 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
721 static inline bfd_boolean
722 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry *h,
723 struct bfd_link_info *info)
725 /* Check if we should do dynamic things to this symbol. The
726 "ignore_protected" argument need not be set, because Xtensa code
727 does not require special handling of STV_PROTECTED to make function
728 pointer comparisons work properly. The PLT addresses are never
729 used for function pointers. */
731 return _bfd_elf_dynamic_symbol_p (h, info, 0);
736 property_table_compare (const void *ap, const void *bp)
738 const property_table_entry *a = (const property_table_entry *) ap;
739 const property_table_entry *b = (const property_table_entry *) bp;
741 if (a->address == b->address)
743 if (a->size != b->size)
744 return (a->size - b->size);
746 if ((a->flags & XTENSA_PROP_ALIGN) != (b->flags & XTENSA_PROP_ALIGN))
747 return ((b->flags & XTENSA_PROP_ALIGN)
748 - (a->flags & XTENSA_PROP_ALIGN));
750 if ((a->flags & XTENSA_PROP_ALIGN)
751 && (GET_XTENSA_PROP_ALIGNMENT (a->flags)
752 != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
753 return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
754 - GET_XTENSA_PROP_ALIGNMENT (b->flags));
756 if ((a->flags & XTENSA_PROP_UNREACHABLE)
757 != (b->flags & XTENSA_PROP_UNREACHABLE))
758 return ((b->flags & XTENSA_PROP_UNREACHABLE)
759 - (a->flags & XTENSA_PROP_UNREACHABLE));
761 return (a->flags - b->flags);
764 return (a->address - b->address);
769 property_table_matches (const void *ap, const void *bp)
771 const property_table_entry *a = (const property_table_entry *) ap;
772 const property_table_entry *b = (const property_table_entry *) bp;
774 /* Check if one entry overlaps with the other. */
775 if ((b->address >= a->address && b->address < (a->address + a->size))
776 || (a->address >= b->address && a->address < (b->address + b->size)))
779 return (a->address - b->address);
783 /* Get the literal table or property table entries for the given
784 section. Sets TABLE_P and returns the number of entries. On
785 error, returns a negative value. */
788 xtensa_read_table_entries (bfd *abfd,
790 property_table_entry **table_p,
791 const char *sec_name,
792 bfd_boolean output_addr)
794 asection *table_section;
795 bfd_size_type table_size = 0;
796 bfd_byte *table_data;
797 property_table_entry *blocks;
798 int blk, block_count;
799 bfd_size_type num_records;
800 Elf_Internal_Rela *internal_relocs, *irel, *rel_end;
801 bfd_vma section_addr, off;
802 flagword predef_flags;
803 bfd_size_type table_entry_size, section_limit;
806 || !(section->flags & SEC_ALLOC)
807 || (section->flags & SEC_DEBUGGING))
813 table_section = xtensa_get_property_section (section, sec_name);
815 table_size = table_section->size;
823 predef_flags = xtensa_get_property_predef_flags (table_section);
824 table_entry_size = 12;
826 table_entry_size -= 4;
828 num_records = table_size / table_entry_size;
829 table_data = retrieve_contents (abfd, table_section, TRUE);
830 blocks = (property_table_entry *)
831 bfd_malloc (num_records * sizeof (property_table_entry));
835 section_addr = section->output_section->vma + section->output_offset;
837 section_addr = section->vma;
839 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
840 if (internal_relocs && !table_section->reloc_done)
842 qsort (internal_relocs, table_section->reloc_count,
843 sizeof (Elf_Internal_Rela), internal_reloc_compare);
844 irel = internal_relocs;
849 section_limit = bfd_get_section_limit (abfd, section);
850 rel_end = internal_relocs + table_section->reloc_count;
852 for (off = 0; off < table_size; off += table_entry_size)
854 bfd_vma address = bfd_get_32 (abfd, table_data + off);
856 /* Skip any relocations before the current offset. This should help
857 avoid confusion caused by unexpected relocations for the preceding
860 (irel->r_offset < off
861 || (irel->r_offset == off
862 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_NONE)))
869 if (irel && irel->r_offset == off)
872 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
873 BFD_ASSERT (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32);
875 if (get_elf_r_symndx_section (abfd, r_symndx) != section)
878 sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
879 BFD_ASSERT (sym_off == 0);
880 address += (section_addr + sym_off + irel->r_addend);
884 if (address < section_addr
885 || address >= section_addr + section_limit)
889 blocks[block_count].address = address;
890 blocks[block_count].size = bfd_get_32 (abfd, table_data + off + 4);
892 blocks[block_count].flags = predef_flags;
894 blocks[block_count].flags = bfd_get_32 (abfd, table_data + off + 8);
898 release_contents (table_section, table_data);
899 release_internal_relocs (table_section, internal_relocs);
903 /* Now sort them into address order for easy reference. */
904 qsort (blocks, block_count, sizeof (property_table_entry),
905 property_table_compare);
907 /* Check that the table contents are valid. Problems may occur,
908 for example, if an unrelocated object file is stripped. */
909 for (blk = 1; blk < block_count; blk++)
911 /* The only circumstance where two entries may legitimately
912 have the same address is when one of them is a zero-size
913 placeholder to mark a place where fill can be inserted.
914 The zero-size entry should come first. */
915 if (blocks[blk - 1].address == blocks[blk].address &&
916 blocks[blk - 1].size != 0)
918 (*_bfd_error_handler) (_("%B(%A): invalid property table"),
920 bfd_set_error (bfd_error_bad_value);
932 static property_table_entry *
933 elf_xtensa_find_property_entry (property_table_entry *property_table,
934 int property_table_size,
937 property_table_entry entry;
938 property_table_entry *rv;
940 if (property_table_size == 0)
943 entry.address = addr;
947 rv = bsearch (&entry, property_table, property_table_size,
948 sizeof (property_table_entry), property_table_matches);
954 elf_xtensa_in_literal_pool (property_table_entry *lit_table,
958 if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
965 /* Look through the relocs for a section during the first phase, and
966 calculate needed space in the dynamic reloc sections. */
969 elf_xtensa_check_relocs (bfd *abfd,
970 struct bfd_link_info *info,
972 const Elf_Internal_Rela *relocs)
974 struct elf_xtensa_link_hash_table *htab;
975 Elf_Internal_Shdr *symtab_hdr;
976 struct elf_link_hash_entry **sym_hashes;
977 const Elf_Internal_Rela *rel;
978 const Elf_Internal_Rela *rel_end;
980 if (info->relocatable || (sec->flags & SEC_ALLOC) == 0)
983 BFD_ASSERT (is_xtensa_elf (abfd));
985 htab = elf_xtensa_hash_table (info);
989 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
990 sym_hashes = elf_sym_hashes (abfd);
992 rel_end = relocs + sec->reloc_count;
993 for (rel = relocs; rel < rel_end; rel++)
996 unsigned long r_symndx;
997 struct elf_link_hash_entry *h = NULL;
998 struct elf_xtensa_link_hash_entry *eh;
999 int tls_type, old_tls_type;
1000 bfd_boolean is_got = FALSE;
1001 bfd_boolean is_plt = FALSE;
1002 bfd_boolean is_tlsfunc = FALSE;
1004 r_symndx = ELF32_R_SYM (rel->r_info);
1005 r_type = ELF32_R_TYPE (rel->r_info);
1007 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1009 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1014 if (r_symndx >= symtab_hdr->sh_info)
1016 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1017 while (h->root.type == bfd_link_hash_indirect
1018 || h->root.type == bfd_link_hash_warning)
1019 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1021 eh = elf_xtensa_hash_entry (h);
1025 case R_XTENSA_TLSDESC_FN:
1028 tls_type = GOT_TLS_GD;
1033 tls_type = GOT_TLS_IE;
1036 case R_XTENSA_TLSDESC_ARG:
1039 tls_type = GOT_TLS_GD;
1044 tls_type = GOT_TLS_IE;
1045 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1050 case R_XTENSA_TLS_DTPOFF:
1052 tls_type = GOT_TLS_GD;
1054 tls_type = GOT_TLS_IE;
1057 case R_XTENSA_TLS_TPOFF:
1058 tls_type = GOT_TLS_IE;
1060 info->flags |= DF_STATIC_TLS;
1061 if (info->shared || h)
1066 tls_type = GOT_NORMAL;
1071 tls_type = GOT_NORMAL;
1075 case R_XTENSA_GNU_VTINHERIT:
1076 /* This relocation describes the C++ object vtable hierarchy.
1077 Reconstruct it for later use during GC. */
1078 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1082 case R_XTENSA_GNU_VTENTRY:
1083 /* This relocation describes which C++ vtable entries are actually
1084 used. Record for later use during GC. */
1085 BFD_ASSERT (h != NULL);
1087 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1092 /* Nothing to do for any other relocations. */
1100 if (h->plt.refcount <= 0)
1103 h->plt.refcount = 1;
1106 h->plt.refcount += 1;
1108 /* Keep track of the total PLT relocation count even if we
1109 don't yet know whether the dynamic sections will be
1111 htab->plt_reloc_count += 1;
1113 if (elf_hash_table (info)->dynamic_sections_created)
1115 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1121 if (h->got.refcount <= 0)
1122 h->got.refcount = 1;
1124 h->got.refcount += 1;
1128 eh->tlsfunc_refcount += 1;
1130 old_tls_type = eh->tls_type;
1134 /* Allocate storage the first time. */
1135 if (elf_local_got_refcounts (abfd) == NULL)
1137 bfd_size_type size = symtab_hdr->sh_info;
1140 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1143 elf_local_got_refcounts (abfd) = (bfd_signed_vma *) mem;
1145 mem = bfd_zalloc (abfd, size);
1148 elf_xtensa_local_got_tls_type (abfd) = (char *) mem;
1150 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1153 elf_xtensa_local_tlsfunc_refcounts (abfd)
1154 = (bfd_signed_vma *) mem;
1157 /* This is a global offset table entry for a local symbol. */
1158 if (is_got || is_plt)
1159 elf_local_got_refcounts (abfd) [r_symndx] += 1;
1162 elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx] += 1;
1164 old_tls_type = elf_xtensa_local_got_tls_type (abfd) [r_symndx];
1167 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1168 tls_type |= old_tls_type;
1169 /* If a TLS symbol is accessed using IE at least once,
1170 there is no point to use a dynamic model for it. */
1171 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1172 && ((old_tls_type & GOT_TLS_GD) == 0
1173 || (tls_type & GOT_TLS_IE) == 0))
1175 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_GD))
1176 tls_type = old_tls_type;
1177 else if ((old_tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_GD))
1178 tls_type |= old_tls_type;
1181 (*_bfd_error_handler)
1182 (_("%B: `%s' accessed both as normal and thread local symbol"),
1184 h ? h->root.root.string : "<local>");
1189 if (old_tls_type != tls_type)
1192 eh->tls_type = tls_type;
1194 elf_xtensa_local_got_tls_type (abfd) [r_symndx] = tls_type;
1203 elf_xtensa_make_sym_local (struct bfd_link_info *info,
1204 struct elf_link_hash_entry *h)
1208 if (h->plt.refcount > 0)
1210 /* For shared objects, there's no need for PLT entries for local
1211 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1212 if (h->got.refcount < 0)
1213 h->got.refcount = 0;
1214 h->got.refcount += h->plt.refcount;
1215 h->plt.refcount = 0;
1220 /* Don't need any dynamic relocations at all. */
1221 h->plt.refcount = 0;
1222 h->got.refcount = 0;
1228 elf_xtensa_hide_symbol (struct bfd_link_info *info,
1229 struct elf_link_hash_entry *h,
1230 bfd_boolean force_local)
1232 /* For a shared link, move the plt refcount to the got refcount to leave
1233 space for RELATIVE relocs. */
1234 elf_xtensa_make_sym_local (info, h);
1236 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
1240 /* Return the section that should be marked against GC for a given
1244 elf_xtensa_gc_mark_hook (asection *sec,
1245 struct bfd_link_info *info,
1246 Elf_Internal_Rela *rel,
1247 struct elf_link_hash_entry *h,
1248 Elf_Internal_Sym *sym)
1250 /* Property sections are marked "KEEP" in the linker scripts, but they
1251 should not cause other sections to be marked. (This approach relies
1252 on elf_xtensa_discard_info to remove property table entries that
1253 describe discarded sections. Alternatively, it might be more
1254 efficient to avoid using "KEEP" in the linker scripts and instead use
1255 the gc_mark_extra_sections hook to mark only the property sections
1256 that describe marked sections. That alternative does not work well
1257 with the current property table sections, which do not correspond
1258 one-to-one with the sections they describe, but that should be fixed
1260 if (xtensa_is_property_section (sec))
1264 switch (ELF32_R_TYPE (rel->r_info))
1266 case R_XTENSA_GNU_VTINHERIT:
1267 case R_XTENSA_GNU_VTENTRY:
1271 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1275 /* Update the GOT & PLT entry reference counts
1276 for the section being removed. */
1279 elf_xtensa_gc_sweep_hook (bfd *abfd,
1280 struct bfd_link_info *info,
1282 const Elf_Internal_Rela *relocs)
1284 Elf_Internal_Shdr *symtab_hdr;
1285 struct elf_link_hash_entry **sym_hashes;
1286 const Elf_Internal_Rela *rel, *relend;
1287 struct elf_xtensa_link_hash_table *htab;
1289 htab = elf_xtensa_hash_table (info);
1293 if (info->relocatable)
1296 if ((sec->flags & SEC_ALLOC) == 0)
1299 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1300 sym_hashes = elf_sym_hashes (abfd);
1302 relend = relocs + sec->reloc_count;
1303 for (rel = relocs; rel < relend; rel++)
1305 unsigned long r_symndx;
1306 unsigned int r_type;
1307 struct elf_link_hash_entry *h = NULL;
1308 struct elf_xtensa_link_hash_entry *eh;
1309 bfd_boolean is_got = FALSE;
1310 bfd_boolean is_plt = FALSE;
1311 bfd_boolean is_tlsfunc = FALSE;
1313 r_symndx = ELF32_R_SYM (rel->r_info);
1314 if (r_symndx >= symtab_hdr->sh_info)
1316 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1317 while (h->root.type == bfd_link_hash_indirect
1318 || h->root.type == bfd_link_hash_warning)
1319 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1321 eh = elf_xtensa_hash_entry (h);
1323 r_type = ELF32_R_TYPE (rel->r_info);
1326 case R_XTENSA_TLSDESC_FN:
1334 case R_XTENSA_TLSDESC_ARG:
1339 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1344 case R_XTENSA_TLS_TPOFF:
1345 if (info->shared || h)
1365 if (h->plt.refcount > 0)
1370 if (h->got.refcount > 0)
1375 if (eh->tlsfunc_refcount > 0)
1376 eh->tlsfunc_refcount--;
1381 if (is_got || is_plt)
1383 bfd_signed_vma *got_refcount
1384 = &elf_local_got_refcounts (abfd) [r_symndx];
1385 if (*got_refcount > 0)
1390 bfd_signed_vma *tlsfunc_refcount
1391 = &elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx];
1392 if (*tlsfunc_refcount > 0)
1393 *tlsfunc_refcount -= 1;
1402 /* Create all the dynamic sections. */
1405 elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1407 struct elf_xtensa_link_hash_table *htab;
1408 flagword flags, noalloc_flags;
1410 htab = elf_xtensa_hash_table (info);
1414 /* First do all the standard stuff. */
1415 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
1417 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1418 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1419 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1420 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1421 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1423 /* Create any extra PLT sections in case check_relocs has already
1424 been called on all the non-dynamic input files. */
1425 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1428 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
1429 | SEC_LINKER_CREATED | SEC_READONLY);
1430 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
1432 /* Mark the ".got.plt" section READONLY. */
1433 if (htab->sgotplt == NULL
1434 || ! bfd_set_section_flags (dynobj, htab->sgotplt, flags))
1437 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1438 htab->sgotloc = bfd_make_section_with_flags (dynobj, ".got.loc", flags);
1439 if (htab->sgotloc == NULL
1440 || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
1443 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1444 htab->spltlittbl = bfd_make_section_with_flags (dynobj, ".xt.lit.plt",
1446 if (htab->spltlittbl == NULL
1447 || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
1455 add_extra_plt_sections (struct bfd_link_info *info, int count)
1457 bfd *dynobj = elf_hash_table (info)->dynobj;
1460 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1461 ".got.plt" sections. */
1462 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1468 /* Stop when we find a section has already been created. */
1469 if (elf_xtensa_get_plt_section (info, chunk))
1472 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1473 | SEC_LINKER_CREATED | SEC_READONLY);
1475 sname = (char *) bfd_malloc (10);
1476 sprintf (sname, ".plt.%u", chunk);
1477 s = bfd_make_section_with_flags (dynobj, sname, flags | SEC_CODE);
1479 || ! bfd_set_section_alignment (dynobj, s, 2))
1482 sname = (char *) bfd_malloc (14);
1483 sprintf (sname, ".got.plt.%u", chunk);
1484 s = bfd_make_section_with_flags (dynobj, sname, flags);
1486 || ! bfd_set_section_alignment (dynobj, s, 2))
1494 /* Adjust a symbol defined by a dynamic object and referenced by a
1495 regular object. The current definition is in some section of the
1496 dynamic object, but we're not including those sections. We have to
1497 change the definition to something the rest of the link can
1501 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1502 struct elf_link_hash_entry *h)
1504 /* If this is a weak symbol, and there is a real definition, the
1505 processor independent code will have arranged for us to see the
1506 real definition first, and we can just use the same value. */
1509 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1510 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1511 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1512 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1516 /* This is a reference to a symbol defined by a dynamic object. The
1517 reference must go through the GOT, so there's no need for COPY relocs,
1525 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry *h, void *arg)
1527 struct bfd_link_info *info;
1528 struct elf_xtensa_link_hash_table *htab;
1529 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (h);
1531 if (h->root.type == bfd_link_hash_indirect)
1534 info = (struct bfd_link_info *) arg;
1535 htab = elf_xtensa_hash_table (info);
1539 /* If we saw any use of an IE model for this symbol, we can then optimize
1540 away GOT entries for any TLSDESC_FN relocs. */
1541 if ((eh->tls_type & GOT_TLS_IE) != 0)
1543 BFD_ASSERT (h->got.refcount >= eh->tlsfunc_refcount);
1544 h->got.refcount -= eh->tlsfunc_refcount;
1547 if (! elf_xtensa_dynamic_symbol_p (h, info))
1548 elf_xtensa_make_sym_local (info, h);
1550 if (h->plt.refcount > 0)
1551 htab->srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1553 if (h->got.refcount > 0)
1554 htab->srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
1561 elf_xtensa_allocate_local_got_size (struct bfd_link_info *info)
1563 struct elf_xtensa_link_hash_table *htab;
1566 htab = elf_xtensa_hash_table (info);
1570 for (i = info->input_bfds; i; i = i->link_next)
1572 bfd_signed_vma *local_got_refcounts;
1573 bfd_size_type j, cnt;
1574 Elf_Internal_Shdr *symtab_hdr;
1576 local_got_refcounts = elf_local_got_refcounts (i);
1577 if (!local_got_refcounts)
1580 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1581 cnt = symtab_hdr->sh_info;
1583 for (j = 0; j < cnt; ++j)
1585 /* If we saw any use of an IE model for this symbol, we can
1586 then optimize away GOT entries for any TLSDESC_FN relocs. */
1587 if ((elf_xtensa_local_got_tls_type (i) [j] & GOT_TLS_IE) != 0)
1589 bfd_signed_vma *tlsfunc_refcount
1590 = &elf_xtensa_local_tlsfunc_refcounts (i) [j];
1591 BFD_ASSERT (local_got_refcounts[j] >= *tlsfunc_refcount);
1592 local_got_refcounts[j] -= *tlsfunc_refcount;
1595 if (local_got_refcounts[j] > 0)
1596 htab->srelgot->size += (local_got_refcounts[j]
1597 * sizeof (Elf32_External_Rela));
1603 /* Set the sizes of the dynamic sections. */
1606 elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1607 struct bfd_link_info *info)
1609 struct elf_xtensa_link_hash_table *htab;
1611 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1612 bfd_boolean relplt, relgot;
1613 int plt_entries, plt_chunks, chunk;
1618 htab = elf_xtensa_hash_table (info);
1622 dynobj = elf_hash_table (info)->dynobj;
1625 srelgot = htab->srelgot;
1626 srelplt = htab->srelplt;
1628 if (elf_hash_table (info)->dynamic_sections_created)
1630 BFD_ASSERT (htab->srelgot != NULL
1631 && htab->srelplt != NULL
1632 && htab->sgot != NULL
1633 && htab->spltlittbl != NULL
1634 && htab->sgotloc != NULL);
1636 /* Set the contents of the .interp section to the interpreter. */
1637 if (info->executable)
1639 s = bfd_get_section_by_name (dynobj, ".interp");
1642 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1643 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1646 /* Allocate room for one word in ".got". */
1647 htab->sgot->size = 4;
1649 /* Allocate space in ".rela.got" for literals that reference global
1650 symbols and space in ".rela.plt" for literals that have PLT
1652 elf_link_hash_traverse (elf_hash_table (info),
1653 elf_xtensa_allocate_dynrelocs,
1656 /* If we are generating a shared object, we also need space in
1657 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1658 reference local symbols. */
1660 elf_xtensa_allocate_local_got_size (info);
1662 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1663 each PLT entry, we need the PLT code plus a 4-byte literal.
1664 For each chunk of ".plt", we also need two more 4-byte
1665 literals, two corresponding entries in ".rela.got", and an
1666 8-byte entry in ".xt.lit.plt". */
1667 spltlittbl = htab->spltlittbl;
1668 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
1670 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1672 /* Iterate over all the PLT chunks, including any extra sections
1673 created earlier because the initial count of PLT relocations
1674 was an overestimate. */
1676 (splt = elf_xtensa_get_plt_section (info, chunk)) != NULL;
1681 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
1682 BFD_ASSERT (sgotplt != NULL);
1684 if (chunk < plt_chunks - 1)
1685 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1686 else if (chunk == plt_chunks - 1)
1687 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1691 if (chunk_entries != 0)
1693 sgotplt->size = 4 * (chunk_entries + 2);
1694 splt->size = PLT_ENTRY_SIZE * chunk_entries;
1695 srelgot->size += 2 * sizeof (Elf32_External_Rela);
1696 spltlittbl->size += 8;
1705 /* Allocate space in ".got.loc" to match the total size of all the
1707 sgotloc = htab->sgotloc;
1708 sgotloc->size = spltlittbl->size;
1709 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1711 if (abfd->flags & DYNAMIC)
1713 for (s = abfd->sections; s != NULL; s = s->next)
1715 if (! elf_discarded_section (s)
1716 && xtensa_is_littable_section (s)
1718 sgotloc->size += s->size;
1723 /* Allocate memory for dynamic sections. */
1726 for (s = dynobj->sections; s != NULL; s = s->next)
1730 if ((s->flags & SEC_LINKER_CREATED) == 0)
1733 /* It's OK to base decisions on the section name, because none
1734 of the dynobj section names depend upon the input files. */
1735 name = bfd_get_section_name (dynobj, s);
1737 if (CONST_STRNEQ (name, ".rela"))
1741 if (strcmp (name, ".rela.plt") == 0)
1743 else if (strcmp (name, ".rela.got") == 0)
1746 /* We use the reloc_count field as a counter if we need
1747 to copy relocs into the output file. */
1751 else if (! CONST_STRNEQ (name, ".plt.")
1752 && ! CONST_STRNEQ (name, ".got.plt.")
1753 && strcmp (name, ".got") != 0
1754 && strcmp (name, ".plt") != 0
1755 && strcmp (name, ".got.plt") != 0
1756 && strcmp (name, ".xt.lit.plt") != 0
1757 && strcmp (name, ".got.loc") != 0)
1759 /* It's not one of our sections, so don't allocate space. */
1765 /* If we don't need this section, strip it from the output
1766 file. We must create the ".plt*" and ".got.plt*"
1767 sections in create_dynamic_sections and/or check_relocs
1768 based on a conservative estimate of the PLT relocation
1769 count, because the sections must be created before the
1770 linker maps input sections to output sections. The
1771 linker does that before size_dynamic_sections, where we
1772 compute the exact size of the PLT, so there may be more
1773 of these sections than are actually needed. */
1774 s->flags |= SEC_EXCLUDE;
1776 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
1778 /* Allocate memory for the section contents. */
1779 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1780 if (s->contents == NULL)
1785 if (elf_hash_table (info)->dynamic_sections_created)
1787 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1788 known until finish_dynamic_sections, but we need to get the relocs
1789 in place before they are sorted. */
1790 for (chunk = 0; chunk < plt_chunks; chunk++)
1792 Elf_Internal_Rela irela;
1796 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1799 loc = (srelgot->contents
1800 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1801 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1802 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1803 loc + sizeof (Elf32_External_Rela));
1804 srelgot->reloc_count += 2;
1807 /* Add some entries to the .dynamic section. We fill in the
1808 values later, in elf_xtensa_finish_dynamic_sections, but we
1809 must add the entries now so that we get the correct size for
1810 the .dynamic section. The DT_DEBUG entry is filled in by the
1811 dynamic linker and used by the debugger. */
1812 #define add_dynamic_entry(TAG, VAL) \
1813 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1815 if (info->executable)
1817 if (!add_dynamic_entry (DT_DEBUG, 0))
1823 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1824 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1825 || !add_dynamic_entry (DT_JMPREL, 0))
1831 if (!add_dynamic_entry (DT_RELA, 0)
1832 || !add_dynamic_entry (DT_RELASZ, 0)
1833 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1837 if (!add_dynamic_entry (DT_PLTGOT, 0)
1838 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1839 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1842 #undef add_dynamic_entry
1848 elf_xtensa_always_size_sections (bfd *output_bfd,
1849 struct bfd_link_info *info)
1851 struct elf_xtensa_link_hash_table *htab;
1854 htab = elf_xtensa_hash_table (info);
1858 tls_sec = htab->elf.tls_sec;
1860 if (tls_sec && (htab->tlsbase->tls_type & GOT_TLS_ANY) != 0)
1862 struct elf_link_hash_entry *tlsbase = &htab->tlsbase->elf;
1863 struct bfd_link_hash_entry *bh = &tlsbase->root;
1864 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
1866 tlsbase->type = STT_TLS;
1867 if (!(_bfd_generic_link_add_one_symbol
1868 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1869 tls_sec, 0, NULL, FALSE,
1870 bed->collect, &bh)))
1872 tlsbase->def_regular = 1;
1873 tlsbase->other = STV_HIDDEN;
1874 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1881 /* Return the base VMA address which should be subtracted from real addresses
1882 when resolving @dtpoff relocation.
1883 This is PT_TLS segment p_vaddr. */
1886 dtpoff_base (struct bfd_link_info *info)
1888 /* If tls_sec is NULL, we should have signalled an error already. */
1889 if (elf_hash_table (info)->tls_sec == NULL)
1891 return elf_hash_table (info)->tls_sec->vma;
1894 /* Return the relocation value for @tpoff relocation
1895 if STT_TLS virtual address is ADDRESS. */
1898 tpoff (struct bfd_link_info *info, bfd_vma address)
1900 struct elf_link_hash_table *htab = elf_hash_table (info);
1903 /* If tls_sec is NULL, we should have signalled an error already. */
1904 if (htab->tls_sec == NULL)
1906 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
1907 return address - htab->tls_sec->vma + base;
1910 /* Perform the specified relocation. The instruction at (contents + address)
1911 is modified to set one operand to represent the value in "relocation". The
1912 operand position is determined by the relocation type recorded in the
1915 #define CALL_SEGMENT_BITS (30)
1916 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1918 static bfd_reloc_status_type
1919 elf_xtensa_do_reloc (reloc_howto_type *howto,
1921 asection *input_section,
1925 bfd_boolean is_weak_undef,
1926 char **error_message)
1929 xtensa_opcode opcode;
1930 xtensa_isa isa = xtensa_default_isa;
1931 static xtensa_insnbuf ibuff = NULL;
1932 static xtensa_insnbuf sbuff = NULL;
1933 bfd_vma self_address;
1934 bfd_size_type input_size;
1940 ibuff = xtensa_insnbuf_alloc (isa);
1941 sbuff = xtensa_insnbuf_alloc (isa);
1944 input_size = bfd_get_section_limit (abfd, input_section);
1946 /* Calculate the PC address for this instruction. */
1947 self_address = (input_section->output_section->vma
1948 + input_section->output_offset
1951 switch (howto->type)
1954 case R_XTENSA_DIFF8:
1955 case R_XTENSA_DIFF16:
1956 case R_XTENSA_DIFF32:
1957 case R_XTENSA_TLS_FUNC:
1958 case R_XTENSA_TLS_ARG:
1959 case R_XTENSA_TLS_CALL:
1960 return bfd_reloc_ok;
1962 case R_XTENSA_ASM_EXPAND:
1965 /* Check for windowed CALL across a 1GB boundary. */
1966 opcode = get_expanded_call_opcode (contents + address,
1967 input_size - address, 0);
1968 if (is_windowed_call_opcode (opcode))
1970 if ((self_address >> CALL_SEGMENT_BITS)
1971 != (relocation >> CALL_SEGMENT_BITS))
1973 *error_message = "windowed longcall crosses 1GB boundary; "
1975 return bfd_reloc_dangerous;
1979 return bfd_reloc_ok;
1981 case R_XTENSA_ASM_SIMPLIFY:
1983 /* Convert the L32R/CALLX to CALL. */
1984 bfd_reloc_status_type retval =
1985 elf_xtensa_do_asm_simplify (contents, address, input_size,
1987 if (retval != bfd_reloc_ok)
1988 return bfd_reloc_dangerous;
1990 /* The CALL needs to be relocated. Continue below for that part. */
1993 howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
2000 x = bfd_get_32 (abfd, contents + address);
2002 bfd_put_32 (abfd, x, contents + address);
2004 return bfd_reloc_ok;
2006 case R_XTENSA_32_PCREL:
2007 bfd_put_32 (abfd, relocation - self_address, contents + address);
2008 return bfd_reloc_ok;
2011 case R_XTENSA_TLSDESC_FN:
2012 case R_XTENSA_TLSDESC_ARG:
2013 case R_XTENSA_TLS_DTPOFF:
2014 case R_XTENSA_TLS_TPOFF:
2015 bfd_put_32 (abfd, relocation, contents + address);
2016 return bfd_reloc_ok;
2019 /* Only instruction slot-specific relocations handled below.... */
2020 slot = get_relocation_slot (howto->type);
2021 if (slot == XTENSA_UNDEFINED)
2023 *error_message = "unexpected relocation";
2024 return bfd_reloc_dangerous;
2027 /* Read the instruction into a buffer and decode the opcode. */
2028 xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
2029 input_size - address);
2030 fmt = xtensa_format_decode (isa, ibuff);
2031 if (fmt == XTENSA_UNDEFINED)
2033 *error_message = "cannot decode instruction format";
2034 return bfd_reloc_dangerous;
2037 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
2039 opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
2040 if (opcode == XTENSA_UNDEFINED)
2042 *error_message = "cannot decode instruction opcode";
2043 return bfd_reloc_dangerous;
2046 /* Check for opcode-specific "alternate" relocations. */
2047 if (is_alt_relocation (howto->type))
2049 if (opcode == get_l32r_opcode ())
2051 /* Handle the special-case of non-PC-relative L32R instructions. */
2052 bfd *output_bfd = input_section->output_section->owner;
2053 asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
2056 *error_message = "relocation references missing .lit4 section";
2057 return bfd_reloc_dangerous;
2059 self_address = ((lit4_sec->vma & ~0xfff)
2060 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2061 newval = relocation;
2064 else if (opcode == get_const16_opcode ())
2066 /* ALT used for high 16 bits. */
2067 newval = relocation >> 16;
2072 /* No other "alternate" relocations currently defined. */
2073 *error_message = "unexpected relocation";
2074 return bfd_reloc_dangerous;
2077 else /* Not an "alternate" relocation.... */
2079 if (opcode == get_const16_opcode ())
2081 newval = relocation & 0xffff;
2086 /* ...normal PC-relative relocation.... */
2088 /* Determine which operand is being relocated. */
2089 opnd = get_relocation_opnd (opcode, howto->type);
2090 if (opnd == XTENSA_UNDEFINED)
2092 *error_message = "unexpected relocation";
2093 return bfd_reloc_dangerous;
2096 if (!howto->pc_relative)
2098 *error_message = "expected PC-relative relocation";
2099 return bfd_reloc_dangerous;
2102 newval = relocation;
2106 /* Apply the relocation. */
2107 if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
2108 || xtensa_operand_encode (isa, opcode, opnd, &newval)
2109 || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
2112 const char *opname = xtensa_opcode_name (isa, opcode);
2115 msg = "cannot encode";
2116 if (is_direct_call_opcode (opcode))
2118 if ((relocation & 0x3) != 0)
2119 msg = "misaligned call target";
2121 msg = "call target out of range";
2123 else if (opcode == get_l32r_opcode ())
2125 if ((relocation & 0x3) != 0)
2126 msg = "misaligned literal target";
2127 else if (is_alt_relocation (howto->type))
2128 msg = "literal target out of range (too many literals)";
2129 else if (self_address > relocation)
2130 msg = "literal target out of range (try using text-section-literals)";
2132 msg = "literal placed after use";
2135 *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
2136 return bfd_reloc_dangerous;
2139 /* Check for calls across 1GB boundaries. */
2140 if (is_direct_call_opcode (opcode)
2141 && is_windowed_call_opcode (opcode))
2143 if ((self_address >> CALL_SEGMENT_BITS)
2144 != (relocation >> CALL_SEGMENT_BITS))
2147 "windowed call crosses 1GB boundary; return may fail";
2148 return bfd_reloc_dangerous;
2152 /* Write the modified instruction back out of the buffer. */
2153 xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
2154 xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
2155 input_size - address);
2156 return bfd_reloc_ok;
2161 vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
2163 /* To reduce the size of the memory leak,
2164 we only use a single message buffer. */
2165 static bfd_size_type alloc_size = 0;
2166 static char *message = NULL;
2167 bfd_size_type orig_len, len = 0;
2168 bfd_boolean is_append;
2170 VA_OPEN (ap, arglen);
2171 VA_FIXEDARG (ap, const char *, origmsg);
2173 is_append = (origmsg == message);
2175 orig_len = strlen (origmsg);
2176 len = orig_len + strlen (fmt) + arglen + 20;
2177 if (len > alloc_size)
2179 message = (char *) bfd_realloc_or_free (message, len);
2182 if (message != NULL)
2185 memcpy (message, origmsg, orig_len);
2186 vsprintf (message + orig_len, fmt, ap);
2193 /* This function is registered as the "special_function" in the
2194 Xtensa howto for handling simplify operations.
2195 bfd_perform_relocation / bfd_install_relocation use it to
2196 perform (install) the specified relocation. Since this replaces the code
2197 in bfd_perform_relocation, it is basically an Xtensa-specific,
2198 stripped-down version of bfd_perform_relocation. */
2200 static bfd_reloc_status_type
2201 bfd_elf_xtensa_reloc (bfd *abfd,
2202 arelent *reloc_entry,
2205 asection *input_section,
2207 char **error_message)
2210 bfd_reloc_status_type flag;
2211 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2212 bfd_vma output_base = 0;
2213 reloc_howto_type *howto = reloc_entry->howto;
2214 asection *reloc_target_output_section;
2215 bfd_boolean is_weak_undef;
2217 if (!xtensa_default_isa)
2218 xtensa_default_isa = xtensa_isa_init (0, 0);
2220 /* ELF relocs are against symbols. If we are producing relocatable
2221 output, and the reloc is against an external symbol, the resulting
2222 reloc will also be against the same symbol. In such a case, we
2223 don't want to change anything about the way the reloc is handled,
2224 since it will all be done at final link time. This test is similar
2225 to what bfd_elf_generic_reloc does except that it lets relocs with
2226 howto->partial_inplace go through even if the addend is non-zero.
2227 (The real problem is that partial_inplace is set for XTENSA_32
2228 relocs to begin with, but that's a long story and there's little we
2229 can do about it now....) */
2231 if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
2233 reloc_entry->address += input_section->output_offset;
2234 return bfd_reloc_ok;
2237 /* Is the address of the relocation really within the section? */
2238 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2239 return bfd_reloc_outofrange;
2241 /* Work out which section the relocation is targeted at and the
2242 initial relocation command value. */
2244 /* Get symbol value. (Common symbols are special.) */
2245 if (bfd_is_com_section (symbol->section))
2248 relocation = symbol->value;
2250 reloc_target_output_section = symbol->section->output_section;
2252 /* Convert input-section-relative symbol value to absolute. */
2253 if ((output_bfd && !howto->partial_inplace)
2254 || reloc_target_output_section == NULL)
2257 output_base = reloc_target_output_section->vma;
2259 relocation += output_base + symbol->section->output_offset;
2261 /* Add in supplied addend. */
2262 relocation += reloc_entry->addend;
2264 /* Here the variable relocation holds the final address of the
2265 symbol we are relocating against, plus any addend. */
2268 if (!howto->partial_inplace)
2270 /* This is a partial relocation, and we want to apply the relocation
2271 to the reloc entry rather than the raw data. Everything except
2272 relocations against section symbols has already been handled
2275 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
2276 reloc_entry->addend = relocation;
2277 reloc_entry->address += input_section->output_offset;
2278 return bfd_reloc_ok;
2282 reloc_entry->address += input_section->output_offset;
2283 reloc_entry->addend = 0;
2287 is_weak_undef = (bfd_is_und_section (symbol->section)
2288 && (symbol->flags & BSF_WEAK) != 0);
2289 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
2290 (bfd_byte *) data, (bfd_vma) octets,
2291 is_weak_undef, error_message);
2293 if (flag == bfd_reloc_dangerous)
2295 /* Add the symbol name to the error message. */
2296 if (! *error_message)
2297 *error_message = "";
2298 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
2299 strlen (symbol->name) + 17,
2301 (unsigned long) reloc_entry->addend);
2308 /* Set up an entry in the procedure linkage table. */
2311 elf_xtensa_create_plt_entry (struct bfd_link_info *info,
2313 unsigned reloc_index)
2315 asection *splt, *sgotplt;
2316 bfd_vma plt_base, got_base;
2317 bfd_vma code_offset, lit_offset;
2320 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
2321 splt = elf_xtensa_get_plt_section (info, chunk);
2322 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
2323 BFD_ASSERT (splt != NULL && sgotplt != NULL);
2325 plt_base = splt->output_section->vma + splt->output_offset;
2326 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
2328 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
2329 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
2331 /* Fill in the literal entry. This is the offset of the dynamic
2332 relocation entry. */
2333 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
2334 sgotplt->contents + lit_offset);
2336 /* Fill in the entry in the procedure linkage table. */
2337 memcpy (splt->contents + code_offset,
2338 (bfd_big_endian (output_bfd)
2339 ? elf_xtensa_be_plt_entry
2340 : elf_xtensa_le_plt_entry),
2342 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
2343 plt_base + code_offset + 3),
2344 splt->contents + code_offset + 4);
2345 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
2346 plt_base + code_offset + 6),
2347 splt->contents + code_offset + 7);
2348 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
2349 plt_base + code_offset + 9),
2350 splt->contents + code_offset + 10);
2352 return plt_base + code_offset;
2356 static bfd_boolean get_indirect_call_dest_reg (xtensa_opcode, unsigned *);
2359 replace_tls_insn (Elf_Internal_Rela *rel,
2361 asection *input_section,
2363 bfd_boolean is_ld_model,
2364 char **error_message)
2366 static xtensa_insnbuf ibuff = NULL;
2367 static xtensa_insnbuf sbuff = NULL;
2368 xtensa_isa isa = xtensa_default_isa;
2370 xtensa_opcode old_op, new_op;
2371 bfd_size_type input_size;
2373 unsigned dest_reg, src_reg;
2377 ibuff = xtensa_insnbuf_alloc (isa);
2378 sbuff = xtensa_insnbuf_alloc (isa);
2381 input_size = bfd_get_section_limit (abfd, input_section);
2383 /* Read the instruction into a buffer and decode the opcode. */
2384 xtensa_insnbuf_from_chars (isa, ibuff, contents + rel->r_offset,
2385 input_size - rel->r_offset);
2386 fmt = xtensa_format_decode (isa, ibuff);
2387 if (fmt == XTENSA_UNDEFINED)
2389 *error_message = "cannot decode instruction format";
2393 BFD_ASSERT (xtensa_format_num_slots (isa, fmt) == 1);
2394 xtensa_format_get_slot (isa, fmt, 0, ibuff, sbuff);
2396 old_op = xtensa_opcode_decode (isa, fmt, 0, sbuff);
2397 if (old_op == XTENSA_UNDEFINED)
2399 *error_message = "cannot decode instruction opcode";
2403 r_type = ELF32_R_TYPE (rel->r_info);
2406 case R_XTENSA_TLS_FUNC:
2407 case R_XTENSA_TLS_ARG:
2408 if (old_op != get_l32r_opcode ()
2409 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2410 sbuff, &dest_reg) != 0)
2412 *error_message = "cannot extract L32R destination for TLS access";
2417 case R_XTENSA_TLS_CALL:
2418 if (! get_indirect_call_dest_reg (old_op, &dest_reg)
2419 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2420 sbuff, &src_reg) != 0)
2422 *error_message = "cannot extract CALLXn operands for TLS access";
2435 case R_XTENSA_TLS_FUNC:
2436 case R_XTENSA_TLS_ARG:
2437 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2438 versions of Xtensa). */
2439 new_op = xtensa_opcode_lookup (isa, "nop");
2440 if (new_op == XTENSA_UNDEFINED)
2442 new_op = xtensa_opcode_lookup (isa, "or");
2443 if (new_op == XTENSA_UNDEFINED
2444 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2445 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2447 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2449 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2452 *error_message = "cannot encode OR for TLS access";
2458 if (xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0)
2460 *error_message = "cannot encode NOP for TLS access";
2466 case R_XTENSA_TLS_CALL:
2467 /* Read THREADPTR into the CALLX's return value register. */
2468 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2469 if (new_op == XTENSA_UNDEFINED
2470 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2471 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2472 sbuff, dest_reg + 2) != 0)
2474 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2484 case R_XTENSA_TLS_FUNC:
2485 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
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) != 0)
2491 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2496 case R_XTENSA_TLS_ARG:
2497 /* Nothing to do. Keep the original L32R instruction. */
2500 case R_XTENSA_TLS_CALL:
2501 /* Add the CALLX's src register (holding the THREADPTR value)
2502 to the first argument register (holding the offset) and put
2503 the result in the CALLX's return value register. */
2504 new_op = xtensa_opcode_lookup (isa, "add");
2505 if (new_op == XTENSA_UNDEFINED
2506 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2507 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2508 sbuff, dest_reg + 2) != 0
2509 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2510 sbuff, dest_reg + 2) != 0
2511 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2512 sbuff, src_reg) != 0)
2514 *error_message = "cannot encode ADD for TLS access";
2521 xtensa_format_set_slot (isa, fmt, 0, ibuff, sbuff);
2522 xtensa_insnbuf_to_chars (isa, ibuff, contents + rel->r_offset,
2523 input_size - rel->r_offset);
2529 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2530 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2531 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2532 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2533 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2534 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2535 || (R_TYPE) == R_XTENSA_TLS_ARG \
2536 || (R_TYPE) == R_XTENSA_TLS_CALL)
2538 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2539 both relocatable and final links. */
2542 elf_xtensa_relocate_section (bfd *output_bfd,
2543 struct bfd_link_info *info,
2545 asection *input_section,
2547 Elf_Internal_Rela *relocs,
2548 Elf_Internal_Sym *local_syms,
2549 asection **local_sections)
2551 struct elf_xtensa_link_hash_table *htab;
2552 Elf_Internal_Shdr *symtab_hdr;
2553 Elf_Internal_Rela *rel;
2554 Elf_Internal_Rela *relend;
2555 struct elf_link_hash_entry **sym_hashes;
2556 property_table_entry *lit_table = 0;
2558 char *local_got_tls_types;
2559 char *error_message = NULL;
2560 bfd_size_type input_size;
2563 if (!xtensa_default_isa)
2564 xtensa_default_isa = xtensa_isa_init (0, 0);
2566 BFD_ASSERT (is_xtensa_elf (input_bfd));
2568 htab = elf_xtensa_hash_table (info);
2572 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2573 sym_hashes = elf_sym_hashes (input_bfd);
2574 local_got_tls_types = elf_xtensa_local_got_tls_type (input_bfd);
2576 if (elf_hash_table (info)->dynamic_sections_created)
2578 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
2579 &lit_table, XTENSA_LIT_SEC_NAME,
2585 input_size = bfd_get_section_limit (input_bfd, input_section);
2588 relend = relocs + input_section->reloc_count;
2589 for (; rel < relend; rel++)
2592 reloc_howto_type *howto;
2593 unsigned long r_symndx;
2594 struct elf_link_hash_entry *h;
2595 Elf_Internal_Sym *sym;
2600 bfd_reloc_status_type r;
2601 bfd_boolean is_weak_undef;
2602 bfd_boolean unresolved_reloc;
2604 bfd_boolean dynamic_symbol;
2606 r_type = ELF32_R_TYPE (rel->r_info);
2607 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2608 || r_type == (int) R_XTENSA_GNU_VTENTRY)
2611 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2613 bfd_set_error (bfd_error_bad_value);
2616 howto = &elf_howto_table[r_type];
2618 r_symndx = ELF32_R_SYM (rel->r_info);
2623 is_weak_undef = FALSE;
2624 unresolved_reloc = FALSE;
2627 if (howto->partial_inplace && !info->relocatable)
2629 /* Because R_XTENSA_32 was made partial_inplace to fix some
2630 problems with DWARF info in partial links, there may be
2631 an addend stored in the contents. Take it out of there
2632 and move it back into the addend field of the reloc. */
2633 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2634 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2637 if (r_symndx < symtab_hdr->sh_info)
2639 sym = local_syms + r_symndx;
2640 sym_type = ELF32_ST_TYPE (sym->st_info);
2641 sec = local_sections[r_symndx];
2642 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2646 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2647 r_symndx, symtab_hdr, sym_hashes,
2649 unresolved_reloc, warned);
2652 && !unresolved_reloc
2653 && h->root.type == bfd_link_hash_undefweak)
2654 is_weak_undef = TRUE;
2659 if (sec != NULL && elf_discarded_section (sec))
2660 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2661 rel, relend, howto, contents);
2663 if (info->relocatable)
2666 asection * sym_sec = get_elf_r_symndx_section (input_bfd, r_symndx);
2668 /* This is a relocatable link.
2669 1) If the reloc is against a section symbol, adjust
2670 according to the output section.
2671 2) If there is a new target for this relocation,
2672 the new target will be in the same output section.
2673 We adjust the relocation by the output section
2676 if (relaxing_section)
2678 /* Check if this references a section in another input file. */
2679 if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2684 dest_addr = sym_sec->output_section->vma + sym_sec->output_offset
2685 + get_elf_r_symndx_offset (input_bfd, r_symndx) + rel->r_addend;
2687 if (r_type == R_XTENSA_ASM_SIMPLIFY)
2689 error_message = NULL;
2690 /* Convert ASM_SIMPLIFY into the simpler relocation
2691 so that they never escape a relaxing link. */
2692 r = contract_asm_expansion (contents, input_size, rel,
2694 if (r != bfd_reloc_ok)
2696 if (!((*info->callbacks->reloc_dangerous)
2697 (info, error_message, input_bfd, input_section,
2701 r_type = ELF32_R_TYPE (rel->r_info);
2704 /* This is a relocatable link, so we don't have to change
2705 anything unless the reloc is against a section symbol,
2706 in which case we have to adjust according to where the
2707 section symbol winds up in the output section. */
2708 if (r_symndx < symtab_hdr->sh_info)
2710 sym = local_syms + r_symndx;
2711 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2713 sec = local_sections[r_symndx];
2714 rel->r_addend += sec->output_offset + sym->st_value;
2718 /* If there is an addend with a partial_inplace howto,
2719 then move the addend to the contents. This is a hack
2720 to work around problems with DWARF in relocatable links
2721 with some previous version of BFD. Now we can't easily get
2722 rid of the hack without breaking backward compatibility.... */
2724 howto = &elf_howto_table[r_type];
2725 if (howto->partial_inplace && rel->r_addend)
2727 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2728 rel->r_addend, contents,
2729 rel->r_offset, FALSE,
2735 /* Put the correct bits in the target instruction, even
2736 though the relocation will still be present in the output
2737 file. This makes disassembly clearer, as well as
2738 allowing loadable kernel modules to work without needing
2739 relocations on anything other than calls and l32r's. */
2741 /* If it is not in the same section, there is nothing we can do. */
2742 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP &&
2743 sym_sec->output_section == input_section->output_section)
2745 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2746 dest_addr, contents,
2747 rel->r_offset, FALSE,
2751 if (r != bfd_reloc_ok)
2753 if (!((*info->callbacks->reloc_dangerous)
2754 (info, error_message, input_bfd, input_section,
2759 /* Done with work for relocatable link; continue with next reloc. */
2763 /* This is a final link. */
2765 if (relaxing_section)
2767 /* Check if this references a section in another input file. */
2768 do_fix_for_final_link (rel, input_bfd, input_section, contents,
2772 /* Sanity check the address. */
2773 if (rel->r_offset >= input_size
2774 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2776 (*_bfd_error_handler)
2777 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2778 input_bfd, input_section, rel->r_offset, input_size);
2779 bfd_set_error (bfd_error_bad_value);
2784 name = h->root.root.string;
2787 name = (bfd_elf_string_from_elf_section
2788 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2789 if (name == NULL || *name == '\0')
2790 name = bfd_section_name (input_bfd, sec);
2793 if (r_symndx != STN_UNDEF
2794 && r_type != R_XTENSA_NONE
2796 || h->root.type == bfd_link_hash_defined
2797 || h->root.type == bfd_link_hash_defweak)
2798 && IS_XTENSA_TLS_RELOC (r_type) != (sym_type == STT_TLS))
2800 (*_bfd_error_handler)
2801 ((sym_type == STT_TLS
2802 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
2803 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
2806 (long) rel->r_offset,
2811 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
2813 tls_type = GOT_UNKNOWN;
2815 tls_type = elf_xtensa_hash_entry (h)->tls_type;
2816 else if (local_got_tls_types)
2817 tls_type = local_got_tls_types [r_symndx];
2823 if (elf_hash_table (info)->dynamic_sections_created
2824 && (input_section->flags & SEC_ALLOC) != 0
2825 && (dynamic_symbol || info->shared))
2827 Elf_Internal_Rela outrel;
2831 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2832 srel = htab->srelplt;
2834 srel = htab->srelgot;
2836 BFD_ASSERT (srel != NULL);
2839 _bfd_elf_section_offset (output_bfd, info,
2840 input_section, rel->r_offset);
2842 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2843 memset (&outrel, 0, sizeof outrel);
2846 outrel.r_offset += (input_section->output_section->vma
2847 + input_section->output_offset);
2849 /* Complain if the relocation is in a read-only section
2850 and not in a literal pool. */
2851 if ((input_section->flags & SEC_READONLY) != 0
2852 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
2856 _("dynamic relocation in read-only section");
2857 if (!((*info->callbacks->reloc_dangerous)
2858 (info, error_message, input_bfd, input_section,
2865 outrel.r_addend = rel->r_addend;
2868 if (r_type == R_XTENSA_32)
2871 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2874 else /* r_type == R_XTENSA_PLT */
2877 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2879 /* Create the PLT entry and set the initial
2880 contents of the literal entry to the address of
2883 elf_xtensa_create_plt_entry (info, output_bfd,
2886 unresolved_reloc = FALSE;
2890 /* Generate a RELATIVE relocation. */
2891 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2892 outrel.r_addend = 0;
2896 loc = (srel->contents
2897 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2898 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2899 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2902 else if (r_type == R_XTENSA_ASM_EXPAND && dynamic_symbol)
2904 /* This should only happen for non-PIC code, which is not
2905 supposed to be used on systems with dynamic linking.
2906 Just ignore these relocations. */
2911 case R_XTENSA_TLS_TPOFF:
2912 /* Switch to LE model for local symbols in an executable. */
2913 if (! info->shared && ! dynamic_symbol)
2915 relocation = tpoff (info, relocation);
2920 case R_XTENSA_TLSDESC_FN:
2921 case R_XTENSA_TLSDESC_ARG:
2923 if (r_type == R_XTENSA_TLSDESC_FN)
2925 if (! info->shared || (tls_type & GOT_TLS_IE) != 0)
2926 r_type = R_XTENSA_NONE;
2928 else if (r_type == R_XTENSA_TLSDESC_ARG)
2932 if ((tls_type & GOT_TLS_IE) != 0)
2933 r_type = R_XTENSA_TLS_TPOFF;
2937 r_type = R_XTENSA_TLS_TPOFF;
2938 if (! dynamic_symbol)
2940 relocation = tpoff (info, relocation);
2946 if (r_type == R_XTENSA_NONE)
2947 /* Nothing to do here; skip to the next reloc. */
2950 if (! elf_hash_table (info)->dynamic_sections_created)
2953 _("TLS relocation invalid without dynamic sections");
2954 if (!((*info->callbacks->reloc_dangerous)
2955 (info, error_message, input_bfd, input_section,
2961 Elf_Internal_Rela outrel;
2963 asection *srel = htab->srelgot;
2966 outrel.r_offset = (input_section->output_section->vma
2967 + input_section->output_offset
2970 /* Complain if the relocation is in a read-only section
2971 and not in a literal pool. */
2972 if ((input_section->flags & SEC_READONLY) != 0
2973 && ! elf_xtensa_in_literal_pool (lit_table, ltblsize,
2977 _("dynamic relocation in read-only section");
2978 if (!((*info->callbacks->reloc_dangerous)
2979 (info, error_message, input_bfd, input_section,
2984 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2986 outrel.r_addend = relocation - dtpoff_base (info);
2988 outrel.r_addend = 0;
2991 outrel.r_info = ELF32_R_INFO (indx, r_type);
2993 unresolved_reloc = FALSE;
2996 loc = (srel->contents
2997 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2998 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2999 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
3005 case R_XTENSA_TLS_DTPOFF:
3007 /* Switch from LD model to LE model. */
3008 relocation = tpoff (info, relocation);
3010 relocation -= dtpoff_base (info);
3013 case R_XTENSA_TLS_FUNC:
3014 case R_XTENSA_TLS_ARG:
3015 case R_XTENSA_TLS_CALL:
3016 /* Check if optimizing to IE or LE model. */
3017 if ((tls_type & GOT_TLS_IE) != 0)
3019 bfd_boolean is_ld_model =
3020 (h && elf_xtensa_hash_entry (h) == htab->tlsbase);
3021 if (! replace_tls_insn (rel, input_bfd, input_section, contents,
3022 is_ld_model, &error_message))
3024 if (!((*info->callbacks->reloc_dangerous)
3025 (info, error_message, input_bfd, input_section,
3030 if (r_type != R_XTENSA_TLS_ARG || is_ld_model)
3032 /* Skip subsequent relocations on the same instruction. */
3033 while (rel + 1 < relend && rel[1].r_offset == rel->r_offset)
3040 if (elf_hash_table (info)->dynamic_sections_created
3041 && dynamic_symbol && (is_operand_relocation (r_type)
3042 || r_type == R_XTENSA_32_PCREL))
3045 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3046 strlen (name) + 2, name);
3047 if (!((*info->callbacks->reloc_dangerous)
3048 (info, error_message, input_bfd, input_section,
3056 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3057 because such sections are not SEC_ALLOC and thus ld.so will
3058 not process them. */
3059 if (unresolved_reloc
3060 && !((input_section->flags & SEC_DEBUGGING) != 0
3063 (*_bfd_error_handler)
3064 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3067 (long) rel->r_offset,
3073 /* TLS optimizations may have changed r_type; update "howto". */
3074 howto = &elf_howto_table[r_type];
3076 /* There's no point in calling bfd_perform_relocation here.
3077 Just go directly to our "special function". */
3078 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
3079 relocation + rel->r_addend,
3080 contents, rel->r_offset, is_weak_undef,
3083 if (r != bfd_reloc_ok && !warned)
3085 BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
3086 BFD_ASSERT (error_message != NULL);
3088 if (rel->r_addend == 0)
3089 error_message = vsprint_msg (error_message, ": %s",
3090 strlen (name) + 2, name);
3092 error_message = vsprint_msg (error_message, ": (%s+0x%x)",
3094 name, (int) rel->r_addend);
3096 if (!((*info->callbacks->reloc_dangerous)
3097 (info, error_message, input_bfd, input_section,
3106 input_section->reloc_done = TRUE;
3112 /* Finish up dynamic symbol handling. There's not much to do here since
3113 the PLT and GOT entries are all set up by relocate_section. */
3116 elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
3117 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3118 struct elf_link_hash_entry *h,
3119 Elf_Internal_Sym *sym)
3121 if (h->needs_plt && !h->def_regular)
3123 /* Mark the symbol as undefined, rather than as defined in
3124 the .plt section. Leave the value alone. */
3125 sym->st_shndx = SHN_UNDEF;
3126 /* If the symbol is weak, we do need to clear the value.
3127 Otherwise, the PLT entry would provide a definition for
3128 the symbol even if the symbol wasn't defined anywhere,
3129 and so the symbol would never be NULL. */
3130 if (!h->ref_regular_nonweak)
3134 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3135 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3136 || h == elf_hash_table (info)->hgot)
3137 sym->st_shndx = SHN_ABS;
3143 /* Combine adjacent literal table entries in the output. Adjacent
3144 entries within each input section may have been removed during
3145 relaxation, but we repeat the process here, even though it's too late
3146 to shrink the output section, because it's important to minimize the
3147 number of literal table entries to reduce the start-up work for the
3148 runtime linker. Returns the number of remaining table entries or -1
3152 elf_xtensa_combine_prop_entries (bfd *output_bfd,
3157 property_table_entry *table;
3158 bfd_size_type section_size, sgotloc_size;
3162 section_size = sxtlit->size;
3163 BFD_ASSERT (section_size % 8 == 0);
3164 num = section_size / 8;
3166 sgotloc_size = sgotloc->size;
3167 if (sgotloc_size != section_size)
3169 (*_bfd_error_handler)
3170 (_("internal inconsistency in size of .got.loc section"));
3174 table = bfd_malloc (num * sizeof (property_table_entry));
3178 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3179 propagates to the output section, where it doesn't really apply and
3180 where it breaks the following call to bfd_malloc_and_get_section. */
3181 sxtlit->flags &= ~SEC_IN_MEMORY;
3183 if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
3191 /* There should never be any relocations left at this point, so this
3192 is quite a bit easier than what is done during relaxation. */
3194 /* Copy the raw contents into a property table array and sort it. */
3196 for (n = 0; n < num; n++)
3198 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
3199 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
3202 qsort (table, num, sizeof (property_table_entry), property_table_compare);
3204 for (n = 0; n < num; n++)
3206 bfd_boolean remove_entry = FALSE;
3208 if (table[n].size == 0)
3209 remove_entry = TRUE;
3211 && (table[n-1].address + table[n-1].size == table[n].address))
3213 table[n-1].size += table[n].size;
3214 remove_entry = TRUE;
3219 for (m = n; m < num - 1; m++)
3221 table[m].address = table[m+1].address;
3222 table[m].size = table[m+1].size;
3230 /* Copy the data back to the raw contents. */
3232 for (n = 0; n < num; n++)
3234 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
3235 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
3239 /* Clear the removed bytes. */
3240 if ((bfd_size_type) (num * 8) < section_size)
3241 memset (&contents[num * 8], 0, section_size - num * 8);
3243 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
3247 /* Copy the contents to ".got.loc". */
3248 memcpy (sgotloc->contents, contents, section_size);
3256 /* Finish up the dynamic sections. */
3259 elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
3260 struct bfd_link_info *info)
3262 struct elf_xtensa_link_hash_table *htab;
3264 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
3265 Elf32_External_Dyn *dyncon, *dynconend;
3266 int num_xtlit_entries = 0;
3268 if (! elf_hash_table (info)->dynamic_sections_created)
3271 htab = elf_xtensa_hash_table (info);
3275 dynobj = elf_hash_table (info)->dynobj;
3276 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3277 BFD_ASSERT (sdyn != NULL);
3279 /* Set the first entry in the global offset table to the address of
3280 the dynamic section. */
3284 BFD_ASSERT (sgot->size == 4);
3286 bfd_put_32 (output_bfd, 0, sgot->contents);
3288 bfd_put_32 (output_bfd,
3289 sdyn->output_section->vma + sdyn->output_offset,
3293 srelplt = htab->srelplt;
3294 if (srelplt && srelplt->size != 0)
3296 asection *sgotplt, *srelgot, *spltlittbl;
3297 int chunk, plt_chunks, plt_entries;
3298 Elf_Internal_Rela irela;
3300 unsigned rtld_reloc;
3302 srelgot = htab->srelgot;
3303 spltlittbl = htab->spltlittbl;
3304 BFD_ASSERT (srelgot != NULL && spltlittbl != NULL);
3306 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3307 of them follow immediately after.... */
3308 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
3310 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3311 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3312 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
3315 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
3317 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
3319 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
3321 for (chunk = 0; chunk < plt_chunks; chunk++)
3323 int chunk_entries = 0;
3325 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
3326 BFD_ASSERT (sgotplt != NULL);
3328 /* Emit special RTLD relocations for the first two entries in
3329 each chunk of the .got.plt section. */
3331 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3332 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3333 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3334 irela.r_offset = (sgotplt->output_section->vma
3335 + sgotplt->output_offset);
3336 irela.r_addend = 1; /* tell rtld to set value to resolver function */
3337 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3339 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3341 /* Next literal immediately follows the first. */
3342 loc += sizeof (Elf32_External_Rela);
3343 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3344 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3345 irela.r_offset = (sgotplt->output_section->vma
3346 + sgotplt->output_offset + 4);
3347 /* Tell rtld to set value to object's link map. */
3349 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3351 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3353 /* Fill in the literal table. */
3354 if (chunk < plt_chunks - 1)
3355 chunk_entries = PLT_ENTRIES_PER_CHUNK;
3357 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
3359 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
3360 bfd_put_32 (output_bfd,
3361 sgotplt->output_section->vma + sgotplt->output_offset,
3362 spltlittbl->contents + (chunk * 8) + 0);
3363 bfd_put_32 (output_bfd,
3364 8 + (chunk_entries * 4),
3365 spltlittbl->contents + (chunk * 8) + 4);
3368 /* All the dynamic relocations have been emitted at this point.
3369 Make sure the relocation sections are the correct size. */
3370 if (srelgot->size != (sizeof (Elf32_External_Rela)
3371 * srelgot->reloc_count)
3372 || srelplt->size != (sizeof (Elf32_External_Rela)
3373 * srelplt->reloc_count))
3376 /* The .xt.lit.plt section has just been modified. This must
3377 happen before the code below which combines adjacent literal
3378 table entries, and the .xt.lit.plt contents have to be forced to
3380 if (! bfd_set_section_contents (output_bfd,
3381 spltlittbl->output_section,
3382 spltlittbl->contents,
3383 spltlittbl->output_offset,
3386 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3387 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
3390 /* Combine adjacent literal table entries. */
3391 BFD_ASSERT (! info->relocatable);
3392 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
3393 sgotloc = htab->sgotloc;
3394 BFD_ASSERT (sgotloc);
3398 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
3399 if (num_xtlit_entries < 0)
3403 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3404 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3405 for (; dyncon < dynconend; dyncon++)
3407 Elf_Internal_Dyn dyn;
3409 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3416 case DT_XTENSA_GOT_LOC_SZ:
3417 dyn.d_un.d_val = num_xtlit_entries;
3420 case DT_XTENSA_GOT_LOC_OFF:
3421 dyn.d_un.d_ptr = htab->sgotloc->output_section->vma;
3425 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3429 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3433 dyn.d_un.d_val = htab->srelplt->output_section->size;
3437 /* Adjust RELASZ to not include JMPREL. This matches what
3438 glibc expects and what is done for several other ELF
3439 targets (e.g., i386, alpha), but the "correct" behavior
3440 seems to be unresolved. Since the linker script arranges
3441 for .rela.plt to follow all other relocation sections, we
3442 don't have to worry about changing the DT_RELA entry. */
3444 dyn.d_un.d_val -= htab->srelplt->output_section->size;
3448 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3455 /* Functions for dealing with the e_flags field. */
3457 /* Merge backend specific data from an object file to the output
3458 object file when linking. */
3461 elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3463 unsigned out_mach, in_mach;
3464 flagword out_flag, in_flag;
3466 /* Check if we have the same endianness. */
3467 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
3470 /* Don't even pretend to support mixed-format linking. */
3471 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3472 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3475 out_flag = elf_elfheader (obfd)->e_flags;
3476 in_flag = elf_elfheader (ibfd)->e_flags;
3478 out_mach = out_flag & EF_XTENSA_MACH;
3479 in_mach = in_flag & EF_XTENSA_MACH;
3480 if (out_mach != in_mach)
3482 (*_bfd_error_handler)
3483 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
3484 ibfd, out_mach, in_mach);
3485 bfd_set_error (bfd_error_wrong_format);
3489 if (! elf_flags_init (obfd))
3491 elf_flags_init (obfd) = TRUE;
3492 elf_elfheader (obfd)->e_flags = in_flag;
3494 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3495 && bfd_get_arch_info (obfd)->the_default)
3496 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3497 bfd_get_mach (ibfd));
3502 if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
3503 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
3505 if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
3506 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
3513 elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
3515 BFD_ASSERT (!elf_flags_init (abfd)
3516 || elf_elfheader (abfd)->e_flags == flags);
3518 elf_elfheader (abfd)->e_flags |= flags;
3519 elf_flags_init (abfd) = TRUE;
3526 elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
3528 FILE *f = (FILE *) farg;
3529 flagword e_flags = elf_elfheader (abfd)->e_flags;
3531 fprintf (f, "\nXtensa header:\n");
3532 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
3533 fprintf (f, "\nMachine = Base\n");
3535 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
3537 fprintf (f, "Insn tables = %s\n",
3538 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
3540 fprintf (f, "Literal tables = %s\n",
3541 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
3543 return _bfd_elf_print_private_bfd_data (abfd, farg);
3547 /* Set the right machine number for an Xtensa ELF file. */
3550 elf_xtensa_object_p (bfd *abfd)
3553 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
3558 mach = bfd_mach_xtensa;
3564 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
3569 /* The final processing done just before writing out an Xtensa ELF object
3570 file. This gets the Xtensa architecture right based on the machine
3574 elf_xtensa_final_write_processing (bfd *abfd,
3575 bfd_boolean linker ATTRIBUTE_UNUSED)
3580 switch (mach = bfd_get_mach (abfd))
3582 case bfd_mach_xtensa:
3583 val = E_XTENSA_MACH;
3589 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
3590 elf_elfheader (abfd)->e_flags |= val;
3594 static enum elf_reloc_type_class
3595 elf_xtensa_reloc_type_class (const Elf_Internal_Rela *rela)
3597 switch ((int) ELF32_R_TYPE (rela->r_info))
3599 case R_XTENSA_RELATIVE:
3600 return reloc_class_relative;
3601 case R_XTENSA_JMP_SLOT:
3602 return reloc_class_plt;
3604 return reloc_class_normal;
3610 elf_xtensa_discard_info_for_section (bfd *abfd,
3611 struct elf_reloc_cookie *cookie,
3612 struct bfd_link_info *info,
3616 bfd_vma offset, actual_offset;
3617 bfd_size_type removed_bytes = 0;
3618 bfd_size_type entry_size;
3620 if (sec->output_section
3621 && bfd_is_abs_section (sec->output_section))
3624 if (xtensa_is_proptable_section (sec))
3629 if (sec->size == 0 || sec->size % entry_size != 0)
3632 contents = retrieve_contents (abfd, sec, info->keep_memory);
3636 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
3639 release_contents (sec, contents);
3643 /* Sort the relocations. They should already be in order when
3644 relaxation is enabled, but it might not be. */
3645 qsort (cookie->rels, sec->reloc_count, sizeof (Elf_Internal_Rela),
3646 internal_reloc_compare);
3648 cookie->rel = cookie->rels;
3649 cookie->relend = cookie->rels + sec->reloc_count;
3651 for (offset = 0; offset < sec->size; offset += entry_size)
3653 actual_offset = offset - removed_bytes;
3655 /* The ...symbol_deleted_p function will skip over relocs but it
3656 won't adjust their offsets, so do that here. */
3657 while (cookie->rel < cookie->relend
3658 && cookie->rel->r_offset < offset)
3660 cookie->rel->r_offset -= removed_bytes;
3664 while (cookie->rel < cookie->relend
3665 && cookie->rel->r_offset == offset)
3667 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
3669 /* Remove the table entry. (If the reloc type is NONE, then
3670 the entry has already been merged with another and deleted
3671 during relaxation.) */
3672 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
3674 /* Shift the contents up. */
3675 if (offset + entry_size < sec->size)
3676 memmove (&contents[actual_offset],
3677 &contents[actual_offset + entry_size],
3678 sec->size - offset - entry_size);
3679 removed_bytes += entry_size;
3682 /* Remove this relocation. */
3683 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3686 /* Adjust the relocation offset for previous removals. This
3687 should not be done before calling ...symbol_deleted_p
3688 because it might mess up the offset comparisons there.
3689 Make sure the offset doesn't underflow in the case where
3690 the first entry is removed. */
3691 if (cookie->rel->r_offset >= removed_bytes)
3692 cookie->rel->r_offset -= removed_bytes;
3694 cookie->rel->r_offset = 0;
3700 if (removed_bytes != 0)
3702 /* Adjust any remaining relocs (shouldn't be any). */
3703 for (; cookie->rel < cookie->relend; cookie->rel++)
3705 if (cookie->rel->r_offset >= removed_bytes)
3706 cookie->rel->r_offset -= removed_bytes;
3708 cookie->rel->r_offset = 0;
3711 /* Clear the removed bytes. */
3712 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
3714 pin_contents (sec, contents);
3715 pin_internal_relocs (sec, cookie->rels);
3718 if (sec->rawsize == 0)
3719 sec->rawsize = sec->size;
3720 sec->size -= removed_bytes;
3722 if (xtensa_is_littable_section (sec))
3724 asection *sgotloc = elf_xtensa_hash_table (info)->sgotloc;
3726 sgotloc->size -= removed_bytes;
3731 release_contents (sec, contents);
3732 release_internal_relocs (sec, cookie->rels);
3735 return (removed_bytes != 0);
3740 elf_xtensa_discard_info (bfd *abfd,
3741 struct elf_reloc_cookie *cookie,
3742 struct bfd_link_info *info)
3745 bfd_boolean changed = FALSE;
3747 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3749 if (xtensa_is_property_section (sec))
3751 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
3761 elf_xtensa_ignore_discarded_relocs (asection *sec)
3763 return xtensa_is_property_section (sec);
3768 elf_xtensa_action_discarded (asection *sec)
3770 if (strcmp (".xt_except_table", sec->name) == 0)
3773 if (strcmp (".xt_except_desc", sec->name) == 0)
3776 return _bfd_elf_default_action_discarded (sec);
3780 /* Support for core dump NOTE sections. */
3783 elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3788 /* The size for Xtensa is variable, so don't try to recognize the format
3789 based on the size. Just assume this is GNU/Linux. */
3792 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3795 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
3799 size = note->descsz - offset - 4;
3801 /* Make a ".reg/999" section. */
3802 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3803 size, note->descpos + offset);
3808 elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3810 switch (note->descsz)
3815 case 128: /* GNU/Linux elf_prpsinfo */
3816 elf_tdata (abfd)->core_program
3817 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3818 elf_tdata (abfd)->core_command
3819 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3822 /* Note that for some reason, a spurious space is tacked
3823 onto the end of the args in some (at least one anyway)
3824 implementations, so strip it off if it exists. */
3827 char *command = elf_tdata (abfd)->core_command;
3828 int n = strlen (command);
3830 if (0 < n && command[n - 1] == ' ')
3831 command[n - 1] = '\0';
3838 /* Generic Xtensa configurability stuff. */
3840 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3841 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3842 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3843 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3844 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3845 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3846 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3847 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3850 init_call_opcodes (void)
3852 if (callx0_op == XTENSA_UNDEFINED)
3854 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3855 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3856 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3857 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3858 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3859 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3860 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3861 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3867 is_indirect_call_opcode (xtensa_opcode opcode)
3869 init_call_opcodes ();
3870 return (opcode == callx0_op
3871 || opcode == callx4_op
3872 || opcode == callx8_op
3873 || opcode == callx12_op);
3878 is_direct_call_opcode (xtensa_opcode opcode)
3880 init_call_opcodes ();
3881 return (opcode == call0_op
3882 || opcode == call4_op
3883 || opcode == call8_op
3884 || opcode == call12_op);
3889 is_windowed_call_opcode (xtensa_opcode opcode)
3891 init_call_opcodes ();
3892 return (opcode == call4_op
3893 || opcode == call8_op
3894 || opcode == call12_op
3895 || opcode == callx4_op
3896 || opcode == callx8_op
3897 || opcode == callx12_op);
3902 get_indirect_call_dest_reg (xtensa_opcode opcode, unsigned *pdst)
3904 unsigned dst = (unsigned) -1;
3906 init_call_opcodes ();
3907 if (opcode == callx0_op)
3909 else if (opcode == callx4_op)
3911 else if (opcode == callx8_op)
3913 else if (opcode == callx12_op)
3916 if (dst == (unsigned) -1)
3924 static xtensa_opcode
3925 get_const16_opcode (void)
3927 static bfd_boolean done_lookup = FALSE;
3928 static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3931 const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3934 return const16_opcode;
3938 static xtensa_opcode
3939 get_l32r_opcode (void)
3941 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
3942 static bfd_boolean done_lookup = FALSE;
3946 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
3954 l32r_offset (bfd_vma addr, bfd_vma pc)
3958 offset = addr - ((pc+3) & -4);
3959 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3960 offset = (signed int) offset >> 2;
3961 BFD_ASSERT ((signed int) offset >> 16 == -1);
3967 get_relocation_opnd (xtensa_opcode opcode, int r_type)
3969 xtensa_isa isa = xtensa_default_isa;
3970 int last_immed, last_opnd, opi;
3972 if (opcode == XTENSA_UNDEFINED)
3973 return XTENSA_UNDEFINED;
3975 /* Find the last visible PC-relative immediate operand for the opcode.
3976 If there are no PC-relative immediates, then choose the last visible
3977 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3978 last_immed = XTENSA_UNDEFINED;
3979 last_opnd = xtensa_opcode_num_operands (isa, opcode);
3980 for (opi = last_opnd - 1; opi >= 0; opi--)
3982 if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
3984 if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
3989 if (last_immed == XTENSA_UNDEFINED
3990 && xtensa_operand_is_register (isa, opcode, opi) == 0)
3994 return XTENSA_UNDEFINED;
3996 /* If the operand number was specified in an old-style relocation,
3997 check for consistency with the operand computed above. */
3998 if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
4000 int reloc_opnd = r_type - R_XTENSA_OP0;
4001 if (reloc_opnd != last_immed)
4002 return XTENSA_UNDEFINED;
4010 get_relocation_slot (int r_type)
4020 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4021 return r_type - R_XTENSA_SLOT0_OP;
4022 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4023 return r_type - R_XTENSA_SLOT0_ALT;
4027 return XTENSA_UNDEFINED;
4031 /* Get the opcode for a relocation. */
4033 static xtensa_opcode
4034 get_relocation_opcode (bfd *abfd,
4037 Elf_Internal_Rela *irel)
4039 static xtensa_insnbuf ibuff = NULL;
4040 static xtensa_insnbuf sbuff = NULL;
4041 xtensa_isa isa = xtensa_default_isa;
4045 if (contents == NULL)
4046 return XTENSA_UNDEFINED;
4048 if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
4049 return XTENSA_UNDEFINED;
4053 ibuff = xtensa_insnbuf_alloc (isa);
4054 sbuff = xtensa_insnbuf_alloc (isa);
4057 /* Decode the instruction. */
4058 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
4059 sec->size - irel->r_offset);
4060 fmt = xtensa_format_decode (isa, ibuff);
4061 slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
4062 if (slot == XTENSA_UNDEFINED)
4063 return XTENSA_UNDEFINED;
4064 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
4065 return xtensa_opcode_decode (isa, fmt, slot, sbuff);
4070 is_l32r_relocation (bfd *abfd,
4073 Elf_Internal_Rela *irel)
4075 xtensa_opcode opcode;
4076 if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
4078 opcode = get_relocation_opcode (abfd, sec, contents, irel);
4079 return (opcode == get_l32r_opcode ());
4083 static bfd_size_type
4084 get_asm_simplify_size (bfd_byte *contents,
4085 bfd_size_type content_len,
4086 bfd_size_type offset)
4088 bfd_size_type insnlen, size = 0;
4090 /* Decode the size of the next two instructions. */
4091 insnlen = insn_decode_len (contents, content_len, offset);
4097 insnlen = insn_decode_len (contents, content_len, offset + size);
4107 is_alt_relocation (int r_type)
4109 return (r_type >= R_XTENSA_SLOT0_ALT
4110 && r_type <= R_XTENSA_SLOT14_ALT);
4115 is_operand_relocation (int r_type)
4125 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4127 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4136 #define MIN_INSN_LENGTH 2
4138 /* Return 0 if it fails to decode. */
4141 insn_decode_len (bfd_byte *contents,
4142 bfd_size_type content_len,
4143 bfd_size_type offset)
4146 xtensa_isa isa = xtensa_default_isa;
4148 static xtensa_insnbuf ibuff = NULL;
4150 if (offset + MIN_INSN_LENGTH > content_len)
4154 ibuff = xtensa_insnbuf_alloc (isa);
4155 xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
4156 content_len - offset);
4157 fmt = xtensa_format_decode (isa, ibuff);
4158 if (fmt == XTENSA_UNDEFINED)
4160 insn_len = xtensa_format_length (isa, fmt);
4161 if (insn_len == XTENSA_UNDEFINED)
4167 /* Decode the opcode for a single slot instruction.
4168 Return 0 if it fails to decode or the instruction is multi-slot. */
4171 insn_decode_opcode (bfd_byte *contents,
4172 bfd_size_type content_len,
4173 bfd_size_type offset,
4176 xtensa_isa isa = xtensa_default_isa;
4178 static xtensa_insnbuf insnbuf = NULL;
4179 static xtensa_insnbuf slotbuf = NULL;
4181 if (offset + MIN_INSN_LENGTH > content_len)
4182 return XTENSA_UNDEFINED;
4184 if (insnbuf == NULL)
4186 insnbuf = xtensa_insnbuf_alloc (isa);
4187 slotbuf = xtensa_insnbuf_alloc (isa);
4190 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4191 content_len - offset);
4192 fmt = xtensa_format_decode (isa, insnbuf);
4193 if (fmt == XTENSA_UNDEFINED)
4194 return XTENSA_UNDEFINED;
4196 if (slot >= xtensa_format_num_slots (isa, fmt))
4197 return XTENSA_UNDEFINED;
4199 xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4200 return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4204 /* The offset is the offset in the contents.
4205 The address is the address of that offset. */
4208 check_branch_target_aligned (bfd_byte *contents,
4209 bfd_size_type content_length,
4213 bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
4216 return check_branch_target_aligned_address (address, insn_len);
4221 check_loop_aligned (bfd_byte *contents,
4222 bfd_size_type content_length,
4226 bfd_size_type loop_len, insn_len;
4227 xtensa_opcode opcode;
4229 opcode = insn_decode_opcode (contents, content_length, offset, 0);
4230 if (opcode == XTENSA_UNDEFINED
4231 || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
4237 loop_len = insn_decode_len (contents, content_length, offset);
4238 insn_len = insn_decode_len (contents, content_length, offset + loop_len);
4239 if (loop_len == 0 || insn_len == 0)
4245 return check_branch_target_aligned_address (address + loop_len, insn_len);
4250 check_branch_target_aligned_address (bfd_vma addr, int len)
4253 return (addr % 8 == 0);
4254 return ((addr >> 2) == ((addr + len - 1) >> 2));
4258 /* Instruction widening and narrowing. */
4260 /* When FLIX is available we need to access certain instructions only
4261 when they are 16-bit or 24-bit instructions. This table caches
4262 information about such instructions by walking through all the
4263 opcodes and finding the smallest single-slot format into which each
4266 static xtensa_format *op_single_fmt_table = NULL;
4270 init_op_single_format_table (void)
4272 xtensa_isa isa = xtensa_default_isa;
4273 xtensa_insnbuf ibuf;
4274 xtensa_opcode opcode;
4278 if (op_single_fmt_table)
4281 ibuf = xtensa_insnbuf_alloc (isa);
4282 num_opcodes = xtensa_isa_num_opcodes (isa);
4284 op_single_fmt_table = (xtensa_format *)
4285 bfd_malloc (sizeof (xtensa_format) * num_opcodes);
4286 for (opcode = 0; opcode < num_opcodes; opcode++)
4288 op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
4289 for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
4291 if (xtensa_format_num_slots (isa, fmt) == 1
4292 && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
4294 xtensa_opcode old_fmt = op_single_fmt_table[opcode];
4295 int fmt_length = xtensa_format_length (isa, fmt);
4296 if (old_fmt == XTENSA_UNDEFINED
4297 || fmt_length < xtensa_format_length (isa, old_fmt))
4298 op_single_fmt_table[opcode] = fmt;
4302 xtensa_insnbuf_free (isa, ibuf);
4306 static xtensa_format
4307 get_single_format (xtensa_opcode opcode)
4309 init_op_single_format_table ();
4310 return op_single_fmt_table[opcode];
4314 /* For the set of narrowable instructions we do NOT include the
4315 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4316 involved during linker relaxation that may require these to
4317 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4318 requires special case code to ensure it only works when op1 == op2. */
4326 struct string_pair narrowable[] =
4329 { "addi", "addi.n" },
4330 { "addmi", "addi.n" },
4331 { "l32i", "l32i.n" },
4332 { "movi", "movi.n" },
4334 { "retw", "retw.n" },
4335 { "s32i", "s32i.n" },
4336 { "or", "mov.n" } /* special case only when op1 == op2 */
4339 struct string_pair widenable[] =
4342 { "addi", "addi.n" },
4343 { "addmi", "addi.n" },
4344 { "beqz", "beqz.n" },
4345 { "bnez", "bnez.n" },
4346 { "l32i", "l32i.n" },
4347 { "movi", "movi.n" },
4349 { "retw", "retw.n" },
4350 { "s32i", "s32i.n" },
4351 { "or", "mov.n" } /* special case only when op1 == op2 */
4355 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4356 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4357 return the instruction buffer holding the narrow instruction. Otherwise,
4358 return 0. The set of valid narrowing are specified by a string table
4359 but require some special case operand checks in some cases. */
4361 static xtensa_insnbuf
4362 can_narrow_instruction (xtensa_insnbuf slotbuf,
4364 xtensa_opcode opcode)
4366 xtensa_isa isa = xtensa_default_isa;
4367 xtensa_format o_fmt;
4370 static xtensa_insnbuf o_insnbuf = NULL;
4371 static xtensa_insnbuf o_slotbuf = NULL;
4373 if (o_insnbuf == NULL)
4375 o_insnbuf = xtensa_insnbuf_alloc (isa);
4376 o_slotbuf = xtensa_insnbuf_alloc (isa);
4379 for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
4381 bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
4383 if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
4385 uint32 value, newval;
4386 int i, operand_count, o_operand_count;
4387 xtensa_opcode o_opcode;
4389 /* Address does not matter in this case. We might need to
4390 fix it to handle branches/jumps. */
4391 bfd_vma self_address = 0;
4393 o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
4394 if (o_opcode == XTENSA_UNDEFINED)
4396 o_fmt = get_single_format (o_opcode);
4397 if (o_fmt == XTENSA_UNDEFINED)
4400 if (xtensa_format_length (isa, fmt) != 3
4401 || xtensa_format_length (isa, o_fmt) != 2)
4404 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4405 operand_count = xtensa_opcode_num_operands (isa, opcode);
4406 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4408 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4413 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4418 uint32 rawval0, rawval1, rawval2;
4420 if (o_operand_count + 1 != operand_count
4421 || xtensa_operand_get_field (isa, opcode, 0,
4422 fmt, 0, slotbuf, &rawval0) != 0
4423 || xtensa_operand_get_field (isa, opcode, 1,
4424 fmt, 0, slotbuf, &rawval1) != 0
4425 || xtensa_operand_get_field (isa, opcode, 2,
4426 fmt, 0, slotbuf, &rawval2) != 0
4427 || rawval1 != rawval2
4428 || rawval0 == rawval1 /* it is a nop */)
4432 for (i = 0; i < o_operand_count; ++i)
4434 if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
4436 || xtensa_operand_decode (isa, opcode, i, &value))
4439 /* PC-relative branches need adjustment, but
4440 the PC-rel operand will always have a relocation. */
4442 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4444 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4445 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4450 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4460 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4461 the action in-place directly into the contents and return TRUE. Otherwise,
4462 the return value is FALSE and the contents are not modified. */
4465 narrow_instruction (bfd_byte *contents,
4466 bfd_size_type content_length,
4467 bfd_size_type offset)
4469 xtensa_opcode opcode;
4470 bfd_size_type insn_len;
4471 xtensa_isa isa = xtensa_default_isa;
4473 xtensa_insnbuf o_insnbuf;
4475 static xtensa_insnbuf insnbuf = NULL;
4476 static xtensa_insnbuf slotbuf = NULL;
4478 if (insnbuf == NULL)
4480 insnbuf = xtensa_insnbuf_alloc (isa);
4481 slotbuf = xtensa_insnbuf_alloc (isa);
4484 BFD_ASSERT (offset < content_length);
4486 if (content_length < 2)
4489 /* We will hand-code a few of these for a little while.
4490 These have all been specified in the assembler aleady. */
4491 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4492 content_length - offset);
4493 fmt = xtensa_format_decode (isa, insnbuf);
4494 if (xtensa_format_num_slots (isa, fmt) != 1)
4497 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4500 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4501 if (opcode == XTENSA_UNDEFINED)
4503 insn_len = xtensa_format_length (isa, fmt);
4504 if (insn_len > content_length)
4507 o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
4510 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4511 content_length - offset);
4519 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4520 "density" instruction to a standard 3-byte instruction. If it is valid,
4521 return the instruction buffer holding the wide instruction. Otherwise,
4522 return 0. The set of valid widenings are specified by a string table
4523 but require some special case operand checks in some cases. */
4525 static xtensa_insnbuf
4526 can_widen_instruction (xtensa_insnbuf slotbuf,
4528 xtensa_opcode opcode)
4530 xtensa_isa isa = xtensa_default_isa;
4531 xtensa_format o_fmt;
4534 static xtensa_insnbuf o_insnbuf = NULL;
4535 static xtensa_insnbuf o_slotbuf = NULL;
4537 if (o_insnbuf == NULL)
4539 o_insnbuf = xtensa_insnbuf_alloc (isa);
4540 o_slotbuf = xtensa_insnbuf_alloc (isa);
4543 for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
4545 bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
4546 bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
4547 || strcmp ("bnez", widenable[opi].wide) == 0);
4549 if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
4551 uint32 value, newval;
4552 int i, operand_count, o_operand_count, check_operand_count;
4553 xtensa_opcode o_opcode;
4555 /* Address does not matter in this case. We might need to fix it
4556 to handle branches/jumps. */
4557 bfd_vma self_address = 0;
4559 o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
4560 if (o_opcode == XTENSA_UNDEFINED)
4562 o_fmt = get_single_format (o_opcode);
4563 if (o_fmt == XTENSA_UNDEFINED)
4566 if (xtensa_format_length (isa, fmt) != 2
4567 || xtensa_format_length (isa, o_fmt) != 3)
4570 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4571 operand_count = xtensa_opcode_num_operands (isa, opcode);
4572 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4573 check_operand_count = o_operand_count;
4575 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4580 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4585 uint32 rawval0, rawval1;
4587 if (o_operand_count != operand_count + 1
4588 || xtensa_operand_get_field (isa, opcode, 0,
4589 fmt, 0, slotbuf, &rawval0) != 0
4590 || xtensa_operand_get_field (isa, opcode, 1,
4591 fmt, 0, slotbuf, &rawval1) != 0
4592 || rawval0 == rawval1 /* it is a nop */)
4596 check_operand_count--;
4598 for (i = 0; i < check_operand_count; i++)
4601 if (is_or && i == o_operand_count - 1)
4603 if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
4605 || xtensa_operand_decode (isa, opcode, new_i, &value))
4608 /* PC-relative branches need adjustment, but
4609 the PC-rel operand will always have a relocation. */
4611 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4613 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4614 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4619 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4629 /* Attempt to widen an instruction. If the widening is valid, perform
4630 the action in-place directly into the contents and return TRUE. Otherwise,
4631 the return value is FALSE and the contents are not modified. */
4634 widen_instruction (bfd_byte *contents,
4635 bfd_size_type content_length,
4636 bfd_size_type offset)
4638 xtensa_opcode opcode;
4639 bfd_size_type insn_len;
4640 xtensa_isa isa = xtensa_default_isa;
4642 xtensa_insnbuf o_insnbuf;
4644 static xtensa_insnbuf insnbuf = NULL;
4645 static xtensa_insnbuf slotbuf = NULL;
4647 if (insnbuf == NULL)
4649 insnbuf = xtensa_insnbuf_alloc (isa);
4650 slotbuf = xtensa_insnbuf_alloc (isa);
4653 BFD_ASSERT (offset < content_length);
4655 if (content_length < 2)
4658 /* We will hand-code a few of these for a little while.
4659 These have all been specified in the assembler aleady. */
4660 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4661 content_length - offset);
4662 fmt = xtensa_format_decode (isa, insnbuf);
4663 if (xtensa_format_num_slots (isa, fmt) != 1)
4666 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4669 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4670 if (opcode == XTENSA_UNDEFINED)
4672 insn_len = xtensa_format_length (isa, fmt);
4673 if (insn_len > content_length)
4676 o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
4679 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4680 content_length - offset);
4687 /* Code for transforming CALLs at link-time. */
4689 static bfd_reloc_status_type
4690 elf_xtensa_do_asm_simplify (bfd_byte *contents,
4692 bfd_vma content_length,
4693 char **error_message)
4695 static xtensa_insnbuf insnbuf = NULL;
4696 static xtensa_insnbuf slotbuf = NULL;
4697 xtensa_format core_format = XTENSA_UNDEFINED;
4698 xtensa_opcode opcode;
4699 xtensa_opcode direct_call_opcode;
4700 xtensa_isa isa = xtensa_default_isa;
4701 bfd_byte *chbuf = contents + address;
4704 if (insnbuf == NULL)
4706 insnbuf = xtensa_insnbuf_alloc (isa);
4707 slotbuf = xtensa_insnbuf_alloc (isa);
4710 if (content_length < address)
4712 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4713 return bfd_reloc_other;
4716 opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
4717 direct_call_opcode = swap_callx_for_call_opcode (opcode);
4718 if (direct_call_opcode == XTENSA_UNDEFINED)
4720 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4721 return bfd_reloc_other;
4724 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4725 core_format = xtensa_format_lookup (isa, "x24");
4726 opcode = xtensa_opcode_lookup (isa, "or");
4727 xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
4728 for (opn = 0; opn < 3; opn++)
4731 xtensa_operand_encode (isa, opcode, opn, ®no);
4732 xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
4735 xtensa_format_encode (isa, core_format, insnbuf);
4736 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4737 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
4739 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4740 xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
4741 xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
4743 xtensa_format_encode (isa, core_format, insnbuf);
4744 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4745 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
4746 content_length - address - 3);
4748 return bfd_reloc_ok;
4752 static bfd_reloc_status_type
4753 contract_asm_expansion (bfd_byte *contents,
4754 bfd_vma content_length,
4755 Elf_Internal_Rela *irel,
4756 char **error_message)
4758 bfd_reloc_status_type retval =
4759 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
4762 if (retval != bfd_reloc_ok)
4763 return bfd_reloc_dangerous;
4765 /* Update the irel->r_offset field so that the right immediate and
4766 the right instruction are modified during the relocation. */
4767 irel->r_offset += 3;
4768 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
4769 return bfd_reloc_ok;
4773 static xtensa_opcode
4774 swap_callx_for_call_opcode (xtensa_opcode opcode)
4776 init_call_opcodes ();
4778 if (opcode == callx0_op) return call0_op;
4779 if (opcode == callx4_op) return call4_op;
4780 if (opcode == callx8_op) return call8_op;
4781 if (opcode == callx12_op) return call12_op;
4783 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4784 return XTENSA_UNDEFINED;
4788 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4789 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4790 If not, return XTENSA_UNDEFINED. */
4792 #define L32R_TARGET_REG_OPERAND 0
4793 #define CONST16_TARGET_REG_OPERAND 0
4794 #define CALLN_SOURCE_OPERAND 0
4796 static xtensa_opcode
4797 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
4799 static xtensa_insnbuf insnbuf = NULL;
4800 static xtensa_insnbuf slotbuf = NULL;
4802 xtensa_opcode opcode;
4803 xtensa_isa isa = xtensa_default_isa;
4804 uint32 regno, const16_regno, call_regno;
4807 if (insnbuf == NULL)
4809 insnbuf = xtensa_insnbuf_alloc (isa);
4810 slotbuf = xtensa_insnbuf_alloc (isa);
4813 xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4814 fmt = xtensa_format_decode (isa, insnbuf);
4815 if (fmt == XTENSA_UNDEFINED
4816 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4817 return XTENSA_UNDEFINED;
4819 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4820 if (opcode == XTENSA_UNDEFINED)
4821 return XTENSA_UNDEFINED;
4823 if (opcode == get_l32r_opcode ())
4826 *p_uses_l32r = TRUE;
4827 if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4828 fmt, 0, slotbuf, ®no)
4829 || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4831 return XTENSA_UNDEFINED;
4833 else if (opcode == get_const16_opcode ())
4836 *p_uses_l32r = FALSE;
4837 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4838 fmt, 0, slotbuf, ®no)
4839 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4841 return XTENSA_UNDEFINED;
4843 /* Check that the next instruction is also CONST16. */
4844 offset += xtensa_format_length (isa, fmt);
4845 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4846 fmt = xtensa_format_decode (isa, insnbuf);
4847 if (fmt == XTENSA_UNDEFINED
4848 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4849 return XTENSA_UNDEFINED;
4850 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4851 if (opcode != get_const16_opcode ())
4852 return XTENSA_UNDEFINED;
4854 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4855 fmt, 0, slotbuf, &const16_regno)
4856 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4858 || const16_regno != regno)
4859 return XTENSA_UNDEFINED;
4862 return XTENSA_UNDEFINED;
4864 /* Next instruction should be an CALLXn with operand 0 == regno. */
4865 offset += xtensa_format_length (isa, fmt);
4866 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4867 fmt = xtensa_format_decode (isa, insnbuf);
4868 if (fmt == XTENSA_UNDEFINED
4869 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4870 return XTENSA_UNDEFINED;
4871 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4872 if (opcode == XTENSA_UNDEFINED
4873 || !is_indirect_call_opcode (opcode))
4874 return XTENSA_UNDEFINED;
4876 if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4877 fmt, 0, slotbuf, &call_regno)
4878 || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4880 return XTENSA_UNDEFINED;
4882 if (call_regno != regno)
4883 return XTENSA_UNDEFINED;
4889 /* Data structures used during relaxation. */
4891 /* r_reloc: relocation values. */
4893 /* Through the relaxation process, we need to keep track of the values
4894 that will result from evaluating relocations. The standard ELF
4895 relocation structure is not sufficient for this purpose because we're
4896 operating on multiple input files at once, so we need to know which
4897 input file a relocation refers to. The r_reloc structure thus
4898 records both the input file (bfd) and ELF relocation.
4900 For efficiency, an r_reloc also contains a "target_offset" field to
4901 cache the target-section-relative offset value that is represented by
4904 The r_reloc also contains a virtual offset that allows multiple
4905 inserted literals to be placed at the same "address" with
4906 different offsets. */
4908 typedef struct r_reloc_struct r_reloc;
4910 struct r_reloc_struct
4913 Elf_Internal_Rela rela;
4914 bfd_vma target_offset;
4915 bfd_vma virtual_offset;
4919 /* The r_reloc structure is included by value in literal_value, but not
4920 every literal_value has an associated relocation -- some are simple
4921 constants. In such cases, we set all the fields in the r_reloc
4922 struct to zero. The r_reloc_is_const function should be used to
4923 detect this case. */
4926 r_reloc_is_const (const r_reloc *r_rel)
4928 return (r_rel->abfd == NULL);
4933 r_reloc_get_target_offset (const r_reloc *r_rel)
4935 bfd_vma target_offset;
4936 unsigned long r_symndx;
4938 BFD_ASSERT (!r_reloc_is_const (r_rel));
4939 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4940 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4941 return (target_offset + r_rel->rela.r_addend);
4945 static struct elf_link_hash_entry *
4946 r_reloc_get_hash_entry (const r_reloc *r_rel)
4948 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4949 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4954 r_reloc_get_section (const r_reloc *r_rel)
4956 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4957 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4962 r_reloc_is_defined (const r_reloc *r_rel)
4968 sec = r_reloc_get_section (r_rel);
4969 if (sec == bfd_abs_section_ptr
4970 || sec == bfd_com_section_ptr
4971 || sec == bfd_und_section_ptr)
4978 r_reloc_init (r_reloc *r_rel,
4980 Elf_Internal_Rela *irel,
4982 bfd_size_type content_length)
4985 reloc_howto_type *howto;
4989 r_rel->rela = *irel;
4991 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
4992 r_rel->virtual_offset = 0;
4993 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
4994 howto = &elf_howto_table[r_type];
4995 if (howto->partial_inplace)
4997 bfd_vma inplace_val;
4998 BFD_ASSERT (r_rel->rela.r_offset < content_length);
5000 inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
5001 r_rel->target_offset += inplace_val;
5005 memset (r_rel, 0, sizeof (r_reloc));
5012 print_r_reloc (FILE *fp, const r_reloc *r_rel)
5014 if (r_reloc_is_defined (r_rel))
5016 asection *sec = r_reloc_get_section (r_rel);
5017 fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
5019 else if (r_reloc_get_hash_entry (r_rel))
5020 fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
5022 fprintf (fp, " ?? + ");
5024 fprintf_vma (fp, r_rel->target_offset);
5025 if (r_rel->virtual_offset)
5027 fprintf (fp, " + ");
5028 fprintf_vma (fp, r_rel->virtual_offset);
5037 /* source_reloc: relocations that reference literals. */
5039 /* To determine whether literals can be coalesced, we need to first
5040 record all the relocations that reference the literals. The
5041 source_reloc structure below is used for this purpose. The
5042 source_reloc entries are kept in a per-literal-section array, sorted
5043 by offset within the literal section (i.e., target offset).
5045 The source_sec and r_rel.rela.r_offset fields identify the source of
5046 the relocation. The r_rel field records the relocation value, i.e.,
5047 the offset of the literal being referenced. The opnd field is needed
5048 to determine the range of the immediate field to which the relocation
5049 applies, so we can determine whether another literal with the same
5050 value is within range. The is_null field is true when the relocation
5051 is being removed (e.g., when an L32R is being removed due to a CALLX
5052 that is converted to a direct CALL). */
5054 typedef struct source_reloc_struct source_reloc;
5056 struct source_reloc_struct
5058 asection *source_sec;
5060 xtensa_opcode opcode;
5062 bfd_boolean is_null;
5063 bfd_boolean is_abs_literal;
5068 init_source_reloc (source_reloc *reloc,
5069 asection *source_sec,
5070 const r_reloc *r_rel,
5071 xtensa_opcode opcode,
5073 bfd_boolean is_abs_literal)
5075 reloc->source_sec = source_sec;
5076 reloc->r_rel = *r_rel;
5077 reloc->opcode = opcode;
5079 reloc->is_null = FALSE;
5080 reloc->is_abs_literal = is_abs_literal;
5084 /* Find the source_reloc for a particular source offset and relocation
5085 type. Note that the array is sorted by _target_ offset, so this is
5086 just a linear search. */
5088 static source_reloc *
5089 find_source_reloc (source_reloc *src_relocs,
5092 Elf_Internal_Rela *irel)
5096 for (i = 0; i < src_count; i++)
5098 if (src_relocs[i].source_sec == sec
5099 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
5100 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
5101 == ELF32_R_TYPE (irel->r_info)))
5102 return &src_relocs[i];
5110 source_reloc_compare (const void *ap, const void *bp)
5112 const source_reloc *a = (const source_reloc *) ap;
5113 const source_reloc *b = (const source_reloc *) bp;
5115 if (a->r_rel.target_offset != b->r_rel.target_offset)
5116 return (a->r_rel.target_offset - b->r_rel.target_offset);
5118 /* We don't need to sort on these criteria for correctness,
5119 but enforcing a more strict ordering prevents unstable qsort
5120 from behaving differently with different implementations.
5121 Without the code below we get correct but different results
5122 on Solaris 2.7 and 2.8. We would like to always produce the
5123 same results no matter the host. */
5125 if ((!a->is_null) - (!b->is_null))
5126 return ((!a->is_null) - (!b->is_null));
5127 return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
5131 /* Literal values and value hash tables. */
5133 /* Literals with the same value can be coalesced. The literal_value
5134 structure records the value of a literal: the "r_rel" field holds the
5135 information from the relocation on the literal (if there is one) and
5136 the "value" field holds the contents of the literal word itself.
5138 The value_map structure records a literal value along with the
5139 location of a literal holding that value. The value_map hash table
5140 is indexed by the literal value, so that we can quickly check if a
5141 particular literal value has been seen before and is thus a candidate
5144 typedef struct literal_value_struct literal_value;
5145 typedef struct value_map_struct value_map;
5146 typedef struct value_map_hash_table_struct value_map_hash_table;
5148 struct literal_value_struct
5151 unsigned long value;
5152 bfd_boolean is_abs_literal;
5155 struct value_map_struct
5157 literal_value val; /* The literal value. */
5158 r_reloc loc; /* Location of the literal. */
5162 struct value_map_hash_table_struct
5164 unsigned bucket_count;
5165 value_map **buckets;
5167 bfd_boolean has_last_loc;
5173 init_literal_value (literal_value *lit,
5174 const r_reloc *r_rel,
5175 unsigned long value,
5176 bfd_boolean is_abs_literal)
5178 lit->r_rel = *r_rel;
5180 lit->is_abs_literal = is_abs_literal;
5185 literal_value_equal (const literal_value *src1,
5186 const literal_value *src2,
5187 bfd_boolean final_static_link)
5189 struct elf_link_hash_entry *h1, *h2;
5191 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
5194 if (r_reloc_is_const (&src1->r_rel))
5195 return (src1->value == src2->value);
5197 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
5198 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
5201 if (src1->r_rel.target_offset != src2->r_rel.target_offset)
5204 if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
5207 if (src1->value != src2->value)
5210 /* Now check for the same section (if defined) or the same elf_hash
5211 (if undefined or weak). */
5212 h1 = r_reloc_get_hash_entry (&src1->r_rel);
5213 h2 = r_reloc_get_hash_entry (&src2->r_rel);
5214 if (r_reloc_is_defined (&src1->r_rel)
5215 && (final_static_link
5216 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
5217 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
5219 if (r_reloc_get_section (&src1->r_rel)
5220 != r_reloc_get_section (&src2->r_rel))
5225 /* Require that the hash entries (i.e., symbols) be identical. */
5226 if (h1 != h2 || h1 == 0)
5230 if (src1->is_abs_literal != src2->is_abs_literal)
5237 /* Must be power of 2. */
5238 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5240 static value_map_hash_table *
5241 value_map_hash_table_init (void)
5243 value_map_hash_table *values;
5245 values = (value_map_hash_table *)
5246 bfd_zmalloc (sizeof (value_map_hash_table));
5247 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
5249 values->buckets = (value_map **)
5250 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
5251 if (values->buckets == NULL)
5256 values->has_last_loc = FALSE;
5263 value_map_hash_table_delete (value_map_hash_table *table)
5265 free (table->buckets);
5271 hash_bfd_vma (bfd_vma val)
5273 return (val >> 2) + (val >> 10);
5278 literal_value_hash (const literal_value *src)
5282 hash_val = hash_bfd_vma (src->value);
5283 if (!r_reloc_is_const (&src->r_rel))
5287 hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
5288 hash_val += hash_bfd_vma (src->r_rel.target_offset);
5289 hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
5291 /* Now check for the same section and the same elf_hash. */
5292 if (r_reloc_is_defined (&src->r_rel))
5293 sec_or_hash = r_reloc_get_section (&src->r_rel);
5295 sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
5296 hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
5302 /* Check if the specified literal_value has been seen before. */
5305 value_map_get_cached_value (value_map_hash_table *map,
5306 const literal_value *val,
5307 bfd_boolean final_static_link)
5313 idx = literal_value_hash (val);
5314 idx = idx & (map->bucket_count - 1);
5315 bucket = map->buckets[idx];
5316 for (map_e = bucket; map_e; map_e = map_e->next)
5318 if (literal_value_equal (&map_e->val, val, final_static_link))
5325 /* Record a new literal value. It is illegal to call this if VALUE
5326 already has an entry here. */
5329 add_value_map (value_map_hash_table *map,
5330 const literal_value *val,
5332 bfd_boolean final_static_link)
5334 value_map **bucket_p;
5337 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
5340 bfd_set_error (bfd_error_no_memory);
5344 BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
5348 idx = literal_value_hash (val);
5349 idx = idx & (map->bucket_count - 1);
5350 bucket_p = &map->buckets[idx];
5352 val_e->next = *bucket_p;
5355 /* FIXME: Consider resizing the hash table if we get too many entries. */
5361 /* Lists of text actions (ta_) for narrowing, widening, longcall
5362 conversion, space fill, code & literal removal, etc. */
5364 /* The following text actions are generated:
5366 "ta_remove_insn" remove an instruction or instructions
5367 "ta_remove_longcall" convert longcall to call
5368 "ta_convert_longcall" convert longcall to nop/call
5369 "ta_narrow_insn" narrow a wide instruction
5370 "ta_widen" widen a narrow instruction
5371 "ta_fill" add fill or remove fill
5372 removed < 0 is a fill; branches to the fill address will be
5373 changed to address + fill size (e.g., address - removed)
5374 removed >= 0 branches to the fill address will stay unchanged
5375 "ta_remove_literal" remove a literal; this action is
5376 indicated when a literal is removed
5378 "ta_add_literal" insert a new literal; this action is
5379 indicated when a literal has been moved.
5380 It may use a virtual_offset because
5381 multiple literals can be placed at the
5384 For each of these text actions, we also record the number of bytes
5385 removed by performing the text action. In the case of a "ta_widen"
5386 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5388 typedef struct text_action_struct text_action;
5389 typedef struct text_action_list_struct text_action_list;
5390 typedef enum text_action_enum_t text_action_t;
5392 enum text_action_enum_t
5395 ta_remove_insn, /* removed = -size */
5396 ta_remove_longcall, /* removed = -size */
5397 ta_convert_longcall, /* removed = 0 */
5398 ta_narrow_insn, /* removed = -1 */
5399 ta_widen_insn, /* removed = +1 */
5400 ta_fill, /* removed = +size */
5406 /* Structure for a text action record. */
5407 struct text_action_struct
5409 text_action_t action;
5410 asection *sec; /* Optional */
5412 bfd_vma virtual_offset; /* Zero except for adding literals. */
5414 literal_value value; /* Only valid when adding literals. */
5420 /* List of all of the actions taken on a text section. */
5421 struct text_action_list_struct
5427 static text_action *
5428 find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
5432 /* It is not necessary to fill at the end of a section. */
5433 if (sec->size == offset)
5436 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
5438 text_action *t = *m_p;
5439 /* When the action is another fill at the same address,
5440 just increase the size. */
5441 if (t->offset == offset && t->action == ta_fill)
5449 compute_removed_action_diff (const text_action *ta,
5453 int removable_space)
5456 int current_removed = 0;
5459 current_removed = ta->removed_bytes;
5461 BFD_ASSERT (ta == NULL || ta->offset == offset);
5462 BFD_ASSERT (ta == NULL || ta->action == ta_fill);
5464 /* It is not necessary to fill at the end of a section. Clean this up. */
5465 if (sec->size == offset)
5466 new_removed = removable_space - 0;
5470 int added = -removed - current_removed;
5471 /* Ignore multiples of the section alignment. */
5472 added = ((1 << sec->alignment_power) - 1) & added;
5473 new_removed = (-added);
5475 /* Modify for removable. */
5476 space = removable_space - new_removed;
5477 new_removed = (removable_space
5478 - (((1 << sec->alignment_power) - 1) & space));
5480 return (new_removed - current_removed);
5485 adjust_fill_action (text_action *ta, int fill_diff)
5487 ta->removed_bytes += fill_diff;
5491 /* Add a modification action to the text. For the case of adding or
5492 removing space, modify any current fill and assume that
5493 "unreachable_space" bytes can be freely contracted. Note that a
5494 negative removed value is a fill. */
5497 text_action_add (text_action_list *l,
5498 text_action_t action,
5506 /* It is not necessary to fill at the end of a section. */
5507 if (action == ta_fill && sec->size == offset)
5510 /* It is not necessary to fill 0 bytes. */
5511 if (action == ta_fill && removed == 0)
5514 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
5516 text_action *t = *m_p;
5518 if (action == ta_fill)
5520 /* When the action is another fill at the same address,
5521 just increase the size. */
5522 if (t->offset == offset && t->action == ta_fill)
5524 t->removed_bytes += removed;
5527 /* Fills need to happen before widens so that we don't
5528 insert fill bytes into the instruction stream. */
5529 if (t->offset == offset && t->action == ta_widen_insn)
5534 /* Create a new record and fill it up. */
5535 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5536 ta->action = action;
5538 ta->offset = offset;
5539 ta->removed_bytes = removed;
5546 text_action_add_literal (text_action_list *l,
5547 text_action_t action,
5549 const literal_value *value,
5554 asection *sec = r_reloc_get_section (loc);
5555 bfd_vma offset = loc->target_offset;
5556 bfd_vma virtual_offset = loc->virtual_offset;
5558 BFD_ASSERT (action == ta_add_literal);
5560 for (m_p = &l->head; *m_p != NULL; m_p = &(*m_p)->next)
5562 if ((*m_p)->offset > offset
5563 && ((*m_p)->offset != offset
5564 || (*m_p)->virtual_offset > virtual_offset))
5568 /* Create a new record and fill it up. */
5569 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5570 ta->action = action;
5572 ta->offset = offset;
5573 ta->virtual_offset = virtual_offset;
5575 ta->removed_bytes = removed;
5581 /* Find the total offset adjustment for the relaxations specified by
5582 text_actions, beginning from a particular starting action. This is
5583 typically used from offset_with_removed_text to search an entire list of
5584 actions, but it may also be called directly when adjusting adjacent offsets
5585 so that each search may begin where the previous one left off. */
5588 removed_by_actions (text_action **p_start_action,
5590 bfd_boolean before_fill)
5595 r = *p_start_action;
5598 if (r->offset > offset)
5601 if (r->offset == offset
5602 && (before_fill || r->action != ta_fill || r->removed_bytes >= 0))
5605 removed += r->removed_bytes;
5610 *p_start_action = r;
5616 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
5618 text_action *r = action_list->head;
5619 return offset - removed_by_actions (&r, offset, FALSE);
5624 action_list_count (text_action_list *action_list)
5626 text_action *r = action_list->head;
5628 for (r = action_list->head; r != NULL; r = r->next)
5636 /* The find_insn_action routine will only find non-fill actions. */
5638 static text_action *
5639 find_insn_action (text_action_list *action_list, bfd_vma offset)
5642 for (t = action_list->head; t; t = t->next)
5644 if (t->offset == offset)
5651 case ta_remove_insn:
5652 case ta_remove_longcall:
5653 case ta_convert_longcall:
5654 case ta_narrow_insn:
5657 case ta_remove_literal:
5658 case ta_add_literal:
5671 print_action_list (FILE *fp, text_action_list *action_list)
5675 fprintf (fp, "Text Action\n");
5676 for (r = action_list->head; r != NULL; r = r->next)
5678 const char *t = "unknown";
5681 case ta_remove_insn:
5682 t = "remove_insn"; break;
5683 case ta_remove_longcall:
5684 t = "remove_longcall"; break;
5685 case ta_convert_longcall:
5686 t = "convert_longcall"; break;
5687 case ta_narrow_insn:
5688 t = "narrow_insn"; break;
5690 t = "widen_insn"; break;
5695 case ta_remove_literal:
5696 t = "remove_literal"; break;
5697 case ta_add_literal:
5698 t = "add_literal"; break;
5701 fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
5702 r->sec->owner->filename,
5703 r->sec->name, (unsigned long) r->offset, t, r->removed_bytes);
5710 /* Lists of literals being coalesced or removed. */
5712 /* In the usual case, the literal identified by "from" is being
5713 coalesced with another literal identified by "to". If the literal is
5714 unused and is being removed altogether, "to.abfd" will be NULL.
5715 The removed_literal entries are kept on a per-section list, sorted
5716 by the "from" offset field. */
5718 typedef struct removed_literal_struct removed_literal;
5719 typedef struct removed_literal_list_struct removed_literal_list;
5721 struct removed_literal_struct
5725 removed_literal *next;
5728 struct removed_literal_list_struct
5730 removed_literal *head;
5731 removed_literal *tail;
5735 /* Record that the literal at "from" is being removed. If "to" is not
5736 NULL, the "from" literal is being coalesced with the "to" literal. */
5739 add_removed_literal (removed_literal_list *removed_list,
5740 const r_reloc *from,
5743 removed_literal *r, *new_r, *next_r;
5745 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
5747 new_r->from = *from;
5751 new_r->to.abfd = NULL;
5754 r = removed_list->head;
5757 removed_list->head = new_r;
5758 removed_list->tail = new_r;
5760 /* Special check for common case of append. */
5761 else if (removed_list->tail->from.target_offset < from->target_offset)
5763 removed_list->tail->next = new_r;
5764 removed_list->tail = new_r;
5768 while (r->from.target_offset < from->target_offset && r->next)
5774 new_r->next = next_r;
5776 removed_list->tail = new_r;
5781 /* Check if the list of removed literals contains an entry for the
5782 given address. Return the entry if found. */
5784 static removed_literal *
5785 find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
5787 removed_literal *r = removed_list->head;
5788 while (r && r->from.target_offset < addr)
5790 if (r && r->from.target_offset == addr)
5799 print_removed_literals (FILE *fp, removed_literal_list *removed_list)
5802 r = removed_list->head;
5804 fprintf (fp, "Removed Literals\n");
5805 for (; r != NULL; r = r->next)
5807 print_r_reloc (fp, &r->from);
5808 fprintf (fp, " => ");
5809 if (r->to.abfd == NULL)
5810 fprintf (fp, "REMOVED");
5812 print_r_reloc (fp, &r->to);
5820 /* Per-section data for relaxation. */
5822 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
5824 struct xtensa_relax_info_struct
5826 bfd_boolean is_relaxable_literal_section;
5827 bfd_boolean is_relaxable_asm_section;
5828 int visited; /* Number of times visited. */
5830 source_reloc *src_relocs; /* Array[src_count]. */
5832 int src_next; /* Next src_relocs entry to assign. */
5834 removed_literal_list removed_list;
5835 text_action_list action_list;
5837 reloc_bfd_fix *fix_list;
5838 reloc_bfd_fix *fix_array;
5839 unsigned fix_array_count;
5841 /* Support for expanding the reloc array that is stored
5842 in the section structure. If the relocations have been
5843 reallocated, the newly allocated relocations will be referenced
5844 here along with the actual size allocated. The relocation
5845 count will always be found in the section structure. */
5846 Elf_Internal_Rela *allocated_relocs;
5847 unsigned relocs_count;
5848 unsigned allocated_relocs_count;
5851 struct elf_xtensa_section_data
5853 struct bfd_elf_section_data elf;
5854 xtensa_relax_info relax_info;
5859 elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
5861 if (!sec->used_by_bfd)
5863 struct elf_xtensa_section_data *sdata;
5864 bfd_size_type amt = sizeof (*sdata);
5866 sdata = bfd_zalloc (abfd, amt);
5869 sec->used_by_bfd = sdata;
5872 return _bfd_elf_new_section_hook (abfd, sec);
5876 static xtensa_relax_info *
5877 get_xtensa_relax_info (asection *sec)
5879 struct elf_xtensa_section_data *section_data;
5881 /* No info available if no section or if it is an output section. */
5882 if (!sec || sec == sec->output_section)
5885 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
5886 return §ion_data->relax_info;
5891 init_xtensa_relax_info (asection *sec)
5893 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5895 relax_info->is_relaxable_literal_section = FALSE;
5896 relax_info->is_relaxable_asm_section = FALSE;
5897 relax_info->visited = 0;
5899 relax_info->src_relocs = NULL;
5900 relax_info->src_count = 0;
5901 relax_info->src_next = 0;
5903 relax_info->removed_list.head = NULL;
5904 relax_info->removed_list.tail = NULL;
5906 relax_info->action_list.head = NULL;
5908 relax_info->fix_list = NULL;
5909 relax_info->fix_array = NULL;
5910 relax_info->fix_array_count = 0;
5912 relax_info->allocated_relocs = NULL;
5913 relax_info->relocs_count = 0;
5914 relax_info->allocated_relocs_count = 0;
5918 /* Coalescing literals may require a relocation to refer to a section in
5919 a different input file, but the standard relocation information
5920 cannot express that. Instead, the reloc_bfd_fix structures are used
5921 to "fix" the relocations that refer to sections in other input files.
5922 These structures are kept on per-section lists. The "src_type" field
5923 records the relocation type in case there are multiple relocations on
5924 the same location. FIXME: This is ugly; an alternative might be to
5925 add new symbols with the "owner" field to some other input file. */
5927 struct reloc_bfd_fix_struct
5931 unsigned src_type; /* Relocation type. */
5933 asection *target_sec;
5934 bfd_vma target_offset;
5935 bfd_boolean translated;
5937 reloc_bfd_fix *next;
5941 static reloc_bfd_fix *
5942 reloc_bfd_fix_init (asection *src_sec,
5945 asection *target_sec,
5946 bfd_vma target_offset,
5947 bfd_boolean translated)
5951 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
5952 fix->src_sec = src_sec;
5953 fix->src_offset = src_offset;
5954 fix->src_type = src_type;
5955 fix->target_sec = target_sec;
5956 fix->target_offset = target_offset;
5957 fix->translated = translated;
5964 add_fix (asection *src_sec, reloc_bfd_fix *fix)
5966 xtensa_relax_info *relax_info;
5968 relax_info = get_xtensa_relax_info (src_sec);
5969 fix->next = relax_info->fix_list;
5970 relax_info->fix_list = fix;
5975 fix_compare (const void *ap, const void *bp)
5977 const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
5978 const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
5980 if (a->src_offset != b->src_offset)
5981 return (a->src_offset - b->src_offset);
5982 return (a->src_type - b->src_type);
5987 cache_fix_array (asection *sec)
5989 unsigned i, count = 0;
5991 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5993 if (relax_info == NULL)
5995 if (relax_info->fix_list == NULL)
5998 for (r = relax_info->fix_list; r != NULL; r = r->next)
6001 relax_info->fix_array =
6002 (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
6003 relax_info->fix_array_count = count;
6005 r = relax_info->fix_list;
6006 for (i = 0; i < count; i++, r = r->next)
6008 relax_info->fix_array[count - 1 - i] = *r;
6009 relax_info->fix_array[count - 1 - i].next = NULL;
6012 qsort (relax_info->fix_array, relax_info->fix_array_count,
6013 sizeof (reloc_bfd_fix), fix_compare);
6017 static reloc_bfd_fix *
6018 get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
6020 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6024 if (relax_info == NULL)
6026 if (relax_info->fix_list == NULL)
6029 if (relax_info->fix_array == NULL)
6030 cache_fix_array (sec);
6032 key.src_offset = offset;
6033 key.src_type = type;
6034 rv = bsearch (&key, relax_info->fix_array, relax_info->fix_array_count,
6035 sizeof (reloc_bfd_fix), fix_compare);
6040 /* Section caching. */
6042 typedef struct section_cache_struct section_cache_t;
6044 struct section_cache_struct
6048 bfd_byte *contents; /* Cache of the section contents. */
6049 bfd_size_type content_length;
6051 property_table_entry *ptbl; /* Cache of the section property table. */
6054 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6055 unsigned reloc_count;
6060 init_section_cache (section_cache_t *sec_cache)
6062 memset (sec_cache, 0, sizeof (*sec_cache));
6067 clear_section_cache (section_cache_t *sec_cache)
6071 release_contents (sec_cache->sec, sec_cache->contents);
6072 release_internal_relocs (sec_cache->sec, sec_cache->relocs);
6073 if (sec_cache->ptbl)
6074 free (sec_cache->ptbl);
6075 memset (sec_cache, 0, sizeof (sec_cache));
6081 section_cache_section (section_cache_t *sec_cache,
6083 struct bfd_link_info *link_info)
6086 property_table_entry *prop_table = NULL;
6088 bfd_byte *contents = NULL;
6089 Elf_Internal_Rela *internal_relocs = NULL;
6090 bfd_size_type sec_size;
6094 if (sec == sec_cache->sec)
6098 sec_size = bfd_get_section_limit (abfd, sec);
6100 /* Get the contents. */
6101 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6102 if (contents == NULL && sec_size != 0)
6105 /* Get the relocations. */
6106 internal_relocs = retrieve_internal_relocs (abfd, sec,
6107 link_info->keep_memory);
6109 /* Get the entry table. */
6110 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6111 XTENSA_PROP_SEC_NAME, FALSE);
6115 /* Fill in the new section cache. */
6116 clear_section_cache (sec_cache);
6117 memset (sec_cache, 0, sizeof (sec_cache));
6119 sec_cache->sec = sec;
6120 sec_cache->contents = contents;
6121 sec_cache->content_length = sec_size;
6122 sec_cache->relocs = internal_relocs;
6123 sec_cache->reloc_count = sec->reloc_count;
6124 sec_cache->pte_count = ptblsize;
6125 sec_cache->ptbl = prop_table;
6130 release_contents (sec, contents);
6131 release_internal_relocs (sec, internal_relocs);
6138 /* Extended basic blocks. */
6140 /* An ebb_struct represents an Extended Basic Block. Within this
6141 range, we guarantee that all instructions are decodable, the
6142 property table entries are contiguous, and no property table
6143 specifies a segment that cannot have instructions moved. This
6144 structure contains caches of the contents, property table and
6145 relocations for the specified section for easy use. The range is
6146 specified by ranges of indices for the byte offset, property table
6147 offsets and relocation offsets. These must be consistent. */
6149 typedef struct ebb_struct ebb_t;
6155 bfd_byte *contents; /* Cache of the section contents. */
6156 bfd_size_type content_length;
6158 property_table_entry *ptbl; /* Cache of the section property table. */
6161 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6162 unsigned reloc_count;
6164 bfd_vma start_offset; /* Offset in section. */
6165 unsigned start_ptbl_idx; /* Offset in the property table. */
6166 unsigned start_reloc_idx; /* Offset in the relocations. */
6169 unsigned end_ptbl_idx;
6170 unsigned end_reloc_idx;
6172 bfd_boolean ends_section; /* Is this the last ebb in a section? */
6174 /* The unreachable property table at the end of this set of blocks;
6175 NULL if the end is not an unreachable block. */
6176 property_table_entry *ends_unreachable;
6180 enum ebb_target_enum
6183 EBB_DESIRE_TGT_ALIGN,
6184 EBB_REQUIRE_TGT_ALIGN,
6185 EBB_REQUIRE_LOOP_ALIGN,
6190 /* proposed_action_struct is similar to the text_action_struct except
6191 that is represents a potential transformation, not one that will
6192 occur. We build a list of these for an extended basic block
6193 and use them to compute the actual actions desired. We must be
6194 careful that the entire set of actual actions we perform do not
6195 break any relocations that would fit if the actions were not
6198 typedef struct proposed_action_struct proposed_action;
6200 struct proposed_action_struct
6202 enum ebb_target_enum align_type; /* for the target alignment */
6203 bfd_vma alignment_pow;
6204 text_action_t action;
6207 bfd_boolean do_action; /* If false, then we will not perform the action. */
6211 /* The ebb_constraint_struct keeps a set of proposed actions for an
6212 extended basic block. */
6214 typedef struct ebb_constraint_struct ebb_constraint;
6216 struct ebb_constraint_struct
6219 bfd_boolean start_movable;
6221 /* Bytes of extra space at the beginning if movable. */
6222 int start_extra_space;
6224 enum ebb_target_enum start_align;
6226 bfd_boolean end_movable;
6228 /* Bytes of extra space at the end if movable. */
6229 int end_extra_space;
6231 unsigned action_count;
6232 unsigned action_allocated;
6234 /* Array of proposed actions. */
6235 proposed_action *actions;
6237 /* Action alignments -- one for each proposed action. */
6238 enum ebb_target_enum *action_aligns;
6243 init_ebb_constraint (ebb_constraint *c)
6245 memset (c, 0, sizeof (ebb_constraint));
6250 free_ebb_constraint (ebb_constraint *c)
6258 init_ebb (ebb_t *ebb,
6261 bfd_size_type content_length,
6262 property_table_entry *prop_table,
6264 Elf_Internal_Rela *internal_relocs,
6265 unsigned reloc_count)
6267 memset (ebb, 0, sizeof (ebb_t));
6269 ebb->contents = contents;
6270 ebb->content_length = content_length;
6271 ebb->ptbl = prop_table;
6272 ebb->pte_count = ptblsize;
6273 ebb->relocs = internal_relocs;
6274 ebb->reloc_count = reloc_count;
6275 ebb->start_offset = 0;
6276 ebb->end_offset = ebb->content_length - 1;
6277 ebb->start_ptbl_idx = 0;
6278 ebb->end_ptbl_idx = ptblsize;
6279 ebb->start_reloc_idx = 0;
6280 ebb->end_reloc_idx = reloc_count;
6284 /* Extend the ebb to all decodable contiguous sections. The algorithm
6285 for building a basic block around an instruction is to push it
6286 forward until we hit the end of a section, an unreachable block or
6287 a block that cannot be transformed. Then we push it backwards
6288 searching for similar conditions. */
6290 static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
6291 static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
6292 static bfd_size_type insn_block_decodable_len
6293 (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
6296 extend_ebb_bounds (ebb_t *ebb)
6298 if (!extend_ebb_bounds_forward (ebb))
6300 if (!extend_ebb_bounds_backward (ebb))
6307 extend_ebb_bounds_forward (ebb_t *ebb)
6309 property_table_entry *the_entry, *new_entry;
6311 the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6313 /* Stop when (1) we cannot decode an instruction, (2) we are at
6314 the end of the property tables, (3) we hit a non-contiguous property
6315 table entry, (4) we hit a NO_TRANSFORM region. */
6320 bfd_size_type insn_block_len;
6322 entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
6324 insn_block_decodable_len (ebb->contents, ebb->content_length,
6326 entry_end - ebb->end_offset);
6327 if (insn_block_len != (entry_end - ebb->end_offset))
6329 (*_bfd_error_handler)
6330 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6331 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6334 ebb->end_offset += insn_block_len;
6336 if (ebb->end_offset == ebb->sec->size)
6337 ebb->ends_section = TRUE;
6339 /* Update the reloc counter. */
6340 while (ebb->end_reloc_idx + 1 < ebb->reloc_count
6341 && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
6344 ebb->end_reloc_idx++;
6347 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6350 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6351 if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
6352 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6353 || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
6356 if (the_entry->address + the_entry->size != new_entry->address)
6359 the_entry = new_entry;
6360 ebb->end_ptbl_idx++;
6363 /* Quick check for an unreachable or end of file just at the end. */
6364 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6366 if (ebb->end_offset == ebb->content_length)
6367 ebb->ends_section = TRUE;
6371 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6372 if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
6373 && the_entry->address + the_entry->size == new_entry->address)
6374 ebb->ends_unreachable = new_entry;
6377 /* Any other ending requires exact alignment. */
6383 extend_ebb_bounds_backward (ebb_t *ebb)
6385 property_table_entry *the_entry, *new_entry;
6387 the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6389 /* Stop when (1) we cannot decode the instructions in the current entry.
6390 (2) we are at the beginning of the property tables, (3) we hit a
6391 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6395 bfd_vma block_begin;
6396 bfd_size_type insn_block_len;
6398 block_begin = the_entry->address - ebb->sec->vma;
6400 insn_block_decodable_len (ebb->contents, ebb->content_length,
6402 ebb->start_offset - block_begin);
6403 if (insn_block_len != ebb->start_offset - block_begin)
6405 (*_bfd_error_handler)
6406 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6407 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6410 ebb->start_offset -= insn_block_len;
6412 /* Update the reloc counter. */
6413 while (ebb->start_reloc_idx > 0
6414 && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
6415 >= ebb->start_offset))
6417 ebb->start_reloc_idx--;
6420 if (ebb->start_ptbl_idx == 0)
6423 new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
6424 if ((new_entry->flags & XTENSA_PROP_INSN) == 0
6425 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6426 || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
6428 if (new_entry->address + new_entry->size != the_entry->address)
6431 the_entry = new_entry;
6432 ebb->start_ptbl_idx--;
6438 static bfd_size_type
6439 insn_block_decodable_len (bfd_byte *contents,
6440 bfd_size_type content_len,
6441 bfd_vma block_offset,
6442 bfd_size_type block_len)
6444 bfd_vma offset = block_offset;
6446 while (offset < block_offset + block_len)
6448 bfd_size_type insn_len = 0;
6450 insn_len = insn_decode_len (contents, content_len, offset);
6452 return (offset - block_offset);
6455 return (offset - block_offset);
6460 ebb_propose_action (ebb_constraint *c,
6461 enum ebb_target_enum align_type,
6462 bfd_vma alignment_pow,
6463 text_action_t action,
6466 bfd_boolean do_action)
6468 proposed_action *act;
6470 if (c->action_allocated <= c->action_count)
6472 unsigned new_allocated, i;
6473 proposed_action *new_actions;
6475 new_allocated = (c->action_count + 2) * 2;
6476 new_actions = (proposed_action *)
6477 bfd_zmalloc (sizeof (proposed_action) * new_allocated);
6479 for (i = 0; i < c->action_count; i++)
6480 new_actions[i] = c->actions[i];
6483 c->actions = new_actions;
6484 c->action_allocated = new_allocated;
6487 act = &c->actions[c->action_count];
6488 act->align_type = align_type;
6489 act->alignment_pow = alignment_pow;
6490 act->action = action;
6491 act->offset = offset;
6492 act->removed_bytes = removed_bytes;
6493 act->do_action = do_action;
6499 /* Access to internal relocations, section contents and symbols. */
6501 /* During relaxation, we need to modify relocations, section contents,
6502 and symbol definitions, and we need to keep the original values from
6503 being reloaded from the input files, i.e., we need to "pin" the
6504 modified values in memory. We also want to continue to observe the
6505 setting of the "keep-memory" flag. The following functions wrap the
6506 standard BFD functions to take care of this for us. */
6508 static Elf_Internal_Rela *
6509 retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6511 Elf_Internal_Rela *internal_relocs;
6513 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6516 internal_relocs = elf_section_data (sec)->relocs;
6517 if (internal_relocs == NULL)
6518 internal_relocs = (_bfd_elf_link_read_relocs
6519 (abfd, sec, NULL, NULL, keep_memory));
6520 return internal_relocs;
6525 pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6527 elf_section_data (sec)->relocs = internal_relocs;
6532 release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6535 && elf_section_data (sec)->relocs != internal_relocs)
6536 free (internal_relocs);
6541 retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6544 bfd_size_type sec_size;
6546 sec_size = bfd_get_section_limit (abfd, sec);
6547 contents = elf_section_data (sec)->this_hdr.contents;
6549 if (contents == NULL && sec_size != 0)
6551 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
6558 elf_section_data (sec)->this_hdr.contents = contents;
6565 pin_contents (asection *sec, bfd_byte *contents)
6567 elf_section_data (sec)->this_hdr.contents = contents;
6572 release_contents (asection *sec, bfd_byte *contents)
6574 if (contents && elf_section_data (sec)->this_hdr.contents != contents)
6579 static Elf_Internal_Sym *
6580 retrieve_local_syms (bfd *input_bfd)
6582 Elf_Internal_Shdr *symtab_hdr;
6583 Elf_Internal_Sym *isymbuf;
6586 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6587 locsymcount = symtab_hdr->sh_info;
6589 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6590 if (isymbuf == NULL && locsymcount != 0)
6591 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
6594 /* Save the symbols for this input file so they won't be read again. */
6595 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
6596 symtab_hdr->contents = (unsigned char *) isymbuf;
6602 /* Code for link-time relaxation. */
6604 /* Initialization for relaxation: */
6605 static bfd_boolean analyze_relocations (struct bfd_link_info *);
6606 static bfd_boolean find_relaxable_sections
6607 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
6608 static bfd_boolean collect_source_relocs
6609 (bfd *, asection *, struct bfd_link_info *);
6610 static bfd_boolean is_resolvable_asm_expansion
6611 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
6613 static Elf_Internal_Rela *find_associated_l32r_irel
6614 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
6615 static bfd_boolean compute_text_actions
6616 (bfd *, asection *, struct bfd_link_info *);
6617 static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
6618 static bfd_boolean compute_ebb_actions (ebb_constraint *);
6619 static bfd_boolean check_section_ebb_pcrels_fit
6620 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, const ebb_constraint *,
6621 const xtensa_opcode *);
6622 static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
6623 static void text_action_add_proposed
6624 (text_action_list *, const ebb_constraint *, asection *);
6625 static int compute_fill_extra_space (property_table_entry *);
6628 static bfd_boolean compute_removed_literals
6629 (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
6630 static Elf_Internal_Rela *get_irel_at_offset
6631 (asection *, Elf_Internal_Rela *, bfd_vma);
6632 static bfd_boolean is_removable_literal
6633 (const source_reloc *, int, const source_reloc *, int, asection *,
6634 property_table_entry *, int);
6635 static bfd_boolean remove_dead_literal
6636 (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
6637 Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
6638 static bfd_boolean identify_literal_placement
6639 (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
6640 value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
6641 source_reloc *, property_table_entry *, int, section_cache_t *,
6643 static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
6644 static bfd_boolean coalesce_shared_literal
6645 (asection *, source_reloc *, property_table_entry *, int, value_map *);
6646 static bfd_boolean move_shared_literal
6647 (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
6648 int, const r_reloc *, const literal_value *, section_cache_t *);
6651 static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
6652 static bfd_boolean translate_section_fixes (asection *);
6653 static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
6654 static asection *translate_reloc (const r_reloc *, r_reloc *, asection *);
6655 static void shrink_dynamic_reloc_sections
6656 (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
6657 static bfd_boolean move_literal
6658 (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
6659 xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
6660 static bfd_boolean relax_property_section
6661 (bfd *, asection *, struct bfd_link_info *);
6664 static bfd_boolean relax_section_symbols (bfd *, asection *);
6668 elf_xtensa_relax_section (bfd *abfd,
6670 struct bfd_link_info *link_info,
6673 static value_map_hash_table *values = NULL;
6674 static bfd_boolean relocations_analyzed = FALSE;
6675 xtensa_relax_info *relax_info;
6677 if (!relocations_analyzed)
6679 /* Do some overall initialization for relaxation. */
6680 values = value_map_hash_table_init ();
6683 relaxing_section = TRUE;
6684 if (!analyze_relocations (link_info))
6686 relocations_analyzed = TRUE;
6690 /* Don't mess with linker-created sections. */
6691 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6694 relax_info = get_xtensa_relax_info (sec);
6695 BFD_ASSERT (relax_info != NULL);
6697 switch (relax_info->visited)
6700 /* Note: It would be nice to fold this pass into
6701 analyze_relocations, but it is important for this step that the
6702 sections be examined in link order. */
6703 if (!compute_removed_literals (abfd, sec, link_info, values))
6710 value_map_hash_table_delete (values);
6712 if (!relax_section (abfd, sec, link_info))
6718 if (!relax_section_symbols (abfd, sec))
6723 relax_info->visited++;
6728 /* Initialization for relaxation. */
6730 /* This function is called once at the start of relaxation. It scans
6731 all the input sections and marks the ones that are relaxable (i.e.,
6732 literal sections with L32R relocations against them), and then
6733 collects source_reloc information for all the relocations against
6734 those relaxable sections. During this process, it also detects
6735 longcalls, i.e., calls relaxed by the assembler into indirect
6736 calls, that can be optimized back into direct calls. Within each
6737 extended basic block (ebb) containing an optimized longcall, it
6738 computes a set of "text actions" that can be performed to remove
6739 the L32R associated with the longcall while optionally preserving
6740 branch target alignments. */
6743 analyze_relocations (struct bfd_link_info *link_info)
6747 bfd_boolean is_relaxable = FALSE;
6749 /* Initialize the per-section relaxation info. */
6750 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6751 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6753 init_xtensa_relax_info (sec);
6756 /* Mark relaxable sections (and count relocations against each one). */
6757 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6758 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6760 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
6764 /* Bail out if there are no relaxable sections. */
6768 /* Allocate space for source_relocs. */
6769 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6770 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6772 xtensa_relax_info *relax_info;
6774 relax_info = get_xtensa_relax_info (sec);
6775 if (relax_info->is_relaxable_literal_section
6776 || relax_info->is_relaxable_asm_section)
6778 relax_info->src_relocs = (source_reloc *)
6779 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
6782 relax_info->src_count = 0;
6785 /* Collect info on relocations against each relaxable section. */
6786 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6787 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6789 if (!collect_source_relocs (abfd, sec, link_info))
6793 /* Compute the text actions. */
6794 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6795 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6797 if (!compute_text_actions (abfd, sec, link_info))
6805 /* Find all the sections that might be relaxed. The motivation for
6806 this pass is that collect_source_relocs() needs to record _all_ the
6807 relocations that target each relaxable section. That is expensive
6808 and unnecessary unless the target section is actually going to be
6809 relaxed. This pass identifies all such sections by checking if
6810 they have L32Rs pointing to them. In the process, the total number
6811 of relocations targeting each section is also counted so that we
6812 know how much space to allocate for source_relocs against each
6813 relaxable literal section. */
6816 find_relaxable_sections (bfd *abfd,
6818 struct bfd_link_info *link_info,
6819 bfd_boolean *is_relaxable_p)
6821 Elf_Internal_Rela *internal_relocs;
6823 bfd_boolean ok = TRUE;
6825 xtensa_relax_info *source_relax_info;
6826 bfd_boolean is_l32r_reloc;
6828 internal_relocs = retrieve_internal_relocs (abfd, sec,
6829 link_info->keep_memory);
6830 if (internal_relocs == NULL)
6833 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6834 if (contents == NULL && sec->size != 0)
6840 source_relax_info = get_xtensa_relax_info (sec);
6841 for (i = 0; i < sec->reloc_count; i++)
6843 Elf_Internal_Rela *irel = &internal_relocs[i];
6845 asection *target_sec;
6846 xtensa_relax_info *target_relax_info;
6848 /* If this section has not already been marked as "relaxable", and
6849 if it contains any ASM_EXPAND relocations (marking expanded
6850 longcalls) that can be optimized into direct calls, then mark
6851 the section as "relaxable". */
6852 if (source_relax_info
6853 && !source_relax_info->is_relaxable_asm_section
6854 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
6856 bfd_boolean is_reachable = FALSE;
6857 if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
6858 link_info, &is_reachable)
6861 source_relax_info->is_relaxable_asm_section = TRUE;
6862 *is_relaxable_p = TRUE;
6866 r_reloc_init (&r_rel, abfd, irel, contents,
6867 bfd_get_section_limit (abfd, sec));
6869 target_sec = r_reloc_get_section (&r_rel);
6870 target_relax_info = get_xtensa_relax_info (target_sec);
6871 if (!target_relax_info)
6874 /* Count PC-relative operand relocations against the target section.
6875 Note: The conditions tested here must match the conditions under
6876 which init_source_reloc is called in collect_source_relocs(). */
6877 is_l32r_reloc = FALSE;
6878 if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6880 xtensa_opcode opcode =
6881 get_relocation_opcode (abfd, sec, contents, irel);
6882 if (opcode != XTENSA_UNDEFINED)
6884 is_l32r_reloc = (opcode == get_l32r_opcode ());
6885 if (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
6887 target_relax_info->src_count++;
6891 if (is_l32r_reloc && r_reloc_is_defined (&r_rel))
6893 /* Mark the target section as relaxable. */
6894 target_relax_info->is_relaxable_literal_section = TRUE;
6895 *is_relaxable_p = TRUE;
6900 release_contents (sec, contents);
6901 release_internal_relocs (sec, internal_relocs);
6906 /* Record _all_ the relocations that point to relaxable sections, and
6907 get rid of ASM_EXPAND relocs by either converting them to
6908 ASM_SIMPLIFY or by removing them. */
6911 collect_source_relocs (bfd *abfd,
6913 struct bfd_link_info *link_info)
6915 Elf_Internal_Rela *internal_relocs;
6917 bfd_boolean ok = TRUE;
6919 bfd_size_type sec_size;
6921 internal_relocs = retrieve_internal_relocs (abfd, sec,
6922 link_info->keep_memory);
6923 if (internal_relocs == NULL)
6926 sec_size = bfd_get_section_limit (abfd, sec);
6927 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6928 if (contents == NULL && sec_size != 0)
6934 /* Record relocations against relaxable literal sections. */
6935 for (i = 0; i < sec->reloc_count; i++)
6937 Elf_Internal_Rela *irel = &internal_relocs[i];
6939 asection *target_sec;
6940 xtensa_relax_info *target_relax_info;
6942 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6944 target_sec = r_reloc_get_section (&r_rel);
6945 target_relax_info = get_xtensa_relax_info (target_sec);
6947 if (target_relax_info
6948 && (target_relax_info->is_relaxable_literal_section
6949 || target_relax_info->is_relaxable_asm_section))
6951 xtensa_opcode opcode = XTENSA_UNDEFINED;
6953 bfd_boolean is_abs_literal = FALSE;
6955 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
6957 /* None of the current alternate relocs are PC-relative,
6958 and only PC-relative relocs matter here. However, we
6959 still need to record the opcode for literal
6961 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6962 if (opcode == get_l32r_opcode ())
6964 is_abs_literal = TRUE;
6968 opcode = XTENSA_UNDEFINED;
6970 else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6972 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6973 opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
6976 if (opcode != XTENSA_UNDEFINED)
6978 int src_next = target_relax_info->src_next++;
6979 source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
6981 init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
6987 /* Now get rid of ASM_EXPAND relocations. At this point, the
6988 src_relocs array for the target literal section may still be
6989 incomplete, but it must at least contain the entries for the L32R
6990 relocations associated with ASM_EXPANDs because they were just
6991 added in the preceding loop over the relocations. */
6993 for (i = 0; i < sec->reloc_count; i++)
6995 Elf_Internal_Rela *irel = &internal_relocs[i];
6996 bfd_boolean is_reachable;
6998 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
7004 Elf_Internal_Rela *l32r_irel;
7006 asection *target_sec;
7007 xtensa_relax_info *target_relax_info;
7009 /* Mark the source_reloc for the L32R so that it will be
7010 removed in compute_removed_literals(), along with the
7011 associated literal. */
7012 l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
7013 irel, internal_relocs);
7014 if (l32r_irel == NULL)
7017 r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
7019 target_sec = r_reloc_get_section (&r_rel);
7020 target_relax_info = get_xtensa_relax_info (target_sec);
7022 if (target_relax_info
7023 && (target_relax_info->is_relaxable_literal_section
7024 || target_relax_info->is_relaxable_asm_section))
7026 source_reloc *s_reloc;
7028 /* Search the source_relocs for the entry corresponding to
7029 the l32r_irel. Note: The src_relocs array is not yet
7030 sorted, but it wouldn't matter anyway because we're
7031 searching by source offset instead of target offset. */
7032 s_reloc = find_source_reloc (target_relax_info->src_relocs,
7033 target_relax_info->src_next,
7035 BFD_ASSERT (s_reloc);
7036 s_reloc->is_null = TRUE;
7039 /* Convert this reloc to ASM_SIMPLIFY. */
7040 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7041 R_XTENSA_ASM_SIMPLIFY);
7042 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7044 pin_internal_relocs (sec, internal_relocs);
7048 /* It is resolvable but doesn't reach. We resolve now
7049 by eliminating the relocation -- the call will remain
7050 expanded into L32R/CALLX. */
7051 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7052 pin_internal_relocs (sec, internal_relocs);
7057 release_contents (sec, contents);
7058 release_internal_relocs (sec, internal_relocs);
7063 /* Return TRUE if the asm expansion can be resolved. Generally it can
7064 be resolved on a final link or when a partial link locates it in the
7065 same section as the target. Set "is_reachable" flag if the target of
7066 the call is within the range of a direct call, given the current VMA
7067 for this section and the target section. */
7070 is_resolvable_asm_expansion (bfd *abfd,
7073 Elf_Internal_Rela *irel,
7074 struct bfd_link_info *link_info,
7075 bfd_boolean *is_reachable_p)
7077 asection *target_sec;
7078 bfd_vma target_offset;
7080 xtensa_opcode opcode, direct_call_opcode;
7081 bfd_vma self_address;
7082 bfd_vma dest_address;
7083 bfd_boolean uses_l32r;
7084 bfd_size_type sec_size;
7086 *is_reachable_p = FALSE;
7088 if (contents == NULL)
7091 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
7094 sec_size = bfd_get_section_limit (abfd, sec);
7095 opcode = get_expanded_call_opcode (contents + irel->r_offset,
7096 sec_size - irel->r_offset, &uses_l32r);
7097 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7101 direct_call_opcode = swap_callx_for_call_opcode (opcode);
7102 if (direct_call_opcode == XTENSA_UNDEFINED)
7105 /* Check and see that the target resolves. */
7106 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7107 if (!r_reloc_is_defined (&r_rel))
7110 target_sec = r_reloc_get_section (&r_rel);
7111 target_offset = r_rel.target_offset;
7113 /* If the target is in a shared library, then it doesn't reach. This
7114 isn't supposed to come up because the compiler should never generate
7115 non-PIC calls on systems that use shared libraries, but the linker
7116 shouldn't crash regardless. */
7117 if (!target_sec->output_section)
7120 /* For relocatable sections, we can only simplify when the output
7121 section of the target is the same as the output section of the
7123 if (link_info->relocatable
7124 && (target_sec->output_section != sec->output_section
7125 || is_reloc_sym_weak (abfd, irel)))
7128 self_address = (sec->output_section->vma
7129 + sec->output_offset + irel->r_offset + 3);
7130 dest_address = (target_sec->output_section->vma
7131 + target_sec->output_offset + target_offset);
7133 *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
7134 self_address, dest_address);
7136 if ((self_address >> CALL_SEGMENT_BITS) !=
7137 (dest_address >> CALL_SEGMENT_BITS))
7144 static Elf_Internal_Rela *
7145 find_associated_l32r_irel (bfd *abfd,
7148 Elf_Internal_Rela *other_irel,
7149 Elf_Internal_Rela *internal_relocs)
7153 for (i = 0; i < sec->reloc_count; i++)
7155 Elf_Internal_Rela *irel = &internal_relocs[i];
7157 if (irel == other_irel)
7159 if (irel->r_offset != other_irel->r_offset)
7161 if (is_l32r_relocation (abfd, sec, contents, irel))
7169 static xtensa_opcode *
7170 build_reloc_opcodes (bfd *abfd,
7173 Elf_Internal_Rela *internal_relocs)
7176 xtensa_opcode *reloc_opcodes =
7177 (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
7178 for (i = 0; i < sec->reloc_count; i++)
7180 Elf_Internal_Rela *irel = &internal_relocs[i];
7181 reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
7183 return reloc_opcodes;
7187 /* The compute_text_actions function will build a list of potential
7188 transformation actions for code in the extended basic block of each
7189 longcall that is optimized to a direct call. From this list we
7190 generate a set of actions to actually perform that optimizes for
7191 space and, if not using size_opt, maintains branch target
7194 These actions to be performed are placed on a per-section list.
7195 The actual changes are performed by relax_section() in the second
7199 compute_text_actions (bfd *abfd,
7201 struct bfd_link_info *link_info)
7203 xtensa_opcode *reloc_opcodes = NULL;
7204 xtensa_relax_info *relax_info;
7206 Elf_Internal_Rela *internal_relocs;
7207 bfd_boolean ok = TRUE;
7209 property_table_entry *prop_table = 0;
7211 bfd_size_type sec_size;
7213 relax_info = get_xtensa_relax_info (sec);
7214 BFD_ASSERT (relax_info);
7215 BFD_ASSERT (relax_info->src_next == relax_info->src_count);
7217 /* Do nothing if the section contains no optimized longcalls. */
7218 if (!relax_info->is_relaxable_asm_section)
7221 internal_relocs = retrieve_internal_relocs (abfd, sec,
7222 link_info->keep_memory);
7224 if (internal_relocs)
7225 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7226 internal_reloc_compare);
7228 sec_size = bfd_get_section_limit (abfd, sec);
7229 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7230 if (contents == NULL && sec_size != 0)
7236 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7237 XTENSA_PROP_SEC_NAME, FALSE);
7244 for (i = 0; i < sec->reloc_count; i++)
7246 Elf_Internal_Rela *irel = &internal_relocs[i];
7248 property_table_entry *the_entry;
7251 ebb_constraint ebb_table;
7252 bfd_size_type simplify_size;
7254 if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
7256 r_offset = irel->r_offset;
7258 simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
7259 if (simplify_size == 0)
7261 (*_bfd_error_handler)
7262 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
7263 sec->owner, sec, r_offset);
7267 /* If the instruction table is not around, then don't do this
7269 the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7270 sec->vma + irel->r_offset);
7271 if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
7273 text_action_add (&relax_info->action_list,
7274 ta_convert_longcall, sec, r_offset,
7279 /* If the next longcall happens to be at the same address as an
7280 unreachable section of size 0, then skip forward. */
7281 ptbl_idx = the_entry - prop_table;
7282 while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
7283 && the_entry->size == 0
7284 && ptbl_idx + 1 < ptblsize
7285 && (prop_table[ptbl_idx + 1].address
7286 == prop_table[ptbl_idx].address))
7292 if (the_entry->flags & XTENSA_PROP_NO_TRANSFORM)
7293 /* NO_REORDER is OK */
7296 init_ebb_constraint (&ebb_table);
7297 ebb = &ebb_table.ebb;
7298 init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
7299 internal_relocs, sec->reloc_count);
7300 ebb->start_offset = r_offset + simplify_size;
7301 ebb->end_offset = r_offset + simplify_size;
7302 ebb->start_ptbl_idx = ptbl_idx;
7303 ebb->end_ptbl_idx = ptbl_idx;
7304 ebb->start_reloc_idx = i;
7305 ebb->end_reloc_idx = i;
7307 /* Precompute the opcode for each relocation. */
7308 if (reloc_opcodes == NULL)
7309 reloc_opcodes = build_reloc_opcodes (abfd, sec, contents,
7312 if (!extend_ebb_bounds (ebb)
7313 || !compute_ebb_proposed_actions (&ebb_table)
7314 || !compute_ebb_actions (&ebb_table)
7315 || !check_section_ebb_pcrels_fit (abfd, sec, contents,
7316 internal_relocs, &ebb_table,
7318 || !check_section_ebb_reduces (&ebb_table))
7320 /* If anything goes wrong or we get unlucky and something does
7321 not fit, with our plan because of expansion between
7322 critical branches, just convert to a NOP. */
7324 text_action_add (&relax_info->action_list,
7325 ta_convert_longcall, sec, r_offset, 0);
7326 i = ebb_table.ebb.end_reloc_idx;
7327 free_ebb_constraint (&ebb_table);
7331 text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
7333 /* Update the index so we do not go looking at the relocations
7334 we have already processed. */
7335 i = ebb_table.ebb.end_reloc_idx;
7336 free_ebb_constraint (&ebb_table);
7340 if (relax_info->action_list.head)
7341 print_action_list (stderr, &relax_info->action_list);
7345 release_contents (sec, contents);
7346 release_internal_relocs (sec, internal_relocs);
7350 free (reloc_opcodes);
7356 /* Do not widen an instruction if it is preceeded by a
7357 loop opcode. It might cause misalignment. */
7360 prev_instr_is_a_loop (bfd_byte *contents,
7361 bfd_size_type content_length,
7362 bfd_size_type offset)
7364 xtensa_opcode prev_opcode;
7368 prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
7369 return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
7373 /* Find all of the possible actions for an extended basic block. */
7376 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
7378 const ebb_t *ebb = &ebb_table->ebb;
7379 unsigned rel_idx = ebb->start_reloc_idx;
7380 property_table_entry *entry, *start_entry, *end_entry;
7382 xtensa_isa isa = xtensa_default_isa;
7384 static xtensa_insnbuf insnbuf = NULL;
7385 static xtensa_insnbuf slotbuf = NULL;
7387 if (insnbuf == NULL)
7389 insnbuf = xtensa_insnbuf_alloc (isa);
7390 slotbuf = xtensa_insnbuf_alloc (isa);
7393 start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
7394 end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
7396 for (entry = start_entry; entry <= end_entry; entry++)
7398 bfd_vma start_offset, end_offset;
7399 bfd_size_type insn_len;
7401 start_offset = entry->address - ebb->sec->vma;
7402 end_offset = entry->address + entry->size - ebb->sec->vma;
7404 if (entry == start_entry)
7405 start_offset = ebb->start_offset;
7406 if (entry == end_entry)
7407 end_offset = ebb->end_offset;
7408 offset = start_offset;
7410 if (offset == entry->address - ebb->sec->vma
7411 && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
7413 enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
7414 BFD_ASSERT (offset != end_offset);
7415 if (offset == end_offset)
7418 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
7423 if (check_branch_target_aligned_address (offset, insn_len))
7424 align_type = EBB_REQUIRE_TGT_ALIGN;
7426 ebb_propose_action (ebb_table, align_type, 0,
7427 ta_none, offset, 0, TRUE);
7430 while (offset != end_offset)
7432 Elf_Internal_Rela *irel;
7433 xtensa_opcode opcode;
7435 while (rel_idx < ebb->end_reloc_idx
7436 && (ebb->relocs[rel_idx].r_offset < offset
7437 || (ebb->relocs[rel_idx].r_offset == offset
7438 && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
7439 != R_XTENSA_ASM_SIMPLIFY))))
7442 /* Check for longcall. */
7443 irel = &ebb->relocs[rel_idx];
7444 if (irel->r_offset == offset
7445 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
7447 bfd_size_type simplify_size;
7449 simplify_size = get_asm_simplify_size (ebb->contents,
7450 ebb->content_length,
7452 if (simplify_size == 0)
7455 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7456 ta_convert_longcall, offset, 0, TRUE);
7458 offset += simplify_size;
7462 if (offset + MIN_INSN_LENGTH > ebb->content_length)
7464 xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
7465 ebb->content_length - offset);
7466 fmt = xtensa_format_decode (isa, insnbuf);
7467 if (fmt == XTENSA_UNDEFINED)
7469 insn_len = xtensa_format_length (isa, fmt);
7470 if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
7473 if (xtensa_format_num_slots (isa, fmt) != 1)
7479 xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7480 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7481 if (opcode == XTENSA_UNDEFINED)
7484 if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
7485 && (entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7486 && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
7488 /* Add an instruction narrow action. */
7489 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7490 ta_narrow_insn, offset, 0, FALSE);
7492 else if ((entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7493 && can_widen_instruction (slotbuf, fmt, opcode) != 0
7494 && ! prev_instr_is_a_loop (ebb->contents,
7495 ebb->content_length, offset))
7497 /* Add an instruction widen action. */
7498 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7499 ta_widen_insn, offset, 0, FALSE);
7501 else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
7503 /* Check for branch targets. */
7504 ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
7505 ta_none, offset, 0, TRUE);
7512 if (ebb->ends_unreachable)
7514 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7515 ta_fill, ebb->end_offset, 0, TRUE);
7521 (*_bfd_error_handler)
7522 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
7523 ebb->sec->owner, ebb->sec, offset);
7528 /* After all of the information has collected about the
7529 transformations possible in an EBB, compute the appropriate actions
7530 here in compute_ebb_actions. We still must check later to make
7531 sure that the actions do not break any relocations. The algorithm
7532 used here is pretty greedy. Basically, it removes as many no-ops
7533 as possible so that the end of the EBB has the same alignment
7534 characteristics as the original. First, it uses narrowing, then
7535 fill space at the end of the EBB, and finally widenings. If that
7536 does not work, it tries again with one fewer no-op removed. The
7537 optimization will only be performed if all of the branch targets
7538 that were aligned before transformation are also aligned after the
7541 When the size_opt flag is set, ignore the branch target alignments,
7542 narrow all wide instructions, and remove all no-ops unless the end
7543 of the EBB prevents it. */
7546 compute_ebb_actions (ebb_constraint *ebb_table)
7550 int removed_bytes = 0;
7551 ebb_t *ebb = &ebb_table->ebb;
7552 unsigned seg_idx_start = 0;
7553 unsigned seg_idx_end = 0;
7555 /* We perform this like the assembler relaxation algorithm: Start by
7556 assuming all instructions are narrow and all no-ops removed; then
7559 /* For each segment of this that has a solid constraint, check to
7560 see if there are any combinations that will keep the constraint.
7562 for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
7564 bfd_boolean requires_text_end_align = FALSE;
7565 unsigned longcall_count = 0;
7566 unsigned longcall_convert_count = 0;
7567 unsigned narrowable_count = 0;
7568 unsigned narrowable_convert_count = 0;
7569 unsigned widenable_count = 0;
7570 unsigned widenable_convert_count = 0;
7572 proposed_action *action = NULL;
7573 int align = (1 << ebb_table->ebb.sec->alignment_power);
7575 seg_idx_start = seg_idx_end;
7577 for (i = seg_idx_start; i < ebb_table->action_count; i++)
7579 action = &ebb_table->actions[i];
7580 if (action->action == ta_convert_longcall)
7582 if (action->action == ta_narrow_insn)
7584 if (action->action == ta_widen_insn)
7586 if (action->action == ta_fill)
7588 if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
7590 if (action->align_type == EBB_REQUIRE_TGT_ALIGN
7591 && !elf32xtensa_size_opt)
7596 if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
7597 requires_text_end_align = TRUE;
7599 if (elf32xtensa_size_opt && !requires_text_end_align
7600 && action->align_type != EBB_REQUIRE_LOOP_ALIGN
7601 && action->align_type != EBB_REQUIRE_TGT_ALIGN)
7603 longcall_convert_count = longcall_count;
7604 narrowable_convert_count = narrowable_count;
7605 widenable_convert_count = 0;
7609 /* There is a constraint. Convert the max number of longcalls. */
7610 narrowable_convert_count = 0;
7611 longcall_convert_count = 0;
7612 widenable_convert_count = 0;
7614 for (j = 0; j < longcall_count; j++)
7616 int removed = (longcall_count - j) * 3 & (align - 1);
7617 unsigned desire_narrow = (align - removed) & (align - 1);
7618 unsigned desire_widen = removed;
7619 if (desire_narrow <= narrowable_count)
7621 narrowable_convert_count = desire_narrow;
7622 narrowable_convert_count +=
7623 (align * ((narrowable_count - narrowable_convert_count)
7625 longcall_convert_count = (longcall_count - j);
7626 widenable_convert_count = 0;
7629 if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
7631 narrowable_convert_count = 0;
7632 longcall_convert_count = longcall_count - j;
7633 widenable_convert_count = desire_widen;
7639 /* Now the number of conversions are saved. Do them. */
7640 for (i = seg_idx_start; i < seg_idx_end; i++)
7642 action = &ebb_table->actions[i];
7643 switch (action->action)
7645 case ta_convert_longcall:
7646 if (longcall_convert_count != 0)
7648 action->action = ta_remove_longcall;
7649 action->do_action = TRUE;
7650 action->removed_bytes += 3;
7651 longcall_convert_count--;
7654 case ta_narrow_insn:
7655 if (narrowable_convert_count != 0)
7657 action->do_action = TRUE;
7658 action->removed_bytes += 1;
7659 narrowable_convert_count--;
7663 if (widenable_convert_count != 0)
7665 action->do_action = TRUE;
7666 action->removed_bytes -= 1;
7667 widenable_convert_count--;
7676 /* Now we move on to some local opts. Try to remove each of the
7677 remaining longcalls. */
7679 if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
7682 for (i = 0; i < ebb_table->action_count; i++)
7684 int old_removed_bytes = removed_bytes;
7685 proposed_action *action = &ebb_table->actions[i];
7687 if (action->do_action && action->action == ta_convert_longcall)
7689 bfd_boolean bad_alignment = FALSE;
7691 for (j = i + 1; j < ebb_table->action_count; j++)
7693 proposed_action *new_action = &ebb_table->actions[j];
7694 bfd_vma offset = new_action->offset;
7695 if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
7697 if (!check_branch_target_aligned
7698 (ebb_table->ebb.contents,
7699 ebb_table->ebb.content_length,
7700 offset, offset - removed_bytes))
7702 bad_alignment = TRUE;
7706 if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
7708 if (!check_loop_aligned (ebb_table->ebb.contents,
7709 ebb_table->ebb.content_length,
7711 offset - removed_bytes))
7713 bad_alignment = TRUE;
7717 if (new_action->action == ta_narrow_insn
7718 && !new_action->do_action
7719 && ebb_table->ebb.sec->alignment_power == 2)
7721 /* Narrow an instruction and we are done. */
7722 new_action->do_action = TRUE;
7723 new_action->removed_bytes += 1;
7724 bad_alignment = FALSE;
7727 if (new_action->action == ta_widen_insn
7728 && new_action->do_action
7729 && ebb_table->ebb.sec->alignment_power == 2)
7731 /* Narrow an instruction and we are done. */
7732 new_action->do_action = FALSE;
7733 new_action->removed_bytes += 1;
7734 bad_alignment = FALSE;
7737 if (new_action->do_action)
7738 removed_bytes += new_action->removed_bytes;
7742 action->removed_bytes += 3;
7743 action->action = ta_remove_longcall;
7744 action->do_action = TRUE;
7747 removed_bytes = old_removed_bytes;
7748 if (action->do_action)
7749 removed_bytes += action->removed_bytes;
7754 for (i = 0; i < ebb_table->action_count; ++i)
7756 proposed_action *action = &ebb_table->actions[i];
7757 if (action->do_action)
7758 removed_bytes += action->removed_bytes;
7761 if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
7762 && ebb->ends_unreachable)
7764 proposed_action *action;
7768 BFD_ASSERT (ebb_table->action_count != 0);
7769 action = &ebb_table->actions[ebb_table->action_count - 1];
7770 BFD_ASSERT (action->action == ta_fill);
7771 BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
7773 extra_space = compute_fill_extra_space (ebb->ends_unreachable);
7774 br = action->removed_bytes + removed_bytes + extra_space;
7775 br = br & ((1 << ebb->sec->alignment_power ) - 1);
7777 action->removed_bytes = extra_space - br;
7783 /* The xlate_map is a sorted array of address mappings designed to
7784 answer the offset_with_removed_text() query with a binary search instead
7785 of a linear search through the section's action_list. */
7787 typedef struct xlate_map_entry xlate_map_entry_t;
7788 typedef struct xlate_map xlate_map_t;
7790 struct xlate_map_entry
7792 unsigned orig_address;
7793 unsigned new_address;
7799 unsigned entry_count;
7800 xlate_map_entry_t *entry;
7805 xlate_compare (const void *a_v, const void *b_v)
7807 const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
7808 const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
7809 if (a->orig_address < b->orig_address)
7811 if (a->orig_address > (b->orig_address + b->size - 1))
7818 xlate_offset_with_removed_text (const xlate_map_t *map,
7819 text_action_list *action_list,
7823 xlate_map_entry_t *e;
7826 return offset_with_removed_text (action_list, offset);
7828 if (map->entry_count == 0)
7831 r = bsearch (&offset, map->entry, map->entry_count,
7832 sizeof (xlate_map_entry_t), &xlate_compare);
7833 e = (xlate_map_entry_t *) r;
7835 BFD_ASSERT (e != NULL);
7838 return e->new_address - e->orig_address + offset;
7842 /* Build a binary searchable offset translation map from a section's
7845 static xlate_map_t *
7846 build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
7848 xlate_map_t *map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
7849 text_action_list *action_list = &relax_info->action_list;
7850 unsigned num_actions = 0;
7853 xlate_map_entry_t *current_entry;
7858 num_actions = action_list_count (action_list);
7859 map->entry = (xlate_map_entry_t *)
7860 bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
7861 if (map->entry == NULL)
7866 map->entry_count = 0;
7869 current_entry = &map->entry[0];
7871 current_entry->orig_address = 0;
7872 current_entry->new_address = 0;
7873 current_entry->size = 0;
7875 for (r = action_list->head; r != NULL; r = r->next)
7877 unsigned orig_size = 0;
7881 case ta_remove_insn:
7882 case ta_convert_longcall:
7883 case ta_remove_literal:
7884 case ta_add_literal:
7886 case ta_remove_longcall:
7889 case ta_narrow_insn:
7898 current_entry->size =
7899 r->offset + orig_size - current_entry->orig_address;
7900 if (current_entry->size != 0)
7905 current_entry->orig_address = r->offset + orig_size;
7906 removed += r->removed_bytes;
7907 current_entry->new_address = r->offset + orig_size - removed;
7908 current_entry->size = 0;
7911 current_entry->size = (bfd_get_section_limit (sec->owner, sec)
7912 - current_entry->orig_address);
7913 if (current_entry->size != 0)
7920 /* Free an offset translation map. */
7923 free_xlate_map (xlate_map_t *map)
7925 if (map && map->entry)
7932 /* Use check_section_ebb_pcrels_fit to make sure that all of the
7933 relocations in a section will fit if a proposed set of actions
7937 check_section_ebb_pcrels_fit (bfd *abfd,
7940 Elf_Internal_Rela *internal_relocs,
7941 const ebb_constraint *constraint,
7942 const xtensa_opcode *reloc_opcodes)
7945 Elf_Internal_Rela *irel;
7946 xlate_map_t *xmap = NULL;
7947 bfd_boolean ok = TRUE;
7948 xtensa_relax_info *relax_info;
7950 relax_info = get_xtensa_relax_info (sec);
7952 if (relax_info && sec->reloc_count > 100)
7954 xmap = build_xlate_map (sec, relax_info);
7955 /* NULL indicates out of memory, but the slow version
7956 can still be used. */
7959 for (i = 0; i < sec->reloc_count; i++)
7962 bfd_vma orig_self_offset, orig_target_offset;
7963 bfd_vma self_offset, target_offset;
7965 reloc_howto_type *howto;
7966 int self_removed_bytes, target_removed_bytes;
7968 irel = &internal_relocs[i];
7969 r_type = ELF32_R_TYPE (irel->r_info);
7971 howto = &elf_howto_table[r_type];
7972 /* We maintain the required invariant: PC-relative relocations
7973 that fit before linking must fit after linking. Thus we only
7974 need to deal with relocations to the same section that are
7976 if (r_type == R_XTENSA_ASM_SIMPLIFY
7977 || r_type == R_XTENSA_32_PCREL
7978 || !howto->pc_relative)
7981 r_reloc_init (&r_rel, abfd, irel, contents,
7982 bfd_get_section_limit (abfd, sec));
7984 if (r_reloc_get_section (&r_rel) != sec)
7987 orig_self_offset = irel->r_offset;
7988 orig_target_offset = r_rel.target_offset;
7990 self_offset = orig_self_offset;
7991 target_offset = orig_target_offset;
7996 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
7999 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8000 orig_target_offset);
8003 self_removed_bytes = 0;
8004 target_removed_bytes = 0;
8006 for (j = 0; j < constraint->action_count; ++j)
8008 proposed_action *action = &constraint->actions[j];
8009 bfd_vma offset = action->offset;
8010 int removed_bytes = action->removed_bytes;
8011 if (offset < orig_self_offset
8012 || (offset == orig_self_offset && action->action == ta_fill
8013 && action->removed_bytes < 0))
8014 self_removed_bytes += removed_bytes;
8015 if (offset < orig_target_offset
8016 || (offset == orig_target_offset && action->action == ta_fill
8017 && action->removed_bytes < 0))
8018 target_removed_bytes += removed_bytes;
8020 self_offset -= self_removed_bytes;
8021 target_offset -= target_removed_bytes;
8023 /* Try to encode it. Get the operand and check. */
8024 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
8026 /* None of the current alternate relocs are PC-relative,
8027 and only PC-relative relocs matter here. */
8031 xtensa_opcode opcode;
8035 opcode = reloc_opcodes[i];
8037 opcode = get_relocation_opcode (abfd, sec, contents, irel);
8038 if (opcode == XTENSA_UNDEFINED)
8044 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
8045 if (opnum == XTENSA_UNDEFINED)
8051 if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
8060 free_xlate_map (xmap);
8067 check_section_ebb_reduces (const ebb_constraint *constraint)
8072 for (i = 0; i < constraint->action_count; i++)
8074 const proposed_action *action = &constraint->actions[i];
8075 if (action->do_action)
8076 removed += action->removed_bytes;
8086 text_action_add_proposed (text_action_list *l,
8087 const ebb_constraint *ebb_table,
8092 for (i = 0; i < ebb_table->action_count; i++)
8094 proposed_action *action = &ebb_table->actions[i];
8096 if (!action->do_action)
8098 switch (action->action)
8100 case ta_remove_insn:
8101 case ta_remove_longcall:
8102 case ta_convert_longcall:
8103 case ta_narrow_insn:
8106 case ta_remove_literal:
8107 text_action_add (l, action->action, sec, action->offset,
8108 action->removed_bytes);
8121 compute_fill_extra_space (property_table_entry *entry)
8123 int fill_extra_space;
8128 if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
8131 fill_extra_space = entry->size;
8132 if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
8134 /* Fill bytes for alignment:
8135 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8136 int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
8137 int nsm = (1 << pow) - 1;
8138 bfd_vma addr = entry->address + entry->size;
8139 bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
8140 fill_extra_space += align_fill;
8142 return fill_extra_space;
8146 /* First relaxation pass. */
8148 /* If the section contains relaxable literals, check each literal to
8149 see if it has the same value as another literal that has already
8150 been seen, either in the current section or a previous one. If so,
8151 add an entry to the per-section list of removed literals. The
8152 actual changes are deferred until the next pass. */
8155 compute_removed_literals (bfd *abfd,
8157 struct bfd_link_info *link_info,
8158 value_map_hash_table *values)
8160 xtensa_relax_info *relax_info;
8162 Elf_Internal_Rela *internal_relocs;
8163 source_reloc *src_relocs, *rel;
8164 bfd_boolean ok = TRUE;
8165 property_table_entry *prop_table = NULL;
8168 bfd_boolean last_loc_is_prev = FALSE;
8169 bfd_vma last_target_offset = 0;
8170 section_cache_t target_sec_cache;
8171 bfd_size_type sec_size;
8173 init_section_cache (&target_sec_cache);
8175 /* Do nothing if it is not a relaxable literal section. */
8176 relax_info = get_xtensa_relax_info (sec);
8177 BFD_ASSERT (relax_info);
8178 if (!relax_info->is_relaxable_literal_section)
8181 internal_relocs = retrieve_internal_relocs (abfd, sec,
8182 link_info->keep_memory);
8184 sec_size = bfd_get_section_limit (abfd, sec);
8185 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8186 if (contents == NULL && sec_size != 0)
8192 /* Sort the source_relocs by target offset. */
8193 src_relocs = relax_info->src_relocs;
8194 qsort (src_relocs, relax_info->src_count,
8195 sizeof (source_reloc), source_reloc_compare);
8196 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8197 internal_reloc_compare);
8199 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
8200 XTENSA_PROP_SEC_NAME, FALSE);
8208 for (i = 0; i < relax_info->src_count; i++)
8210 Elf_Internal_Rela *irel = NULL;
8212 rel = &src_relocs[i];
8213 if (get_l32r_opcode () != rel->opcode)
8215 irel = get_irel_at_offset (sec, internal_relocs,
8216 rel->r_rel.target_offset);
8218 /* If the relocation on this is not a simple R_XTENSA_32 or
8219 R_XTENSA_PLT then do not consider it. This may happen when
8220 the difference of two symbols is used in a literal. */
8221 if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
8222 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
8225 /* If the target_offset for this relocation is the same as the
8226 previous relocation, then we've already considered whether the
8227 literal can be coalesced. Skip to the next one.... */
8228 if (i != 0 && prev_i != -1
8229 && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
8233 if (last_loc_is_prev &&
8234 last_target_offset + 4 != rel->r_rel.target_offset)
8235 last_loc_is_prev = FALSE;
8237 /* Check if the relocation was from an L32R that is being removed
8238 because a CALLX was converted to a direct CALL, and check if
8239 there are no other relocations to the literal. */
8240 if (is_removable_literal (rel, i, src_relocs, relax_info->src_count,
8241 sec, prop_table, ptblsize))
8243 if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
8244 irel, rel, prop_table, ptblsize))
8249 last_target_offset = rel->r_rel.target_offset;
8253 if (!identify_literal_placement (abfd, sec, contents, link_info,
8255 &last_loc_is_prev, irel,
8256 relax_info->src_count - i, rel,
8257 prop_table, ptblsize,
8258 &target_sec_cache, rel->is_abs_literal))
8263 last_target_offset = rel->r_rel.target_offset;
8267 print_removed_literals (stderr, &relax_info->removed_list);
8268 print_action_list (stderr, &relax_info->action_list);
8272 if (prop_table) free (prop_table);
8273 clear_section_cache (&target_sec_cache);
8275 release_contents (sec, contents);
8276 release_internal_relocs (sec, internal_relocs);
8281 static Elf_Internal_Rela *
8282 get_irel_at_offset (asection *sec,
8283 Elf_Internal_Rela *internal_relocs,
8287 Elf_Internal_Rela *irel;
8289 Elf_Internal_Rela key;
8291 if (!internal_relocs)
8294 key.r_offset = offset;
8295 irel = bsearch (&key, internal_relocs, sec->reloc_count,
8296 sizeof (Elf_Internal_Rela), internal_reloc_matches);
8300 /* bsearch does not guarantee which will be returned if there are
8301 multiple matches. We need the first that is not an alignment. */
8302 i = irel - internal_relocs;
8305 if (internal_relocs[i-1].r_offset != offset)
8309 for ( ; i < sec->reloc_count; i++)
8311 irel = &internal_relocs[i];
8312 r_type = ELF32_R_TYPE (irel->r_info);
8313 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
8322 is_removable_literal (const source_reloc *rel,
8324 const source_reloc *src_relocs,
8327 property_table_entry *prop_table,
8330 const source_reloc *curr_rel;
8331 property_table_entry *entry;
8336 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8337 sec->vma + rel->r_rel.target_offset);
8338 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8341 for (++i; i < src_count; ++i)
8343 curr_rel = &src_relocs[i];
8344 /* If all others have the same target offset.... */
8345 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
8348 if (!curr_rel->is_null
8349 && !xtensa_is_property_section (curr_rel->source_sec)
8350 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
8358 remove_dead_literal (bfd *abfd,
8360 struct bfd_link_info *link_info,
8361 Elf_Internal_Rela *internal_relocs,
8362 Elf_Internal_Rela *irel,
8364 property_table_entry *prop_table,
8367 property_table_entry *entry;
8368 xtensa_relax_info *relax_info;
8370 relax_info = get_xtensa_relax_info (sec);
8374 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8375 sec->vma + rel->r_rel.target_offset);
8377 /* Mark the unused literal so that it will be removed. */
8378 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
8380 text_action_add (&relax_info->action_list,
8381 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8383 /* If the section is 4-byte aligned, do not add fill. */
8384 if (sec->alignment_power > 2)
8386 int fill_extra_space;
8387 bfd_vma entry_sec_offset;
8389 property_table_entry *the_add_entry;
8393 entry_sec_offset = entry->address - sec->vma + entry->size;
8395 entry_sec_offset = rel->r_rel.target_offset + 4;
8397 /* If the literal range is at the end of the section,
8399 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8401 fill_extra_space = compute_fill_extra_space (the_add_entry);
8403 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8404 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8405 -4, fill_extra_space);
8407 adjust_fill_action (fa, removed_diff);
8409 text_action_add (&relax_info->action_list,
8410 ta_fill, sec, entry_sec_offset, removed_diff);
8413 /* Zero out the relocation on this literal location. */
8416 if (elf_hash_table (link_info)->dynamic_sections_created)
8417 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8419 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8420 pin_internal_relocs (sec, internal_relocs);
8423 /* Do not modify "last_loc_is_prev". */
8429 identify_literal_placement (bfd *abfd,
8432 struct bfd_link_info *link_info,
8433 value_map_hash_table *values,
8434 bfd_boolean *last_loc_is_prev_p,
8435 Elf_Internal_Rela *irel,
8436 int remaining_src_rels,
8438 property_table_entry *prop_table,
8440 section_cache_t *target_sec_cache,
8441 bfd_boolean is_abs_literal)
8445 xtensa_relax_info *relax_info;
8446 bfd_boolean literal_placed = FALSE;
8448 unsigned long value;
8449 bfd_boolean final_static_link;
8450 bfd_size_type sec_size;
8452 relax_info = get_xtensa_relax_info (sec);
8456 sec_size = bfd_get_section_limit (abfd, sec);
8459 (!link_info->relocatable
8460 && !elf_hash_table (link_info)->dynamic_sections_created);
8462 /* The placement algorithm first checks to see if the literal is
8463 already in the value map. If so and the value map is reachable
8464 from all uses, then the literal is moved to that location. If
8465 not, then we identify the last location where a fresh literal was
8466 placed. If the literal can be safely moved there, then we do so.
8467 If not, then we assume that the literal is not to move and leave
8468 the literal where it is, marking it as the last literal
8471 /* Find the literal value. */
8473 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8476 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
8477 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
8479 init_literal_value (&val, &r_rel, value, is_abs_literal);
8481 /* Check if we've seen another literal with the same value that
8482 is in the same output section. */
8483 val_map = value_map_get_cached_value (values, &val, final_static_link);
8486 && (r_reloc_get_section (&val_map->loc)->output_section
8487 == sec->output_section)
8488 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
8489 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
8491 /* No change to last_loc_is_prev. */
8492 literal_placed = TRUE;
8495 /* For relocatable links, do not try to move literals. To do it
8496 correctly might increase the number of relocations in an input
8497 section making the default relocatable linking fail. */
8498 if (!link_info->relocatable && !literal_placed
8499 && values->has_last_loc && !(*last_loc_is_prev_p))
8501 asection *target_sec = r_reloc_get_section (&values->last_loc);
8502 if (target_sec && target_sec->output_section == sec->output_section)
8504 /* Increment the virtual offset. */
8505 r_reloc try_loc = values->last_loc;
8506 try_loc.virtual_offset += 4;
8508 /* There is a last loc that was in the same output section. */
8509 if (relocations_reach (rel, remaining_src_rels, &try_loc)
8510 && move_shared_literal (sec, link_info, rel,
8511 prop_table, ptblsize,
8512 &try_loc, &val, target_sec_cache))
8514 values->last_loc.virtual_offset += 4;
8515 literal_placed = TRUE;
8517 val_map = add_value_map (values, &val, &try_loc,
8520 val_map->loc = try_loc;
8525 if (!literal_placed)
8527 /* Nothing worked, leave the literal alone but update the last loc. */
8528 values->has_last_loc = TRUE;
8529 values->last_loc = rel->r_rel;
8531 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
8533 val_map->loc = rel->r_rel;
8534 *last_loc_is_prev_p = TRUE;
8541 /* Check if the original relocations (presumably on L32R instructions)
8542 identified by reloc[0..N] can be changed to reference the literal
8543 identified by r_rel. If r_rel is out of range for any of the
8544 original relocations, then we don't want to coalesce the original
8545 literal with the one at r_rel. We only check reloc[0..N], where the
8546 offsets are all the same as for reloc[0] (i.e., they're all
8547 referencing the same literal) and where N is also bounded by the
8548 number of remaining entries in the "reloc" array. The "reloc" array
8549 is sorted by target offset so we know all the entries for the same
8550 literal will be contiguous. */
8553 relocations_reach (source_reloc *reloc,
8554 int remaining_relocs,
8555 const r_reloc *r_rel)
8557 bfd_vma from_offset, source_address, dest_address;
8561 if (!r_reloc_is_defined (r_rel))
8564 sec = r_reloc_get_section (r_rel);
8565 from_offset = reloc[0].r_rel.target_offset;
8567 for (i = 0; i < remaining_relocs; i++)
8569 if (reloc[i].r_rel.target_offset != from_offset)
8572 /* Ignore relocations that have been removed. */
8573 if (reloc[i].is_null)
8576 /* The original and new output section for these must be the same
8577 in order to coalesce. */
8578 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
8579 != sec->output_section)
8582 /* Absolute literals in the same output section can always be
8584 if (reloc[i].is_abs_literal)
8587 /* A literal with no PC-relative relocations can be moved anywhere. */
8588 if (reloc[i].opnd != -1)
8590 /* Otherwise, check to see that it fits. */
8591 source_address = (reloc[i].source_sec->output_section->vma
8592 + reloc[i].source_sec->output_offset
8593 + reloc[i].r_rel.rela.r_offset);
8594 dest_address = (sec->output_section->vma
8595 + sec->output_offset
8596 + r_rel->target_offset);
8598 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
8599 source_address, dest_address))
8608 /* Move a literal to another literal location because it is
8609 the same as the other literal value. */
8612 coalesce_shared_literal (asection *sec,
8614 property_table_entry *prop_table,
8618 property_table_entry *entry;
8620 property_table_entry *the_add_entry;
8622 xtensa_relax_info *relax_info;
8624 relax_info = get_xtensa_relax_info (sec);
8628 entry = elf_xtensa_find_property_entry
8629 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
8630 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8633 /* Mark that the literal will be coalesced. */
8634 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
8636 text_action_add (&relax_info->action_list,
8637 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8639 /* If the section is 4-byte aligned, do not add fill. */
8640 if (sec->alignment_power > 2)
8642 int fill_extra_space;
8643 bfd_vma entry_sec_offset;
8646 entry_sec_offset = entry->address - sec->vma + entry->size;
8648 entry_sec_offset = rel->r_rel.target_offset + 4;
8650 /* If the literal range is at the end of the section,
8652 fill_extra_space = 0;
8653 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8655 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8656 fill_extra_space = the_add_entry->size;
8658 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8659 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8660 -4, fill_extra_space);
8662 adjust_fill_action (fa, removed_diff);
8664 text_action_add (&relax_info->action_list,
8665 ta_fill, sec, entry_sec_offset, removed_diff);
8672 /* Move a literal to another location. This may actually increase the
8673 total amount of space used because of alignments so we need to do
8674 this carefully. Also, it may make a branch go out of range. */
8677 move_shared_literal (asection *sec,
8678 struct bfd_link_info *link_info,
8680 property_table_entry *prop_table,
8682 const r_reloc *target_loc,
8683 const literal_value *lit_value,
8684 section_cache_t *target_sec_cache)
8686 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
8687 text_action *fa, *target_fa;
8689 xtensa_relax_info *relax_info, *target_relax_info;
8690 asection *target_sec;
8692 ebb_constraint ebb_table;
8693 bfd_boolean relocs_fit;
8695 /* If this routine always returns FALSE, the literals that cannot be
8696 coalesced will not be moved. */
8697 if (elf32xtensa_no_literal_movement)
8700 relax_info = get_xtensa_relax_info (sec);
8704 target_sec = r_reloc_get_section (target_loc);
8705 target_relax_info = get_xtensa_relax_info (target_sec);
8707 /* Literals to undefined sections may not be moved because they
8708 must report an error. */
8709 if (bfd_is_und_section (target_sec))
8712 src_entry = elf_xtensa_find_property_entry
8713 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
8715 if (!section_cache_section (target_sec_cache, target_sec, link_info))
8718 target_entry = elf_xtensa_find_property_entry
8719 (target_sec_cache->ptbl, target_sec_cache->pte_count,
8720 target_sec->vma + target_loc->target_offset);
8725 /* Make sure that we have not broken any branches. */
8728 init_ebb_constraint (&ebb_table);
8729 ebb = &ebb_table.ebb;
8730 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
8731 target_sec_cache->content_length,
8732 target_sec_cache->ptbl, target_sec_cache->pte_count,
8733 target_sec_cache->relocs, target_sec_cache->reloc_count);
8735 /* Propose to add 4 bytes + worst-case alignment size increase to
8737 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
8738 ta_fill, target_loc->target_offset,
8739 -4 - (1 << target_sec->alignment_power), TRUE);
8741 /* Check all of the PC-relative relocations to make sure they still fit. */
8742 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
8743 target_sec_cache->contents,
8744 target_sec_cache->relocs,
8750 text_action_add_literal (&target_relax_info->action_list,
8751 ta_add_literal, target_loc, lit_value, -4);
8753 if (target_sec->alignment_power > 2 && target_entry != src_entry)
8755 /* May need to add or remove some fill to maintain alignment. */
8756 int fill_extra_space;
8757 bfd_vma entry_sec_offset;
8760 target_entry->address - target_sec->vma + target_entry->size;
8762 /* If the literal range is at the end of the section,
8764 fill_extra_space = 0;
8766 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
8767 target_sec_cache->pte_count,
8769 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8770 fill_extra_space = the_add_entry->size;
8772 target_fa = find_fill_action (&target_relax_info->action_list,
8773 target_sec, entry_sec_offset);
8774 removed_diff = compute_removed_action_diff (target_fa, target_sec,
8775 entry_sec_offset, 4,
8778 adjust_fill_action (target_fa, removed_diff);
8780 text_action_add (&target_relax_info->action_list,
8781 ta_fill, target_sec, entry_sec_offset, removed_diff);
8784 /* Mark that the literal will be moved to the new location. */
8785 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
8787 /* Remove the literal. */
8788 text_action_add (&relax_info->action_list,
8789 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8791 /* If the section is 4-byte aligned, do not add fill. */
8792 if (sec->alignment_power > 2 && target_entry != src_entry)
8794 int fill_extra_space;
8795 bfd_vma entry_sec_offset;
8798 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
8800 entry_sec_offset = rel->r_rel.target_offset+4;
8802 /* If the literal range is at the end of the section,
8804 fill_extra_space = 0;
8805 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8807 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8808 fill_extra_space = the_add_entry->size;
8810 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8811 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8812 -4, fill_extra_space);
8814 adjust_fill_action (fa, removed_diff);
8816 text_action_add (&relax_info->action_list,
8817 ta_fill, sec, entry_sec_offset, removed_diff);
8824 /* Second relaxation pass. */
8826 /* Modify all of the relocations to point to the right spot, and if this
8827 is a relaxable section, delete the unwanted literals and fix the
8831 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
8833 Elf_Internal_Rela *internal_relocs;
8834 xtensa_relax_info *relax_info;
8836 bfd_boolean ok = TRUE;
8838 bfd_boolean rv = FALSE;
8839 bfd_boolean virtual_action;
8840 bfd_size_type sec_size;
8842 sec_size = bfd_get_section_limit (abfd, sec);
8843 relax_info = get_xtensa_relax_info (sec);
8844 BFD_ASSERT (relax_info);
8846 /* First translate any of the fixes that have been added already. */
8847 translate_section_fixes (sec);
8849 /* Handle property sections (e.g., literal tables) specially. */
8850 if (xtensa_is_property_section (sec))
8852 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
8853 return relax_property_section (abfd, sec, link_info);
8856 internal_relocs = retrieve_internal_relocs (abfd, sec,
8857 link_info->keep_memory);
8858 if (!internal_relocs && !relax_info->action_list.head)
8861 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8862 if (contents == NULL && sec_size != 0)
8868 if (internal_relocs)
8870 for (i = 0; i < sec->reloc_count; i++)
8872 Elf_Internal_Rela *irel;
8873 xtensa_relax_info *target_relax_info;
8874 bfd_vma source_offset, old_source_offset;
8877 asection *target_sec;
8879 /* Locally change the source address.
8880 Translate the target to the new target address.
8881 If it points to this section and has been removed,
8885 irel = &internal_relocs[i];
8886 source_offset = irel->r_offset;
8887 old_source_offset = source_offset;
8889 r_type = ELF32_R_TYPE (irel->r_info);
8890 r_reloc_init (&r_rel, abfd, irel, contents,
8891 bfd_get_section_limit (abfd, sec));
8893 /* If this section could have changed then we may need to
8894 change the relocation's offset. */
8896 if (relax_info->is_relaxable_literal_section
8897 || relax_info->is_relaxable_asm_section)
8899 pin_internal_relocs (sec, internal_relocs);
8901 if (r_type != R_XTENSA_NONE
8902 && find_removed_literal (&relax_info->removed_list,
8905 /* Remove this relocation. */
8906 if (elf_hash_table (link_info)->dynamic_sections_created)
8907 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8908 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8909 irel->r_offset = offset_with_removed_text
8910 (&relax_info->action_list, irel->r_offset);
8914 if (r_type == R_XTENSA_ASM_SIMPLIFY)
8916 text_action *action =
8917 find_insn_action (&relax_info->action_list,
8919 if (action && (action->action == ta_convert_longcall
8920 || action->action == ta_remove_longcall))
8922 bfd_reloc_status_type retval;
8923 char *error_message = NULL;
8925 retval = contract_asm_expansion (contents, sec_size,
8926 irel, &error_message);
8927 if (retval != bfd_reloc_ok)
8929 (*link_info->callbacks->reloc_dangerous)
8930 (link_info, error_message, abfd, sec,
8934 /* Update the action so that the code that moves
8935 the contents will do the right thing. */
8936 if (action->action == ta_remove_longcall)
8937 action->action = ta_remove_insn;
8939 action->action = ta_none;
8940 /* Refresh the info in the r_rel. */
8941 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8942 r_type = ELF32_R_TYPE (irel->r_info);
8946 source_offset = offset_with_removed_text
8947 (&relax_info->action_list, irel->r_offset);
8948 irel->r_offset = source_offset;
8951 /* If the target section could have changed then
8952 we may need to change the relocation's target offset. */
8954 target_sec = r_reloc_get_section (&r_rel);
8956 /* For a reference to a discarded section from a DWARF section,
8957 i.e., where action_discarded is PRETEND, the symbol will
8958 eventually be modified to refer to the kept section (at least if
8959 the kept and discarded sections are the same size). Anticipate
8960 that here and adjust things accordingly. */
8961 if (! elf_xtensa_ignore_discarded_relocs (sec)
8962 && elf_xtensa_action_discarded (sec) == PRETEND
8963 && sec->sec_info_type != ELF_INFO_TYPE_STABS
8964 && target_sec != NULL
8965 && elf_discarded_section (target_sec))
8967 /* It would be natural to call _bfd_elf_check_kept_section
8968 here, but it's not exported from elflink.c. It's also a
8969 fairly expensive check. Adjusting the relocations to the
8970 discarded section is fairly harmless; it will only adjust
8971 some addends and difference values. If it turns out that
8972 _bfd_elf_check_kept_section fails later, it won't matter,
8973 so just compare the section names to find the right group
8975 asection *kept = target_sec->kept_section;
8978 if ((kept->flags & SEC_GROUP) != 0)
8980 asection *first = elf_next_in_group (kept);
8981 asection *s = first;
8986 if (strcmp (s->name, target_sec->name) == 0)
8991 s = elf_next_in_group (s);
8998 && ((target_sec->rawsize != 0
8999 ? target_sec->rawsize : target_sec->size)
9000 == (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9004 target_relax_info = get_xtensa_relax_info (target_sec);
9005 if (target_relax_info
9006 && (target_relax_info->is_relaxable_literal_section
9007 || target_relax_info->is_relaxable_asm_section))
9010 target_sec = translate_reloc (&r_rel, &new_reloc, target_sec);
9012 if (r_type == R_XTENSA_DIFF8
9013 || r_type == R_XTENSA_DIFF16
9014 || r_type == R_XTENSA_DIFF32)
9016 bfd_vma diff_value = 0, new_end_offset, diff_mask = 0;
9018 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
9020 (*link_info->callbacks->reloc_dangerous)
9021 (link_info, _("invalid relocation address"),
9022 abfd, sec, old_source_offset);
9028 case R_XTENSA_DIFF8:
9030 bfd_get_8 (abfd, &contents[old_source_offset]);
9032 case R_XTENSA_DIFF16:
9034 bfd_get_16 (abfd, &contents[old_source_offset]);
9036 case R_XTENSA_DIFF32:
9038 bfd_get_32 (abfd, &contents[old_source_offset]);
9042 new_end_offset = offset_with_removed_text
9043 (&target_relax_info->action_list,
9044 r_rel.target_offset + diff_value);
9045 diff_value = new_end_offset - new_reloc.target_offset;
9049 case R_XTENSA_DIFF8:
9051 bfd_put_8 (abfd, diff_value,
9052 &contents[old_source_offset]);
9054 case R_XTENSA_DIFF16:
9056 bfd_put_16 (abfd, diff_value,
9057 &contents[old_source_offset]);
9059 case R_XTENSA_DIFF32:
9060 diff_mask = 0xffffffff;
9061 bfd_put_32 (abfd, diff_value,
9062 &contents[old_source_offset]);
9066 /* Check for overflow. */
9067 if ((diff_value & ~diff_mask) != 0)
9069 (*link_info->callbacks->reloc_dangerous)
9070 (link_info, _("overflow after relaxation"),
9071 abfd, sec, old_source_offset);
9075 pin_contents (sec, contents);
9078 /* If the relocation still references a section in the same
9079 input file, modify the relocation directly instead of
9080 adding a "fix" record. */
9081 if (target_sec->owner == abfd)
9083 unsigned r_symndx = ELF32_R_SYM (new_reloc.rela.r_info);
9084 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
9085 irel->r_addend = new_reloc.rela.r_addend;
9086 pin_internal_relocs (sec, internal_relocs);
9090 bfd_vma addend_displacement;
9093 addend_displacement =
9094 new_reloc.target_offset + new_reloc.virtual_offset;
9095 fix = reloc_bfd_fix_init (sec, source_offset, r_type,
9097 addend_displacement, TRUE);
9104 if ((relax_info->is_relaxable_literal_section
9105 || relax_info->is_relaxable_asm_section)
9106 && relax_info->action_list.head)
9108 /* Walk through the planned actions and build up a table
9109 of move, copy and fill records. Use the move, copy and
9110 fill records to perform the actions once. */
9113 bfd_size_type final_size, copy_size, orig_insn_size;
9114 bfd_byte *scratch = NULL;
9115 bfd_byte *dup_contents = NULL;
9116 bfd_size_type orig_size = sec->size;
9117 bfd_vma orig_dot = 0;
9118 bfd_vma orig_dot_copied = 0; /* Byte copied already from
9119 orig dot in physical memory. */
9120 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
9121 bfd_vma dup_dot = 0;
9123 text_action *action = relax_info->action_list.head;
9125 final_size = sec->size;
9126 for (action = relax_info->action_list.head; action;
9127 action = action->next)
9129 final_size -= action->removed_bytes;
9132 scratch = (bfd_byte *) bfd_zmalloc (final_size);
9133 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
9135 /* The dot is the current fill location. */
9137 print_action_list (stderr, &relax_info->action_list);
9140 for (action = relax_info->action_list.head; action;
9141 action = action->next)
9143 virtual_action = FALSE;
9144 if (action->offset > orig_dot)
9146 orig_dot += orig_dot_copied;
9147 orig_dot_copied = 0;
9149 /* Out of the virtual world. */
9152 if (action->offset > orig_dot)
9154 copy_size = action->offset - orig_dot;
9155 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9156 orig_dot += copy_size;
9157 dup_dot += copy_size;
9158 BFD_ASSERT (action->offset == orig_dot);
9160 else if (action->offset < orig_dot)
9162 if (action->action == ta_fill
9163 && action->offset - action->removed_bytes == orig_dot)
9165 /* This is OK because the fill only effects the dup_dot. */
9167 else if (action->action == ta_add_literal)
9169 /* TBD. Might need to handle this. */
9172 if (action->offset == orig_dot)
9174 if (action->virtual_offset > orig_dot_vo)
9176 if (orig_dot_vo == 0)
9178 /* Need to copy virtual_offset bytes. Probably four. */
9179 copy_size = action->virtual_offset - orig_dot_vo;
9180 memmove (&dup_contents[dup_dot],
9181 &contents[orig_dot], copy_size);
9182 orig_dot_copied = copy_size;
9183 dup_dot += copy_size;
9185 virtual_action = TRUE;
9188 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
9190 switch (action->action)
9192 case ta_remove_literal:
9193 case ta_remove_insn:
9194 BFD_ASSERT (action->removed_bytes >= 0);
9195 orig_dot += action->removed_bytes;
9198 case ta_narrow_insn:
9201 memmove (scratch, &contents[orig_dot], orig_insn_size);
9202 BFD_ASSERT (action->removed_bytes == 1);
9203 rv = narrow_instruction (scratch, final_size, 0);
9205 memmove (&dup_contents[dup_dot], scratch, copy_size);
9206 orig_dot += orig_insn_size;
9207 dup_dot += copy_size;
9211 if (action->removed_bytes >= 0)
9212 orig_dot += action->removed_bytes;
9215 /* Already zeroed in dup_contents. Just bump the
9217 dup_dot += (-action->removed_bytes);
9222 BFD_ASSERT (action->removed_bytes == 0);
9225 case ta_convert_longcall:
9226 case ta_remove_longcall:
9227 /* These will be removed or converted before we get here. */
9234 memmove (scratch, &contents[orig_dot], orig_insn_size);
9235 BFD_ASSERT (action->removed_bytes == -1);
9236 rv = widen_instruction (scratch, final_size, 0);
9238 memmove (&dup_contents[dup_dot], scratch, copy_size);
9239 orig_dot += orig_insn_size;
9240 dup_dot += copy_size;
9243 case ta_add_literal:
9246 BFD_ASSERT (action->removed_bytes == -4);
9247 /* TBD -- place the literal value here and insert
9249 memset (&dup_contents[dup_dot], 0, 4);
9250 pin_internal_relocs (sec, internal_relocs);
9251 pin_contents (sec, contents);
9253 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
9254 relax_info, &internal_relocs, &action->value))
9258 orig_dot_vo += copy_size;
9260 orig_dot += orig_insn_size;
9261 dup_dot += copy_size;
9265 /* Not implemented yet. */
9270 removed += action->removed_bytes;
9271 BFD_ASSERT (dup_dot <= final_size);
9272 BFD_ASSERT (orig_dot <= orig_size);
9275 orig_dot += orig_dot_copied;
9276 orig_dot_copied = 0;
9278 if (orig_dot != orig_size)
9280 copy_size = orig_size - orig_dot;
9281 BFD_ASSERT (orig_size > orig_dot);
9282 BFD_ASSERT (dup_dot + copy_size == final_size);
9283 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9284 orig_dot += copy_size;
9285 dup_dot += copy_size;
9287 BFD_ASSERT (orig_size == orig_dot);
9288 BFD_ASSERT (final_size == dup_dot);
9290 /* Move the dup_contents back. */
9291 if (final_size > orig_size)
9293 /* Contents need to be reallocated. Swap the dup_contents into
9295 sec->contents = dup_contents;
9297 contents = dup_contents;
9298 pin_contents (sec, contents);
9302 BFD_ASSERT (final_size <= orig_size);
9303 memset (contents, 0, orig_size);
9304 memcpy (contents, dup_contents, final_size);
9305 free (dup_contents);
9308 pin_contents (sec, contents);
9310 if (sec->rawsize == 0)
9311 sec->rawsize = sec->size;
9312 sec->size = final_size;
9316 release_internal_relocs (sec, internal_relocs);
9317 release_contents (sec, contents);
9323 translate_section_fixes (asection *sec)
9325 xtensa_relax_info *relax_info;
9328 relax_info = get_xtensa_relax_info (sec);
9332 for (r = relax_info->fix_list; r != NULL; r = r->next)
9333 if (!translate_reloc_bfd_fix (r))
9340 /* Translate a fix given the mapping in the relax info for the target
9341 section. If it has already been translated, no work is required. */
9344 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
9346 reloc_bfd_fix new_fix;
9348 xtensa_relax_info *relax_info;
9349 removed_literal *removed;
9350 bfd_vma new_offset, target_offset;
9352 if (fix->translated)
9355 sec = fix->target_sec;
9356 target_offset = fix->target_offset;
9358 relax_info = get_xtensa_relax_info (sec);
9361 fix->translated = TRUE;
9367 /* The fix does not need to be translated if the section cannot change. */
9368 if (!relax_info->is_relaxable_literal_section
9369 && !relax_info->is_relaxable_asm_section)
9371 fix->translated = TRUE;
9375 /* If the literal has been moved and this relocation was on an
9376 opcode, then the relocation should move to the new literal
9377 location. Otherwise, the relocation should move within the
9381 if (is_operand_relocation (fix->src_type))
9383 /* Check if the original relocation is against a literal being
9385 removed = find_removed_literal (&relax_info->removed_list,
9393 /* The fact that there is still a relocation to this literal indicates
9394 that the literal is being coalesced, not simply removed. */
9395 BFD_ASSERT (removed->to.abfd != NULL);
9397 /* This was moved to some other address (possibly another section). */
9398 new_sec = r_reloc_get_section (&removed->to);
9402 relax_info = get_xtensa_relax_info (sec);
9404 (!relax_info->is_relaxable_literal_section
9405 && !relax_info->is_relaxable_asm_section))
9407 target_offset = removed->to.target_offset;
9408 new_fix.target_sec = new_sec;
9409 new_fix.target_offset = target_offset;
9410 new_fix.translated = TRUE;
9415 target_offset = removed->to.target_offset;
9416 new_fix.target_sec = new_sec;
9419 /* The target address may have been moved within its section. */
9420 new_offset = offset_with_removed_text (&relax_info->action_list,
9423 new_fix.target_offset = new_offset;
9424 new_fix.target_offset = new_offset;
9425 new_fix.translated = TRUE;
9431 /* Fix up a relocation to take account of removed literals. */
9434 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec)
9436 xtensa_relax_info *relax_info;
9437 removed_literal *removed;
9438 bfd_vma target_offset, base_offset;
9441 *new_rel = *orig_rel;
9443 if (!r_reloc_is_defined (orig_rel))
9446 relax_info = get_xtensa_relax_info (sec);
9447 BFD_ASSERT (relax_info && (relax_info->is_relaxable_literal_section
9448 || relax_info->is_relaxable_asm_section));
9450 target_offset = orig_rel->target_offset;
9453 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
9455 /* Check if the original relocation is against a literal being
9457 removed = find_removed_literal (&relax_info->removed_list,
9460 if (removed && removed->to.abfd)
9464 /* The fact that there is still a relocation to this literal indicates
9465 that the literal is being coalesced, not simply removed. */
9466 BFD_ASSERT (removed->to.abfd != NULL);
9468 /* This was moved to some other address
9469 (possibly in another section). */
9470 *new_rel = removed->to;
9471 new_sec = r_reloc_get_section (new_rel);
9475 relax_info = get_xtensa_relax_info (sec);
9477 || (!relax_info->is_relaxable_literal_section
9478 && !relax_info->is_relaxable_asm_section))
9481 target_offset = new_rel->target_offset;
9484 /* Find the base offset of the reloc symbol, excluding any addend from the
9485 reloc or from the section contents (for a partial_inplace reloc). Then
9486 find the adjusted values of the offsets due to relaxation. The base
9487 offset is needed to determine the change to the reloc's addend; the reloc
9488 addend should not be adjusted due to relaxations located before the base
9491 base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend;
9492 act = relax_info->action_list.head;
9493 if (base_offset <= target_offset)
9495 int base_removed = removed_by_actions (&act, base_offset, FALSE);
9496 int addend_removed = removed_by_actions (&act, target_offset, FALSE);
9497 new_rel->target_offset = target_offset - base_removed - addend_removed;
9498 new_rel->rela.r_addend -= addend_removed;
9502 /* Handle a negative addend. The base offset comes first. */
9503 int tgt_removed = removed_by_actions (&act, target_offset, FALSE);
9504 int addend_removed = removed_by_actions (&act, base_offset, FALSE);
9505 new_rel->target_offset = target_offset - tgt_removed;
9506 new_rel->rela.r_addend += addend_removed;
9513 /* For dynamic links, there may be a dynamic relocation for each
9514 literal. The number of dynamic relocations must be computed in
9515 size_dynamic_sections, which occurs before relaxation. When a
9516 literal is removed, this function checks if there is a corresponding
9517 dynamic relocation and shrinks the size of the appropriate dynamic
9518 relocation section accordingly. At this point, the contents of the
9519 dynamic relocation sections have not yet been filled in, so there's
9520 nothing else that needs to be done. */
9523 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
9525 asection *input_section,
9526 Elf_Internal_Rela *rel)
9528 struct elf_xtensa_link_hash_table *htab;
9529 Elf_Internal_Shdr *symtab_hdr;
9530 struct elf_link_hash_entry **sym_hashes;
9531 unsigned long r_symndx;
9533 struct elf_link_hash_entry *h;
9534 bfd_boolean dynamic_symbol;
9536 htab = elf_xtensa_hash_table (info);
9540 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9541 sym_hashes = elf_sym_hashes (abfd);
9543 r_type = ELF32_R_TYPE (rel->r_info);
9544 r_symndx = ELF32_R_SYM (rel->r_info);
9546 if (r_symndx < symtab_hdr->sh_info)
9549 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9551 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
9553 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
9554 && (input_section->flags & SEC_ALLOC) != 0
9555 && (dynamic_symbol || info->shared))
9558 bfd_boolean is_plt = FALSE;
9560 if (dynamic_symbol && r_type == R_XTENSA_PLT)
9562 srel = htab->srelplt;
9566 srel = htab->srelgot;
9568 /* Reduce size of the .rela.* section by one reloc. */
9569 BFD_ASSERT (srel != NULL);
9570 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
9571 srel->size -= sizeof (Elf32_External_Rela);
9575 asection *splt, *sgotplt, *srelgot;
9576 int reloc_index, chunk;
9578 /* Find the PLT reloc index of the entry being removed. This
9579 is computed from the size of ".rela.plt". It is needed to
9580 figure out which PLT chunk to resize. Usually "last index
9581 = size - 1" since the index starts at zero, but in this
9582 context, the size has just been decremented so there's no
9583 need to subtract one. */
9584 reloc_index = srel->size / sizeof (Elf32_External_Rela);
9586 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
9587 splt = elf_xtensa_get_plt_section (info, chunk);
9588 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
9589 BFD_ASSERT (splt != NULL && sgotplt != NULL);
9591 /* Check if an entire PLT chunk has just been eliminated. */
9592 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
9594 /* The two magic GOT entries for that chunk can go away. */
9595 srelgot = htab->srelgot;
9596 BFD_ASSERT (srelgot != NULL);
9597 srelgot->reloc_count -= 2;
9598 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
9601 /* There should be only one entry left (and it will be
9603 BFD_ASSERT (sgotplt->size == 4);
9604 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
9607 BFD_ASSERT (sgotplt->size >= 4);
9608 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
9611 splt->size -= PLT_ENTRY_SIZE;
9617 /* Take an r_rel and move it to another section. This usually
9618 requires extending the interal_relocation array and pinning it. If
9619 the original r_rel is from the same BFD, we can complete this here.
9620 Otherwise, we add a fix record to let the final link fix the
9621 appropriate address. Contents and internal relocations for the
9622 section must be pinned after calling this routine. */
9625 move_literal (bfd *abfd,
9626 struct bfd_link_info *link_info,
9630 xtensa_relax_info *relax_info,
9631 Elf_Internal_Rela **internal_relocs_p,
9632 const literal_value *lit)
9634 Elf_Internal_Rela *new_relocs = NULL;
9635 size_t new_relocs_count = 0;
9636 Elf_Internal_Rela this_rela;
9637 const r_reloc *r_rel;
9639 r_rel = &lit->r_rel;
9640 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
9642 if (r_reloc_is_const (r_rel))
9643 bfd_put_32 (abfd, lit->value, contents + offset);
9651 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
9653 /* This is the difficult case. We have to create a fix up. */
9654 this_rela.r_offset = offset;
9655 this_rela.r_info = ELF32_R_INFO (0, r_type);
9656 this_rela.r_addend =
9657 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
9658 bfd_put_32 (abfd, lit->value, contents + offset);
9660 /* Currently, we cannot move relocations during a relocatable link. */
9661 BFD_ASSERT (!link_info->relocatable);
9662 fix = reloc_bfd_fix_init (sec, offset, r_type,
9663 r_reloc_get_section (r_rel),
9664 r_rel->target_offset + r_rel->virtual_offset,
9666 /* We also need to mark that relocations are needed here. */
9667 sec->flags |= SEC_RELOC;
9669 translate_reloc_bfd_fix (fix);
9670 /* This fix has not yet been translated. */
9673 /* Add the relocation. If we have already allocated our own
9674 space for the relocations and we have room for more, then use
9675 it. Otherwise, allocate new space and move the literals. */
9676 insert_at = sec->reloc_count;
9677 for (i = 0; i < sec->reloc_count; ++i)
9679 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
9686 if (*internal_relocs_p != relax_info->allocated_relocs
9687 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
9689 BFD_ASSERT (relax_info->allocated_relocs == NULL
9690 || sec->reloc_count == relax_info->relocs_count);
9692 if (relax_info->allocated_relocs_count == 0)
9693 new_relocs_count = (sec->reloc_count + 2) * 2;
9695 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
9697 new_relocs = (Elf_Internal_Rela *)
9698 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
9702 /* We could handle this more quickly by finding the split point. */
9704 memcpy (new_relocs, *internal_relocs_p,
9705 insert_at * sizeof (Elf_Internal_Rela));
9707 new_relocs[insert_at] = this_rela;
9709 if (insert_at != sec->reloc_count)
9710 memcpy (new_relocs + insert_at + 1,
9711 (*internal_relocs_p) + insert_at,
9712 (sec->reloc_count - insert_at)
9713 * sizeof (Elf_Internal_Rela));
9715 if (*internal_relocs_p != relax_info->allocated_relocs)
9717 /* The first time we re-allocate, we can only free the
9718 old relocs if they were allocated with bfd_malloc.
9719 This is not true when keep_memory is in effect. */
9720 if (!link_info->keep_memory)
9721 free (*internal_relocs_p);
9724 free (*internal_relocs_p);
9725 relax_info->allocated_relocs = new_relocs;
9726 relax_info->allocated_relocs_count = new_relocs_count;
9727 elf_section_data (sec)->relocs = new_relocs;
9729 relax_info->relocs_count = sec->reloc_count;
9730 *internal_relocs_p = new_relocs;
9734 if (insert_at != sec->reloc_count)
9737 for (idx = sec->reloc_count; idx > insert_at; idx--)
9738 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
9740 (*internal_relocs_p)[insert_at] = this_rela;
9742 if (relax_info->allocated_relocs)
9743 relax_info->relocs_count = sec->reloc_count;
9750 /* This is similar to relax_section except that when a target is moved,
9751 we shift addresses up. We also need to modify the size. This
9752 algorithm does NOT allow for relocations into the middle of the
9753 property sections. */
9756 relax_property_section (bfd *abfd,
9758 struct bfd_link_info *link_info)
9760 Elf_Internal_Rela *internal_relocs;
9763 bfd_boolean ok = TRUE;
9764 bfd_boolean is_full_prop_section;
9765 size_t last_zfill_target_offset = 0;
9766 asection *last_zfill_target_sec = NULL;
9767 bfd_size_type sec_size;
9768 bfd_size_type entry_size;
9770 sec_size = bfd_get_section_limit (abfd, sec);
9771 internal_relocs = retrieve_internal_relocs (abfd, sec,
9772 link_info->keep_memory);
9773 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9774 if (contents == NULL && sec_size != 0)
9780 is_full_prop_section = xtensa_is_proptable_section (sec);
9781 if (is_full_prop_section)
9786 if (internal_relocs)
9788 for (i = 0; i < sec->reloc_count; i++)
9790 Elf_Internal_Rela *irel;
9791 xtensa_relax_info *target_relax_info;
9793 asection *target_sec;
9795 bfd_byte *size_p, *flags_p;
9797 /* Locally change the source address.
9798 Translate the target to the new target address.
9799 If it points to this section and has been removed, MOVE IT.
9800 Also, don't forget to modify the associated SIZE at
9803 irel = &internal_relocs[i];
9804 r_type = ELF32_R_TYPE (irel->r_info);
9805 if (r_type == R_XTENSA_NONE)
9808 /* Find the literal value. */
9809 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
9810 size_p = &contents[irel->r_offset + 4];
9812 if (is_full_prop_section)
9813 flags_p = &contents[irel->r_offset + 8];
9814 BFD_ASSERT (irel->r_offset + entry_size <= sec_size);
9816 target_sec = r_reloc_get_section (&val.r_rel);
9817 target_relax_info = get_xtensa_relax_info (target_sec);
9819 if (target_relax_info
9820 && (target_relax_info->is_relaxable_literal_section
9821 || target_relax_info->is_relaxable_asm_section ))
9823 /* Translate the relocation's destination. */
9824 bfd_vma old_offset = val.r_rel.target_offset;
9826 long old_size, new_size;
9827 text_action *act = target_relax_info->action_list.head;
9828 new_offset = old_offset -
9829 removed_by_actions (&act, old_offset, FALSE);
9831 /* Assert that we are not out of bounds. */
9832 old_size = bfd_get_32 (abfd, size_p);
9833 new_size = old_size;
9837 /* Only the first zero-sized unreachable entry is
9838 allowed to expand. In this case the new offset
9839 should be the offset before the fill and the new
9840 size is the expansion size. For other zero-sized
9841 entries the resulting size should be zero with an
9842 offset before or after the fill address depending
9843 on whether the expanding unreachable entry
9845 if (last_zfill_target_sec == 0
9846 || last_zfill_target_sec != target_sec
9847 || last_zfill_target_offset != old_offset)
9849 bfd_vma new_end_offset = new_offset;
9851 /* Recompute the new_offset, but this time don't
9852 include any fill inserted by relaxation. */
9853 act = target_relax_info->action_list.head;
9854 new_offset = old_offset -
9855 removed_by_actions (&act, old_offset, TRUE);
9857 /* If it is not unreachable and we have not yet
9858 seen an unreachable at this address, place it
9859 before the fill address. */
9860 if (flags_p && (bfd_get_32 (abfd, flags_p)
9861 & XTENSA_PROP_UNREACHABLE) != 0)
9863 new_size = new_end_offset - new_offset;
9865 last_zfill_target_sec = target_sec;
9866 last_zfill_target_offset = old_offset;
9872 removed_by_actions (&act, old_offset + old_size, TRUE);
9874 if (new_size != old_size)
9876 bfd_put_32 (abfd, new_size, size_p);
9877 pin_contents (sec, contents);
9880 if (new_offset != old_offset)
9882 bfd_vma diff = new_offset - old_offset;
9883 irel->r_addend += diff;
9884 pin_internal_relocs (sec, internal_relocs);
9890 /* Combine adjacent property table entries. This is also done in
9891 finish_dynamic_sections() but at that point it's too late to
9892 reclaim the space in the output section, so we do this twice. */
9894 if (internal_relocs && (!link_info->relocatable
9895 || xtensa_is_littable_section (sec)))
9897 Elf_Internal_Rela *last_irel = NULL;
9898 Elf_Internal_Rela *irel, *next_rel, *rel_end;
9899 int removed_bytes = 0;
9901 flagword predef_flags;
9903 predef_flags = xtensa_get_property_predef_flags (sec);
9905 /* Walk over memory and relocations at the same time.
9906 This REQUIRES that the internal_relocs be sorted by offset. */
9907 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
9908 internal_reloc_compare);
9910 pin_internal_relocs (sec, internal_relocs);
9911 pin_contents (sec, contents);
9913 next_rel = internal_relocs;
9914 rel_end = internal_relocs + sec->reloc_count;
9916 BFD_ASSERT (sec->size % entry_size == 0);
9918 for (offset = 0; offset < sec->size; offset += entry_size)
9920 Elf_Internal_Rela *offset_rel, *extra_rel;
9921 bfd_vma bytes_to_remove, size, actual_offset;
9922 bfd_boolean remove_this_rel;
9925 /* Find the first relocation for the entry at the current offset.
9926 Adjust the offsets of any extra relocations for the previous
9931 for (irel = next_rel; irel < rel_end; irel++)
9933 if ((irel->r_offset == offset
9934 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9935 || irel->r_offset > offset)
9940 irel->r_offset -= removed_bytes;
9944 /* Find the next relocation (if there are any left). */
9948 for (irel = offset_rel + 1; irel < rel_end; irel++)
9950 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9958 /* Check if there are relocations on the current entry. There
9959 should usually be a relocation on the offset field. If there
9960 are relocations on the size or flags, then we can't optimize
9961 this entry. Also, find the next relocation to examine on the
9965 if (offset_rel->r_offset >= offset + entry_size)
9967 next_rel = offset_rel;
9968 /* There are no relocations on the current entry, but we
9969 might still be able to remove it if the size is zero. */
9972 else if (offset_rel->r_offset > offset
9974 && extra_rel->r_offset < offset + entry_size))
9976 /* There is a relocation on the size or flags, so we can't
9977 do anything with this entry. Continue with the next. */
9978 next_rel = offset_rel;
9983 BFD_ASSERT (offset_rel->r_offset == offset);
9984 offset_rel->r_offset -= removed_bytes;
9985 next_rel = offset_rel + 1;
9991 remove_this_rel = FALSE;
9992 bytes_to_remove = 0;
9993 actual_offset = offset - removed_bytes;
9994 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
9996 if (is_full_prop_section)
9997 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
9999 flags = predef_flags;
10002 && (flags & XTENSA_PROP_ALIGN) == 0
10003 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
10005 /* Always remove entries with zero size and no alignment. */
10006 bytes_to_remove = entry_size;
10008 remove_this_rel = TRUE;
10010 else if (offset_rel
10011 && ELF32_R_TYPE (offset_rel->r_info) == R_XTENSA_32)
10015 flagword old_flags;
10017 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
10018 bfd_vma old_address =
10019 (last_irel->r_addend
10020 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
10021 bfd_vma new_address =
10022 (offset_rel->r_addend
10023 + bfd_get_32 (abfd, &contents[actual_offset]));
10024 if (is_full_prop_section)
10025 old_flags = bfd_get_32
10026 (abfd, &contents[last_irel->r_offset + 8]);
10028 old_flags = predef_flags;
10030 if ((ELF32_R_SYM (offset_rel->r_info)
10031 == ELF32_R_SYM (last_irel->r_info))
10032 && old_address + old_size == new_address
10033 && old_flags == flags
10034 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
10035 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
10037 /* Fix the old size. */
10038 bfd_put_32 (abfd, old_size + size,
10039 &contents[last_irel->r_offset + 4]);
10040 bytes_to_remove = entry_size;
10041 remove_this_rel = TRUE;
10044 last_irel = offset_rel;
10047 last_irel = offset_rel;
10050 if (remove_this_rel)
10052 offset_rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
10053 offset_rel->r_offset = 0;
10056 if (bytes_to_remove != 0)
10058 removed_bytes += bytes_to_remove;
10059 if (offset + bytes_to_remove < sec->size)
10060 memmove (&contents[actual_offset],
10061 &contents[actual_offset + bytes_to_remove],
10062 sec->size - offset - bytes_to_remove);
10068 /* Fix up any extra relocations on the last entry. */
10069 for (irel = next_rel; irel < rel_end; irel++)
10070 irel->r_offset -= removed_bytes;
10072 /* Clear the removed bytes. */
10073 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
10075 if (sec->rawsize == 0)
10076 sec->rawsize = sec->size;
10077 sec->size -= removed_bytes;
10079 if (xtensa_is_littable_section (sec))
10081 asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
10083 sgotloc->size -= removed_bytes;
10089 release_internal_relocs (sec, internal_relocs);
10090 release_contents (sec, contents);
10095 /* Third relaxation pass. */
10097 /* Change symbol values to account for removed literals. */
10100 relax_section_symbols (bfd *abfd, asection *sec)
10102 xtensa_relax_info *relax_info;
10103 unsigned int sec_shndx;
10104 Elf_Internal_Shdr *symtab_hdr;
10105 Elf_Internal_Sym *isymbuf;
10106 unsigned i, num_syms, num_locals;
10108 relax_info = get_xtensa_relax_info (sec);
10109 BFD_ASSERT (relax_info);
10111 if (!relax_info->is_relaxable_literal_section
10112 && !relax_info->is_relaxable_asm_section)
10115 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
10117 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10118 isymbuf = retrieve_local_syms (abfd);
10120 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
10121 num_locals = symtab_hdr->sh_info;
10123 /* Adjust the local symbols defined in this section. */
10124 for (i = 0; i < num_locals; i++)
10126 Elf_Internal_Sym *isym = &isymbuf[i];
10128 if (isym->st_shndx == sec_shndx)
10130 text_action *act = relax_info->action_list.head;
10131 bfd_vma orig_addr = isym->st_value;
10133 isym->st_value -= removed_by_actions (&act, orig_addr, FALSE);
10135 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
10137 removed_by_actions (&act, orig_addr + isym->st_size, FALSE);
10141 /* Now adjust the global symbols defined in this section. */
10142 for (i = 0; i < (num_syms - num_locals); i++)
10144 struct elf_link_hash_entry *sym_hash;
10146 sym_hash = elf_sym_hashes (abfd)[i];
10148 if (sym_hash->root.type == bfd_link_hash_warning)
10149 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
10151 if ((sym_hash->root.type == bfd_link_hash_defined
10152 || sym_hash->root.type == bfd_link_hash_defweak)
10153 && sym_hash->root.u.def.section == sec)
10155 text_action *act = relax_info->action_list.head;
10156 bfd_vma orig_addr = sym_hash->root.u.def.value;
10158 sym_hash->root.u.def.value -=
10159 removed_by_actions (&act, orig_addr, FALSE);
10161 if (sym_hash->type == STT_FUNC)
10163 removed_by_actions (&act, orig_addr + sym_hash->size, FALSE);
10171 /* "Fix" handling functions, called while performing relocations. */
10174 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
10176 asection *input_section,
10177 bfd_byte *contents)
10180 asection *sec, *old_sec;
10181 bfd_vma old_offset;
10182 int r_type = ELF32_R_TYPE (rel->r_info);
10183 reloc_bfd_fix *fix;
10185 if (r_type == R_XTENSA_NONE)
10188 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10192 r_reloc_init (&r_rel, input_bfd, rel, contents,
10193 bfd_get_section_limit (input_bfd, input_section));
10194 old_sec = r_reloc_get_section (&r_rel);
10195 old_offset = r_rel.target_offset;
10197 if (!old_sec || !r_reloc_is_defined (&r_rel))
10199 if (r_type != R_XTENSA_ASM_EXPAND)
10201 (*_bfd_error_handler)
10202 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
10203 input_bfd, input_section, rel->r_offset,
10204 elf_howto_table[r_type].name);
10207 /* Leave it be. Resolution will happen in a later stage. */
10211 sec = fix->target_sec;
10212 rel->r_addend += ((sec->output_offset + fix->target_offset)
10213 - (old_sec->output_offset + old_offset));
10220 do_fix_for_final_link (Elf_Internal_Rela *rel,
10222 asection *input_section,
10223 bfd_byte *contents,
10224 bfd_vma *relocationp)
10227 int r_type = ELF32_R_TYPE (rel->r_info);
10228 reloc_bfd_fix *fix;
10229 bfd_vma fixup_diff;
10231 if (r_type == R_XTENSA_NONE)
10234 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10238 sec = fix->target_sec;
10240 fixup_diff = rel->r_addend;
10241 if (elf_howto_table[fix->src_type].partial_inplace)
10243 bfd_vma inplace_val;
10244 BFD_ASSERT (fix->src_offset
10245 < bfd_get_section_limit (input_bfd, input_section));
10246 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
10247 fixup_diff += inplace_val;
10250 *relocationp = (sec->output_section->vma
10251 + sec->output_offset
10252 + fix->target_offset - fixup_diff);
10256 /* Miscellaneous utility functions.... */
10259 elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
10261 struct elf_xtensa_link_hash_table *htab;
10267 htab = elf_xtensa_hash_table (info);
10274 dynobj = elf_hash_table (info)->dynobj;
10275 sprintf (plt_name, ".plt.%u", chunk);
10276 return bfd_get_section_by_name (dynobj, plt_name);
10281 elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
10283 struct elf_xtensa_link_hash_table *htab;
10289 htab = elf_xtensa_hash_table (info);
10292 return htab->sgotplt;
10295 dynobj = elf_hash_table (info)->dynobj;
10296 sprintf (got_name, ".got.plt.%u", chunk);
10297 return bfd_get_section_by_name (dynobj, got_name);
10301 /* Get the input section for a given symbol index.
10303 . a section symbol, return the section;
10304 . a common symbol, return the common section;
10305 . an undefined symbol, return the undefined section;
10306 . an indirect symbol, follow the links;
10307 . an absolute value, return the absolute section. */
10310 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
10312 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10313 asection *target_sec = NULL;
10314 if (r_symndx < symtab_hdr->sh_info)
10316 Elf_Internal_Sym *isymbuf;
10317 unsigned int section_index;
10319 isymbuf = retrieve_local_syms (abfd);
10320 section_index = isymbuf[r_symndx].st_shndx;
10322 if (section_index == SHN_UNDEF)
10323 target_sec = bfd_und_section_ptr;
10324 else if (section_index == SHN_ABS)
10325 target_sec = bfd_abs_section_ptr;
10326 else if (section_index == SHN_COMMON)
10327 target_sec = bfd_com_section_ptr;
10329 target_sec = bfd_section_from_elf_index (abfd, section_index);
10333 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10334 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
10336 while (h->root.type == bfd_link_hash_indirect
10337 || h->root.type == bfd_link_hash_warning)
10338 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10340 switch (h->root.type)
10342 case bfd_link_hash_defined:
10343 case bfd_link_hash_defweak:
10344 target_sec = h->root.u.def.section;
10346 case bfd_link_hash_common:
10347 target_sec = bfd_com_section_ptr;
10349 case bfd_link_hash_undefined:
10350 case bfd_link_hash_undefweak:
10351 target_sec = bfd_und_section_ptr;
10353 default: /* New indirect warning. */
10354 target_sec = bfd_und_section_ptr;
10362 static struct elf_link_hash_entry *
10363 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
10365 unsigned long indx;
10366 struct elf_link_hash_entry *h;
10367 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10369 if (r_symndx < symtab_hdr->sh_info)
10372 indx = r_symndx - symtab_hdr->sh_info;
10373 h = elf_sym_hashes (abfd)[indx];
10374 while (h->root.type == bfd_link_hash_indirect
10375 || h->root.type == bfd_link_hash_warning)
10376 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10381 /* Get the section-relative offset for a symbol number. */
10384 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
10386 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10387 bfd_vma offset = 0;
10389 if (r_symndx < symtab_hdr->sh_info)
10391 Elf_Internal_Sym *isymbuf;
10392 isymbuf = retrieve_local_syms (abfd);
10393 offset = isymbuf[r_symndx].st_value;
10397 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10398 struct elf_link_hash_entry *h =
10399 elf_sym_hashes (abfd)[indx];
10401 while (h->root.type == bfd_link_hash_indirect
10402 || h->root.type == bfd_link_hash_warning)
10403 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10404 if (h->root.type == bfd_link_hash_defined
10405 || h->root.type == bfd_link_hash_defweak)
10406 offset = h->root.u.def.value;
10413 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
10415 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
10416 struct elf_link_hash_entry *h;
10418 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
10419 if (h && h->root.type == bfd_link_hash_defweak)
10426 pcrel_reloc_fits (xtensa_opcode opc,
10428 bfd_vma self_address,
10429 bfd_vma dest_address)
10431 xtensa_isa isa = xtensa_default_isa;
10432 uint32 valp = dest_address;
10433 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
10434 || xtensa_operand_encode (isa, opc, opnd, &valp))
10441 xtensa_is_property_section (asection *sec)
10443 if (xtensa_is_insntable_section (sec)
10444 || xtensa_is_littable_section (sec)
10445 || xtensa_is_proptable_section (sec))
10453 xtensa_is_insntable_section (asection *sec)
10455 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
10456 || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
10464 xtensa_is_littable_section (asection *sec)
10466 if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
10467 || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
10475 xtensa_is_proptable_section (asection *sec)
10477 if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
10478 || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
10486 internal_reloc_compare (const void *ap, const void *bp)
10488 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10489 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10491 if (a->r_offset != b->r_offset)
10492 return (a->r_offset - b->r_offset);
10494 /* We don't need to sort on these criteria for correctness,
10495 but enforcing a more strict ordering prevents unstable qsort
10496 from behaving differently with different implementations.
10497 Without the code below we get correct but different results
10498 on Solaris 2.7 and 2.8. We would like to always produce the
10499 same results no matter the host. */
10501 if (a->r_info != b->r_info)
10502 return (a->r_info - b->r_info);
10504 return (a->r_addend - b->r_addend);
10509 internal_reloc_matches (const void *ap, const void *bp)
10511 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10512 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10514 /* Check if one entry overlaps with the other; this shouldn't happen
10515 except when searching for a match. */
10516 return (a->r_offset - b->r_offset);
10520 /* Predicate function used to look up a section in a particular group. */
10523 match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
10525 const char *gname = inf;
10526 const char *group_name = elf_group_name (sec);
10528 return (group_name == gname
10529 || (group_name != NULL
10531 && strcmp (group_name, gname) == 0));
10535 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
10538 xtensa_property_section_name (asection *sec, const char *base_name)
10540 const char *suffix, *group_name;
10541 char *prop_sec_name;
10543 group_name = elf_group_name (sec);
10546 suffix = strrchr (sec->name, '.');
10547 if (suffix == sec->name)
10549 prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
10550 + (suffix ? strlen (suffix) : 0));
10551 strcpy (prop_sec_name, base_name);
10553 strcat (prop_sec_name, suffix);
10555 else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
10557 char *linkonce_kind = 0;
10559 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
10560 linkonce_kind = "x.";
10561 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
10562 linkonce_kind = "p.";
10563 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
10564 linkonce_kind = "prop.";
10568 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
10569 + strlen (linkonce_kind) + 1);
10570 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
10571 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
10573 suffix = sec->name + linkonce_len;
10574 /* For backward compatibility, replace "t." instead of inserting
10575 the new linkonce_kind (but not for "prop" sections). */
10576 if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
10578 strcat (prop_sec_name + linkonce_len, suffix);
10581 prop_sec_name = strdup (base_name);
10583 return prop_sec_name;
10588 xtensa_get_property_section (asection *sec, const char *base_name)
10590 char *prop_sec_name;
10591 asection *prop_sec;
10593 prop_sec_name = xtensa_property_section_name (sec, base_name);
10594 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10595 match_section_group,
10596 (void *) elf_group_name (sec));
10597 free (prop_sec_name);
10603 xtensa_make_property_section (asection *sec, const char *base_name)
10605 char *prop_sec_name;
10606 asection *prop_sec;
10608 /* Check if the section already exists. */
10609 prop_sec_name = xtensa_property_section_name (sec, base_name);
10610 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10611 match_section_group,
10612 (void *) elf_group_name (sec));
10613 /* If not, create it. */
10616 flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
10617 flags |= (bfd_get_section_flags (sec->owner, sec)
10618 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
10620 prop_sec = bfd_make_section_anyway_with_flags
10621 (sec->owner, strdup (prop_sec_name), flags);
10625 elf_group_name (prop_sec) = elf_group_name (sec);
10628 free (prop_sec_name);
10634 xtensa_get_property_predef_flags (asection *sec)
10636 if (xtensa_is_insntable_section (sec))
10637 return (XTENSA_PROP_INSN
10638 | XTENSA_PROP_NO_TRANSFORM
10639 | XTENSA_PROP_INSN_NO_REORDER);
10641 if (xtensa_is_littable_section (sec))
10642 return (XTENSA_PROP_LITERAL
10643 | XTENSA_PROP_NO_TRANSFORM
10644 | XTENSA_PROP_INSN_NO_REORDER);
10650 /* Other functions called directly by the linker. */
10653 xtensa_callback_required_dependence (bfd *abfd,
10655 struct bfd_link_info *link_info,
10656 deps_callback_t callback,
10659 Elf_Internal_Rela *internal_relocs;
10660 bfd_byte *contents;
10662 bfd_boolean ok = TRUE;
10663 bfd_size_type sec_size;
10665 sec_size = bfd_get_section_limit (abfd, sec);
10667 /* ".plt*" sections have no explicit relocations but they contain L32R
10668 instructions that reference the corresponding ".got.plt*" sections. */
10669 if ((sec->flags & SEC_LINKER_CREATED) != 0
10670 && CONST_STRNEQ (sec->name, ".plt"))
10674 /* Find the corresponding ".got.plt*" section. */
10675 if (sec->name[4] == '\0')
10676 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
10682 BFD_ASSERT (sec->name[4] == '.');
10683 chunk = strtol (&sec->name[5], NULL, 10);
10685 sprintf (got_name, ".got.plt.%u", chunk);
10686 sgotplt = bfd_get_section_by_name (sec->owner, got_name);
10688 BFD_ASSERT (sgotplt);
10690 /* Assume worst-case offsets: L32R at the very end of the ".plt"
10691 section referencing a literal at the very beginning of
10692 ".got.plt". This is very close to the real dependence, anyway. */
10693 (*callback) (sec, sec_size, sgotplt, 0, closure);
10696 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
10697 when building uclibc, which runs "ld -b binary /dev/null". */
10698 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
10701 internal_relocs = retrieve_internal_relocs (abfd, sec,
10702 link_info->keep_memory);
10703 if (internal_relocs == NULL
10704 || sec->reloc_count == 0)
10707 /* Cache the contents for the duration of this scan. */
10708 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
10709 if (contents == NULL && sec_size != 0)
10715 if (!xtensa_default_isa)
10716 xtensa_default_isa = xtensa_isa_init (0, 0);
10718 for (i = 0; i < sec->reloc_count; i++)
10720 Elf_Internal_Rela *irel = &internal_relocs[i];
10721 if (is_l32r_relocation (abfd, sec, contents, irel))
10724 asection *target_sec;
10725 bfd_vma target_offset;
10727 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
10730 /* L32Rs must be local to the input file. */
10731 if (r_reloc_is_defined (&l32r_rel))
10733 target_sec = r_reloc_get_section (&l32r_rel);
10734 target_offset = l32r_rel.target_offset;
10736 (*callback) (sec, irel->r_offset, target_sec, target_offset,
10742 release_internal_relocs (sec, internal_relocs);
10743 release_contents (sec, contents);
10747 /* The default literal sections should always be marked as "code" (i.e.,
10748 SHF_EXECINSTR). This is particularly important for the Linux kernel
10749 module loader so that the literals are not placed after the text. */
10750 static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
10752 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10753 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10754 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10755 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 },
10756 { NULL, 0, 0, 0, 0 }
10759 #define ELF_TARGET_ID XTENSA_ELF_DATA
10761 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
10762 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
10763 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
10764 #define TARGET_BIG_NAME "elf32-xtensa-be"
10765 #define ELF_ARCH bfd_arch_xtensa
10767 #define ELF_MACHINE_CODE EM_XTENSA
10768 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
10771 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
10772 #else /* !XCHAL_HAVE_MMU */
10773 #define ELF_MAXPAGESIZE 1
10774 #endif /* !XCHAL_HAVE_MMU */
10775 #endif /* ELF_ARCH */
10777 #define elf_backend_can_gc_sections 1
10778 #define elf_backend_can_refcount 1
10779 #define elf_backend_plt_readonly 1
10780 #define elf_backend_got_header_size 4
10781 #define elf_backend_want_dynbss 0
10782 #define elf_backend_want_got_plt 1
10784 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
10786 #define bfd_elf32_mkobject elf_xtensa_mkobject
10788 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
10789 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
10790 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
10791 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
10792 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
10793 #define bfd_elf32_bfd_reloc_name_lookup \
10794 elf_xtensa_reloc_name_lookup
10795 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
10796 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
10798 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
10799 #define elf_backend_check_relocs elf_xtensa_check_relocs
10800 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
10801 #define elf_backend_discard_info elf_xtensa_discard_info
10802 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
10803 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
10804 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
10805 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
10806 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
10807 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
10808 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
10809 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
10810 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
10811 #define elf_backend_object_p elf_xtensa_object_p
10812 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
10813 #define elf_backend_relocate_section elf_xtensa_relocate_section
10814 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
10815 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
10816 #define elf_backend_omit_section_dynsym \
10817 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
10818 #define elf_backend_special_sections elf_xtensa_special_sections
10819 #define elf_backend_action_discarded elf_xtensa_action_discarded
10820 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
10822 #include "elf32-target.h"