1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright (C) 2003-2016 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 3 of the
9 License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
30 #include "elf/xtensa.h"
31 #include "splay-tree.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, 3, 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_signed,
227 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF8", FALSE, 0, 0xff, FALSE),
228 HOWTO (R_XTENSA_DIFF16, 0, 1, 16, FALSE, 0, complain_overflow_signed,
229 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF16", FALSE, 0, 0xffff, FALSE),
230 HOWTO (R_XTENSA_DIFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
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 if (r_type >= (unsigned int) R_XTENSA_max)
485 _bfd_error_handler (_("%B: invalid XTENSA reloc number: %d"), abfd, r_type);
488 cache_ptr->howto = &elf_howto_table[r_type];
492 /* Functions for the Xtensa ELF linker. */
494 /* The name of the dynamic interpreter. This is put in the .interp
497 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
499 /* The size in bytes of an entry in the procedure linkage table.
500 (This does _not_ include the space for the literals associated with
503 #define PLT_ENTRY_SIZE 16
505 /* For _really_ large PLTs, we may need to alternate between literals
506 and code to keep the literals within the 256K range of the L32R
507 instructions in the code. It's unlikely that anyone would ever need
508 such a big PLT, but an arbitrary limit on the PLT size would be bad.
509 Thus, we split the PLT into chunks. Since there's very little
510 overhead (2 extra literals) for each chunk, the chunk size is kept
511 small so that the code for handling multiple chunks get used and
512 tested regularly. With 254 entries, there are 1K of literals for
513 each chunk, and that seems like a nice round number. */
515 #define PLT_ENTRIES_PER_CHUNK 254
517 /* PLT entries are actually used as stub functions for lazy symbol
518 resolution. Once the symbol is resolved, the stub function is never
519 invoked. Note: the 32-byte frame size used here cannot be changed
520 without a corresponding change in the runtime linker. */
522 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
524 #if XSHAL_ABI == XTHAL_ABI_WINDOWED
525 0x6c, 0x10, 0x04, /* entry sp, 32 */
527 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
528 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
529 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
530 0x0a, 0x80, 0x00, /* jx a8 */
534 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
536 #if XSHAL_ABI == XTHAL_ABI_WINDOWED
537 0x36, 0x41, 0x00, /* entry sp, 32 */
539 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
540 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
541 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
542 0xa0, 0x08, 0x00, /* jx a8 */
546 /* The size of the thread control block. */
549 struct elf_xtensa_link_hash_entry
551 struct elf_link_hash_entry elf;
553 bfd_signed_vma tlsfunc_refcount;
555 #define GOT_UNKNOWN 0
557 #define GOT_TLS_GD 2 /* global or local dynamic */
558 #define GOT_TLS_IE 4 /* initial or local exec */
559 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
560 unsigned char tls_type;
563 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
565 struct elf_xtensa_obj_tdata
567 struct elf_obj_tdata root;
569 /* tls_type for each local got entry. */
570 char *local_got_tls_type;
572 bfd_signed_vma *local_tlsfunc_refcounts;
575 #define elf_xtensa_tdata(abfd) \
576 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
578 #define elf_xtensa_local_got_tls_type(abfd) \
579 (elf_xtensa_tdata (abfd)->local_got_tls_type)
581 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
582 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
584 #define is_xtensa_elf(bfd) \
585 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
586 && elf_tdata (bfd) != NULL \
587 && elf_object_id (bfd) == XTENSA_ELF_DATA)
590 elf_xtensa_mkobject (bfd *abfd)
592 return bfd_elf_allocate_object (abfd, sizeof (struct elf_xtensa_obj_tdata),
596 /* Xtensa ELF linker hash table. */
598 struct elf_xtensa_link_hash_table
600 struct elf_link_hash_table elf;
602 /* Short-cuts to get to dynamic linker sections. */
609 asection *spltlittbl;
611 /* Total count of PLT relocations seen during check_relocs.
612 The actual PLT code must be split into multiple sections and all
613 the sections have to be created before size_dynamic_sections,
614 where we figure out the exact number of PLT entries that will be
615 needed. It is OK if this count is an overestimate, e.g., some
616 relocations may be removed by GC. */
619 struct elf_xtensa_link_hash_entry *tlsbase;
622 /* Get the Xtensa ELF linker hash table from a link_info structure. */
624 #define elf_xtensa_hash_table(p) \
625 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
626 == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
628 /* Create an entry in an Xtensa ELF linker hash table. */
630 static struct bfd_hash_entry *
631 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry *entry,
632 struct bfd_hash_table *table,
635 /* Allocate the structure if it has not already been allocated by a
639 entry = bfd_hash_allocate (table,
640 sizeof (struct elf_xtensa_link_hash_entry));
645 /* Call the allocation method of the superclass. */
646 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
649 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (entry);
650 eh->tlsfunc_refcount = 0;
651 eh->tls_type = GOT_UNKNOWN;
657 /* Create an Xtensa ELF linker hash table. */
659 static struct bfd_link_hash_table *
660 elf_xtensa_link_hash_table_create (bfd *abfd)
662 struct elf_link_hash_entry *tlsbase;
663 struct elf_xtensa_link_hash_table *ret;
664 bfd_size_type amt = sizeof (struct elf_xtensa_link_hash_table);
666 ret = bfd_zmalloc (amt);
670 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
671 elf_xtensa_link_hash_newfunc,
672 sizeof (struct elf_xtensa_link_hash_entry),
679 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
681 tlsbase = elf_link_hash_lookup (&ret->elf, "_TLS_MODULE_BASE_",
683 tlsbase->root.type = bfd_link_hash_new;
684 tlsbase->root.u.undef.abfd = NULL;
685 tlsbase->non_elf = 0;
686 ret->tlsbase = elf_xtensa_hash_entry (tlsbase);
687 ret->tlsbase->tls_type = GOT_UNKNOWN;
689 return &ret->elf.root;
692 /* Copy the extra info we tack onto an elf_link_hash_entry. */
695 elf_xtensa_copy_indirect_symbol (struct bfd_link_info *info,
696 struct elf_link_hash_entry *dir,
697 struct elf_link_hash_entry *ind)
699 struct elf_xtensa_link_hash_entry *edir, *eind;
701 edir = elf_xtensa_hash_entry (dir);
702 eind = elf_xtensa_hash_entry (ind);
704 if (ind->root.type == bfd_link_hash_indirect)
706 edir->tlsfunc_refcount += eind->tlsfunc_refcount;
707 eind->tlsfunc_refcount = 0;
709 if (dir->got.refcount <= 0)
711 edir->tls_type = eind->tls_type;
712 eind->tls_type = GOT_UNKNOWN;
716 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
719 static inline bfd_boolean
720 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry *h,
721 struct bfd_link_info *info)
723 /* Check if we should do dynamic things to this symbol. The
724 "ignore_protected" argument need not be set, because Xtensa code
725 does not require special handling of STV_PROTECTED to make function
726 pointer comparisons work properly. The PLT addresses are never
727 used for function pointers. */
729 return _bfd_elf_dynamic_symbol_p (h, info, 0);
734 property_table_compare (const void *ap, const void *bp)
736 const property_table_entry *a = (const property_table_entry *) ap;
737 const property_table_entry *b = (const property_table_entry *) bp;
739 if (a->address == b->address)
741 if (a->size != b->size)
742 return (a->size - b->size);
744 if ((a->flags & XTENSA_PROP_ALIGN) != (b->flags & XTENSA_PROP_ALIGN))
745 return ((b->flags & XTENSA_PROP_ALIGN)
746 - (a->flags & XTENSA_PROP_ALIGN));
748 if ((a->flags & XTENSA_PROP_ALIGN)
749 && (GET_XTENSA_PROP_ALIGNMENT (a->flags)
750 != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
751 return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
752 - GET_XTENSA_PROP_ALIGNMENT (b->flags));
754 if ((a->flags & XTENSA_PROP_UNREACHABLE)
755 != (b->flags & XTENSA_PROP_UNREACHABLE))
756 return ((b->flags & XTENSA_PROP_UNREACHABLE)
757 - (a->flags & XTENSA_PROP_UNREACHABLE));
759 return (a->flags - b->flags);
762 return (a->address - b->address);
767 property_table_matches (const void *ap, const void *bp)
769 const property_table_entry *a = (const property_table_entry *) ap;
770 const property_table_entry *b = (const property_table_entry *) bp;
772 /* Check if one entry overlaps with the other. */
773 if ((b->address >= a->address && b->address < (a->address + a->size))
774 || (a->address >= b->address && a->address < (b->address + b->size)))
777 return (a->address - b->address);
781 /* Get the literal table or property table entries for the given
782 section. Sets TABLE_P and returns the number of entries. On
783 error, returns a negative value. */
786 xtensa_read_table_entries (bfd *abfd,
788 property_table_entry **table_p,
789 const char *sec_name,
790 bfd_boolean output_addr)
792 asection *table_section;
793 bfd_size_type table_size = 0;
794 bfd_byte *table_data;
795 property_table_entry *blocks;
796 int blk, block_count;
797 bfd_size_type num_records;
798 Elf_Internal_Rela *internal_relocs, *irel, *rel_end;
799 bfd_vma section_addr, off;
800 flagword predef_flags;
801 bfd_size_type table_entry_size, section_limit;
804 || !(section->flags & SEC_ALLOC)
805 || (section->flags & SEC_DEBUGGING))
811 table_section = xtensa_get_property_section (section, sec_name);
813 table_size = table_section->size;
821 predef_flags = xtensa_get_property_predef_flags (table_section);
822 table_entry_size = 12;
824 table_entry_size -= 4;
826 num_records = table_size / table_entry_size;
827 table_data = retrieve_contents (abfd, table_section, TRUE);
828 blocks = (property_table_entry *)
829 bfd_malloc (num_records * sizeof (property_table_entry));
833 section_addr = section->output_section->vma + section->output_offset;
835 section_addr = section->vma;
837 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
838 if (internal_relocs && !table_section->reloc_done)
840 qsort (internal_relocs, table_section->reloc_count,
841 sizeof (Elf_Internal_Rela), internal_reloc_compare);
842 irel = internal_relocs;
847 section_limit = bfd_get_section_limit (abfd, section);
848 rel_end = internal_relocs + table_section->reloc_count;
850 for (off = 0; off < table_size; off += table_entry_size)
852 bfd_vma address = bfd_get_32 (abfd, table_data + off);
854 /* Skip any relocations before the current offset. This should help
855 avoid confusion caused by unexpected relocations for the preceding
858 (irel->r_offset < off
859 || (irel->r_offset == off
860 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_NONE)))
867 if (irel && irel->r_offset == off)
870 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
871 BFD_ASSERT (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32);
873 if (get_elf_r_symndx_section (abfd, r_symndx) != section)
876 sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
877 BFD_ASSERT (sym_off == 0);
878 address += (section_addr + sym_off + irel->r_addend);
882 if (address < section_addr
883 || address >= section_addr + section_limit)
887 blocks[block_count].address = address;
888 blocks[block_count].size = bfd_get_32 (abfd, table_data + off + 4);
890 blocks[block_count].flags = predef_flags;
892 blocks[block_count].flags = bfd_get_32 (abfd, table_data + off + 8);
896 release_contents (table_section, table_data);
897 release_internal_relocs (table_section, internal_relocs);
901 /* Now sort them into address order for easy reference. */
902 qsort (blocks, block_count, sizeof (property_table_entry),
903 property_table_compare);
905 /* Check that the table contents are valid. Problems may occur,
906 for example, if an unrelocated object file is stripped. */
907 for (blk = 1; blk < block_count; blk++)
909 /* The only circumstance where two entries may legitimately
910 have the same address is when one of them is a zero-size
911 placeholder to mark a place where fill can be inserted.
912 The zero-size entry should come first. */
913 if (blocks[blk - 1].address == blocks[blk].address &&
914 blocks[blk - 1].size != 0)
916 (*_bfd_error_handler) (_("%B(%A): invalid property table"),
918 bfd_set_error (bfd_error_bad_value);
930 static property_table_entry *
931 elf_xtensa_find_property_entry (property_table_entry *property_table,
932 int property_table_size,
935 property_table_entry entry;
936 property_table_entry *rv;
938 if (property_table_size == 0)
941 entry.address = addr;
945 rv = bsearch (&entry, property_table, property_table_size,
946 sizeof (property_table_entry), property_table_matches);
952 elf_xtensa_in_literal_pool (property_table_entry *lit_table,
956 if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
963 /* Look through the relocs for a section during the first phase, and
964 calculate needed space in the dynamic reloc sections. */
967 elf_xtensa_check_relocs (bfd *abfd,
968 struct bfd_link_info *info,
970 const Elf_Internal_Rela *relocs)
972 struct elf_xtensa_link_hash_table *htab;
973 Elf_Internal_Shdr *symtab_hdr;
974 struct elf_link_hash_entry **sym_hashes;
975 const Elf_Internal_Rela *rel;
976 const Elf_Internal_Rela *rel_end;
978 if (bfd_link_relocatable (info) || (sec->flags & SEC_ALLOC) == 0)
981 BFD_ASSERT (is_xtensa_elf (abfd));
983 htab = elf_xtensa_hash_table (info);
987 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
988 sym_hashes = elf_sym_hashes (abfd);
990 rel_end = relocs + sec->reloc_count;
991 for (rel = relocs; rel < rel_end; rel++)
994 unsigned long r_symndx;
995 struct elf_link_hash_entry *h = NULL;
996 struct elf_xtensa_link_hash_entry *eh;
997 int tls_type, old_tls_type;
998 bfd_boolean is_got = FALSE;
999 bfd_boolean is_plt = FALSE;
1000 bfd_boolean is_tlsfunc = FALSE;
1002 r_symndx = ELF32_R_SYM (rel->r_info);
1003 r_type = ELF32_R_TYPE (rel->r_info);
1005 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1007 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1012 if (r_symndx >= symtab_hdr->sh_info)
1014 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1015 while (h->root.type == bfd_link_hash_indirect
1016 || h->root.type == bfd_link_hash_warning)
1017 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1019 /* PR15323, ref flags aren't set for references in the same
1021 h->root.non_ir_ref = 1;
1023 eh = elf_xtensa_hash_entry (h);
1027 case R_XTENSA_TLSDESC_FN:
1028 if (bfd_link_pic (info))
1030 tls_type = GOT_TLS_GD;
1035 tls_type = GOT_TLS_IE;
1038 case R_XTENSA_TLSDESC_ARG:
1039 if (bfd_link_pic (info))
1041 tls_type = GOT_TLS_GD;
1046 tls_type = GOT_TLS_IE;
1047 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1052 case R_XTENSA_TLS_DTPOFF:
1053 if (bfd_link_pic (info))
1054 tls_type = GOT_TLS_GD;
1056 tls_type = GOT_TLS_IE;
1059 case R_XTENSA_TLS_TPOFF:
1060 tls_type = GOT_TLS_IE;
1061 if (bfd_link_pic (info))
1062 info->flags |= DF_STATIC_TLS;
1063 if (bfd_link_pic (info) || h)
1068 tls_type = GOT_NORMAL;
1073 tls_type = GOT_NORMAL;
1077 case R_XTENSA_GNU_VTINHERIT:
1078 /* This relocation describes the C++ object vtable hierarchy.
1079 Reconstruct it for later use during GC. */
1080 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1084 case R_XTENSA_GNU_VTENTRY:
1085 /* This relocation describes which C++ vtable entries are actually
1086 used. Record for later use during GC. */
1087 BFD_ASSERT (h != NULL);
1089 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1094 /* Nothing to do for any other relocations. */
1102 if (h->plt.refcount <= 0)
1105 h->plt.refcount = 1;
1108 h->plt.refcount += 1;
1110 /* Keep track of the total PLT relocation count even if we
1111 don't yet know whether the dynamic sections will be
1113 htab->plt_reloc_count += 1;
1115 if (elf_hash_table (info)->dynamic_sections_created)
1117 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1123 if (h->got.refcount <= 0)
1124 h->got.refcount = 1;
1126 h->got.refcount += 1;
1130 eh->tlsfunc_refcount += 1;
1132 old_tls_type = eh->tls_type;
1136 /* Allocate storage the first time. */
1137 if (elf_local_got_refcounts (abfd) == NULL)
1139 bfd_size_type size = symtab_hdr->sh_info;
1142 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1145 elf_local_got_refcounts (abfd) = (bfd_signed_vma *) mem;
1147 mem = bfd_zalloc (abfd, size);
1150 elf_xtensa_local_got_tls_type (abfd) = (char *) mem;
1152 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1155 elf_xtensa_local_tlsfunc_refcounts (abfd)
1156 = (bfd_signed_vma *) mem;
1159 /* This is a global offset table entry for a local symbol. */
1160 if (is_got || is_plt)
1161 elf_local_got_refcounts (abfd) [r_symndx] += 1;
1164 elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx] += 1;
1166 old_tls_type = elf_xtensa_local_got_tls_type (abfd) [r_symndx];
1169 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1170 tls_type |= old_tls_type;
1171 /* If a TLS symbol is accessed using IE at least once,
1172 there is no point to use a dynamic model for it. */
1173 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1174 && ((old_tls_type & GOT_TLS_GD) == 0
1175 || (tls_type & GOT_TLS_IE) == 0))
1177 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_GD))
1178 tls_type = old_tls_type;
1179 else if ((old_tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_GD))
1180 tls_type |= old_tls_type;
1183 (*_bfd_error_handler)
1184 (_("%B: `%s' accessed both as normal and thread local symbol"),
1186 h ? h->root.root.string : "<local>");
1191 if (old_tls_type != tls_type)
1194 eh->tls_type = tls_type;
1196 elf_xtensa_local_got_tls_type (abfd) [r_symndx] = tls_type;
1205 elf_xtensa_make_sym_local (struct bfd_link_info *info,
1206 struct elf_link_hash_entry *h)
1208 if (bfd_link_pic (info))
1210 if (h->plt.refcount > 0)
1212 /* For shared objects, there's no need for PLT entries for local
1213 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1214 if (h->got.refcount < 0)
1215 h->got.refcount = 0;
1216 h->got.refcount += h->plt.refcount;
1217 h->plt.refcount = 0;
1222 /* Don't need any dynamic relocations at all. */
1223 h->plt.refcount = 0;
1224 h->got.refcount = 0;
1230 elf_xtensa_hide_symbol (struct bfd_link_info *info,
1231 struct elf_link_hash_entry *h,
1232 bfd_boolean force_local)
1234 /* For a shared link, move the plt refcount to the got refcount to leave
1235 space for RELATIVE relocs. */
1236 elf_xtensa_make_sym_local (info, h);
1238 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
1242 /* Return the section that should be marked against GC for a given
1246 elf_xtensa_gc_mark_hook (asection *sec,
1247 struct bfd_link_info *info,
1248 Elf_Internal_Rela *rel,
1249 struct elf_link_hash_entry *h,
1250 Elf_Internal_Sym *sym)
1252 /* Property sections are marked "KEEP" in the linker scripts, but they
1253 should not cause other sections to be marked. (This approach relies
1254 on elf_xtensa_discard_info to remove property table entries that
1255 describe discarded sections. Alternatively, it might be more
1256 efficient to avoid using "KEEP" in the linker scripts and instead use
1257 the gc_mark_extra_sections hook to mark only the property sections
1258 that describe marked sections. That alternative does not work well
1259 with the current property table sections, which do not correspond
1260 one-to-one with the sections they describe, but that should be fixed
1262 if (xtensa_is_property_section (sec))
1266 switch (ELF32_R_TYPE (rel->r_info))
1268 case R_XTENSA_GNU_VTINHERIT:
1269 case R_XTENSA_GNU_VTENTRY:
1273 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1277 /* Update the GOT & PLT entry reference counts
1278 for the section being removed. */
1281 elf_xtensa_gc_sweep_hook (bfd *abfd,
1282 struct bfd_link_info *info,
1284 const Elf_Internal_Rela *relocs)
1286 Elf_Internal_Shdr *symtab_hdr;
1287 struct elf_link_hash_entry **sym_hashes;
1288 const Elf_Internal_Rela *rel, *relend;
1289 struct elf_xtensa_link_hash_table *htab;
1291 htab = elf_xtensa_hash_table (info);
1295 if (bfd_link_relocatable (info))
1298 if ((sec->flags & SEC_ALLOC) == 0)
1301 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1302 sym_hashes = elf_sym_hashes (abfd);
1304 relend = relocs + sec->reloc_count;
1305 for (rel = relocs; rel < relend; rel++)
1307 unsigned long r_symndx;
1308 unsigned int r_type;
1309 struct elf_link_hash_entry *h = NULL;
1310 struct elf_xtensa_link_hash_entry *eh;
1311 bfd_boolean is_got = FALSE;
1312 bfd_boolean is_plt = FALSE;
1313 bfd_boolean is_tlsfunc = FALSE;
1315 r_symndx = ELF32_R_SYM (rel->r_info);
1316 if (r_symndx >= symtab_hdr->sh_info)
1318 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1319 while (h->root.type == bfd_link_hash_indirect
1320 || h->root.type == bfd_link_hash_warning)
1321 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1323 eh = elf_xtensa_hash_entry (h);
1325 r_type = ELF32_R_TYPE (rel->r_info);
1328 case R_XTENSA_TLSDESC_FN:
1329 if (bfd_link_pic (info))
1336 case R_XTENSA_TLSDESC_ARG:
1337 if (bfd_link_pic (info))
1341 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1346 case R_XTENSA_TLS_TPOFF:
1347 if (bfd_link_pic (info) || h)
1367 /* If the symbol has been localized its plt.refcount got moved
1368 to got.refcount. Handle it as GOT. */
1369 if (h->plt.refcount > 0)
1376 if (h->got.refcount > 0)
1381 if (eh->tlsfunc_refcount > 0)
1382 eh->tlsfunc_refcount--;
1387 if (is_got || is_plt)
1389 bfd_signed_vma *got_refcount
1390 = &elf_local_got_refcounts (abfd) [r_symndx];
1391 if (*got_refcount > 0)
1396 bfd_signed_vma *tlsfunc_refcount
1397 = &elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx];
1398 if (*tlsfunc_refcount > 0)
1399 *tlsfunc_refcount -= 1;
1408 /* Create all the dynamic sections. */
1411 elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1413 struct elf_xtensa_link_hash_table *htab;
1414 flagword flags, noalloc_flags;
1416 htab = elf_xtensa_hash_table (info);
1420 /* First do all the standard stuff. */
1421 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
1423 htab->splt = bfd_get_linker_section (dynobj, ".plt");
1424 htab->srelplt = bfd_get_linker_section (dynobj, ".rela.plt");
1425 htab->sgot = bfd_get_linker_section (dynobj, ".got");
1426 htab->sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
1427 htab->srelgot = bfd_get_linker_section (dynobj, ".rela.got");
1429 /* Create any extra PLT sections in case check_relocs has already
1430 been called on all the non-dynamic input files. */
1431 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1434 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
1435 | SEC_LINKER_CREATED | SEC_READONLY);
1436 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
1438 /* Mark the ".got.plt" section READONLY. */
1439 if (htab->sgotplt == NULL
1440 || ! bfd_set_section_flags (dynobj, htab->sgotplt, flags))
1443 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1444 htab->sgotloc = bfd_make_section_anyway_with_flags (dynobj, ".got.loc",
1446 if (htab->sgotloc == NULL
1447 || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
1450 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1451 htab->spltlittbl = bfd_make_section_anyway_with_flags (dynobj, ".xt.lit.plt",
1453 if (htab->spltlittbl == NULL
1454 || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
1462 add_extra_plt_sections (struct bfd_link_info *info, int count)
1464 bfd *dynobj = elf_hash_table (info)->dynobj;
1467 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1468 ".got.plt" sections. */
1469 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1475 /* Stop when we find a section has already been created. */
1476 if (elf_xtensa_get_plt_section (info, chunk))
1479 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1480 | SEC_LINKER_CREATED | SEC_READONLY);
1482 sname = (char *) bfd_malloc (10);
1483 sprintf (sname, ".plt.%u", chunk);
1484 s = bfd_make_section_anyway_with_flags (dynobj, sname, flags | SEC_CODE);
1486 || ! bfd_set_section_alignment (dynobj, s, 2))
1489 sname = (char *) bfd_malloc (14);
1490 sprintf (sname, ".got.plt.%u", chunk);
1491 s = bfd_make_section_anyway_with_flags (dynobj, sname, flags);
1493 || ! bfd_set_section_alignment (dynobj, s, 2))
1501 /* Adjust a symbol defined by a dynamic object and referenced by a
1502 regular object. The current definition is in some section of the
1503 dynamic object, but we're not including those sections. We have to
1504 change the definition to something the rest of the link can
1508 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1509 struct elf_link_hash_entry *h)
1511 /* If this is a weak symbol, and there is a real definition, the
1512 processor independent code will have arranged for us to see the
1513 real definition first, and we can just use the same value. */
1516 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1517 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1518 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1519 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1523 /* This is a reference to a symbol defined by a dynamic object. The
1524 reference must go through the GOT, so there's no need for COPY relocs,
1532 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry *h, void *arg)
1534 struct bfd_link_info *info;
1535 struct elf_xtensa_link_hash_table *htab;
1536 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (h);
1538 if (h->root.type == bfd_link_hash_indirect)
1541 info = (struct bfd_link_info *) arg;
1542 htab = elf_xtensa_hash_table (info);
1546 /* If we saw any use of an IE model for this symbol, we can then optimize
1547 away GOT entries for any TLSDESC_FN relocs. */
1548 if ((eh->tls_type & GOT_TLS_IE) != 0)
1550 BFD_ASSERT (h->got.refcount >= eh->tlsfunc_refcount);
1551 h->got.refcount -= eh->tlsfunc_refcount;
1554 if (! elf_xtensa_dynamic_symbol_p (h, info))
1555 elf_xtensa_make_sym_local (info, h);
1557 if (h->plt.refcount > 0)
1558 htab->srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1560 if (h->got.refcount > 0)
1561 htab->srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
1568 elf_xtensa_allocate_local_got_size (struct bfd_link_info *info)
1570 struct elf_xtensa_link_hash_table *htab;
1573 htab = elf_xtensa_hash_table (info);
1577 for (i = info->input_bfds; i; i = i->link.next)
1579 bfd_signed_vma *local_got_refcounts;
1580 bfd_size_type j, cnt;
1581 Elf_Internal_Shdr *symtab_hdr;
1583 local_got_refcounts = elf_local_got_refcounts (i);
1584 if (!local_got_refcounts)
1587 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1588 cnt = symtab_hdr->sh_info;
1590 for (j = 0; j < cnt; ++j)
1592 /* If we saw any use of an IE model for this symbol, we can
1593 then optimize away GOT entries for any TLSDESC_FN relocs. */
1594 if ((elf_xtensa_local_got_tls_type (i) [j] & GOT_TLS_IE) != 0)
1596 bfd_signed_vma *tlsfunc_refcount
1597 = &elf_xtensa_local_tlsfunc_refcounts (i) [j];
1598 BFD_ASSERT (local_got_refcounts[j] >= *tlsfunc_refcount);
1599 local_got_refcounts[j] -= *tlsfunc_refcount;
1602 if (local_got_refcounts[j] > 0)
1603 htab->srelgot->size += (local_got_refcounts[j]
1604 * sizeof (Elf32_External_Rela));
1610 /* Set the sizes of the dynamic sections. */
1613 elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1614 struct bfd_link_info *info)
1616 struct elf_xtensa_link_hash_table *htab;
1618 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1619 bfd_boolean relplt, relgot;
1620 int plt_entries, plt_chunks, chunk;
1625 htab = elf_xtensa_hash_table (info);
1629 dynobj = elf_hash_table (info)->dynobj;
1632 srelgot = htab->srelgot;
1633 srelplt = htab->srelplt;
1635 if (elf_hash_table (info)->dynamic_sections_created)
1637 BFD_ASSERT (htab->srelgot != NULL
1638 && htab->srelplt != NULL
1639 && htab->sgot != NULL
1640 && htab->spltlittbl != NULL
1641 && htab->sgotloc != NULL);
1643 /* Set the contents of the .interp section to the interpreter. */
1644 if (bfd_link_executable (info) && !info->nointerp)
1646 s = bfd_get_linker_section (dynobj, ".interp");
1649 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1650 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1653 /* Allocate room for one word in ".got". */
1654 htab->sgot->size = 4;
1656 /* Allocate space in ".rela.got" for literals that reference global
1657 symbols and space in ".rela.plt" for literals that have PLT
1659 elf_link_hash_traverse (elf_hash_table (info),
1660 elf_xtensa_allocate_dynrelocs,
1663 /* If we are generating a shared object, we also need space in
1664 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1665 reference local symbols. */
1666 if (bfd_link_pic (info))
1667 elf_xtensa_allocate_local_got_size (info);
1669 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1670 each PLT entry, we need the PLT code plus a 4-byte literal.
1671 For each chunk of ".plt", we also need two more 4-byte
1672 literals, two corresponding entries in ".rela.got", and an
1673 8-byte entry in ".xt.lit.plt". */
1674 spltlittbl = htab->spltlittbl;
1675 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
1677 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1679 /* Iterate over all the PLT chunks, including any extra sections
1680 created earlier because the initial count of PLT relocations
1681 was an overestimate. */
1683 (splt = elf_xtensa_get_plt_section (info, chunk)) != NULL;
1688 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
1689 BFD_ASSERT (sgotplt != NULL);
1691 if (chunk < plt_chunks - 1)
1692 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1693 else if (chunk == plt_chunks - 1)
1694 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1698 if (chunk_entries != 0)
1700 sgotplt->size = 4 * (chunk_entries + 2);
1701 splt->size = PLT_ENTRY_SIZE * chunk_entries;
1702 srelgot->size += 2 * sizeof (Elf32_External_Rela);
1703 spltlittbl->size += 8;
1712 /* Allocate space in ".got.loc" to match the total size of all the
1714 sgotloc = htab->sgotloc;
1715 sgotloc->size = spltlittbl->size;
1716 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
1718 if (abfd->flags & DYNAMIC)
1720 for (s = abfd->sections; s != NULL; s = s->next)
1722 if (! discarded_section (s)
1723 && xtensa_is_littable_section (s)
1725 sgotloc->size += s->size;
1730 /* Allocate memory for dynamic sections. */
1733 for (s = dynobj->sections; s != NULL; s = s->next)
1737 if ((s->flags & SEC_LINKER_CREATED) == 0)
1740 /* It's OK to base decisions on the section name, because none
1741 of the dynobj section names depend upon the input files. */
1742 name = bfd_get_section_name (dynobj, s);
1744 if (CONST_STRNEQ (name, ".rela"))
1748 if (strcmp (name, ".rela.plt") == 0)
1750 else if (strcmp (name, ".rela.got") == 0)
1753 /* We use the reloc_count field as a counter if we need
1754 to copy relocs into the output file. */
1758 else if (! CONST_STRNEQ (name, ".plt.")
1759 && ! CONST_STRNEQ (name, ".got.plt.")
1760 && strcmp (name, ".got") != 0
1761 && strcmp (name, ".plt") != 0
1762 && strcmp (name, ".got.plt") != 0
1763 && strcmp (name, ".xt.lit.plt") != 0
1764 && strcmp (name, ".got.loc") != 0)
1766 /* It's not one of our sections, so don't allocate space. */
1772 /* If we don't need this section, strip it from the output
1773 file. We must create the ".plt*" and ".got.plt*"
1774 sections in create_dynamic_sections and/or check_relocs
1775 based on a conservative estimate of the PLT relocation
1776 count, because the sections must be created before the
1777 linker maps input sections to output sections. The
1778 linker does that before size_dynamic_sections, where we
1779 compute the exact size of the PLT, so there may be more
1780 of these sections than are actually needed. */
1781 s->flags |= SEC_EXCLUDE;
1783 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
1785 /* Allocate memory for the section contents. */
1786 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1787 if (s->contents == NULL)
1792 if (elf_hash_table (info)->dynamic_sections_created)
1794 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1795 known until finish_dynamic_sections, but we need to get the relocs
1796 in place before they are sorted. */
1797 for (chunk = 0; chunk < plt_chunks; chunk++)
1799 Elf_Internal_Rela irela;
1803 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1806 loc = (srelgot->contents
1807 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1808 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1809 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1810 loc + sizeof (Elf32_External_Rela));
1811 srelgot->reloc_count += 2;
1814 /* Add some entries to the .dynamic section. We fill in the
1815 values later, in elf_xtensa_finish_dynamic_sections, but we
1816 must add the entries now so that we get the correct size for
1817 the .dynamic section. The DT_DEBUG entry is filled in by the
1818 dynamic linker and used by the debugger. */
1819 #define add_dynamic_entry(TAG, VAL) \
1820 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1822 if (bfd_link_executable (info))
1824 if (!add_dynamic_entry (DT_DEBUG, 0))
1830 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1831 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1832 || !add_dynamic_entry (DT_JMPREL, 0))
1838 if (!add_dynamic_entry (DT_RELA, 0)
1839 || !add_dynamic_entry (DT_RELASZ, 0)
1840 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1844 if (!add_dynamic_entry (DT_PLTGOT, 0)
1845 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1846 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1849 #undef add_dynamic_entry
1855 elf_xtensa_always_size_sections (bfd *output_bfd,
1856 struct bfd_link_info *info)
1858 struct elf_xtensa_link_hash_table *htab;
1861 htab = elf_xtensa_hash_table (info);
1865 tls_sec = htab->elf.tls_sec;
1867 if (tls_sec && (htab->tlsbase->tls_type & GOT_TLS_ANY) != 0)
1869 struct elf_link_hash_entry *tlsbase = &htab->tlsbase->elf;
1870 struct bfd_link_hash_entry *bh = &tlsbase->root;
1871 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
1873 tlsbase->type = STT_TLS;
1874 if (!(_bfd_generic_link_add_one_symbol
1875 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1876 tls_sec, 0, NULL, FALSE,
1877 bed->collect, &bh)))
1879 tlsbase->def_regular = 1;
1880 tlsbase->other = STV_HIDDEN;
1881 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1888 /* Return the base VMA address which should be subtracted from real addresses
1889 when resolving @dtpoff relocation.
1890 This is PT_TLS segment p_vaddr. */
1893 dtpoff_base (struct bfd_link_info *info)
1895 /* If tls_sec is NULL, we should have signalled an error already. */
1896 if (elf_hash_table (info)->tls_sec == NULL)
1898 return elf_hash_table (info)->tls_sec->vma;
1901 /* Return the relocation value for @tpoff relocation
1902 if STT_TLS virtual address is ADDRESS. */
1905 tpoff (struct bfd_link_info *info, bfd_vma address)
1907 struct elf_link_hash_table *htab = elf_hash_table (info);
1910 /* If tls_sec is NULL, we should have signalled an error already. */
1911 if (htab->tls_sec == NULL)
1913 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
1914 return address - htab->tls_sec->vma + base;
1917 /* Perform the specified relocation. The instruction at (contents + address)
1918 is modified to set one operand to represent the value in "relocation". The
1919 operand position is determined by the relocation type recorded in the
1922 #define CALL_SEGMENT_BITS (30)
1923 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1925 static bfd_reloc_status_type
1926 elf_xtensa_do_reloc (reloc_howto_type *howto,
1928 asection *input_section,
1932 bfd_boolean is_weak_undef,
1933 char **error_message)
1936 xtensa_opcode opcode;
1937 xtensa_isa isa = xtensa_default_isa;
1938 static xtensa_insnbuf ibuff = NULL;
1939 static xtensa_insnbuf sbuff = NULL;
1940 bfd_vma self_address;
1941 bfd_size_type input_size;
1947 ibuff = xtensa_insnbuf_alloc (isa);
1948 sbuff = xtensa_insnbuf_alloc (isa);
1951 input_size = bfd_get_section_limit (abfd, input_section);
1953 /* Calculate the PC address for this instruction. */
1954 self_address = (input_section->output_section->vma
1955 + input_section->output_offset
1958 switch (howto->type)
1961 case R_XTENSA_DIFF8:
1962 case R_XTENSA_DIFF16:
1963 case R_XTENSA_DIFF32:
1964 case R_XTENSA_TLS_FUNC:
1965 case R_XTENSA_TLS_ARG:
1966 case R_XTENSA_TLS_CALL:
1967 return bfd_reloc_ok;
1969 case R_XTENSA_ASM_EXPAND:
1972 /* Check for windowed CALL across a 1GB boundary. */
1973 opcode = get_expanded_call_opcode (contents + address,
1974 input_size - address, 0);
1975 if (is_windowed_call_opcode (opcode))
1977 if ((self_address >> CALL_SEGMENT_BITS)
1978 != (relocation >> CALL_SEGMENT_BITS))
1980 *error_message = "windowed longcall crosses 1GB boundary; "
1982 return bfd_reloc_dangerous;
1986 return bfd_reloc_ok;
1988 case R_XTENSA_ASM_SIMPLIFY:
1990 /* Convert the L32R/CALLX to CALL. */
1991 bfd_reloc_status_type retval =
1992 elf_xtensa_do_asm_simplify (contents, address, input_size,
1994 if (retval != bfd_reloc_ok)
1995 return bfd_reloc_dangerous;
1997 /* The CALL needs to be relocated. Continue below for that part. */
2000 howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
2007 x = bfd_get_32 (abfd, contents + address);
2009 bfd_put_32 (abfd, x, contents + address);
2011 return bfd_reloc_ok;
2013 case R_XTENSA_32_PCREL:
2014 bfd_put_32 (abfd, relocation - self_address, contents + address);
2015 return bfd_reloc_ok;
2018 case R_XTENSA_TLSDESC_FN:
2019 case R_XTENSA_TLSDESC_ARG:
2020 case R_XTENSA_TLS_DTPOFF:
2021 case R_XTENSA_TLS_TPOFF:
2022 bfd_put_32 (abfd, relocation, contents + address);
2023 return bfd_reloc_ok;
2026 /* Only instruction slot-specific relocations handled below.... */
2027 slot = get_relocation_slot (howto->type);
2028 if (slot == XTENSA_UNDEFINED)
2030 *error_message = "unexpected relocation";
2031 return bfd_reloc_dangerous;
2034 /* Read the instruction into a buffer and decode the opcode. */
2035 xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
2036 input_size - address);
2037 fmt = xtensa_format_decode (isa, ibuff);
2038 if (fmt == XTENSA_UNDEFINED)
2040 *error_message = "cannot decode instruction format";
2041 return bfd_reloc_dangerous;
2044 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
2046 opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
2047 if (opcode == XTENSA_UNDEFINED)
2049 *error_message = "cannot decode instruction opcode";
2050 return bfd_reloc_dangerous;
2053 /* Check for opcode-specific "alternate" relocations. */
2054 if (is_alt_relocation (howto->type))
2056 if (opcode == get_l32r_opcode ())
2058 /* Handle the special-case of non-PC-relative L32R instructions. */
2059 bfd *output_bfd = input_section->output_section->owner;
2060 asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
2063 *error_message = "relocation references missing .lit4 section";
2064 return bfd_reloc_dangerous;
2066 self_address = ((lit4_sec->vma & ~0xfff)
2067 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2068 newval = relocation;
2071 else if (opcode == get_const16_opcode ())
2073 /* ALT used for high 16 bits. */
2074 newval = relocation >> 16;
2079 /* No other "alternate" relocations currently defined. */
2080 *error_message = "unexpected relocation";
2081 return bfd_reloc_dangerous;
2084 else /* Not an "alternate" relocation.... */
2086 if (opcode == get_const16_opcode ())
2088 newval = relocation & 0xffff;
2093 /* ...normal PC-relative relocation.... */
2095 /* Determine which operand is being relocated. */
2096 opnd = get_relocation_opnd (opcode, howto->type);
2097 if (opnd == XTENSA_UNDEFINED)
2099 *error_message = "unexpected relocation";
2100 return bfd_reloc_dangerous;
2103 if (!howto->pc_relative)
2105 *error_message = "expected PC-relative relocation";
2106 return bfd_reloc_dangerous;
2109 newval = relocation;
2113 /* Apply the relocation. */
2114 if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
2115 || xtensa_operand_encode (isa, opcode, opnd, &newval)
2116 || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
2119 const char *opname = xtensa_opcode_name (isa, opcode);
2122 msg = "cannot encode";
2123 if (is_direct_call_opcode (opcode))
2125 if ((relocation & 0x3) != 0)
2126 msg = "misaligned call target";
2128 msg = "call target out of range";
2130 else if (opcode == get_l32r_opcode ())
2132 if ((relocation & 0x3) != 0)
2133 msg = "misaligned literal target";
2134 else if (is_alt_relocation (howto->type))
2135 msg = "literal target out of range (too many literals)";
2136 else if (self_address > relocation)
2137 msg = "literal target out of range (try using text-section-literals)";
2139 msg = "literal placed after use";
2142 *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
2143 return bfd_reloc_dangerous;
2146 /* Check for calls across 1GB boundaries. */
2147 if (is_direct_call_opcode (opcode)
2148 && is_windowed_call_opcode (opcode))
2150 if ((self_address >> CALL_SEGMENT_BITS)
2151 != (relocation >> CALL_SEGMENT_BITS))
2154 "windowed call crosses 1GB boundary; return may fail";
2155 return bfd_reloc_dangerous;
2159 /* Write the modified instruction back out of the buffer. */
2160 xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
2161 xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
2162 input_size - address);
2163 return bfd_reloc_ok;
2168 vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
2170 /* To reduce the size of the memory leak,
2171 we only use a single message buffer. */
2172 static bfd_size_type alloc_size = 0;
2173 static char *message = NULL;
2174 bfd_size_type orig_len, len = 0;
2175 bfd_boolean is_append;
2178 va_start (ap, arglen);
2180 is_append = (origmsg == message);
2182 orig_len = strlen (origmsg);
2183 len = orig_len + strlen (fmt) + arglen + 20;
2184 if (len > alloc_size)
2186 message = (char *) bfd_realloc_or_free (message, len);
2189 if (message != NULL)
2192 memcpy (message, origmsg, orig_len);
2193 vsprintf (message + orig_len, fmt, ap);
2200 /* This function is registered as the "special_function" in the
2201 Xtensa howto for handling simplify operations.
2202 bfd_perform_relocation / bfd_install_relocation use it to
2203 perform (install) the specified relocation. Since this replaces the code
2204 in bfd_perform_relocation, it is basically an Xtensa-specific,
2205 stripped-down version of bfd_perform_relocation. */
2207 static bfd_reloc_status_type
2208 bfd_elf_xtensa_reloc (bfd *abfd,
2209 arelent *reloc_entry,
2212 asection *input_section,
2214 char **error_message)
2217 bfd_reloc_status_type flag;
2218 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2219 bfd_vma output_base = 0;
2220 reloc_howto_type *howto = reloc_entry->howto;
2221 asection *reloc_target_output_section;
2222 bfd_boolean is_weak_undef;
2224 if (!xtensa_default_isa)
2225 xtensa_default_isa = xtensa_isa_init (0, 0);
2227 /* ELF relocs are against symbols. If we are producing relocatable
2228 output, and the reloc is against an external symbol, the resulting
2229 reloc will also be against the same symbol. In such a case, we
2230 don't want to change anything about the way the reloc is handled,
2231 since it will all be done at final link time. This test is similar
2232 to what bfd_elf_generic_reloc does except that it lets relocs with
2233 howto->partial_inplace go through even if the addend is non-zero.
2234 (The real problem is that partial_inplace is set for XTENSA_32
2235 relocs to begin with, but that's a long story and there's little we
2236 can do about it now....) */
2238 if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
2240 reloc_entry->address += input_section->output_offset;
2241 return bfd_reloc_ok;
2244 /* Is the address of the relocation really within the section? */
2245 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2246 return bfd_reloc_outofrange;
2248 /* Work out which section the relocation is targeted at and the
2249 initial relocation command value. */
2251 /* Get symbol value. (Common symbols are special.) */
2252 if (bfd_is_com_section (symbol->section))
2255 relocation = symbol->value;
2257 reloc_target_output_section = symbol->section->output_section;
2259 /* Convert input-section-relative symbol value to absolute. */
2260 if ((output_bfd && !howto->partial_inplace)
2261 || reloc_target_output_section == NULL)
2264 output_base = reloc_target_output_section->vma;
2266 relocation += output_base + symbol->section->output_offset;
2268 /* Add in supplied addend. */
2269 relocation += reloc_entry->addend;
2271 /* Here the variable relocation holds the final address of the
2272 symbol we are relocating against, plus any addend. */
2275 if (!howto->partial_inplace)
2277 /* This is a partial relocation, and we want to apply the relocation
2278 to the reloc entry rather than the raw data. Everything except
2279 relocations against section symbols has already been handled
2282 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
2283 reloc_entry->addend = relocation;
2284 reloc_entry->address += input_section->output_offset;
2285 return bfd_reloc_ok;
2289 reloc_entry->address += input_section->output_offset;
2290 reloc_entry->addend = 0;
2294 is_weak_undef = (bfd_is_und_section (symbol->section)
2295 && (symbol->flags & BSF_WEAK) != 0);
2296 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
2297 (bfd_byte *) data, (bfd_vma) octets,
2298 is_weak_undef, error_message);
2300 if (flag == bfd_reloc_dangerous)
2302 /* Add the symbol name to the error message. */
2303 if (! *error_message)
2304 *error_message = "";
2305 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
2306 strlen (symbol->name) + 17,
2308 (unsigned long) reloc_entry->addend);
2315 /* Set up an entry in the procedure linkage table. */
2318 elf_xtensa_create_plt_entry (struct bfd_link_info *info,
2320 unsigned reloc_index)
2322 asection *splt, *sgotplt;
2323 bfd_vma plt_base, got_base;
2324 bfd_vma code_offset, lit_offset, abi_offset;
2327 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
2328 splt = elf_xtensa_get_plt_section (info, chunk);
2329 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
2330 BFD_ASSERT (splt != NULL && sgotplt != NULL);
2332 plt_base = splt->output_section->vma + splt->output_offset;
2333 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
2335 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
2336 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
2338 /* Fill in the literal entry. This is the offset of the dynamic
2339 relocation entry. */
2340 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
2341 sgotplt->contents + lit_offset);
2343 /* Fill in the entry in the procedure linkage table. */
2344 memcpy (splt->contents + code_offset,
2345 (bfd_big_endian (output_bfd)
2346 ? elf_xtensa_be_plt_entry
2347 : elf_xtensa_le_plt_entry),
2349 abi_offset = XSHAL_ABI == XTHAL_ABI_WINDOWED ? 3 : 0;
2350 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
2351 plt_base + code_offset + abi_offset),
2352 splt->contents + code_offset + abi_offset + 1);
2353 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
2354 plt_base + code_offset + abi_offset + 3),
2355 splt->contents + code_offset + abi_offset + 4);
2356 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
2357 plt_base + code_offset + abi_offset + 6),
2358 splt->contents + code_offset + abi_offset + 7);
2360 return plt_base + code_offset;
2364 static bfd_boolean get_indirect_call_dest_reg (xtensa_opcode, unsigned *);
2367 replace_tls_insn (Elf_Internal_Rela *rel,
2369 asection *input_section,
2371 bfd_boolean is_ld_model,
2372 char **error_message)
2374 static xtensa_insnbuf ibuff = NULL;
2375 static xtensa_insnbuf sbuff = NULL;
2376 xtensa_isa isa = xtensa_default_isa;
2378 xtensa_opcode old_op, new_op;
2379 bfd_size_type input_size;
2381 unsigned dest_reg, src_reg;
2385 ibuff = xtensa_insnbuf_alloc (isa);
2386 sbuff = xtensa_insnbuf_alloc (isa);
2389 input_size = bfd_get_section_limit (abfd, input_section);
2391 /* Read the instruction into a buffer and decode the opcode. */
2392 xtensa_insnbuf_from_chars (isa, ibuff, contents + rel->r_offset,
2393 input_size - rel->r_offset);
2394 fmt = xtensa_format_decode (isa, ibuff);
2395 if (fmt == XTENSA_UNDEFINED)
2397 *error_message = "cannot decode instruction format";
2401 BFD_ASSERT (xtensa_format_num_slots (isa, fmt) == 1);
2402 xtensa_format_get_slot (isa, fmt, 0, ibuff, sbuff);
2404 old_op = xtensa_opcode_decode (isa, fmt, 0, sbuff);
2405 if (old_op == XTENSA_UNDEFINED)
2407 *error_message = "cannot decode instruction opcode";
2411 r_type = ELF32_R_TYPE (rel->r_info);
2414 case R_XTENSA_TLS_FUNC:
2415 case R_XTENSA_TLS_ARG:
2416 if (old_op != get_l32r_opcode ()
2417 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2418 sbuff, &dest_reg) != 0)
2420 *error_message = "cannot extract L32R destination for TLS access";
2425 case R_XTENSA_TLS_CALL:
2426 if (! get_indirect_call_dest_reg (old_op, &dest_reg)
2427 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2428 sbuff, &src_reg) != 0)
2430 *error_message = "cannot extract CALLXn operands for TLS access";
2443 case R_XTENSA_TLS_FUNC:
2444 case R_XTENSA_TLS_ARG:
2445 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2446 versions of Xtensa). */
2447 new_op = xtensa_opcode_lookup (isa, "nop");
2448 if (new_op == XTENSA_UNDEFINED)
2450 new_op = xtensa_opcode_lookup (isa, "or");
2451 if (new_op == XTENSA_UNDEFINED
2452 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2453 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2455 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2457 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2460 *error_message = "cannot encode OR for TLS access";
2466 if (xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0)
2468 *error_message = "cannot encode NOP for TLS access";
2474 case R_XTENSA_TLS_CALL:
2475 /* Read THREADPTR into the CALLX's return value register. */
2476 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2477 if (new_op == XTENSA_UNDEFINED
2478 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2479 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2480 sbuff, dest_reg + 2) != 0)
2482 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2492 case R_XTENSA_TLS_FUNC:
2493 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2494 if (new_op == XTENSA_UNDEFINED
2495 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2496 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2497 sbuff, dest_reg) != 0)
2499 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2504 case R_XTENSA_TLS_ARG:
2505 /* Nothing to do. Keep the original L32R instruction. */
2508 case R_XTENSA_TLS_CALL:
2509 /* Add the CALLX's src register (holding the THREADPTR value)
2510 to the first argument register (holding the offset) and put
2511 the result in the CALLX's return value register. */
2512 new_op = xtensa_opcode_lookup (isa, "add");
2513 if (new_op == XTENSA_UNDEFINED
2514 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2515 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2516 sbuff, dest_reg + 2) != 0
2517 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2518 sbuff, dest_reg + 2) != 0
2519 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2520 sbuff, src_reg) != 0)
2522 *error_message = "cannot encode ADD for TLS access";
2529 xtensa_format_set_slot (isa, fmt, 0, ibuff, sbuff);
2530 xtensa_insnbuf_to_chars (isa, ibuff, contents + rel->r_offset,
2531 input_size - rel->r_offset);
2537 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2538 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2539 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2540 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2541 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2542 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2543 || (R_TYPE) == R_XTENSA_TLS_ARG \
2544 || (R_TYPE) == R_XTENSA_TLS_CALL)
2546 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2547 both relocatable and final links. */
2550 elf_xtensa_relocate_section (bfd *output_bfd,
2551 struct bfd_link_info *info,
2553 asection *input_section,
2555 Elf_Internal_Rela *relocs,
2556 Elf_Internal_Sym *local_syms,
2557 asection **local_sections)
2559 struct elf_xtensa_link_hash_table *htab;
2560 Elf_Internal_Shdr *symtab_hdr;
2561 Elf_Internal_Rela *rel;
2562 Elf_Internal_Rela *relend;
2563 struct elf_link_hash_entry **sym_hashes;
2564 property_table_entry *lit_table = 0;
2566 char *local_got_tls_types;
2567 char *error_message = NULL;
2568 bfd_size_type input_size;
2571 if (!xtensa_default_isa)
2572 xtensa_default_isa = xtensa_isa_init (0, 0);
2574 BFD_ASSERT (is_xtensa_elf (input_bfd));
2576 htab = elf_xtensa_hash_table (info);
2580 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2581 sym_hashes = elf_sym_hashes (input_bfd);
2582 local_got_tls_types = elf_xtensa_local_got_tls_type (input_bfd);
2584 if (elf_hash_table (info)->dynamic_sections_created)
2586 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
2587 &lit_table, XTENSA_LIT_SEC_NAME,
2593 input_size = bfd_get_section_limit (input_bfd, input_section);
2596 relend = relocs + input_section->reloc_count;
2597 for (; rel < relend; rel++)
2600 reloc_howto_type *howto;
2601 unsigned long r_symndx;
2602 struct elf_link_hash_entry *h;
2603 Elf_Internal_Sym *sym;
2608 bfd_reloc_status_type r;
2609 bfd_boolean is_weak_undef;
2610 bfd_boolean unresolved_reloc;
2612 bfd_boolean dynamic_symbol;
2614 r_type = ELF32_R_TYPE (rel->r_info);
2615 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2616 || r_type == (int) R_XTENSA_GNU_VTENTRY)
2619 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2621 bfd_set_error (bfd_error_bad_value);
2624 howto = &elf_howto_table[r_type];
2626 r_symndx = ELF32_R_SYM (rel->r_info);
2631 is_weak_undef = FALSE;
2632 unresolved_reloc = FALSE;
2635 if (howto->partial_inplace && !bfd_link_relocatable (info))
2637 /* Because R_XTENSA_32 was made partial_inplace to fix some
2638 problems with DWARF info in partial links, there may be
2639 an addend stored in the contents. Take it out of there
2640 and move it back into the addend field of the reloc. */
2641 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2642 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2645 if (r_symndx < symtab_hdr->sh_info)
2647 sym = local_syms + r_symndx;
2648 sym_type = ELF32_ST_TYPE (sym->st_info);
2649 sec = local_sections[r_symndx];
2650 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2654 bfd_boolean ignored;
2656 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2657 r_symndx, symtab_hdr, sym_hashes,
2659 unresolved_reloc, warned, ignored);
2662 && !unresolved_reloc
2663 && h->root.type == bfd_link_hash_undefweak)
2664 is_weak_undef = TRUE;
2669 if (sec != NULL && discarded_section (sec))
2670 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2671 rel, 1, relend, howto, 0, contents);
2673 if (bfd_link_relocatable (info))
2676 asection * sym_sec = get_elf_r_symndx_section (input_bfd, r_symndx);
2678 /* This is a relocatable link.
2679 1) If the reloc is against a section symbol, adjust
2680 according to the output section.
2681 2) If there is a new target for this relocation,
2682 the new target will be in the same output section.
2683 We adjust the relocation by the output section
2686 if (relaxing_section)
2688 /* Check if this references a section in another input file. */
2689 if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2694 dest_addr = sym_sec->output_section->vma + sym_sec->output_offset
2695 + get_elf_r_symndx_offset (input_bfd, r_symndx) + rel->r_addend;
2697 if (r_type == R_XTENSA_ASM_SIMPLIFY)
2699 error_message = NULL;
2700 /* Convert ASM_SIMPLIFY into the simpler relocation
2701 so that they never escape a relaxing link. */
2702 r = contract_asm_expansion (contents, input_size, rel,
2704 if (r != bfd_reloc_ok)
2706 if (!((*info->callbacks->reloc_dangerous)
2707 (info, error_message, input_bfd, input_section,
2711 r_type = ELF32_R_TYPE (rel->r_info);
2714 /* This is a relocatable link, so we don't have to change
2715 anything unless the reloc is against a section symbol,
2716 in which case we have to adjust according to where the
2717 section symbol winds up in the output section. */
2718 if (r_symndx < symtab_hdr->sh_info)
2720 sym = local_syms + r_symndx;
2721 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2723 sec = local_sections[r_symndx];
2724 rel->r_addend += sec->output_offset + sym->st_value;
2728 /* If there is an addend with a partial_inplace howto,
2729 then move the addend to the contents. This is a hack
2730 to work around problems with DWARF in relocatable links
2731 with some previous version of BFD. Now we can't easily get
2732 rid of the hack without breaking backward compatibility.... */
2734 howto = &elf_howto_table[r_type];
2735 if (howto->partial_inplace && rel->r_addend)
2737 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2738 rel->r_addend, contents,
2739 rel->r_offset, FALSE,
2745 /* Put the correct bits in the target instruction, even
2746 though the relocation will still be present in the output
2747 file. This makes disassembly clearer, as well as
2748 allowing loadable kernel modules to work without needing
2749 relocations on anything other than calls and l32r's. */
2751 /* If it is not in the same section, there is nothing we can do. */
2752 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP &&
2753 sym_sec->output_section == input_section->output_section)
2755 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2756 dest_addr, contents,
2757 rel->r_offset, FALSE,
2761 if (r != bfd_reloc_ok)
2763 if (!((*info->callbacks->reloc_dangerous)
2764 (info, error_message, input_bfd, input_section,
2769 /* Done with work for relocatable link; continue with next reloc. */
2773 /* This is a final link. */
2775 if (relaxing_section)
2777 /* Check if this references a section in another input file. */
2778 do_fix_for_final_link (rel, input_bfd, input_section, contents,
2782 /* Sanity check the address. */
2783 if (rel->r_offset >= input_size
2784 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2786 (*_bfd_error_handler)
2787 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2788 input_bfd, input_section, rel->r_offset, input_size);
2789 bfd_set_error (bfd_error_bad_value);
2794 name = h->root.root.string;
2797 name = (bfd_elf_string_from_elf_section
2798 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2799 if (name == NULL || *name == '\0')
2800 name = bfd_section_name (input_bfd, sec);
2803 if (r_symndx != STN_UNDEF
2804 && r_type != R_XTENSA_NONE
2806 || h->root.type == bfd_link_hash_defined
2807 || h->root.type == bfd_link_hash_defweak)
2808 && IS_XTENSA_TLS_RELOC (r_type) != (sym_type == STT_TLS))
2810 (*_bfd_error_handler)
2811 ((sym_type == STT_TLS
2812 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
2813 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
2816 (long) rel->r_offset,
2821 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
2823 tls_type = GOT_UNKNOWN;
2825 tls_type = elf_xtensa_hash_entry (h)->tls_type;
2826 else if (local_got_tls_types)
2827 tls_type = local_got_tls_types [r_symndx];
2833 if (elf_hash_table (info)->dynamic_sections_created
2834 && (input_section->flags & SEC_ALLOC) != 0
2835 && (dynamic_symbol || bfd_link_pic (info)))
2837 Elf_Internal_Rela outrel;
2841 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2842 srel = htab->srelplt;
2844 srel = htab->srelgot;
2846 BFD_ASSERT (srel != NULL);
2849 _bfd_elf_section_offset (output_bfd, info,
2850 input_section, rel->r_offset);
2852 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2853 memset (&outrel, 0, sizeof outrel);
2856 outrel.r_offset += (input_section->output_section->vma
2857 + input_section->output_offset);
2859 /* Complain if the relocation is in a read-only section
2860 and not in a literal pool. */
2861 if ((input_section->flags & SEC_READONLY) != 0
2862 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
2866 _("dynamic relocation in read-only section");
2867 if (!((*info->callbacks->reloc_dangerous)
2868 (info, error_message, input_bfd, input_section,
2875 outrel.r_addend = rel->r_addend;
2878 if (r_type == R_XTENSA_32)
2881 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2884 else /* r_type == R_XTENSA_PLT */
2887 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2889 /* Create the PLT entry and set the initial
2890 contents of the literal entry to the address of
2893 elf_xtensa_create_plt_entry (info, output_bfd,
2896 unresolved_reloc = FALSE;
2900 /* Generate a RELATIVE relocation. */
2901 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2902 outrel.r_addend = 0;
2906 loc = (srel->contents
2907 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2908 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2909 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2912 else if (r_type == R_XTENSA_ASM_EXPAND && dynamic_symbol)
2914 /* This should only happen for non-PIC code, which is not
2915 supposed to be used on systems with dynamic linking.
2916 Just ignore these relocations. */
2921 case R_XTENSA_TLS_TPOFF:
2922 /* Switch to LE model for local symbols in an executable. */
2923 if (! bfd_link_pic (info) && ! dynamic_symbol)
2925 relocation = tpoff (info, relocation);
2930 case R_XTENSA_TLSDESC_FN:
2931 case R_XTENSA_TLSDESC_ARG:
2933 if (r_type == R_XTENSA_TLSDESC_FN)
2935 if (! bfd_link_pic (info) || (tls_type & GOT_TLS_IE) != 0)
2936 r_type = R_XTENSA_NONE;
2938 else if (r_type == R_XTENSA_TLSDESC_ARG)
2940 if (bfd_link_pic (info))
2942 if ((tls_type & GOT_TLS_IE) != 0)
2943 r_type = R_XTENSA_TLS_TPOFF;
2947 r_type = R_XTENSA_TLS_TPOFF;
2948 if (! dynamic_symbol)
2950 relocation = tpoff (info, relocation);
2956 if (r_type == R_XTENSA_NONE)
2957 /* Nothing to do here; skip to the next reloc. */
2960 if (! elf_hash_table (info)->dynamic_sections_created)
2963 _("TLS relocation invalid without dynamic sections");
2964 if (!((*info->callbacks->reloc_dangerous)
2965 (info, error_message, input_bfd, input_section,
2971 Elf_Internal_Rela outrel;
2973 asection *srel = htab->srelgot;
2976 outrel.r_offset = (input_section->output_section->vma
2977 + input_section->output_offset
2980 /* Complain if the relocation is in a read-only section
2981 and not in a literal pool. */
2982 if ((input_section->flags & SEC_READONLY) != 0
2983 && ! elf_xtensa_in_literal_pool (lit_table, ltblsize,
2987 _("dynamic relocation in read-only section");
2988 if (!((*info->callbacks->reloc_dangerous)
2989 (info, error_message, input_bfd, input_section,
2994 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2996 outrel.r_addend = relocation - dtpoff_base (info);
2998 outrel.r_addend = 0;
3001 outrel.r_info = ELF32_R_INFO (indx, r_type);
3003 unresolved_reloc = FALSE;
3006 loc = (srel->contents
3007 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
3008 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3009 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
3015 case R_XTENSA_TLS_DTPOFF:
3016 if (! bfd_link_pic (info))
3017 /* Switch from LD model to LE model. */
3018 relocation = tpoff (info, relocation);
3020 relocation -= dtpoff_base (info);
3023 case R_XTENSA_TLS_FUNC:
3024 case R_XTENSA_TLS_ARG:
3025 case R_XTENSA_TLS_CALL:
3026 /* Check if optimizing to IE or LE model. */
3027 if ((tls_type & GOT_TLS_IE) != 0)
3029 bfd_boolean is_ld_model =
3030 (h && elf_xtensa_hash_entry (h) == htab->tlsbase);
3031 if (! replace_tls_insn (rel, input_bfd, input_section, contents,
3032 is_ld_model, &error_message))
3034 if (!((*info->callbacks->reloc_dangerous)
3035 (info, error_message, input_bfd, input_section,
3040 if (r_type != R_XTENSA_TLS_ARG || is_ld_model)
3042 /* Skip subsequent relocations on the same instruction. */
3043 while (rel + 1 < relend && rel[1].r_offset == rel->r_offset)
3050 if (elf_hash_table (info)->dynamic_sections_created
3051 && dynamic_symbol && (is_operand_relocation (r_type)
3052 || r_type == R_XTENSA_32_PCREL))
3055 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3056 strlen (name) + 2, name);
3057 if (!((*info->callbacks->reloc_dangerous)
3058 (info, error_message, input_bfd, input_section,
3066 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3067 because such sections are not SEC_ALLOC and thus ld.so will
3068 not process them. */
3069 if (unresolved_reloc
3070 && !((input_section->flags & SEC_DEBUGGING) != 0
3072 && _bfd_elf_section_offset (output_bfd, info, input_section,
3073 rel->r_offset) != (bfd_vma) -1)
3075 (*_bfd_error_handler)
3076 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3079 (long) rel->r_offset,
3085 /* TLS optimizations may have changed r_type; update "howto". */
3086 howto = &elf_howto_table[r_type];
3088 /* There's no point in calling bfd_perform_relocation here.
3089 Just go directly to our "special function". */
3090 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
3091 relocation + rel->r_addend,
3092 contents, rel->r_offset, is_weak_undef,
3095 if (r != bfd_reloc_ok && !warned)
3097 BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
3098 BFD_ASSERT (error_message != NULL);
3100 if (rel->r_addend == 0)
3101 error_message = vsprint_msg (error_message, ": %s",
3102 strlen (name) + 2, name);
3104 error_message = vsprint_msg (error_message, ": (%s+0x%x)",
3106 name, (int) rel->r_addend);
3108 if (!((*info->callbacks->reloc_dangerous)
3109 (info, error_message, input_bfd, input_section,
3118 input_section->reloc_done = TRUE;
3124 /* Finish up dynamic symbol handling. There's not much to do here since
3125 the PLT and GOT entries are all set up by relocate_section. */
3128 elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
3129 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3130 struct elf_link_hash_entry *h,
3131 Elf_Internal_Sym *sym)
3133 if (h->needs_plt && !h->def_regular)
3135 /* Mark the symbol as undefined, rather than as defined in
3136 the .plt section. Leave the value alone. */
3137 sym->st_shndx = SHN_UNDEF;
3138 /* If the symbol is weak, we do need to clear the value.
3139 Otherwise, the PLT entry would provide a definition for
3140 the symbol even if the symbol wasn't defined anywhere,
3141 and so the symbol would never be NULL. */
3142 if (!h->ref_regular_nonweak)
3146 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3147 if (h == elf_hash_table (info)->hdynamic
3148 || h == elf_hash_table (info)->hgot)
3149 sym->st_shndx = SHN_ABS;
3155 /* Combine adjacent literal table entries in the output. Adjacent
3156 entries within each input section may have been removed during
3157 relaxation, but we repeat the process here, even though it's too late
3158 to shrink the output section, because it's important to minimize the
3159 number of literal table entries to reduce the start-up work for the
3160 runtime linker. Returns the number of remaining table entries or -1
3164 elf_xtensa_combine_prop_entries (bfd *output_bfd,
3169 property_table_entry *table;
3170 bfd_size_type section_size, sgotloc_size;
3174 section_size = sxtlit->size;
3175 BFD_ASSERT (section_size % 8 == 0);
3176 num = section_size / 8;
3178 sgotloc_size = sgotloc->size;
3179 if (sgotloc_size != section_size)
3181 (*_bfd_error_handler)
3182 (_("internal inconsistency in size of .got.loc section"));
3186 table = bfd_malloc (num * sizeof (property_table_entry));
3190 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3191 propagates to the output section, where it doesn't really apply and
3192 where it breaks the following call to bfd_malloc_and_get_section. */
3193 sxtlit->flags &= ~SEC_IN_MEMORY;
3195 if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
3203 /* There should never be any relocations left at this point, so this
3204 is quite a bit easier than what is done during relaxation. */
3206 /* Copy the raw contents into a property table array and sort it. */
3208 for (n = 0; n < num; n++)
3210 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
3211 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
3214 qsort (table, num, sizeof (property_table_entry), property_table_compare);
3216 for (n = 0; n < num; n++)
3218 bfd_boolean remove_entry = FALSE;
3220 if (table[n].size == 0)
3221 remove_entry = TRUE;
3223 && (table[n-1].address + table[n-1].size == table[n].address))
3225 table[n-1].size += table[n].size;
3226 remove_entry = TRUE;
3231 for (m = n; m < num - 1; m++)
3233 table[m].address = table[m+1].address;
3234 table[m].size = table[m+1].size;
3242 /* Copy the data back to the raw contents. */
3244 for (n = 0; n < num; n++)
3246 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
3247 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
3251 /* Clear the removed bytes. */
3252 if ((bfd_size_type) (num * 8) < section_size)
3253 memset (&contents[num * 8], 0, section_size - num * 8);
3255 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
3259 /* Copy the contents to ".got.loc". */
3260 memcpy (sgotloc->contents, contents, section_size);
3268 /* Finish up the dynamic sections. */
3271 elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
3272 struct bfd_link_info *info)
3274 struct elf_xtensa_link_hash_table *htab;
3276 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
3277 Elf32_External_Dyn *dyncon, *dynconend;
3278 int num_xtlit_entries = 0;
3280 if (! elf_hash_table (info)->dynamic_sections_created)
3283 htab = elf_xtensa_hash_table (info);
3287 dynobj = elf_hash_table (info)->dynobj;
3288 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3289 BFD_ASSERT (sdyn != NULL);
3291 /* Set the first entry in the global offset table to the address of
3292 the dynamic section. */
3296 BFD_ASSERT (sgot->size == 4);
3298 bfd_put_32 (output_bfd, 0, sgot->contents);
3300 bfd_put_32 (output_bfd,
3301 sdyn->output_section->vma + sdyn->output_offset,
3305 srelplt = htab->srelplt;
3306 if (srelplt && srelplt->size != 0)
3308 asection *sgotplt, *srelgot, *spltlittbl;
3309 int chunk, plt_chunks, plt_entries;
3310 Elf_Internal_Rela irela;
3312 unsigned rtld_reloc;
3314 srelgot = htab->srelgot;
3315 spltlittbl = htab->spltlittbl;
3316 BFD_ASSERT (srelgot != NULL && spltlittbl != NULL);
3318 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3319 of them follow immediately after.... */
3320 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
3322 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3323 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3324 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
3327 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
3329 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
3331 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
3333 for (chunk = 0; chunk < plt_chunks; chunk++)
3335 int chunk_entries = 0;
3337 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
3338 BFD_ASSERT (sgotplt != NULL);
3340 /* Emit special RTLD relocations for the first two entries in
3341 each chunk of the .got.plt section. */
3343 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3344 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3345 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3346 irela.r_offset = (sgotplt->output_section->vma
3347 + sgotplt->output_offset);
3348 irela.r_addend = 1; /* tell rtld to set value to resolver function */
3349 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3351 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3353 /* Next literal immediately follows the first. */
3354 loc += sizeof (Elf32_External_Rela);
3355 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3356 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3357 irela.r_offset = (sgotplt->output_section->vma
3358 + sgotplt->output_offset + 4);
3359 /* Tell rtld to set value to object's link map. */
3361 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3363 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3365 /* Fill in the literal table. */
3366 if (chunk < plt_chunks - 1)
3367 chunk_entries = PLT_ENTRIES_PER_CHUNK;
3369 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
3371 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
3372 bfd_put_32 (output_bfd,
3373 sgotplt->output_section->vma + sgotplt->output_offset,
3374 spltlittbl->contents + (chunk * 8) + 0);
3375 bfd_put_32 (output_bfd,
3376 8 + (chunk_entries * 4),
3377 spltlittbl->contents + (chunk * 8) + 4);
3380 /* All the dynamic relocations have been emitted at this point.
3381 Make sure the relocation sections are the correct size. */
3382 if (srelgot->size != (sizeof (Elf32_External_Rela)
3383 * srelgot->reloc_count)
3384 || srelplt->size != (sizeof (Elf32_External_Rela)
3385 * srelplt->reloc_count))
3388 /* The .xt.lit.plt section has just been modified. This must
3389 happen before the code below which combines adjacent literal
3390 table entries, and the .xt.lit.plt contents have to be forced to
3392 if (! bfd_set_section_contents (output_bfd,
3393 spltlittbl->output_section,
3394 spltlittbl->contents,
3395 spltlittbl->output_offset,
3398 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3399 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
3402 /* Combine adjacent literal table entries. */
3403 BFD_ASSERT (! bfd_link_relocatable (info));
3404 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
3405 sgotloc = htab->sgotloc;
3406 BFD_ASSERT (sgotloc);
3410 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
3411 if (num_xtlit_entries < 0)
3415 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3416 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3417 for (; dyncon < dynconend; dyncon++)
3419 Elf_Internal_Dyn dyn;
3421 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3428 case DT_XTENSA_GOT_LOC_SZ:
3429 dyn.d_un.d_val = num_xtlit_entries;
3432 case DT_XTENSA_GOT_LOC_OFF:
3433 dyn.d_un.d_ptr = (htab->sgotloc->output_section->vma
3434 + htab->sgotloc->output_offset);
3438 dyn.d_un.d_ptr = (htab->sgot->output_section->vma
3439 + htab->sgot->output_offset);
3443 dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
3444 + htab->srelplt->output_offset);
3448 dyn.d_un.d_val = htab->srelplt->size;
3452 /* Adjust RELASZ to not include JMPREL. This matches what
3453 glibc expects and what is done for several other ELF
3454 targets (e.g., i386, alpha), but the "correct" behavior
3455 seems to be unresolved. Since the linker script arranges
3456 for .rela.plt to follow all other relocation sections, we
3457 don't have to worry about changing the DT_RELA entry. */
3459 dyn.d_un.d_val -= htab->srelplt->size;
3463 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3470 /* Functions for dealing with the e_flags field. */
3472 /* Merge backend specific data from an object file to the output
3473 object file when linking. */
3476 elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3478 unsigned out_mach, in_mach;
3479 flagword out_flag, in_flag;
3481 /* Check if we have the same endianness. */
3482 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
3485 /* Don't even pretend to support mixed-format linking. */
3486 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3487 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3490 out_flag = elf_elfheader (obfd)->e_flags;
3491 in_flag = elf_elfheader (ibfd)->e_flags;
3493 out_mach = out_flag & EF_XTENSA_MACH;
3494 in_mach = in_flag & EF_XTENSA_MACH;
3495 if (out_mach != in_mach)
3497 (*_bfd_error_handler)
3498 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
3499 ibfd, out_mach, in_mach);
3500 bfd_set_error (bfd_error_wrong_format);
3504 if (! elf_flags_init (obfd))
3506 elf_flags_init (obfd) = TRUE;
3507 elf_elfheader (obfd)->e_flags = in_flag;
3509 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3510 && bfd_get_arch_info (obfd)->the_default)
3511 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3512 bfd_get_mach (ibfd));
3517 if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
3518 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
3520 if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
3521 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
3528 elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
3530 BFD_ASSERT (!elf_flags_init (abfd)
3531 || elf_elfheader (abfd)->e_flags == flags);
3533 elf_elfheader (abfd)->e_flags |= flags;
3534 elf_flags_init (abfd) = TRUE;
3541 elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
3543 FILE *f = (FILE *) farg;
3544 flagword e_flags = elf_elfheader (abfd)->e_flags;
3546 fprintf (f, "\nXtensa header:\n");
3547 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
3548 fprintf (f, "\nMachine = Base\n");
3550 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
3552 fprintf (f, "Insn tables = %s\n",
3553 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
3555 fprintf (f, "Literal tables = %s\n",
3556 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
3558 return _bfd_elf_print_private_bfd_data (abfd, farg);
3562 /* Set the right machine number for an Xtensa ELF file. */
3565 elf_xtensa_object_p (bfd *abfd)
3568 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
3573 mach = bfd_mach_xtensa;
3579 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
3584 /* The final processing done just before writing out an Xtensa ELF object
3585 file. This gets the Xtensa architecture right based on the machine
3589 elf_xtensa_final_write_processing (bfd *abfd,
3590 bfd_boolean linker ATTRIBUTE_UNUSED)
3595 switch (mach = bfd_get_mach (abfd))
3597 case bfd_mach_xtensa:
3598 val = E_XTENSA_MACH;
3604 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
3605 elf_elfheader (abfd)->e_flags |= val;
3609 static enum elf_reloc_type_class
3610 elf_xtensa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3611 const asection *rel_sec ATTRIBUTE_UNUSED,
3612 const Elf_Internal_Rela *rela)
3614 switch ((int) ELF32_R_TYPE (rela->r_info))
3616 case R_XTENSA_RELATIVE:
3617 return reloc_class_relative;
3618 case R_XTENSA_JMP_SLOT:
3619 return reloc_class_plt;
3621 return reloc_class_normal;
3627 elf_xtensa_discard_info_for_section (bfd *abfd,
3628 struct elf_reloc_cookie *cookie,
3629 struct bfd_link_info *info,
3633 bfd_vma offset, actual_offset;
3634 bfd_size_type removed_bytes = 0;
3635 bfd_size_type entry_size;
3637 if (sec->output_section
3638 && bfd_is_abs_section (sec->output_section))
3641 if (xtensa_is_proptable_section (sec))
3646 if (sec->size == 0 || sec->size % entry_size != 0)
3649 contents = retrieve_contents (abfd, sec, info->keep_memory);
3653 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
3656 release_contents (sec, contents);
3660 /* Sort the relocations. They should already be in order when
3661 relaxation is enabled, but it might not be. */
3662 qsort (cookie->rels, sec->reloc_count, sizeof (Elf_Internal_Rela),
3663 internal_reloc_compare);
3665 cookie->rel = cookie->rels;
3666 cookie->relend = cookie->rels + sec->reloc_count;
3668 for (offset = 0; offset < sec->size; offset += entry_size)
3670 actual_offset = offset - removed_bytes;
3672 /* The ...symbol_deleted_p function will skip over relocs but it
3673 won't adjust their offsets, so do that here. */
3674 while (cookie->rel < cookie->relend
3675 && cookie->rel->r_offset < offset)
3677 cookie->rel->r_offset -= removed_bytes;
3681 while (cookie->rel < cookie->relend
3682 && cookie->rel->r_offset == offset)
3684 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
3686 /* Remove the table entry. (If the reloc type is NONE, then
3687 the entry has already been merged with another and deleted
3688 during relaxation.) */
3689 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
3691 /* Shift the contents up. */
3692 if (offset + entry_size < sec->size)
3693 memmove (&contents[actual_offset],
3694 &contents[actual_offset + entry_size],
3695 sec->size - offset - entry_size);
3696 removed_bytes += entry_size;
3699 /* Remove this relocation. */
3700 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3703 /* Adjust the relocation offset for previous removals. This
3704 should not be done before calling ...symbol_deleted_p
3705 because it might mess up the offset comparisons there.
3706 Make sure the offset doesn't underflow in the case where
3707 the first entry is removed. */
3708 if (cookie->rel->r_offset >= removed_bytes)
3709 cookie->rel->r_offset -= removed_bytes;
3711 cookie->rel->r_offset = 0;
3717 if (removed_bytes != 0)
3719 /* Adjust any remaining relocs (shouldn't be any). */
3720 for (; cookie->rel < cookie->relend; cookie->rel++)
3722 if (cookie->rel->r_offset >= removed_bytes)
3723 cookie->rel->r_offset -= removed_bytes;
3725 cookie->rel->r_offset = 0;
3728 /* Clear the removed bytes. */
3729 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
3731 pin_contents (sec, contents);
3732 pin_internal_relocs (sec, cookie->rels);
3735 if (sec->rawsize == 0)
3736 sec->rawsize = sec->size;
3737 sec->size -= removed_bytes;
3739 if (xtensa_is_littable_section (sec))
3741 asection *sgotloc = elf_xtensa_hash_table (info)->sgotloc;
3743 sgotloc->size -= removed_bytes;
3748 release_contents (sec, contents);
3749 release_internal_relocs (sec, cookie->rels);
3752 return (removed_bytes != 0);
3757 elf_xtensa_discard_info (bfd *abfd,
3758 struct elf_reloc_cookie *cookie,
3759 struct bfd_link_info *info)
3762 bfd_boolean changed = FALSE;
3764 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3766 if (xtensa_is_property_section (sec))
3768 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
3778 elf_xtensa_ignore_discarded_relocs (asection *sec)
3780 return xtensa_is_property_section (sec);
3785 elf_xtensa_action_discarded (asection *sec)
3787 if (strcmp (".xt_except_table", sec->name) == 0)
3790 if (strcmp (".xt_except_desc", sec->name) == 0)
3793 return _bfd_elf_default_action_discarded (sec);
3797 /* Support for core dump NOTE sections. */
3800 elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3805 /* The size for Xtensa is variable, so don't try to recognize the format
3806 based on the size. Just assume this is GNU/Linux. */
3809 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3812 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
3816 size = note->descsz - offset - 4;
3818 /* Make a ".reg/999" section. */
3819 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3820 size, note->descpos + offset);
3825 elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3827 switch (note->descsz)
3832 case 128: /* GNU/Linux elf_prpsinfo */
3833 elf_tdata (abfd)->core->program
3834 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3835 elf_tdata (abfd)->core->command
3836 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3839 /* Note that for some reason, a spurious space is tacked
3840 onto the end of the args in some (at least one anyway)
3841 implementations, so strip it off if it exists. */
3844 char *command = elf_tdata (abfd)->core->command;
3845 int n = strlen (command);
3847 if (0 < n && command[n - 1] == ' ')
3848 command[n - 1] = '\0';
3855 /* Generic Xtensa configurability stuff. */
3857 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3858 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3859 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3860 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3861 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3862 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3863 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3864 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3867 init_call_opcodes (void)
3869 if (callx0_op == XTENSA_UNDEFINED)
3871 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3872 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3873 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3874 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3875 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3876 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3877 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3878 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3884 is_indirect_call_opcode (xtensa_opcode opcode)
3886 init_call_opcodes ();
3887 return (opcode == callx0_op
3888 || opcode == callx4_op
3889 || opcode == callx8_op
3890 || opcode == callx12_op);
3895 is_direct_call_opcode (xtensa_opcode opcode)
3897 init_call_opcodes ();
3898 return (opcode == call0_op
3899 || opcode == call4_op
3900 || opcode == call8_op
3901 || opcode == call12_op);
3906 is_windowed_call_opcode (xtensa_opcode opcode)
3908 init_call_opcodes ();
3909 return (opcode == call4_op
3910 || opcode == call8_op
3911 || opcode == call12_op
3912 || opcode == callx4_op
3913 || opcode == callx8_op
3914 || opcode == callx12_op);
3919 get_indirect_call_dest_reg (xtensa_opcode opcode, unsigned *pdst)
3921 unsigned dst = (unsigned) -1;
3923 init_call_opcodes ();
3924 if (opcode == callx0_op)
3926 else if (opcode == callx4_op)
3928 else if (opcode == callx8_op)
3930 else if (opcode == callx12_op)
3933 if (dst == (unsigned) -1)
3941 static xtensa_opcode
3942 get_const16_opcode (void)
3944 static bfd_boolean done_lookup = FALSE;
3945 static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3948 const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3951 return const16_opcode;
3955 static xtensa_opcode
3956 get_l32r_opcode (void)
3958 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
3959 static bfd_boolean done_lookup = FALSE;
3963 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
3971 l32r_offset (bfd_vma addr, bfd_vma pc)
3975 offset = addr - ((pc+3) & -4);
3976 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3977 offset = (signed int) offset >> 2;
3978 BFD_ASSERT ((signed int) offset >> 16 == -1);
3984 get_relocation_opnd (xtensa_opcode opcode, int r_type)
3986 xtensa_isa isa = xtensa_default_isa;
3987 int last_immed, last_opnd, opi;
3989 if (opcode == XTENSA_UNDEFINED)
3990 return XTENSA_UNDEFINED;
3992 /* Find the last visible PC-relative immediate operand for the opcode.
3993 If there are no PC-relative immediates, then choose the last visible
3994 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3995 last_immed = XTENSA_UNDEFINED;
3996 last_opnd = xtensa_opcode_num_operands (isa, opcode);
3997 for (opi = last_opnd - 1; opi >= 0; opi--)
3999 if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
4001 if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
4006 if (last_immed == XTENSA_UNDEFINED
4007 && xtensa_operand_is_register (isa, opcode, opi) == 0)
4011 return XTENSA_UNDEFINED;
4013 /* If the operand number was specified in an old-style relocation,
4014 check for consistency with the operand computed above. */
4015 if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
4017 int reloc_opnd = r_type - R_XTENSA_OP0;
4018 if (reloc_opnd != last_immed)
4019 return XTENSA_UNDEFINED;
4027 get_relocation_slot (int r_type)
4037 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4038 return r_type - R_XTENSA_SLOT0_OP;
4039 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4040 return r_type - R_XTENSA_SLOT0_ALT;
4044 return XTENSA_UNDEFINED;
4048 /* Get the opcode for a relocation. */
4050 static xtensa_opcode
4051 get_relocation_opcode (bfd *abfd,
4054 Elf_Internal_Rela *irel)
4056 static xtensa_insnbuf ibuff = NULL;
4057 static xtensa_insnbuf sbuff = NULL;
4058 xtensa_isa isa = xtensa_default_isa;
4062 if (contents == NULL)
4063 return XTENSA_UNDEFINED;
4065 if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
4066 return XTENSA_UNDEFINED;
4070 ibuff = xtensa_insnbuf_alloc (isa);
4071 sbuff = xtensa_insnbuf_alloc (isa);
4074 /* Decode the instruction. */
4075 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
4076 sec->size - irel->r_offset);
4077 fmt = xtensa_format_decode (isa, ibuff);
4078 slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
4079 if (slot == XTENSA_UNDEFINED)
4080 return XTENSA_UNDEFINED;
4081 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
4082 return xtensa_opcode_decode (isa, fmt, slot, sbuff);
4087 is_l32r_relocation (bfd *abfd,
4090 Elf_Internal_Rela *irel)
4092 xtensa_opcode opcode;
4093 if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
4095 opcode = get_relocation_opcode (abfd, sec, contents, irel);
4096 return (opcode == get_l32r_opcode ());
4100 static bfd_size_type
4101 get_asm_simplify_size (bfd_byte *contents,
4102 bfd_size_type content_len,
4103 bfd_size_type offset)
4105 bfd_size_type insnlen, size = 0;
4107 /* Decode the size of the next two instructions. */
4108 insnlen = insn_decode_len (contents, content_len, offset);
4114 insnlen = insn_decode_len (contents, content_len, offset + size);
4124 is_alt_relocation (int r_type)
4126 return (r_type >= R_XTENSA_SLOT0_ALT
4127 && r_type <= R_XTENSA_SLOT14_ALT);
4132 is_operand_relocation (int r_type)
4142 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4144 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4153 #define MIN_INSN_LENGTH 2
4155 /* Return 0 if it fails to decode. */
4158 insn_decode_len (bfd_byte *contents,
4159 bfd_size_type content_len,
4160 bfd_size_type offset)
4163 xtensa_isa isa = xtensa_default_isa;
4165 static xtensa_insnbuf ibuff = NULL;
4167 if (offset + MIN_INSN_LENGTH > content_len)
4171 ibuff = xtensa_insnbuf_alloc (isa);
4172 xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
4173 content_len - offset);
4174 fmt = xtensa_format_decode (isa, ibuff);
4175 if (fmt == XTENSA_UNDEFINED)
4177 insn_len = xtensa_format_length (isa, fmt);
4178 if (insn_len == XTENSA_UNDEFINED)
4184 /* Decode the opcode for a single slot instruction.
4185 Return 0 if it fails to decode or the instruction is multi-slot. */
4188 insn_decode_opcode (bfd_byte *contents,
4189 bfd_size_type content_len,
4190 bfd_size_type offset,
4193 xtensa_isa isa = xtensa_default_isa;
4195 static xtensa_insnbuf insnbuf = NULL;
4196 static xtensa_insnbuf slotbuf = NULL;
4198 if (offset + MIN_INSN_LENGTH > content_len)
4199 return XTENSA_UNDEFINED;
4201 if (insnbuf == NULL)
4203 insnbuf = xtensa_insnbuf_alloc (isa);
4204 slotbuf = xtensa_insnbuf_alloc (isa);
4207 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4208 content_len - offset);
4209 fmt = xtensa_format_decode (isa, insnbuf);
4210 if (fmt == XTENSA_UNDEFINED)
4211 return XTENSA_UNDEFINED;
4213 if (slot >= xtensa_format_num_slots (isa, fmt))
4214 return XTENSA_UNDEFINED;
4216 xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4217 return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4221 /* The offset is the offset in the contents.
4222 The address is the address of that offset. */
4225 check_branch_target_aligned (bfd_byte *contents,
4226 bfd_size_type content_length,
4230 bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
4233 return check_branch_target_aligned_address (address, insn_len);
4238 check_loop_aligned (bfd_byte *contents,
4239 bfd_size_type content_length,
4243 bfd_size_type loop_len, insn_len;
4244 xtensa_opcode opcode;
4246 opcode = insn_decode_opcode (contents, content_length, offset, 0);
4247 if (opcode == XTENSA_UNDEFINED
4248 || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
4254 loop_len = insn_decode_len (contents, content_length, offset);
4255 insn_len = insn_decode_len (contents, content_length, offset + loop_len);
4256 if (loop_len == 0 || insn_len == 0)
4262 return check_branch_target_aligned_address (address + loop_len, insn_len);
4267 check_branch_target_aligned_address (bfd_vma addr, int len)
4270 return (addr % 8 == 0);
4271 return ((addr >> 2) == ((addr + len - 1) >> 2));
4275 /* Instruction widening and narrowing. */
4277 /* When FLIX is available we need to access certain instructions only
4278 when they are 16-bit or 24-bit instructions. This table caches
4279 information about such instructions by walking through all the
4280 opcodes and finding the smallest single-slot format into which each
4283 static xtensa_format *op_single_fmt_table = NULL;
4287 init_op_single_format_table (void)
4289 xtensa_isa isa = xtensa_default_isa;
4290 xtensa_insnbuf ibuf;
4291 xtensa_opcode opcode;
4295 if (op_single_fmt_table)
4298 ibuf = xtensa_insnbuf_alloc (isa);
4299 num_opcodes = xtensa_isa_num_opcodes (isa);
4301 op_single_fmt_table = (xtensa_format *)
4302 bfd_malloc (sizeof (xtensa_format) * num_opcodes);
4303 for (opcode = 0; opcode < num_opcodes; opcode++)
4305 op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
4306 for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
4308 if (xtensa_format_num_slots (isa, fmt) == 1
4309 && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
4311 xtensa_opcode old_fmt = op_single_fmt_table[opcode];
4312 int fmt_length = xtensa_format_length (isa, fmt);
4313 if (old_fmt == XTENSA_UNDEFINED
4314 || fmt_length < xtensa_format_length (isa, old_fmt))
4315 op_single_fmt_table[opcode] = fmt;
4319 xtensa_insnbuf_free (isa, ibuf);
4323 static xtensa_format
4324 get_single_format (xtensa_opcode opcode)
4326 init_op_single_format_table ();
4327 return op_single_fmt_table[opcode];
4331 /* For the set of narrowable instructions we do NOT include the
4332 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4333 involved during linker relaxation that may require these to
4334 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4335 requires special case code to ensure it only works when op1 == op2. */
4343 struct string_pair narrowable[] =
4346 { "addi", "addi.n" },
4347 { "addmi", "addi.n" },
4348 { "l32i", "l32i.n" },
4349 { "movi", "movi.n" },
4351 { "retw", "retw.n" },
4352 { "s32i", "s32i.n" },
4353 { "or", "mov.n" } /* special case only when op1 == op2 */
4356 struct string_pair widenable[] =
4359 { "addi", "addi.n" },
4360 { "addmi", "addi.n" },
4361 { "beqz", "beqz.n" },
4362 { "bnez", "bnez.n" },
4363 { "l32i", "l32i.n" },
4364 { "movi", "movi.n" },
4366 { "retw", "retw.n" },
4367 { "s32i", "s32i.n" },
4368 { "or", "mov.n" } /* special case only when op1 == op2 */
4372 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4373 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4374 return the instruction buffer holding the narrow instruction. Otherwise,
4375 return 0. The set of valid narrowing are specified by a string table
4376 but require some special case operand checks in some cases. */
4378 static xtensa_insnbuf
4379 can_narrow_instruction (xtensa_insnbuf slotbuf,
4381 xtensa_opcode opcode)
4383 xtensa_isa isa = xtensa_default_isa;
4384 xtensa_format o_fmt;
4387 static xtensa_insnbuf o_insnbuf = NULL;
4388 static xtensa_insnbuf o_slotbuf = NULL;
4390 if (o_insnbuf == NULL)
4392 o_insnbuf = xtensa_insnbuf_alloc (isa);
4393 o_slotbuf = xtensa_insnbuf_alloc (isa);
4396 for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
4398 bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
4400 if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
4402 uint32 value, newval;
4403 int i, operand_count, o_operand_count;
4404 xtensa_opcode o_opcode;
4406 /* Address does not matter in this case. We might need to
4407 fix it to handle branches/jumps. */
4408 bfd_vma self_address = 0;
4410 o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
4411 if (o_opcode == XTENSA_UNDEFINED)
4413 o_fmt = get_single_format (o_opcode);
4414 if (o_fmt == XTENSA_UNDEFINED)
4417 if (xtensa_format_length (isa, fmt) != 3
4418 || xtensa_format_length (isa, o_fmt) != 2)
4421 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4422 operand_count = xtensa_opcode_num_operands (isa, opcode);
4423 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4425 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4430 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4435 uint32 rawval0, rawval1, rawval2;
4437 if (o_operand_count + 1 != operand_count
4438 || xtensa_operand_get_field (isa, opcode, 0,
4439 fmt, 0, slotbuf, &rawval0) != 0
4440 || xtensa_operand_get_field (isa, opcode, 1,
4441 fmt, 0, slotbuf, &rawval1) != 0
4442 || xtensa_operand_get_field (isa, opcode, 2,
4443 fmt, 0, slotbuf, &rawval2) != 0
4444 || rawval1 != rawval2
4445 || rawval0 == rawval1 /* it is a nop */)
4449 for (i = 0; i < o_operand_count; ++i)
4451 if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
4453 || xtensa_operand_decode (isa, opcode, i, &value))
4456 /* PC-relative branches need adjustment, but
4457 the PC-rel operand will always have a relocation. */
4459 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4461 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4462 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4467 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4477 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4478 the action in-place directly into the contents and return TRUE. Otherwise,
4479 the return value is FALSE and the contents are not modified. */
4482 narrow_instruction (bfd_byte *contents,
4483 bfd_size_type content_length,
4484 bfd_size_type offset)
4486 xtensa_opcode opcode;
4487 bfd_size_type insn_len;
4488 xtensa_isa isa = xtensa_default_isa;
4490 xtensa_insnbuf o_insnbuf;
4492 static xtensa_insnbuf insnbuf = NULL;
4493 static xtensa_insnbuf slotbuf = NULL;
4495 if (insnbuf == NULL)
4497 insnbuf = xtensa_insnbuf_alloc (isa);
4498 slotbuf = xtensa_insnbuf_alloc (isa);
4501 BFD_ASSERT (offset < content_length);
4503 if (content_length < 2)
4506 /* We will hand-code a few of these for a little while.
4507 These have all been specified in the assembler aleady. */
4508 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4509 content_length - offset);
4510 fmt = xtensa_format_decode (isa, insnbuf);
4511 if (xtensa_format_num_slots (isa, fmt) != 1)
4514 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4517 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4518 if (opcode == XTENSA_UNDEFINED)
4520 insn_len = xtensa_format_length (isa, fmt);
4521 if (insn_len > content_length)
4524 o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
4527 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4528 content_length - offset);
4536 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4537 "density" instruction to a standard 3-byte instruction. If it is valid,
4538 return the instruction buffer holding the wide instruction. Otherwise,
4539 return 0. The set of valid widenings are specified by a string table
4540 but require some special case operand checks in some cases. */
4542 static xtensa_insnbuf
4543 can_widen_instruction (xtensa_insnbuf slotbuf,
4545 xtensa_opcode opcode)
4547 xtensa_isa isa = xtensa_default_isa;
4548 xtensa_format o_fmt;
4551 static xtensa_insnbuf o_insnbuf = NULL;
4552 static xtensa_insnbuf o_slotbuf = NULL;
4554 if (o_insnbuf == NULL)
4556 o_insnbuf = xtensa_insnbuf_alloc (isa);
4557 o_slotbuf = xtensa_insnbuf_alloc (isa);
4560 for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
4562 bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
4563 bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
4564 || strcmp ("bnez", widenable[opi].wide) == 0);
4566 if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
4568 uint32 value, newval;
4569 int i, operand_count, o_operand_count, check_operand_count;
4570 xtensa_opcode o_opcode;
4572 /* Address does not matter in this case. We might need to fix it
4573 to handle branches/jumps. */
4574 bfd_vma self_address = 0;
4576 o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
4577 if (o_opcode == XTENSA_UNDEFINED)
4579 o_fmt = get_single_format (o_opcode);
4580 if (o_fmt == XTENSA_UNDEFINED)
4583 if (xtensa_format_length (isa, fmt) != 2
4584 || xtensa_format_length (isa, o_fmt) != 3)
4587 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4588 operand_count = xtensa_opcode_num_operands (isa, opcode);
4589 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4590 check_operand_count = o_operand_count;
4592 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4597 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4602 uint32 rawval0, rawval1;
4604 if (o_operand_count != operand_count + 1
4605 || xtensa_operand_get_field (isa, opcode, 0,
4606 fmt, 0, slotbuf, &rawval0) != 0
4607 || xtensa_operand_get_field (isa, opcode, 1,
4608 fmt, 0, slotbuf, &rawval1) != 0
4609 || rawval0 == rawval1 /* it is a nop */)
4613 check_operand_count--;
4615 for (i = 0; i < check_operand_count; i++)
4618 if (is_or && i == o_operand_count - 1)
4620 if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
4622 || xtensa_operand_decode (isa, opcode, new_i, &value))
4625 /* PC-relative branches need adjustment, but
4626 the PC-rel operand will always have a relocation. */
4628 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4630 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4631 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4636 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4646 /* Attempt to widen an instruction. If the widening is valid, perform
4647 the action in-place directly into the contents and return TRUE. Otherwise,
4648 the return value is FALSE and the contents are not modified. */
4651 widen_instruction (bfd_byte *contents,
4652 bfd_size_type content_length,
4653 bfd_size_type offset)
4655 xtensa_opcode opcode;
4656 bfd_size_type insn_len;
4657 xtensa_isa isa = xtensa_default_isa;
4659 xtensa_insnbuf o_insnbuf;
4661 static xtensa_insnbuf insnbuf = NULL;
4662 static xtensa_insnbuf slotbuf = NULL;
4664 if (insnbuf == NULL)
4666 insnbuf = xtensa_insnbuf_alloc (isa);
4667 slotbuf = xtensa_insnbuf_alloc (isa);
4670 BFD_ASSERT (offset < content_length);
4672 if (content_length < 2)
4675 /* We will hand-code a few of these for a little while.
4676 These have all been specified in the assembler aleady. */
4677 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4678 content_length - offset);
4679 fmt = xtensa_format_decode (isa, insnbuf);
4680 if (xtensa_format_num_slots (isa, fmt) != 1)
4683 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4686 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4687 if (opcode == XTENSA_UNDEFINED)
4689 insn_len = xtensa_format_length (isa, fmt);
4690 if (insn_len > content_length)
4693 o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
4696 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4697 content_length - offset);
4704 /* Code for transforming CALLs at link-time. */
4706 static bfd_reloc_status_type
4707 elf_xtensa_do_asm_simplify (bfd_byte *contents,
4709 bfd_vma content_length,
4710 char **error_message)
4712 static xtensa_insnbuf insnbuf = NULL;
4713 static xtensa_insnbuf slotbuf = NULL;
4714 xtensa_format core_format = XTENSA_UNDEFINED;
4715 xtensa_opcode opcode;
4716 xtensa_opcode direct_call_opcode;
4717 xtensa_isa isa = xtensa_default_isa;
4718 bfd_byte *chbuf = contents + address;
4721 if (insnbuf == NULL)
4723 insnbuf = xtensa_insnbuf_alloc (isa);
4724 slotbuf = xtensa_insnbuf_alloc (isa);
4727 if (content_length < address)
4729 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4730 return bfd_reloc_other;
4733 opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
4734 direct_call_opcode = swap_callx_for_call_opcode (opcode);
4735 if (direct_call_opcode == XTENSA_UNDEFINED)
4737 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4738 return bfd_reloc_other;
4741 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4742 core_format = xtensa_format_lookup (isa, "x24");
4743 opcode = xtensa_opcode_lookup (isa, "or");
4744 xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
4745 for (opn = 0; opn < 3; opn++)
4748 xtensa_operand_encode (isa, opcode, opn, ®no);
4749 xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
4752 xtensa_format_encode (isa, core_format, insnbuf);
4753 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4754 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
4756 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4757 xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
4758 xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
4760 xtensa_format_encode (isa, core_format, insnbuf);
4761 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4762 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
4763 content_length - address - 3);
4765 return bfd_reloc_ok;
4769 static bfd_reloc_status_type
4770 contract_asm_expansion (bfd_byte *contents,
4771 bfd_vma content_length,
4772 Elf_Internal_Rela *irel,
4773 char **error_message)
4775 bfd_reloc_status_type retval =
4776 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
4779 if (retval != bfd_reloc_ok)
4780 return bfd_reloc_dangerous;
4782 /* Update the irel->r_offset field so that the right immediate and
4783 the right instruction are modified during the relocation. */
4784 irel->r_offset += 3;
4785 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
4786 return bfd_reloc_ok;
4790 static xtensa_opcode
4791 swap_callx_for_call_opcode (xtensa_opcode opcode)
4793 init_call_opcodes ();
4795 if (opcode == callx0_op) return call0_op;
4796 if (opcode == callx4_op) return call4_op;
4797 if (opcode == callx8_op) return call8_op;
4798 if (opcode == callx12_op) return call12_op;
4800 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4801 return XTENSA_UNDEFINED;
4805 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4806 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4807 If not, return XTENSA_UNDEFINED. */
4809 #define L32R_TARGET_REG_OPERAND 0
4810 #define CONST16_TARGET_REG_OPERAND 0
4811 #define CALLN_SOURCE_OPERAND 0
4813 static xtensa_opcode
4814 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
4816 static xtensa_insnbuf insnbuf = NULL;
4817 static xtensa_insnbuf slotbuf = NULL;
4819 xtensa_opcode opcode;
4820 xtensa_isa isa = xtensa_default_isa;
4821 uint32 regno, const16_regno, call_regno;
4824 if (insnbuf == NULL)
4826 insnbuf = xtensa_insnbuf_alloc (isa);
4827 slotbuf = xtensa_insnbuf_alloc (isa);
4830 xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4831 fmt = xtensa_format_decode (isa, insnbuf);
4832 if (fmt == XTENSA_UNDEFINED
4833 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4834 return XTENSA_UNDEFINED;
4836 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4837 if (opcode == XTENSA_UNDEFINED)
4838 return XTENSA_UNDEFINED;
4840 if (opcode == get_l32r_opcode ())
4843 *p_uses_l32r = TRUE;
4844 if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4845 fmt, 0, slotbuf, ®no)
4846 || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4848 return XTENSA_UNDEFINED;
4850 else if (opcode == get_const16_opcode ())
4853 *p_uses_l32r = FALSE;
4854 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4855 fmt, 0, slotbuf, ®no)
4856 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4858 return XTENSA_UNDEFINED;
4860 /* Check that the next instruction is also CONST16. */
4861 offset += xtensa_format_length (isa, fmt);
4862 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4863 fmt = xtensa_format_decode (isa, insnbuf);
4864 if (fmt == XTENSA_UNDEFINED
4865 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4866 return XTENSA_UNDEFINED;
4867 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4868 if (opcode != get_const16_opcode ())
4869 return XTENSA_UNDEFINED;
4871 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4872 fmt, 0, slotbuf, &const16_regno)
4873 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4875 || const16_regno != regno)
4876 return XTENSA_UNDEFINED;
4879 return XTENSA_UNDEFINED;
4881 /* Next instruction should be an CALLXn with operand 0 == regno. */
4882 offset += xtensa_format_length (isa, fmt);
4883 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4884 fmt = xtensa_format_decode (isa, insnbuf);
4885 if (fmt == XTENSA_UNDEFINED
4886 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4887 return XTENSA_UNDEFINED;
4888 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4889 if (opcode == XTENSA_UNDEFINED
4890 || !is_indirect_call_opcode (opcode))
4891 return XTENSA_UNDEFINED;
4893 if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4894 fmt, 0, slotbuf, &call_regno)
4895 || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4897 return XTENSA_UNDEFINED;
4899 if (call_regno != regno)
4900 return XTENSA_UNDEFINED;
4906 /* Data structures used during relaxation. */
4908 /* r_reloc: relocation values. */
4910 /* Through the relaxation process, we need to keep track of the values
4911 that will result from evaluating relocations. The standard ELF
4912 relocation structure is not sufficient for this purpose because we're
4913 operating on multiple input files at once, so we need to know which
4914 input file a relocation refers to. The r_reloc structure thus
4915 records both the input file (bfd) and ELF relocation.
4917 For efficiency, an r_reloc also contains a "target_offset" field to
4918 cache the target-section-relative offset value that is represented by
4921 The r_reloc also contains a virtual offset that allows multiple
4922 inserted literals to be placed at the same "address" with
4923 different offsets. */
4925 typedef struct r_reloc_struct r_reloc;
4927 struct r_reloc_struct
4930 Elf_Internal_Rela rela;
4931 bfd_vma target_offset;
4932 bfd_vma virtual_offset;
4936 /* The r_reloc structure is included by value in literal_value, but not
4937 every literal_value has an associated relocation -- some are simple
4938 constants. In such cases, we set all the fields in the r_reloc
4939 struct to zero. The r_reloc_is_const function should be used to
4940 detect this case. */
4943 r_reloc_is_const (const r_reloc *r_rel)
4945 return (r_rel->abfd == NULL);
4950 r_reloc_get_target_offset (const r_reloc *r_rel)
4952 bfd_vma target_offset;
4953 unsigned long r_symndx;
4955 BFD_ASSERT (!r_reloc_is_const (r_rel));
4956 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4957 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4958 return (target_offset + r_rel->rela.r_addend);
4962 static struct elf_link_hash_entry *
4963 r_reloc_get_hash_entry (const r_reloc *r_rel)
4965 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4966 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4971 r_reloc_get_section (const r_reloc *r_rel)
4973 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4974 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4979 r_reloc_is_defined (const r_reloc *r_rel)
4985 sec = r_reloc_get_section (r_rel);
4986 if (sec == bfd_abs_section_ptr
4987 || sec == bfd_com_section_ptr
4988 || sec == bfd_und_section_ptr)
4995 r_reloc_init (r_reloc *r_rel,
4997 Elf_Internal_Rela *irel,
4999 bfd_size_type content_length)
5002 reloc_howto_type *howto;
5006 r_rel->rela = *irel;
5008 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
5009 r_rel->virtual_offset = 0;
5010 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
5011 howto = &elf_howto_table[r_type];
5012 if (howto->partial_inplace)
5014 bfd_vma inplace_val;
5015 BFD_ASSERT (r_rel->rela.r_offset < content_length);
5017 inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
5018 r_rel->target_offset += inplace_val;
5022 memset (r_rel, 0, sizeof (r_reloc));
5029 print_r_reloc (FILE *fp, const r_reloc *r_rel)
5031 if (r_reloc_is_defined (r_rel))
5033 asection *sec = r_reloc_get_section (r_rel);
5034 fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
5036 else if (r_reloc_get_hash_entry (r_rel))
5037 fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
5039 fprintf (fp, " ?? + ");
5041 fprintf_vma (fp, r_rel->target_offset);
5042 if (r_rel->virtual_offset)
5044 fprintf (fp, " + ");
5045 fprintf_vma (fp, r_rel->virtual_offset);
5054 /* source_reloc: relocations that reference literals. */
5056 /* To determine whether literals can be coalesced, we need to first
5057 record all the relocations that reference the literals. The
5058 source_reloc structure below is used for this purpose. The
5059 source_reloc entries are kept in a per-literal-section array, sorted
5060 by offset within the literal section (i.e., target offset).
5062 The source_sec and r_rel.rela.r_offset fields identify the source of
5063 the relocation. The r_rel field records the relocation value, i.e.,
5064 the offset of the literal being referenced. The opnd field is needed
5065 to determine the range of the immediate field to which the relocation
5066 applies, so we can determine whether another literal with the same
5067 value is within range. The is_null field is true when the relocation
5068 is being removed (e.g., when an L32R is being removed due to a CALLX
5069 that is converted to a direct CALL). */
5071 typedef struct source_reloc_struct source_reloc;
5073 struct source_reloc_struct
5075 asection *source_sec;
5077 xtensa_opcode opcode;
5079 bfd_boolean is_null;
5080 bfd_boolean is_abs_literal;
5085 init_source_reloc (source_reloc *reloc,
5086 asection *source_sec,
5087 const r_reloc *r_rel,
5088 xtensa_opcode opcode,
5090 bfd_boolean is_abs_literal)
5092 reloc->source_sec = source_sec;
5093 reloc->r_rel = *r_rel;
5094 reloc->opcode = opcode;
5096 reloc->is_null = FALSE;
5097 reloc->is_abs_literal = is_abs_literal;
5101 /* Find the source_reloc for a particular source offset and relocation
5102 type. Note that the array is sorted by _target_ offset, so this is
5103 just a linear search. */
5105 static source_reloc *
5106 find_source_reloc (source_reloc *src_relocs,
5109 Elf_Internal_Rela *irel)
5113 for (i = 0; i < src_count; i++)
5115 if (src_relocs[i].source_sec == sec
5116 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
5117 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
5118 == ELF32_R_TYPE (irel->r_info)))
5119 return &src_relocs[i];
5127 source_reloc_compare (const void *ap, const void *bp)
5129 const source_reloc *a = (const source_reloc *) ap;
5130 const source_reloc *b = (const source_reloc *) bp;
5132 if (a->r_rel.target_offset != b->r_rel.target_offset)
5133 return (a->r_rel.target_offset - b->r_rel.target_offset);
5135 /* We don't need to sort on these criteria for correctness,
5136 but enforcing a more strict ordering prevents unstable qsort
5137 from behaving differently with different implementations.
5138 Without the code below we get correct but different results
5139 on Solaris 2.7 and 2.8. We would like to always produce the
5140 same results no matter the host. */
5142 if ((!a->is_null) - (!b->is_null))
5143 return ((!a->is_null) - (!b->is_null));
5144 return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
5148 /* Literal values and value hash tables. */
5150 /* Literals with the same value can be coalesced. The literal_value
5151 structure records the value of a literal: the "r_rel" field holds the
5152 information from the relocation on the literal (if there is one) and
5153 the "value" field holds the contents of the literal word itself.
5155 The value_map structure records a literal value along with the
5156 location of a literal holding that value. The value_map hash table
5157 is indexed by the literal value, so that we can quickly check if a
5158 particular literal value has been seen before and is thus a candidate
5161 typedef struct literal_value_struct literal_value;
5162 typedef struct value_map_struct value_map;
5163 typedef struct value_map_hash_table_struct value_map_hash_table;
5165 struct literal_value_struct
5168 unsigned long value;
5169 bfd_boolean is_abs_literal;
5172 struct value_map_struct
5174 literal_value val; /* The literal value. */
5175 r_reloc loc; /* Location of the literal. */
5179 struct value_map_hash_table_struct
5181 unsigned bucket_count;
5182 value_map **buckets;
5184 bfd_boolean has_last_loc;
5190 init_literal_value (literal_value *lit,
5191 const r_reloc *r_rel,
5192 unsigned long value,
5193 bfd_boolean is_abs_literal)
5195 lit->r_rel = *r_rel;
5197 lit->is_abs_literal = is_abs_literal;
5202 literal_value_equal (const literal_value *src1,
5203 const literal_value *src2,
5204 bfd_boolean final_static_link)
5206 struct elf_link_hash_entry *h1, *h2;
5208 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
5211 if (r_reloc_is_const (&src1->r_rel))
5212 return (src1->value == src2->value);
5214 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
5215 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
5218 if (src1->r_rel.target_offset != src2->r_rel.target_offset)
5221 if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
5224 if (src1->value != src2->value)
5227 /* Now check for the same section (if defined) or the same elf_hash
5228 (if undefined or weak). */
5229 h1 = r_reloc_get_hash_entry (&src1->r_rel);
5230 h2 = r_reloc_get_hash_entry (&src2->r_rel);
5231 if (r_reloc_is_defined (&src1->r_rel)
5232 && (final_static_link
5233 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
5234 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
5236 if (r_reloc_get_section (&src1->r_rel)
5237 != r_reloc_get_section (&src2->r_rel))
5242 /* Require that the hash entries (i.e., symbols) be identical. */
5243 if (h1 != h2 || h1 == 0)
5247 if (src1->is_abs_literal != src2->is_abs_literal)
5254 /* Must be power of 2. */
5255 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5257 static value_map_hash_table *
5258 value_map_hash_table_init (void)
5260 value_map_hash_table *values;
5262 values = (value_map_hash_table *)
5263 bfd_zmalloc (sizeof (value_map_hash_table));
5264 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
5266 values->buckets = (value_map **)
5267 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
5268 if (values->buckets == NULL)
5273 values->has_last_loc = FALSE;
5280 value_map_hash_table_delete (value_map_hash_table *table)
5282 free (table->buckets);
5288 hash_bfd_vma (bfd_vma val)
5290 return (val >> 2) + (val >> 10);
5295 literal_value_hash (const literal_value *src)
5299 hash_val = hash_bfd_vma (src->value);
5300 if (!r_reloc_is_const (&src->r_rel))
5304 hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
5305 hash_val += hash_bfd_vma (src->r_rel.target_offset);
5306 hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
5308 /* Now check for the same section and the same elf_hash. */
5309 if (r_reloc_is_defined (&src->r_rel))
5310 sec_or_hash = r_reloc_get_section (&src->r_rel);
5312 sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
5313 hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
5319 /* Check if the specified literal_value has been seen before. */
5322 value_map_get_cached_value (value_map_hash_table *map,
5323 const literal_value *val,
5324 bfd_boolean final_static_link)
5330 idx = literal_value_hash (val);
5331 idx = idx & (map->bucket_count - 1);
5332 bucket = map->buckets[idx];
5333 for (map_e = bucket; map_e; map_e = map_e->next)
5335 if (literal_value_equal (&map_e->val, val, final_static_link))
5342 /* Record a new literal value. It is illegal to call this if VALUE
5343 already has an entry here. */
5346 add_value_map (value_map_hash_table *map,
5347 const literal_value *val,
5349 bfd_boolean final_static_link)
5351 value_map **bucket_p;
5354 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
5357 bfd_set_error (bfd_error_no_memory);
5361 BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
5365 idx = literal_value_hash (val);
5366 idx = idx & (map->bucket_count - 1);
5367 bucket_p = &map->buckets[idx];
5369 val_e->next = *bucket_p;
5372 /* FIXME: Consider resizing the hash table if we get too many entries. */
5378 /* Lists of text actions (ta_) for narrowing, widening, longcall
5379 conversion, space fill, code & literal removal, etc. */
5381 /* The following text actions are generated:
5383 "ta_remove_insn" remove an instruction or instructions
5384 "ta_remove_longcall" convert longcall to call
5385 "ta_convert_longcall" convert longcall to nop/call
5386 "ta_narrow_insn" narrow a wide instruction
5387 "ta_widen" widen a narrow instruction
5388 "ta_fill" add fill or remove fill
5389 removed < 0 is a fill; branches to the fill address will be
5390 changed to address + fill size (e.g., address - removed)
5391 removed >= 0 branches to the fill address will stay unchanged
5392 "ta_remove_literal" remove a literal; this action is
5393 indicated when a literal is removed
5395 "ta_add_literal" insert a new literal; this action is
5396 indicated when a literal has been moved.
5397 It may use a virtual_offset because
5398 multiple literals can be placed at the
5401 For each of these text actions, we also record the number of bytes
5402 removed by performing the text action. In the case of a "ta_widen"
5403 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5405 typedef struct text_action_struct text_action;
5406 typedef struct text_action_list_struct text_action_list;
5407 typedef enum text_action_enum_t text_action_t;
5409 enum text_action_enum_t
5412 ta_remove_insn, /* removed = -size */
5413 ta_remove_longcall, /* removed = -size */
5414 ta_convert_longcall, /* removed = 0 */
5415 ta_narrow_insn, /* removed = -1 */
5416 ta_widen_insn, /* removed = +1 */
5417 ta_fill, /* removed = +size */
5423 /* Structure for a text action record. */
5424 struct text_action_struct
5426 text_action_t action;
5427 asection *sec; /* Optional */
5429 bfd_vma virtual_offset; /* Zero except for adding literals. */
5431 literal_value value; /* Only valid when adding literals. */
5434 struct removal_by_action_entry_struct
5439 int eq_removed_before_fill;
5441 typedef struct removal_by_action_entry_struct removal_by_action_entry;
5443 struct removal_by_action_map_struct
5446 removal_by_action_entry *entry;
5448 typedef struct removal_by_action_map_struct removal_by_action_map;
5451 /* List of all of the actions taken on a text section. */
5452 struct text_action_list_struct
5456 removal_by_action_map map;
5460 static text_action *
5461 find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
5465 /* It is not necessary to fill at the end of a section. */
5466 if (sec->size == offset)
5472 splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
5474 return (text_action *)node->value;
5480 compute_removed_action_diff (const text_action *ta,
5484 int removable_space)
5487 int current_removed = 0;
5490 current_removed = ta->removed_bytes;
5492 BFD_ASSERT (ta == NULL || ta->offset == offset);
5493 BFD_ASSERT (ta == NULL || ta->action == ta_fill);
5495 /* It is not necessary to fill at the end of a section. Clean this up. */
5496 if (sec->size == offset)
5497 new_removed = removable_space - 0;
5501 int added = -removed - current_removed;
5502 /* Ignore multiples of the section alignment. */
5503 added = ((1 << sec->alignment_power) - 1) & added;
5504 new_removed = (-added);
5506 /* Modify for removable. */
5507 space = removable_space - new_removed;
5508 new_removed = (removable_space
5509 - (((1 << sec->alignment_power) - 1) & space));
5511 return (new_removed - current_removed);
5516 adjust_fill_action (text_action *ta, int fill_diff)
5518 ta->removed_bytes += fill_diff;
5523 text_action_compare (splay_tree_key a, splay_tree_key b)
5525 text_action *pa = (text_action *)a;
5526 text_action *pb = (text_action *)b;
5527 static const int action_priority[] =
5531 [ta_convert_longcall] = 2,
5532 [ta_narrow_insn] = 3,
5533 [ta_remove_insn] = 4,
5534 [ta_remove_longcall] = 5,
5535 [ta_remove_literal] = 6,
5536 [ta_widen_insn] = 7,
5537 [ta_add_literal] = 8,
5540 if (pa->offset == pb->offset)
5542 if (pa->action == pb->action)
5544 return action_priority[pa->action] - action_priority[pb->action];
5547 return pa->offset < pb->offset ? -1 : 1;
5550 static text_action *
5551 action_first (text_action_list *action_list)
5553 splay_tree_node node = splay_tree_min (action_list->tree);
5554 return node ? (text_action *)node->value : NULL;
5557 static text_action *
5558 action_next (text_action_list *action_list, text_action *action)
5560 splay_tree_node node = splay_tree_successor (action_list->tree,
5561 (splay_tree_key)action);
5562 return node ? (text_action *)node->value : NULL;
5565 /* Add a modification action to the text. For the case of adding or
5566 removing space, modify any current fill and assume that
5567 "unreachable_space" bytes can be freely contracted. Note that a
5568 negative removed value is a fill. */
5571 text_action_add (text_action_list *l,
5572 text_action_t action,
5580 /* It is not necessary to fill at the end of a section. */
5581 if (action == ta_fill && sec->size == offset)
5584 /* It is not necessary to fill 0 bytes. */
5585 if (action == ta_fill && removed == 0)
5591 if (action == ta_fill)
5593 splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
5597 ta = (text_action *)node->value;
5598 ta->removed_bytes += removed;
5603 BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)&a) == NULL);
5605 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5606 ta->action = action;
5608 ta->offset = offset;
5609 ta->removed_bytes = removed;
5610 splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
5616 text_action_add_literal (text_action_list *l,
5617 text_action_t action,
5619 const literal_value *value,
5623 asection *sec = r_reloc_get_section (loc);
5624 bfd_vma offset = loc->target_offset;
5625 bfd_vma virtual_offset = loc->virtual_offset;
5627 BFD_ASSERT (action == ta_add_literal);
5629 /* Create a new record and fill it up. */
5630 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5631 ta->action = action;
5633 ta->offset = offset;
5634 ta->virtual_offset = virtual_offset;
5636 ta->removed_bytes = removed;
5638 BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)ta) == NULL);
5639 splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
5644 /* Find the total offset adjustment for the relaxations specified by
5645 text_actions, beginning from a particular starting action. This is
5646 typically used from offset_with_removed_text to search an entire list of
5647 actions, but it may also be called directly when adjusting adjacent offsets
5648 so that each search may begin where the previous one left off. */
5651 removed_by_actions (text_action_list *action_list,
5652 text_action **p_start_action,
5654 bfd_boolean before_fill)
5659 r = *p_start_action;
5662 splay_tree_node node = splay_tree_lookup (action_list->tree,
5664 BFD_ASSERT (node != NULL && r == (text_action *)node->value);
5669 if (r->offset > offset)
5672 if (r->offset == offset
5673 && (before_fill || r->action != ta_fill || r->removed_bytes >= 0))
5676 removed += r->removed_bytes;
5678 r = action_next (action_list, r);
5681 *p_start_action = r;
5687 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
5689 text_action *r = action_first (action_list);
5691 return offset - removed_by_actions (action_list, &r, offset, FALSE);
5696 action_list_count (text_action_list *action_list)
5698 return action_list->count;
5701 typedef struct map_action_fn_context_struct map_action_fn_context;
5702 struct map_action_fn_context_struct
5705 removal_by_action_map map;
5706 bfd_boolean eq_complete;
5710 map_action_fn (splay_tree_node node, void *p)
5712 map_action_fn_context *ctx = p;
5713 text_action *r = (text_action *)node->value;
5714 removal_by_action_entry *ientry = ctx->map.entry + ctx->map.n_entries;
5716 if (ctx->map.n_entries && (ientry - 1)->offset == r->offset)
5722 ++ctx->map.n_entries;
5723 ctx->eq_complete = FALSE;
5724 ientry->offset = r->offset;
5725 ientry->eq_removed_before_fill = ctx->removed;
5728 if (!ctx->eq_complete)
5730 if (r->action != ta_fill || r->removed_bytes >= 0)
5732 ientry->eq_removed = ctx->removed;
5733 ctx->eq_complete = TRUE;
5736 ientry->eq_removed = ctx->removed + r->removed_bytes;
5739 ctx->removed += r->removed_bytes;
5740 ientry->removed = ctx->removed;
5745 map_removal_by_action (text_action_list *action_list)
5747 map_action_fn_context ctx;
5750 ctx.map.n_entries = 0;
5751 ctx.map.entry = bfd_malloc (action_list_count (action_list) *
5752 sizeof (removal_by_action_entry));
5753 ctx.eq_complete = FALSE;
5755 splay_tree_foreach (action_list->tree, map_action_fn, &ctx);
5756 action_list->map = ctx.map;
5760 removed_by_actions_map (text_action_list *action_list, bfd_vma offset,
5761 bfd_boolean before_fill)
5765 if (!action_list->map.entry)
5766 map_removal_by_action (action_list);
5768 if (!action_list->map.n_entries)
5772 b = action_list->map.n_entries;
5776 unsigned c = (a + b) / 2;
5778 if (action_list->map.entry[c].offset <= offset)
5784 if (action_list->map.entry[a].offset < offset)
5786 return action_list->map.entry[a].removed;
5788 else if (action_list->map.entry[a].offset == offset)
5790 return before_fill ?
5791 action_list->map.entry[a].eq_removed_before_fill :
5792 action_list->map.entry[a].eq_removed;
5801 offset_with_removed_text_map (text_action_list *action_list, bfd_vma offset)
5803 int removed = removed_by_actions_map (action_list, offset, FALSE);
5804 return offset - removed;
5808 /* The find_insn_action routine will only find non-fill actions. */
5810 static text_action *
5811 find_insn_action (text_action_list *action_list, bfd_vma offset)
5813 static const text_action_t action[] =
5815 ta_convert_longcall,
5825 for (i = 0; i < sizeof (action) / sizeof (*action); ++i)
5827 splay_tree_node node;
5829 a.action = action[i];
5830 node = splay_tree_lookup (action_list->tree, (splay_tree_key)&a);
5832 return (text_action *)node->value;
5841 print_action (FILE *fp, text_action *r)
5843 const char *t = "unknown";
5846 case ta_remove_insn:
5847 t = "remove_insn"; break;
5848 case ta_remove_longcall:
5849 t = "remove_longcall"; break;
5850 case ta_convert_longcall:
5851 t = "convert_longcall"; break;
5852 case ta_narrow_insn:
5853 t = "narrow_insn"; break;
5855 t = "widen_insn"; break;
5860 case ta_remove_literal:
5861 t = "remove_literal"; break;
5862 case ta_add_literal:
5863 t = "add_literal"; break;
5866 fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
5867 r->sec->owner->filename,
5868 r->sec->name, (unsigned long) r->offset, t, r->removed_bytes);
5872 print_action_list_fn (splay_tree_node node, void *p)
5874 text_action *r = (text_action *)node->value;
5876 print_action (p, r);
5881 print_action_list (FILE *fp, text_action_list *action_list)
5883 fprintf (fp, "Text Action\n");
5884 splay_tree_foreach (action_list->tree, print_action_list_fn, fp);
5890 /* Lists of literals being coalesced or removed. */
5892 /* In the usual case, the literal identified by "from" is being
5893 coalesced with another literal identified by "to". If the literal is
5894 unused and is being removed altogether, "to.abfd" will be NULL.
5895 The removed_literal entries are kept on a per-section list, sorted
5896 by the "from" offset field. */
5898 typedef struct removed_literal_struct removed_literal;
5899 typedef struct removed_literal_map_entry_struct removed_literal_map_entry;
5900 typedef struct removed_literal_list_struct removed_literal_list;
5902 struct removed_literal_struct
5906 removed_literal *next;
5909 struct removed_literal_map_entry_struct
5912 removed_literal *literal;
5915 struct removed_literal_list_struct
5917 removed_literal *head;
5918 removed_literal *tail;
5921 removed_literal_map_entry *map;
5925 /* Record that the literal at "from" is being removed. If "to" is not
5926 NULL, the "from" literal is being coalesced with the "to" literal. */
5929 add_removed_literal (removed_literal_list *removed_list,
5930 const r_reloc *from,
5933 removed_literal *r, *new_r, *next_r;
5935 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
5937 new_r->from = *from;
5941 new_r->to.abfd = NULL;
5944 r = removed_list->head;
5947 removed_list->head = new_r;
5948 removed_list->tail = new_r;
5950 /* Special check for common case of append. */
5951 else if (removed_list->tail->from.target_offset < from->target_offset)
5953 removed_list->tail->next = new_r;
5954 removed_list->tail = new_r;
5958 while (r->from.target_offset < from->target_offset && r->next)
5964 new_r->next = next_r;
5966 removed_list->tail = new_r;
5971 map_removed_literal (removed_literal_list *removed_list)
5975 removed_literal_map_entry *map = NULL;
5976 removed_literal *r = removed_list->head;
5978 for (i = 0; r; ++i, r = r->next)
5982 n_map = (n_map * 2) + 2;
5983 map = bfd_realloc (map, n_map * sizeof (*map));
5985 map[i].addr = r->from.target_offset;
5988 removed_list->map = map;
5989 removed_list->n_map = i;
5993 removed_literal_compare (const void *a, const void *b)
5995 const removed_literal_map_entry *pa = a;
5996 const removed_literal_map_entry *pb = b;
5998 if (pa->addr == pb->addr)
6001 return pa->addr < pb->addr ? -1 : 1;
6004 /* Check if the list of removed literals contains an entry for the
6005 given address. Return the entry if found. */
6007 static removed_literal *
6008 find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
6010 removed_literal_map_entry *p;
6011 removed_literal *r = NULL;
6013 if (removed_list->map == NULL)
6014 map_removed_literal (removed_list);
6016 p = bsearch (&addr, removed_list->map, removed_list->n_map,
6017 sizeof (*removed_list->map), removed_literal_compare);
6020 while (p != removed_list->map && (p - 1)->addr == addr)
6031 print_removed_literals (FILE *fp, removed_literal_list *removed_list)
6034 r = removed_list->head;
6036 fprintf (fp, "Removed Literals\n");
6037 for (; r != NULL; r = r->next)
6039 print_r_reloc (fp, &r->from);
6040 fprintf (fp, " => ");
6041 if (r->to.abfd == NULL)
6042 fprintf (fp, "REMOVED");
6044 print_r_reloc (fp, &r->to);
6052 /* Per-section data for relaxation. */
6054 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
6056 struct xtensa_relax_info_struct
6058 bfd_boolean is_relaxable_literal_section;
6059 bfd_boolean is_relaxable_asm_section;
6060 int visited; /* Number of times visited. */
6062 source_reloc *src_relocs; /* Array[src_count]. */
6064 int src_next; /* Next src_relocs entry to assign. */
6066 removed_literal_list removed_list;
6067 text_action_list action_list;
6069 reloc_bfd_fix *fix_list;
6070 reloc_bfd_fix *fix_array;
6071 unsigned fix_array_count;
6073 /* Support for expanding the reloc array that is stored
6074 in the section structure. If the relocations have been
6075 reallocated, the newly allocated relocations will be referenced
6076 here along with the actual size allocated. The relocation
6077 count will always be found in the section structure. */
6078 Elf_Internal_Rela *allocated_relocs;
6079 unsigned relocs_count;
6080 unsigned allocated_relocs_count;
6083 struct elf_xtensa_section_data
6085 struct bfd_elf_section_data elf;
6086 xtensa_relax_info relax_info;
6091 elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
6093 if (!sec->used_by_bfd)
6095 struct elf_xtensa_section_data *sdata;
6096 bfd_size_type amt = sizeof (*sdata);
6098 sdata = bfd_zalloc (abfd, amt);
6101 sec->used_by_bfd = sdata;
6104 return _bfd_elf_new_section_hook (abfd, sec);
6108 static xtensa_relax_info *
6109 get_xtensa_relax_info (asection *sec)
6111 struct elf_xtensa_section_data *section_data;
6113 /* No info available if no section or if it is an output section. */
6114 if (!sec || sec == sec->output_section)
6117 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
6118 return §ion_data->relax_info;
6123 init_xtensa_relax_info (asection *sec)
6125 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6127 relax_info->is_relaxable_literal_section = FALSE;
6128 relax_info->is_relaxable_asm_section = FALSE;
6129 relax_info->visited = 0;
6131 relax_info->src_relocs = NULL;
6132 relax_info->src_count = 0;
6133 relax_info->src_next = 0;
6135 relax_info->removed_list.head = NULL;
6136 relax_info->removed_list.tail = NULL;
6138 relax_info->action_list.tree = splay_tree_new (text_action_compare,
6140 relax_info->action_list.map.n_entries = 0;
6141 relax_info->action_list.map.entry = NULL;
6143 relax_info->fix_list = NULL;
6144 relax_info->fix_array = NULL;
6145 relax_info->fix_array_count = 0;
6147 relax_info->allocated_relocs = NULL;
6148 relax_info->relocs_count = 0;
6149 relax_info->allocated_relocs_count = 0;
6153 /* Coalescing literals may require a relocation to refer to a section in
6154 a different input file, but the standard relocation information
6155 cannot express that. Instead, the reloc_bfd_fix structures are used
6156 to "fix" the relocations that refer to sections in other input files.
6157 These structures are kept on per-section lists. The "src_type" field
6158 records the relocation type in case there are multiple relocations on
6159 the same location. FIXME: This is ugly; an alternative might be to
6160 add new symbols with the "owner" field to some other input file. */
6162 struct reloc_bfd_fix_struct
6166 unsigned src_type; /* Relocation type. */
6168 asection *target_sec;
6169 bfd_vma target_offset;
6170 bfd_boolean translated;
6172 reloc_bfd_fix *next;
6176 static reloc_bfd_fix *
6177 reloc_bfd_fix_init (asection *src_sec,
6180 asection *target_sec,
6181 bfd_vma target_offset,
6182 bfd_boolean translated)
6186 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
6187 fix->src_sec = src_sec;
6188 fix->src_offset = src_offset;
6189 fix->src_type = src_type;
6190 fix->target_sec = target_sec;
6191 fix->target_offset = target_offset;
6192 fix->translated = translated;
6199 add_fix (asection *src_sec, reloc_bfd_fix *fix)
6201 xtensa_relax_info *relax_info;
6203 relax_info = get_xtensa_relax_info (src_sec);
6204 fix->next = relax_info->fix_list;
6205 relax_info->fix_list = fix;
6210 fix_compare (const void *ap, const void *bp)
6212 const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
6213 const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
6215 if (a->src_offset != b->src_offset)
6216 return (a->src_offset - b->src_offset);
6217 return (a->src_type - b->src_type);
6222 cache_fix_array (asection *sec)
6224 unsigned i, count = 0;
6226 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6228 if (relax_info == NULL)
6230 if (relax_info->fix_list == NULL)
6233 for (r = relax_info->fix_list; r != NULL; r = r->next)
6236 relax_info->fix_array =
6237 (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
6238 relax_info->fix_array_count = count;
6240 r = relax_info->fix_list;
6241 for (i = 0; i < count; i++, r = r->next)
6243 relax_info->fix_array[count - 1 - i] = *r;
6244 relax_info->fix_array[count - 1 - i].next = NULL;
6247 qsort (relax_info->fix_array, relax_info->fix_array_count,
6248 sizeof (reloc_bfd_fix), fix_compare);
6252 static reloc_bfd_fix *
6253 get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
6255 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6259 if (relax_info == NULL)
6261 if (relax_info->fix_list == NULL)
6264 if (relax_info->fix_array == NULL)
6265 cache_fix_array (sec);
6267 key.src_offset = offset;
6268 key.src_type = type;
6269 rv = bsearch (&key, relax_info->fix_array, relax_info->fix_array_count,
6270 sizeof (reloc_bfd_fix), fix_compare);
6275 /* Section caching. */
6277 typedef struct section_cache_struct section_cache_t;
6279 struct section_cache_struct
6283 bfd_byte *contents; /* Cache of the section contents. */
6284 bfd_size_type content_length;
6286 property_table_entry *ptbl; /* Cache of the section property table. */
6289 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6290 unsigned reloc_count;
6295 init_section_cache (section_cache_t *sec_cache)
6297 memset (sec_cache, 0, sizeof (*sec_cache));
6302 free_section_cache (section_cache_t *sec_cache)
6306 release_contents (sec_cache->sec, sec_cache->contents);
6307 release_internal_relocs (sec_cache->sec, sec_cache->relocs);
6308 if (sec_cache->ptbl)
6309 free (sec_cache->ptbl);
6315 section_cache_section (section_cache_t *sec_cache,
6317 struct bfd_link_info *link_info)
6320 property_table_entry *prop_table = NULL;
6322 bfd_byte *contents = NULL;
6323 Elf_Internal_Rela *internal_relocs = NULL;
6324 bfd_size_type sec_size;
6328 if (sec == sec_cache->sec)
6332 sec_size = bfd_get_section_limit (abfd, sec);
6334 /* Get the contents. */
6335 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6336 if (contents == NULL && sec_size != 0)
6339 /* Get the relocations. */
6340 internal_relocs = retrieve_internal_relocs (abfd, sec,
6341 link_info->keep_memory);
6343 /* Get the entry table. */
6344 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6345 XTENSA_PROP_SEC_NAME, FALSE);
6349 /* Fill in the new section cache. */
6350 free_section_cache (sec_cache);
6351 init_section_cache (sec_cache);
6353 sec_cache->sec = sec;
6354 sec_cache->contents = contents;
6355 sec_cache->content_length = sec_size;
6356 sec_cache->relocs = internal_relocs;
6357 sec_cache->reloc_count = sec->reloc_count;
6358 sec_cache->pte_count = ptblsize;
6359 sec_cache->ptbl = prop_table;
6364 release_contents (sec, contents);
6365 release_internal_relocs (sec, internal_relocs);
6372 /* Extended basic blocks. */
6374 /* An ebb_struct represents an Extended Basic Block. Within this
6375 range, we guarantee that all instructions are decodable, the
6376 property table entries are contiguous, and no property table
6377 specifies a segment that cannot have instructions moved. This
6378 structure contains caches of the contents, property table and
6379 relocations for the specified section for easy use. The range is
6380 specified by ranges of indices for the byte offset, property table
6381 offsets and relocation offsets. These must be consistent. */
6383 typedef struct ebb_struct ebb_t;
6389 bfd_byte *contents; /* Cache of the section contents. */
6390 bfd_size_type content_length;
6392 property_table_entry *ptbl; /* Cache of the section property table. */
6395 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6396 unsigned reloc_count;
6398 bfd_vma start_offset; /* Offset in section. */
6399 unsigned start_ptbl_idx; /* Offset in the property table. */
6400 unsigned start_reloc_idx; /* Offset in the relocations. */
6403 unsigned end_ptbl_idx;
6404 unsigned end_reloc_idx;
6406 bfd_boolean ends_section; /* Is this the last ebb in a section? */
6408 /* The unreachable property table at the end of this set of blocks;
6409 NULL if the end is not an unreachable block. */
6410 property_table_entry *ends_unreachable;
6414 enum ebb_target_enum
6417 EBB_DESIRE_TGT_ALIGN,
6418 EBB_REQUIRE_TGT_ALIGN,
6419 EBB_REQUIRE_LOOP_ALIGN,
6424 /* proposed_action_struct is similar to the text_action_struct except
6425 that is represents a potential transformation, not one that will
6426 occur. We build a list of these for an extended basic block
6427 and use them to compute the actual actions desired. We must be
6428 careful that the entire set of actual actions we perform do not
6429 break any relocations that would fit if the actions were not
6432 typedef struct proposed_action_struct proposed_action;
6434 struct proposed_action_struct
6436 enum ebb_target_enum align_type; /* for the target alignment */
6437 bfd_vma alignment_pow;
6438 text_action_t action;
6441 bfd_boolean do_action; /* If false, then we will not perform the action. */
6445 /* The ebb_constraint_struct keeps a set of proposed actions for an
6446 extended basic block. */
6448 typedef struct ebb_constraint_struct ebb_constraint;
6450 struct ebb_constraint_struct
6453 bfd_boolean start_movable;
6455 /* Bytes of extra space at the beginning if movable. */
6456 int start_extra_space;
6458 enum ebb_target_enum start_align;
6460 bfd_boolean end_movable;
6462 /* Bytes of extra space at the end if movable. */
6463 int end_extra_space;
6465 unsigned action_count;
6466 unsigned action_allocated;
6468 /* Array of proposed actions. */
6469 proposed_action *actions;
6471 /* Action alignments -- one for each proposed action. */
6472 enum ebb_target_enum *action_aligns;
6477 init_ebb_constraint (ebb_constraint *c)
6479 memset (c, 0, sizeof (ebb_constraint));
6484 free_ebb_constraint (ebb_constraint *c)
6492 init_ebb (ebb_t *ebb,
6495 bfd_size_type content_length,
6496 property_table_entry *prop_table,
6498 Elf_Internal_Rela *internal_relocs,
6499 unsigned reloc_count)
6501 memset (ebb, 0, sizeof (ebb_t));
6503 ebb->contents = contents;
6504 ebb->content_length = content_length;
6505 ebb->ptbl = prop_table;
6506 ebb->pte_count = ptblsize;
6507 ebb->relocs = internal_relocs;
6508 ebb->reloc_count = reloc_count;
6509 ebb->start_offset = 0;
6510 ebb->end_offset = ebb->content_length - 1;
6511 ebb->start_ptbl_idx = 0;
6512 ebb->end_ptbl_idx = ptblsize;
6513 ebb->start_reloc_idx = 0;
6514 ebb->end_reloc_idx = reloc_count;
6518 /* Extend the ebb to all decodable contiguous sections. The algorithm
6519 for building a basic block around an instruction is to push it
6520 forward until we hit the end of a section, an unreachable block or
6521 a block that cannot be transformed. Then we push it backwards
6522 searching for similar conditions. */
6524 static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
6525 static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
6526 static bfd_size_type insn_block_decodable_len
6527 (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
6530 extend_ebb_bounds (ebb_t *ebb)
6532 if (!extend_ebb_bounds_forward (ebb))
6534 if (!extend_ebb_bounds_backward (ebb))
6541 extend_ebb_bounds_forward (ebb_t *ebb)
6543 property_table_entry *the_entry, *new_entry;
6545 the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6547 /* Stop when (1) we cannot decode an instruction, (2) we are at
6548 the end of the property tables, (3) we hit a non-contiguous property
6549 table entry, (4) we hit a NO_TRANSFORM region. */
6554 bfd_size_type insn_block_len;
6556 entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
6558 insn_block_decodable_len (ebb->contents, ebb->content_length,
6560 entry_end - ebb->end_offset);
6561 if (insn_block_len != (entry_end - ebb->end_offset))
6563 (*_bfd_error_handler)
6564 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6565 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6568 ebb->end_offset += insn_block_len;
6570 if (ebb->end_offset == ebb->sec->size)
6571 ebb->ends_section = TRUE;
6573 /* Update the reloc counter. */
6574 while (ebb->end_reloc_idx + 1 < ebb->reloc_count
6575 && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
6578 ebb->end_reloc_idx++;
6581 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6584 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6585 if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
6586 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6587 || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
6590 if (the_entry->address + the_entry->size != new_entry->address)
6593 the_entry = new_entry;
6594 ebb->end_ptbl_idx++;
6597 /* Quick check for an unreachable or end of file just at the end. */
6598 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6600 if (ebb->end_offset == ebb->content_length)
6601 ebb->ends_section = TRUE;
6605 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6606 if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
6607 && the_entry->address + the_entry->size == new_entry->address)
6608 ebb->ends_unreachable = new_entry;
6611 /* Any other ending requires exact alignment. */
6617 extend_ebb_bounds_backward (ebb_t *ebb)
6619 property_table_entry *the_entry, *new_entry;
6621 the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6623 /* Stop when (1) we cannot decode the instructions in the current entry.
6624 (2) we are at the beginning of the property tables, (3) we hit a
6625 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6629 bfd_vma block_begin;
6630 bfd_size_type insn_block_len;
6632 block_begin = the_entry->address - ebb->sec->vma;
6634 insn_block_decodable_len (ebb->contents, ebb->content_length,
6636 ebb->start_offset - block_begin);
6637 if (insn_block_len != ebb->start_offset - block_begin)
6639 (*_bfd_error_handler)
6640 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6641 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6644 ebb->start_offset -= insn_block_len;
6646 /* Update the reloc counter. */
6647 while (ebb->start_reloc_idx > 0
6648 && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
6649 >= ebb->start_offset))
6651 ebb->start_reloc_idx--;
6654 if (ebb->start_ptbl_idx == 0)
6657 new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
6658 if ((new_entry->flags & XTENSA_PROP_INSN) == 0
6659 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6660 || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
6662 if (new_entry->address + new_entry->size != the_entry->address)
6665 the_entry = new_entry;
6666 ebb->start_ptbl_idx--;
6672 static bfd_size_type
6673 insn_block_decodable_len (bfd_byte *contents,
6674 bfd_size_type content_len,
6675 bfd_vma block_offset,
6676 bfd_size_type block_len)
6678 bfd_vma offset = block_offset;
6680 while (offset < block_offset + block_len)
6682 bfd_size_type insn_len = 0;
6684 insn_len = insn_decode_len (contents, content_len, offset);
6686 return (offset - block_offset);
6689 return (offset - block_offset);
6694 ebb_propose_action (ebb_constraint *c,
6695 enum ebb_target_enum align_type,
6696 bfd_vma alignment_pow,
6697 text_action_t action,
6700 bfd_boolean do_action)
6702 proposed_action *act;
6704 if (c->action_allocated <= c->action_count)
6706 unsigned new_allocated, i;
6707 proposed_action *new_actions;
6709 new_allocated = (c->action_count + 2) * 2;
6710 new_actions = (proposed_action *)
6711 bfd_zmalloc (sizeof (proposed_action) * new_allocated);
6713 for (i = 0; i < c->action_count; i++)
6714 new_actions[i] = c->actions[i];
6717 c->actions = new_actions;
6718 c->action_allocated = new_allocated;
6721 act = &c->actions[c->action_count];
6722 act->align_type = align_type;
6723 act->alignment_pow = alignment_pow;
6724 act->action = action;
6725 act->offset = offset;
6726 act->removed_bytes = removed_bytes;
6727 act->do_action = do_action;
6733 /* Access to internal relocations, section contents and symbols. */
6735 /* During relaxation, we need to modify relocations, section contents,
6736 and symbol definitions, and we need to keep the original values from
6737 being reloaded from the input files, i.e., we need to "pin" the
6738 modified values in memory. We also want to continue to observe the
6739 setting of the "keep-memory" flag. The following functions wrap the
6740 standard BFD functions to take care of this for us. */
6742 static Elf_Internal_Rela *
6743 retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6745 Elf_Internal_Rela *internal_relocs;
6747 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6750 internal_relocs = elf_section_data (sec)->relocs;
6751 if (internal_relocs == NULL)
6752 internal_relocs = (_bfd_elf_link_read_relocs
6753 (abfd, sec, NULL, NULL, keep_memory));
6754 return internal_relocs;
6759 pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6761 elf_section_data (sec)->relocs = internal_relocs;
6766 release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6769 && elf_section_data (sec)->relocs != internal_relocs)
6770 free (internal_relocs);
6775 retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6778 bfd_size_type sec_size;
6780 sec_size = bfd_get_section_limit (abfd, sec);
6781 contents = elf_section_data (sec)->this_hdr.contents;
6783 if (contents == NULL && sec_size != 0)
6785 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
6792 elf_section_data (sec)->this_hdr.contents = contents;
6799 pin_contents (asection *sec, bfd_byte *contents)
6801 elf_section_data (sec)->this_hdr.contents = contents;
6806 release_contents (asection *sec, bfd_byte *contents)
6808 if (contents && elf_section_data (sec)->this_hdr.contents != contents)
6813 static Elf_Internal_Sym *
6814 retrieve_local_syms (bfd *input_bfd)
6816 Elf_Internal_Shdr *symtab_hdr;
6817 Elf_Internal_Sym *isymbuf;
6820 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6821 locsymcount = symtab_hdr->sh_info;
6823 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6824 if (isymbuf == NULL && locsymcount != 0)
6825 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
6828 /* Save the symbols for this input file so they won't be read again. */
6829 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
6830 symtab_hdr->contents = (unsigned char *) isymbuf;
6836 /* Code for link-time relaxation. */
6838 /* Initialization for relaxation: */
6839 static bfd_boolean analyze_relocations (struct bfd_link_info *);
6840 static bfd_boolean find_relaxable_sections
6841 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
6842 static bfd_boolean collect_source_relocs
6843 (bfd *, asection *, struct bfd_link_info *);
6844 static bfd_boolean is_resolvable_asm_expansion
6845 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
6847 static Elf_Internal_Rela *find_associated_l32r_irel
6848 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
6849 static bfd_boolean compute_text_actions
6850 (bfd *, asection *, struct bfd_link_info *);
6851 static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
6852 static bfd_boolean compute_ebb_actions (ebb_constraint *);
6853 typedef struct reloc_range_list_struct reloc_range_list;
6854 static bfd_boolean check_section_ebb_pcrels_fit
6855 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
6856 reloc_range_list *, const ebb_constraint *,
6857 const xtensa_opcode *);
6858 static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
6859 static void text_action_add_proposed
6860 (text_action_list *, const ebb_constraint *, asection *);
6861 static int compute_fill_extra_space (property_table_entry *);
6864 static bfd_boolean compute_removed_literals
6865 (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
6866 static Elf_Internal_Rela *get_irel_at_offset
6867 (asection *, Elf_Internal_Rela *, bfd_vma);
6868 static bfd_boolean is_removable_literal
6869 (const source_reloc *, int, const source_reloc *, int, asection *,
6870 property_table_entry *, int);
6871 static bfd_boolean remove_dead_literal
6872 (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
6873 Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
6874 static bfd_boolean identify_literal_placement
6875 (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
6876 value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
6877 source_reloc *, property_table_entry *, int, section_cache_t *,
6879 static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
6880 static bfd_boolean coalesce_shared_literal
6881 (asection *, source_reloc *, property_table_entry *, int, value_map *);
6882 static bfd_boolean move_shared_literal
6883 (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
6884 int, const r_reloc *, const literal_value *, section_cache_t *);
6887 static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
6888 static bfd_boolean translate_section_fixes (asection *);
6889 static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
6890 static asection *translate_reloc (const r_reloc *, r_reloc *, asection *);
6891 static void shrink_dynamic_reloc_sections
6892 (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
6893 static bfd_boolean move_literal
6894 (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
6895 xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
6896 static bfd_boolean relax_property_section
6897 (bfd *, asection *, struct bfd_link_info *);
6900 static bfd_boolean relax_section_symbols (bfd *, asection *);
6904 elf_xtensa_relax_section (bfd *abfd,
6906 struct bfd_link_info *link_info,
6909 static value_map_hash_table *values = NULL;
6910 static bfd_boolean relocations_analyzed = FALSE;
6911 xtensa_relax_info *relax_info;
6913 if (!relocations_analyzed)
6915 /* Do some overall initialization for relaxation. */
6916 values = value_map_hash_table_init ();
6919 relaxing_section = TRUE;
6920 if (!analyze_relocations (link_info))
6922 relocations_analyzed = TRUE;
6926 /* Don't mess with linker-created sections. */
6927 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6930 relax_info = get_xtensa_relax_info (sec);
6931 BFD_ASSERT (relax_info != NULL);
6933 switch (relax_info->visited)
6936 /* Note: It would be nice to fold this pass into
6937 analyze_relocations, but it is important for this step that the
6938 sections be examined in link order. */
6939 if (!compute_removed_literals (abfd, sec, link_info, values))
6946 value_map_hash_table_delete (values);
6948 if (!relax_section (abfd, sec, link_info))
6954 if (!relax_section_symbols (abfd, sec))
6959 relax_info->visited++;
6964 /* Initialization for relaxation. */
6966 /* This function is called once at the start of relaxation. It scans
6967 all the input sections and marks the ones that are relaxable (i.e.,
6968 literal sections with L32R relocations against them), and then
6969 collects source_reloc information for all the relocations against
6970 those relaxable sections. During this process, it also detects
6971 longcalls, i.e., calls relaxed by the assembler into indirect
6972 calls, that can be optimized back into direct calls. Within each
6973 extended basic block (ebb) containing an optimized longcall, it
6974 computes a set of "text actions" that can be performed to remove
6975 the L32R associated with the longcall while optionally preserving
6976 branch target alignments. */
6979 analyze_relocations (struct bfd_link_info *link_info)
6983 bfd_boolean is_relaxable = FALSE;
6985 /* Initialize the per-section relaxation info. */
6986 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
6987 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6989 init_xtensa_relax_info (sec);
6992 /* Mark relaxable sections (and count relocations against each one). */
6993 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
6994 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6996 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
7000 /* Bail out if there are no relaxable sections. */
7004 /* Allocate space for source_relocs. */
7005 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
7006 for (sec = abfd->sections; sec != NULL; sec = sec->next)
7008 xtensa_relax_info *relax_info;
7010 relax_info = get_xtensa_relax_info (sec);
7011 if (relax_info->is_relaxable_literal_section
7012 || relax_info->is_relaxable_asm_section)
7014 relax_info->src_relocs = (source_reloc *)
7015 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
7018 relax_info->src_count = 0;
7021 /* Collect info on relocations against each relaxable section. */
7022 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
7023 for (sec = abfd->sections; sec != NULL; sec = sec->next)
7025 if (!collect_source_relocs (abfd, sec, link_info))
7029 /* Compute the text actions. */
7030 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
7031 for (sec = abfd->sections; sec != NULL; sec = sec->next)
7033 if (!compute_text_actions (abfd, sec, link_info))
7041 /* Find all the sections that might be relaxed. The motivation for
7042 this pass is that collect_source_relocs() needs to record _all_ the
7043 relocations that target each relaxable section. That is expensive
7044 and unnecessary unless the target section is actually going to be
7045 relaxed. This pass identifies all such sections by checking if
7046 they have L32Rs pointing to them. In the process, the total number
7047 of relocations targeting each section is also counted so that we
7048 know how much space to allocate for source_relocs against each
7049 relaxable literal section. */
7052 find_relaxable_sections (bfd *abfd,
7054 struct bfd_link_info *link_info,
7055 bfd_boolean *is_relaxable_p)
7057 Elf_Internal_Rela *internal_relocs;
7059 bfd_boolean ok = TRUE;
7061 xtensa_relax_info *source_relax_info;
7062 bfd_boolean is_l32r_reloc;
7064 internal_relocs = retrieve_internal_relocs (abfd, sec,
7065 link_info->keep_memory);
7066 if (internal_relocs == NULL)
7069 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7070 if (contents == NULL && sec->size != 0)
7076 source_relax_info = get_xtensa_relax_info (sec);
7077 for (i = 0; i < sec->reloc_count; i++)
7079 Elf_Internal_Rela *irel = &internal_relocs[i];
7081 asection *target_sec;
7082 xtensa_relax_info *target_relax_info;
7084 /* If this section has not already been marked as "relaxable", and
7085 if it contains any ASM_EXPAND relocations (marking expanded
7086 longcalls) that can be optimized into direct calls, then mark
7087 the section as "relaxable". */
7088 if (source_relax_info
7089 && !source_relax_info->is_relaxable_asm_section
7090 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
7092 bfd_boolean is_reachable = FALSE;
7093 if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
7094 link_info, &is_reachable)
7097 source_relax_info->is_relaxable_asm_section = TRUE;
7098 *is_relaxable_p = TRUE;
7102 r_reloc_init (&r_rel, abfd, irel, contents,
7103 bfd_get_section_limit (abfd, sec));
7105 target_sec = r_reloc_get_section (&r_rel);
7106 target_relax_info = get_xtensa_relax_info (target_sec);
7107 if (!target_relax_info)
7110 /* Count PC-relative operand relocations against the target section.
7111 Note: The conditions tested here must match the conditions under
7112 which init_source_reloc is called in collect_source_relocs(). */
7113 is_l32r_reloc = FALSE;
7114 if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
7116 xtensa_opcode opcode =
7117 get_relocation_opcode (abfd, sec, contents, irel);
7118 if (opcode != XTENSA_UNDEFINED)
7120 is_l32r_reloc = (opcode == get_l32r_opcode ());
7121 if (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
7123 target_relax_info->src_count++;
7127 if (is_l32r_reloc && r_reloc_is_defined (&r_rel))
7129 /* Mark the target section as relaxable. */
7130 target_relax_info->is_relaxable_literal_section = TRUE;
7131 *is_relaxable_p = TRUE;
7136 release_contents (sec, contents);
7137 release_internal_relocs (sec, internal_relocs);
7142 /* Record _all_ the relocations that point to relaxable sections, and
7143 get rid of ASM_EXPAND relocs by either converting them to
7144 ASM_SIMPLIFY or by removing them. */
7147 collect_source_relocs (bfd *abfd,
7149 struct bfd_link_info *link_info)
7151 Elf_Internal_Rela *internal_relocs;
7153 bfd_boolean ok = TRUE;
7155 bfd_size_type sec_size;
7157 internal_relocs = retrieve_internal_relocs (abfd, sec,
7158 link_info->keep_memory);
7159 if (internal_relocs == NULL)
7162 sec_size = bfd_get_section_limit (abfd, sec);
7163 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7164 if (contents == NULL && sec_size != 0)
7170 /* Record relocations against relaxable literal sections. */
7171 for (i = 0; i < sec->reloc_count; i++)
7173 Elf_Internal_Rela *irel = &internal_relocs[i];
7175 asection *target_sec;
7176 xtensa_relax_info *target_relax_info;
7178 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7180 target_sec = r_reloc_get_section (&r_rel);
7181 target_relax_info = get_xtensa_relax_info (target_sec);
7183 if (target_relax_info
7184 && (target_relax_info->is_relaxable_literal_section
7185 || target_relax_info->is_relaxable_asm_section))
7187 xtensa_opcode opcode = XTENSA_UNDEFINED;
7189 bfd_boolean is_abs_literal = FALSE;
7191 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7193 /* None of the current alternate relocs are PC-relative,
7194 and only PC-relative relocs matter here. However, we
7195 still need to record the opcode for literal
7197 opcode = get_relocation_opcode (abfd, sec, contents, irel);
7198 if (opcode == get_l32r_opcode ())
7200 is_abs_literal = TRUE;
7204 opcode = XTENSA_UNDEFINED;
7206 else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
7208 opcode = get_relocation_opcode (abfd, sec, contents, irel);
7209 opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7212 if (opcode != XTENSA_UNDEFINED)
7214 int src_next = target_relax_info->src_next++;
7215 source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
7217 init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
7223 /* Now get rid of ASM_EXPAND relocations. At this point, the
7224 src_relocs array for the target literal section may still be
7225 incomplete, but it must at least contain the entries for the L32R
7226 relocations associated with ASM_EXPANDs because they were just
7227 added in the preceding loop over the relocations. */
7229 for (i = 0; i < sec->reloc_count; i++)
7231 Elf_Internal_Rela *irel = &internal_relocs[i];
7232 bfd_boolean is_reachable;
7234 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
7240 Elf_Internal_Rela *l32r_irel;
7242 asection *target_sec;
7243 xtensa_relax_info *target_relax_info;
7245 /* Mark the source_reloc for the L32R so that it will be
7246 removed in compute_removed_literals(), along with the
7247 associated literal. */
7248 l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
7249 irel, internal_relocs);
7250 if (l32r_irel == NULL)
7253 r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
7255 target_sec = r_reloc_get_section (&r_rel);
7256 target_relax_info = get_xtensa_relax_info (target_sec);
7258 if (target_relax_info
7259 && (target_relax_info->is_relaxable_literal_section
7260 || target_relax_info->is_relaxable_asm_section))
7262 source_reloc *s_reloc;
7264 /* Search the source_relocs for the entry corresponding to
7265 the l32r_irel. Note: The src_relocs array is not yet
7266 sorted, but it wouldn't matter anyway because we're
7267 searching by source offset instead of target offset. */
7268 s_reloc = find_source_reloc (target_relax_info->src_relocs,
7269 target_relax_info->src_next,
7271 BFD_ASSERT (s_reloc);
7272 s_reloc->is_null = TRUE;
7275 /* Convert this reloc to ASM_SIMPLIFY. */
7276 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7277 R_XTENSA_ASM_SIMPLIFY);
7278 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7280 pin_internal_relocs (sec, internal_relocs);
7284 /* It is resolvable but doesn't reach. We resolve now
7285 by eliminating the relocation -- the call will remain
7286 expanded into L32R/CALLX. */
7287 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7288 pin_internal_relocs (sec, internal_relocs);
7293 release_contents (sec, contents);
7294 release_internal_relocs (sec, internal_relocs);
7299 /* Return TRUE if the asm expansion can be resolved. Generally it can
7300 be resolved on a final link or when a partial link locates it in the
7301 same section as the target. Set "is_reachable" flag if the target of
7302 the call is within the range of a direct call, given the current VMA
7303 for this section and the target section. */
7306 is_resolvable_asm_expansion (bfd *abfd,
7309 Elf_Internal_Rela *irel,
7310 struct bfd_link_info *link_info,
7311 bfd_boolean *is_reachable_p)
7313 asection *target_sec;
7314 bfd_vma target_offset;
7316 xtensa_opcode opcode, direct_call_opcode;
7317 bfd_vma self_address;
7318 bfd_vma dest_address;
7319 bfd_boolean uses_l32r;
7320 bfd_size_type sec_size;
7322 *is_reachable_p = FALSE;
7324 if (contents == NULL)
7327 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
7330 sec_size = bfd_get_section_limit (abfd, sec);
7331 opcode = get_expanded_call_opcode (contents + irel->r_offset,
7332 sec_size - irel->r_offset, &uses_l32r);
7333 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7337 direct_call_opcode = swap_callx_for_call_opcode (opcode);
7338 if (direct_call_opcode == XTENSA_UNDEFINED)
7341 /* Check and see that the target resolves. */
7342 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7343 if (!r_reloc_is_defined (&r_rel))
7346 target_sec = r_reloc_get_section (&r_rel);
7347 target_offset = r_rel.target_offset;
7349 /* If the target is in a shared library, then it doesn't reach. This
7350 isn't supposed to come up because the compiler should never generate
7351 non-PIC calls on systems that use shared libraries, but the linker
7352 shouldn't crash regardless. */
7353 if (!target_sec->output_section)
7356 /* For relocatable sections, we can only simplify when the output
7357 section of the target is the same as the output section of the
7359 if (bfd_link_relocatable (link_info)
7360 && (target_sec->output_section != sec->output_section
7361 || is_reloc_sym_weak (abfd, irel)))
7364 if (target_sec->output_section != sec->output_section)
7366 /* If the two sections are sufficiently far away that relaxation
7367 might take the call out of range, we can't simplify. For
7368 example, a positive displacement call into another memory
7369 could get moved to a lower address due to literal removal,
7370 but the destination won't move, and so the displacment might
7373 If the displacement is negative, assume the destination could
7374 move as far back as the start of the output section. The
7375 self_address will be at least as far into the output section
7376 as it is prior to relaxation.
7378 If the displacement is postive, assume the destination will be in
7379 it's pre-relaxed location (because relaxation only makes sections
7380 smaller). The self_address could go all the way to the beginning
7381 of the output section. */
7383 dest_address = target_sec->output_section->vma;
7384 self_address = sec->output_section->vma;
7386 if (sec->output_section->vma > target_sec->output_section->vma)
7387 self_address += sec->output_offset + irel->r_offset + 3;
7389 dest_address += bfd_get_section_limit (abfd, target_sec->output_section);
7390 /* Call targets should be four-byte aligned. */
7391 dest_address = (dest_address + 3) & ~3;
7396 self_address = (sec->output_section->vma
7397 + sec->output_offset + irel->r_offset + 3);
7398 dest_address = (target_sec->output_section->vma
7399 + target_sec->output_offset + target_offset);
7402 *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
7403 self_address, dest_address);
7405 if ((self_address >> CALL_SEGMENT_BITS) !=
7406 (dest_address >> CALL_SEGMENT_BITS))
7413 static Elf_Internal_Rela *
7414 find_associated_l32r_irel (bfd *abfd,
7417 Elf_Internal_Rela *other_irel,
7418 Elf_Internal_Rela *internal_relocs)
7422 for (i = 0; i < sec->reloc_count; i++)
7424 Elf_Internal_Rela *irel = &internal_relocs[i];
7426 if (irel == other_irel)
7428 if (irel->r_offset != other_irel->r_offset)
7430 if (is_l32r_relocation (abfd, sec, contents, irel))
7438 static xtensa_opcode *
7439 build_reloc_opcodes (bfd *abfd,
7442 Elf_Internal_Rela *internal_relocs)
7445 xtensa_opcode *reloc_opcodes =
7446 (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
7447 for (i = 0; i < sec->reloc_count; i++)
7449 Elf_Internal_Rela *irel = &internal_relocs[i];
7450 reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
7452 return reloc_opcodes;
7455 struct reloc_range_struct
7458 bfd_boolean add; /* TRUE if start of a range, FALSE otherwise. */
7459 /* Original irel index in the array of relocations for a section. */
7460 unsigned irel_index;
7462 typedef struct reloc_range_struct reloc_range;
7464 typedef struct reloc_range_list_entry_struct reloc_range_list_entry;
7465 struct reloc_range_list_entry_struct
7467 reloc_range_list_entry *next;
7468 reloc_range_list_entry *prev;
7469 Elf_Internal_Rela *irel;
7470 xtensa_opcode opcode;
7474 struct reloc_range_list_struct
7476 /* The rest of the structure is only meaningful when ok is TRUE. */
7479 unsigned n_range; /* Number of range markers. */
7480 reloc_range *range; /* Sorted range markers. */
7482 unsigned first; /* Index of a first range element in the list. */
7483 unsigned last; /* One past index of a last range element in the list. */
7485 unsigned n_list; /* Number of list elements. */
7486 reloc_range_list_entry *reloc; /* */
7487 reloc_range_list_entry list_root;
7491 reloc_range_compare (const void *a, const void *b)
7493 const reloc_range *ra = a;
7494 const reloc_range *rb = b;
7496 if (ra->addr != rb->addr)
7497 return ra->addr < rb->addr ? -1 : 1;
7498 if (ra->add != rb->add)
7499 return ra->add ? -1 : 1;
7504 build_reloc_ranges (bfd *abfd, asection *sec,
7506 Elf_Internal_Rela *internal_relocs,
7507 xtensa_opcode *reloc_opcodes,
7508 reloc_range_list *list)
7513 reloc_range *ranges = NULL;
7514 reloc_range_list_entry *reloc =
7515 bfd_malloc (sec->reloc_count * sizeof (*reloc));
7517 memset (list, 0, sizeof (*list));
7520 for (i = 0; i < sec->reloc_count; i++)
7522 Elf_Internal_Rela *irel = &internal_relocs[i];
7523 int r_type = ELF32_R_TYPE (irel->r_info);
7524 reloc_howto_type *howto = &elf_howto_table[r_type];
7527 if (r_type == R_XTENSA_ASM_SIMPLIFY
7528 || r_type == R_XTENSA_32_PCREL
7529 || !howto->pc_relative)
7532 r_reloc_init (&r_rel, abfd, irel, contents,
7533 bfd_get_section_limit (abfd, sec));
7535 if (r_reloc_get_section (&r_rel) != sec)
7540 max_n = (max_n + 2) * 2;
7541 ranges = bfd_realloc (ranges, max_n * sizeof (*ranges));
7544 ranges[n].addr = irel->r_offset;
7545 ranges[n + 1].addr = r_rel.target_offset;
7547 ranges[n].add = ranges[n].addr < ranges[n + 1].addr;
7548 ranges[n + 1].add = !ranges[n].add;
7550 ranges[n].irel_index = i;
7551 ranges[n + 1].irel_index = i;
7555 reloc[i].irel = irel;
7557 /* Every relocation won't possibly be checked in the optimized version of
7558 check_section_ebb_pcrels_fit, so this needs to be done here. */
7559 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7561 /* None of the current alternate relocs are PC-relative,
7562 and only PC-relative relocs matter here. */
7566 xtensa_opcode opcode;
7570 opcode = reloc_opcodes[i];
7572 opcode = get_relocation_opcode (abfd, sec, contents, irel);
7574 if (opcode == XTENSA_UNDEFINED)
7580 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7581 if (opnum == XTENSA_UNDEFINED)
7587 /* Record relocation opcode and opnum as we've calculated them
7588 anyway and they won't change. */
7589 reloc[i].opcode = opcode;
7590 reloc[i].opnum = opnum;
7596 ranges = bfd_realloc (ranges, n * sizeof (*ranges));
7597 qsort (ranges, n, sizeof (*ranges), reloc_range_compare);
7600 list->range = ranges;
7601 list->reloc = reloc;
7602 list->list_root.prev = &list->list_root;
7603 list->list_root.next = &list->list_root;
7612 static void reloc_range_list_append (reloc_range_list *list,
7613 unsigned irel_index)
7615 reloc_range_list_entry *entry = list->reloc + irel_index;
7617 entry->prev = list->list_root.prev;
7618 entry->next = &list->list_root;
7619 entry->prev->next = entry;
7620 entry->next->prev = entry;
7624 static void reloc_range_list_remove (reloc_range_list *list,
7625 unsigned irel_index)
7627 reloc_range_list_entry *entry = list->reloc + irel_index;
7629 entry->next->prev = entry->prev;
7630 entry->prev->next = entry->next;
7634 /* Update relocation list object so that it lists all relocations that cross
7635 [first; last] range. Range bounds should not decrease with successive
7637 static void reloc_range_list_update_range (reloc_range_list *list,
7638 bfd_vma first, bfd_vma last)
7640 /* This should not happen: EBBs are iterated from lower addresses to higher.
7641 But even if that happens there's no need to break: just flush current list
7642 and start from scratch. */
7643 if ((list->last > 0 && list->range[list->last - 1].addr > last) ||
7644 (list->first > 0 && list->range[list->first - 1].addr >= first))
7649 list->list_root.next = &list->list_root;
7650 list->list_root.prev = &list->list_root;
7651 fprintf (stderr, "%s: move backwards requested\n", __func__);
7654 for (; list->last < list->n_range &&
7655 list->range[list->last].addr <= last; ++list->last)
7656 if (list->range[list->last].add)
7657 reloc_range_list_append (list, list->range[list->last].irel_index);
7659 for (; list->first < list->n_range &&
7660 list->range[list->first].addr < first; ++list->first)
7661 if (!list->range[list->first].add)
7662 reloc_range_list_remove (list, list->range[list->first].irel_index);
7665 static void free_reloc_range_list (reloc_range_list *list)
7671 /* The compute_text_actions function will build a list of potential
7672 transformation actions for code in the extended basic block of each
7673 longcall that is optimized to a direct call. From this list we
7674 generate a set of actions to actually perform that optimizes for
7675 space and, if not using size_opt, maintains branch target
7678 These actions to be performed are placed on a per-section list.
7679 The actual changes are performed by relax_section() in the second
7683 compute_text_actions (bfd *abfd,
7685 struct bfd_link_info *link_info)
7687 xtensa_opcode *reloc_opcodes = NULL;
7688 xtensa_relax_info *relax_info;
7690 Elf_Internal_Rela *internal_relocs;
7691 bfd_boolean ok = TRUE;
7693 property_table_entry *prop_table = 0;
7695 bfd_size_type sec_size;
7696 reloc_range_list relevant_relocs;
7698 relax_info = get_xtensa_relax_info (sec);
7699 BFD_ASSERT (relax_info);
7700 BFD_ASSERT (relax_info->src_next == relax_info->src_count);
7702 /* Do nothing if the section contains no optimized longcalls. */
7703 if (!relax_info->is_relaxable_asm_section)
7706 internal_relocs = retrieve_internal_relocs (abfd, sec,
7707 link_info->keep_memory);
7709 if (internal_relocs)
7710 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7711 internal_reloc_compare);
7713 sec_size = bfd_get_section_limit (abfd, sec);
7714 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7715 if (contents == NULL && sec_size != 0)
7721 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7722 XTENSA_PROP_SEC_NAME, FALSE);
7729 /* Precompute the opcode for each relocation. */
7730 reloc_opcodes = build_reloc_opcodes (abfd, sec, contents, internal_relocs);
7732 build_reloc_ranges (abfd, sec, contents, internal_relocs, reloc_opcodes,
7735 for (i = 0; i < sec->reloc_count; i++)
7737 Elf_Internal_Rela *irel = &internal_relocs[i];
7739 property_table_entry *the_entry;
7742 ebb_constraint ebb_table;
7743 bfd_size_type simplify_size;
7745 if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
7747 r_offset = irel->r_offset;
7749 simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
7750 if (simplify_size == 0)
7752 (*_bfd_error_handler)
7753 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
7754 sec->owner, sec, r_offset);
7758 /* If the instruction table is not around, then don't do this
7760 the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7761 sec->vma + irel->r_offset);
7762 if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
7764 text_action_add (&relax_info->action_list,
7765 ta_convert_longcall, sec, r_offset,
7770 /* If the next longcall happens to be at the same address as an
7771 unreachable section of size 0, then skip forward. */
7772 ptbl_idx = the_entry - prop_table;
7773 while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
7774 && the_entry->size == 0
7775 && ptbl_idx + 1 < ptblsize
7776 && (prop_table[ptbl_idx + 1].address
7777 == prop_table[ptbl_idx].address))
7783 if (the_entry->flags & XTENSA_PROP_NO_TRANSFORM)
7784 /* NO_REORDER is OK */
7787 init_ebb_constraint (&ebb_table);
7788 ebb = &ebb_table.ebb;
7789 init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
7790 internal_relocs, sec->reloc_count);
7791 ebb->start_offset = r_offset + simplify_size;
7792 ebb->end_offset = r_offset + simplify_size;
7793 ebb->start_ptbl_idx = ptbl_idx;
7794 ebb->end_ptbl_idx = ptbl_idx;
7795 ebb->start_reloc_idx = i;
7796 ebb->end_reloc_idx = i;
7798 if (!extend_ebb_bounds (ebb)
7799 || !compute_ebb_proposed_actions (&ebb_table)
7800 || !compute_ebb_actions (&ebb_table)
7801 || !check_section_ebb_pcrels_fit (abfd, sec, contents,
7804 &ebb_table, reloc_opcodes)
7805 || !check_section_ebb_reduces (&ebb_table))
7807 /* If anything goes wrong or we get unlucky and something does
7808 not fit, with our plan because of expansion between
7809 critical branches, just convert to a NOP. */
7811 text_action_add (&relax_info->action_list,
7812 ta_convert_longcall, sec, r_offset, 0);
7813 i = ebb_table.ebb.end_reloc_idx;
7814 free_ebb_constraint (&ebb_table);
7818 text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
7820 /* Update the index so we do not go looking at the relocations
7821 we have already processed. */
7822 i = ebb_table.ebb.end_reloc_idx;
7823 free_ebb_constraint (&ebb_table);
7826 free_reloc_range_list (&relevant_relocs);
7829 if (action_list_count (&relax_info->action_list))
7830 print_action_list (stderr, &relax_info->action_list);
7834 release_contents (sec, contents);
7835 release_internal_relocs (sec, internal_relocs);
7839 free (reloc_opcodes);
7845 /* Do not widen an instruction if it is preceeded by a
7846 loop opcode. It might cause misalignment. */
7849 prev_instr_is_a_loop (bfd_byte *contents,
7850 bfd_size_type content_length,
7851 bfd_size_type offset)
7853 xtensa_opcode prev_opcode;
7857 prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
7858 return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
7862 /* Find all of the possible actions for an extended basic block. */
7865 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
7867 const ebb_t *ebb = &ebb_table->ebb;
7868 unsigned rel_idx = ebb->start_reloc_idx;
7869 property_table_entry *entry, *start_entry, *end_entry;
7871 xtensa_isa isa = xtensa_default_isa;
7873 static xtensa_insnbuf insnbuf = NULL;
7874 static xtensa_insnbuf slotbuf = NULL;
7876 if (insnbuf == NULL)
7878 insnbuf = xtensa_insnbuf_alloc (isa);
7879 slotbuf = xtensa_insnbuf_alloc (isa);
7882 start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
7883 end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
7885 for (entry = start_entry; entry <= end_entry; entry++)
7887 bfd_vma start_offset, end_offset;
7888 bfd_size_type insn_len;
7890 start_offset = entry->address - ebb->sec->vma;
7891 end_offset = entry->address + entry->size - ebb->sec->vma;
7893 if (entry == start_entry)
7894 start_offset = ebb->start_offset;
7895 if (entry == end_entry)
7896 end_offset = ebb->end_offset;
7897 offset = start_offset;
7899 if (offset == entry->address - ebb->sec->vma
7900 && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
7902 enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
7903 BFD_ASSERT (offset != end_offset);
7904 if (offset == end_offset)
7907 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
7912 if (check_branch_target_aligned_address (offset, insn_len))
7913 align_type = EBB_REQUIRE_TGT_ALIGN;
7915 ebb_propose_action (ebb_table, align_type, 0,
7916 ta_none, offset, 0, TRUE);
7919 while (offset != end_offset)
7921 Elf_Internal_Rela *irel;
7922 xtensa_opcode opcode;
7924 while (rel_idx < ebb->end_reloc_idx
7925 && (ebb->relocs[rel_idx].r_offset < offset
7926 || (ebb->relocs[rel_idx].r_offset == offset
7927 && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
7928 != R_XTENSA_ASM_SIMPLIFY))))
7931 /* Check for longcall. */
7932 irel = &ebb->relocs[rel_idx];
7933 if (irel->r_offset == offset
7934 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
7936 bfd_size_type simplify_size;
7938 simplify_size = get_asm_simplify_size (ebb->contents,
7939 ebb->content_length,
7941 if (simplify_size == 0)
7944 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7945 ta_convert_longcall, offset, 0, TRUE);
7947 offset += simplify_size;
7951 if (offset + MIN_INSN_LENGTH > ebb->content_length)
7953 xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
7954 ebb->content_length - offset);
7955 fmt = xtensa_format_decode (isa, insnbuf);
7956 if (fmt == XTENSA_UNDEFINED)
7958 insn_len = xtensa_format_length (isa, fmt);
7959 if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
7962 if (xtensa_format_num_slots (isa, fmt) != 1)
7968 xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7969 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7970 if (opcode == XTENSA_UNDEFINED)
7973 if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
7974 && (entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7975 && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
7977 /* Add an instruction narrow action. */
7978 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7979 ta_narrow_insn, offset, 0, FALSE);
7981 else if ((entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7982 && can_widen_instruction (slotbuf, fmt, opcode) != 0
7983 && ! prev_instr_is_a_loop (ebb->contents,
7984 ebb->content_length, offset))
7986 /* Add an instruction widen action. */
7987 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7988 ta_widen_insn, offset, 0, FALSE);
7990 else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
7992 /* Check for branch targets. */
7993 ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
7994 ta_none, offset, 0, TRUE);
8001 if (ebb->ends_unreachable)
8003 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
8004 ta_fill, ebb->end_offset, 0, TRUE);
8010 (*_bfd_error_handler)
8011 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
8012 ebb->sec->owner, ebb->sec, offset);
8017 /* After all of the information has collected about the
8018 transformations possible in an EBB, compute the appropriate actions
8019 here in compute_ebb_actions. We still must check later to make
8020 sure that the actions do not break any relocations. The algorithm
8021 used here is pretty greedy. Basically, it removes as many no-ops
8022 as possible so that the end of the EBB has the same alignment
8023 characteristics as the original. First, it uses narrowing, then
8024 fill space at the end of the EBB, and finally widenings. If that
8025 does not work, it tries again with one fewer no-op removed. The
8026 optimization will only be performed if all of the branch targets
8027 that were aligned before transformation are also aligned after the
8030 When the size_opt flag is set, ignore the branch target alignments,
8031 narrow all wide instructions, and remove all no-ops unless the end
8032 of the EBB prevents it. */
8035 compute_ebb_actions (ebb_constraint *ebb_table)
8039 int removed_bytes = 0;
8040 ebb_t *ebb = &ebb_table->ebb;
8041 unsigned seg_idx_start = 0;
8042 unsigned seg_idx_end = 0;
8044 /* We perform this like the assembler relaxation algorithm: Start by
8045 assuming all instructions are narrow and all no-ops removed; then
8048 /* For each segment of this that has a solid constraint, check to
8049 see if there are any combinations that will keep the constraint.
8051 for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
8053 bfd_boolean requires_text_end_align = FALSE;
8054 unsigned longcall_count = 0;
8055 unsigned longcall_convert_count = 0;
8056 unsigned narrowable_count = 0;
8057 unsigned narrowable_convert_count = 0;
8058 unsigned widenable_count = 0;
8059 unsigned widenable_convert_count = 0;
8061 proposed_action *action = NULL;
8062 int align = (1 << ebb_table->ebb.sec->alignment_power);
8064 seg_idx_start = seg_idx_end;
8066 for (i = seg_idx_start; i < ebb_table->action_count; i++)
8068 action = &ebb_table->actions[i];
8069 if (action->action == ta_convert_longcall)
8071 if (action->action == ta_narrow_insn)
8073 if (action->action == ta_widen_insn)
8075 if (action->action == ta_fill)
8077 if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
8079 if (action->align_type == EBB_REQUIRE_TGT_ALIGN
8080 && !elf32xtensa_size_opt)
8085 if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
8086 requires_text_end_align = TRUE;
8088 if (elf32xtensa_size_opt && !requires_text_end_align
8089 && action->align_type != EBB_REQUIRE_LOOP_ALIGN
8090 && action->align_type != EBB_REQUIRE_TGT_ALIGN)
8092 longcall_convert_count = longcall_count;
8093 narrowable_convert_count = narrowable_count;
8094 widenable_convert_count = 0;
8098 /* There is a constraint. Convert the max number of longcalls. */
8099 narrowable_convert_count = 0;
8100 longcall_convert_count = 0;
8101 widenable_convert_count = 0;
8103 for (j = 0; j < longcall_count; j++)
8105 int removed = (longcall_count - j) * 3 & (align - 1);
8106 unsigned desire_narrow = (align - removed) & (align - 1);
8107 unsigned desire_widen = removed;
8108 if (desire_narrow <= narrowable_count)
8110 narrowable_convert_count = desire_narrow;
8111 narrowable_convert_count +=
8112 (align * ((narrowable_count - narrowable_convert_count)
8114 longcall_convert_count = (longcall_count - j);
8115 widenable_convert_count = 0;
8118 if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
8120 narrowable_convert_count = 0;
8121 longcall_convert_count = longcall_count - j;
8122 widenable_convert_count = desire_widen;
8128 /* Now the number of conversions are saved. Do them. */
8129 for (i = seg_idx_start; i < seg_idx_end; i++)
8131 action = &ebb_table->actions[i];
8132 switch (action->action)
8134 case ta_convert_longcall:
8135 if (longcall_convert_count != 0)
8137 action->action = ta_remove_longcall;
8138 action->do_action = TRUE;
8139 action->removed_bytes += 3;
8140 longcall_convert_count--;
8143 case ta_narrow_insn:
8144 if (narrowable_convert_count != 0)
8146 action->do_action = TRUE;
8147 action->removed_bytes += 1;
8148 narrowable_convert_count--;
8152 if (widenable_convert_count != 0)
8154 action->do_action = TRUE;
8155 action->removed_bytes -= 1;
8156 widenable_convert_count--;
8165 /* Now we move on to some local opts. Try to remove each of the
8166 remaining longcalls. */
8168 if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
8171 for (i = 0; i < ebb_table->action_count; i++)
8173 int old_removed_bytes = removed_bytes;
8174 proposed_action *action = &ebb_table->actions[i];
8176 if (action->do_action && action->action == ta_convert_longcall)
8178 bfd_boolean bad_alignment = FALSE;
8180 for (j = i + 1; j < ebb_table->action_count; j++)
8182 proposed_action *new_action = &ebb_table->actions[j];
8183 bfd_vma offset = new_action->offset;
8184 if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
8186 if (!check_branch_target_aligned
8187 (ebb_table->ebb.contents,
8188 ebb_table->ebb.content_length,
8189 offset, offset - removed_bytes))
8191 bad_alignment = TRUE;
8195 if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
8197 if (!check_loop_aligned (ebb_table->ebb.contents,
8198 ebb_table->ebb.content_length,
8200 offset - removed_bytes))
8202 bad_alignment = TRUE;
8206 if (new_action->action == ta_narrow_insn
8207 && !new_action->do_action
8208 && ebb_table->ebb.sec->alignment_power == 2)
8210 /* Narrow an instruction and we are done. */
8211 new_action->do_action = TRUE;
8212 new_action->removed_bytes += 1;
8213 bad_alignment = FALSE;
8216 if (new_action->action == ta_widen_insn
8217 && new_action->do_action
8218 && ebb_table->ebb.sec->alignment_power == 2)
8220 /* Narrow an instruction and we are done. */
8221 new_action->do_action = FALSE;
8222 new_action->removed_bytes += 1;
8223 bad_alignment = FALSE;
8226 if (new_action->do_action)
8227 removed_bytes += new_action->removed_bytes;
8231 action->removed_bytes += 3;
8232 action->action = ta_remove_longcall;
8233 action->do_action = TRUE;
8236 removed_bytes = old_removed_bytes;
8237 if (action->do_action)
8238 removed_bytes += action->removed_bytes;
8243 for (i = 0; i < ebb_table->action_count; ++i)
8245 proposed_action *action = &ebb_table->actions[i];
8246 if (action->do_action)
8247 removed_bytes += action->removed_bytes;
8250 if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
8251 && ebb->ends_unreachable)
8253 proposed_action *action;
8257 BFD_ASSERT (ebb_table->action_count != 0);
8258 action = &ebb_table->actions[ebb_table->action_count - 1];
8259 BFD_ASSERT (action->action == ta_fill);
8260 BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
8262 extra_space = compute_fill_extra_space (ebb->ends_unreachable);
8263 br = action->removed_bytes + removed_bytes + extra_space;
8264 br = br & ((1 << ebb->sec->alignment_power ) - 1);
8266 action->removed_bytes = extra_space - br;
8272 /* The xlate_map is a sorted array of address mappings designed to
8273 answer the offset_with_removed_text() query with a binary search instead
8274 of a linear search through the section's action_list. */
8276 typedef struct xlate_map_entry xlate_map_entry_t;
8277 typedef struct xlate_map xlate_map_t;
8279 struct xlate_map_entry
8281 unsigned orig_address;
8282 unsigned new_address;
8288 unsigned entry_count;
8289 xlate_map_entry_t *entry;
8294 xlate_compare (const void *a_v, const void *b_v)
8296 const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
8297 const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
8298 if (a->orig_address < b->orig_address)
8300 if (a->orig_address > (b->orig_address + b->size - 1))
8307 xlate_offset_with_removed_text (const xlate_map_t *map,
8308 text_action_list *action_list,
8312 xlate_map_entry_t *e;
8315 return offset_with_removed_text (action_list, offset);
8317 if (map->entry_count == 0)
8320 r = bsearch (&offset, map->entry, map->entry_count,
8321 sizeof (xlate_map_entry_t), &xlate_compare);
8322 e = (xlate_map_entry_t *) r;
8324 BFD_ASSERT (e != NULL);
8327 return e->new_address - e->orig_address + offset;
8330 typedef struct xlate_map_context_struct xlate_map_context;
8331 struct xlate_map_context_struct
8334 xlate_map_entry_t *current_entry;
8339 xlate_map_fn (splay_tree_node node, void *p)
8341 text_action *r = (text_action *)node->value;
8342 xlate_map_context *ctx = p;
8343 unsigned orig_size = 0;
8348 case ta_remove_insn:
8349 case ta_convert_longcall:
8350 case ta_remove_literal:
8351 case ta_add_literal:
8353 case ta_remove_longcall:
8356 case ta_narrow_insn:
8365 ctx->current_entry->size =
8366 r->offset + orig_size - ctx->current_entry->orig_address;
8367 if (ctx->current_entry->size != 0)
8369 ctx->current_entry++;
8370 ctx->map->entry_count++;
8372 ctx->current_entry->orig_address = r->offset + orig_size;
8373 ctx->removed += r->removed_bytes;
8374 ctx->current_entry->new_address = r->offset + orig_size - ctx->removed;
8375 ctx->current_entry->size = 0;
8379 /* Build a binary searchable offset translation map from a section's
8382 static xlate_map_t *
8383 build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
8385 text_action_list *action_list = &relax_info->action_list;
8386 unsigned num_actions = 0;
8387 xlate_map_context ctx;
8389 ctx.map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
8391 if (ctx.map == NULL)
8394 num_actions = action_list_count (action_list);
8395 ctx.map->entry = (xlate_map_entry_t *)
8396 bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
8397 if (ctx.map->entry == NULL)
8402 ctx.map->entry_count = 0;
8405 ctx.current_entry = &ctx.map->entry[0];
8407 ctx.current_entry->orig_address = 0;
8408 ctx.current_entry->new_address = 0;
8409 ctx.current_entry->size = 0;
8411 splay_tree_foreach (action_list->tree, xlate_map_fn, &ctx);
8413 ctx.current_entry->size = (bfd_get_section_limit (sec->owner, sec)
8414 - ctx.current_entry->orig_address);
8415 if (ctx.current_entry->size != 0)
8416 ctx.map->entry_count++;
8422 /* Free an offset translation map. */
8425 free_xlate_map (xlate_map_t *map)
8427 if (map && map->entry)
8434 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8435 relocations in a section will fit if a proposed set of actions
8439 check_section_ebb_pcrels_fit (bfd *abfd,
8442 Elf_Internal_Rela *internal_relocs,
8443 reloc_range_list *relevant_relocs,
8444 const ebb_constraint *constraint,
8445 const xtensa_opcode *reloc_opcodes)
8448 unsigned n = sec->reloc_count;
8449 Elf_Internal_Rela *irel;
8450 xlate_map_t *xmap = NULL;
8451 bfd_boolean ok = TRUE;
8452 xtensa_relax_info *relax_info;
8453 reloc_range_list_entry *entry = NULL;
8455 relax_info = get_xtensa_relax_info (sec);
8457 if (relax_info && sec->reloc_count > 100)
8459 xmap = build_xlate_map (sec, relax_info);
8460 /* NULL indicates out of memory, but the slow version
8461 can still be used. */
8464 if (relevant_relocs && constraint->action_count)
8466 if (!relevant_relocs->ok)
8473 bfd_vma min_offset, max_offset;
8474 min_offset = max_offset = constraint->actions[0].offset;
8476 for (i = 1; i < constraint->action_count; ++i)
8478 proposed_action *action = &constraint->actions[i];
8479 bfd_vma offset = action->offset;
8481 if (offset < min_offset)
8482 min_offset = offset;
8483 if (offset > max_offset)
8484 max_offset = offset;
8486 reloc_range_list_update_range (relevant_relocs, min_offset,
8488 n = relevant_relocs->n_list;
8489 entry = &relevant_relocs->list_root;
8494 relevant_relocs = NULL;
8497 for (i = 0; i < n; i++)
8500 bfd_vma orig_self_offset, orig_target_offset;
8501 bfd_vma self_offset, target_offset;
8503 reloc_howto_type *howto;
8504 int self_removed_bytes, target_removed_bytes;
8506 if (relevant_relocs)
8508 entry = entry->next;
8513 irel = internal_relocs + i;
8515 r_type = ELF32_R_TYPE (irel->r_info);
8517 howto = &elf_howto_table[r_type];
8518 /* We maintain the required invariant: PC-relative relocations
8519 that fit before linking must fit after linking. Thus we only
8520 need to deal with relocations to the same section that are
8522 if (r_type == R_XTENSA_ASM_SIMPLIFY
8523 || r_type == R_XTENSA_32_PCREL
8524 || !howto->pc_relative)
8527 r_reloc_init (&r_rel, abfd, irel, contents,
8528 bfd_get_section_limit (abfd, sec));
8530 if (r_reloc_get_section (&r_rel) != sec)
8533 orig_self_offset = irel->r_offset;
8534 orig_target_offset = r_rel.target_offset;
8536 self_offset = orig_self_offset;
8537 target_offset = orig_target_offset;
8542 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8545 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8546 orig_target_offset);
8549 self_removed_bytes = 0;
8550 target_removed_bytes = 0;
8552 for (j = 0; j < constraint->action_count; ++j)
8554 proposed_action *action = &constraint->actions[j];
8555 bfd_vma offset = action->offset;
8556 int removed_bytes = action->removed_bytes;
8557 if (offset < orig_self_offset
8558 || (offset == orig_self_offset && action->action == ta_fill
8559 && action->removed_bytes < 0))
8560 self_removed_bytes += removed_bytes;
8561 if (offset < orig_target_offset
8562 || (offset == orig_target_offset && action->action == ta_fill
8563 && action->removed_bytes < 0))
8564 target_removed_bytes += removed_bytes;
8566 self_offset -= self_removed_bytes;
8567 target_offset -= target_removed_bytes;
8569 /* Try to encode it. Get the operand and check. */
8570 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
8572 /* None of the current alternate relocs are PC-relative,
8573 and only PC-relative relocs matter here. */
8577 xtensa_opcode opcode;
8580 if (relevant_relocs)
8582 opcode = entry->opcode;
8583 opnum = entry->opnum;
8588 opcode = reloc_opcodes[relevant_relocs ?
8589 (unsigned)(entry - relevant_relocs->reloc) : i];
8591 opcode = get_relocation_opcode (abfd, sec, contents, irel);
8592 if (opcode == XTENSA_UNDEFINED)
8598 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
8599 if (opnum == XTENSA_UNDEFINED)
8606 if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
8615 free_xlate_map (xmap);
8622 check_section_ebb_reduces (const ebb_constraint *constraint)
8627 for (i = 0; i < constraint->action_count; i++)
8629 const proposed_action *action = &constraint->actions[i];
8630 if (action->do_action)
8631 removed += action->removed_bytes;
8641 text_action_add_proposed (text_action_list *l,
8642 const ebb_constraint *ebb_table,
8647 for (i = 0; i < ebb_table->action_count; i++)
8649 proposed_action *action = &ebb_table->actions[i];
8651 if (!action->do_action)
8653 switch (action->action)
8655 case ta_remove_insn:
8656 case ta_remove_longcall:
8657 case ta_convert_longcall:
8658 case ta_narrow_insn:
8661 case ta_remove_literal:
8662 text_action_add (l, action->action, sec, action->offset,
8663 action->removed_bytes);
8676 compute_fill_extra_space (property_table_entry *entry)
8678 int fill_extra_space;
8683 if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
8686 fill_extra_space = entry->size;
8687 if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
8689 /* Fill bytes for alignment:
8690 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8691 int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
8692 int nsm = (1 << pow) - 1;
8693 bfd_vma addr = entry->address + entry->size;
8694 bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
8695 fill_extra_space += align_fill;
8697 return fill_extra_space;
8701 /* First relaxation pass. */
8703 /* If the section contains relaxable literals, check each literal to
8704 see if it has the same value as another literal that has already
8705 been seen, either in the current section or a previous one. If so,
8706 add an entry to the per-section list of removed literals. The
8707 actual changes are deferred until the next pass. */
8710 compute_removed_literals (bfd *abfd,
8712 struct bfd_link_info *link_info,
8713 value_map_hash_table *values)
8715 xtensa_relax_info *relax_info;
8717 Elf_Internal_Rela *internal_relocs;
8718 source_reloc *src_relocs, *rel;
8719 bfd_boolean ok = TRUE;
8720 property_table_entry *prop_table = NULL;
8723 bfd_boolean last_loc_is_prev = FALSE;
8724 bfd_vma last_target_offset = 0;
8725 section_cache_t target_sec_cache;
8726 bfd_size_type sec_size;
8728 init_section_cache (&target_sec_cache);
8730 /* Do nothing if it is not a relaxable literal section. */
8731 relax_info = get_xtensa_relax_info (sec);
8732 BFD_ASSERT (relax_info);
8733 if (!relax_info->is_relaxable_literal_section)
8736 internal_relocs = retrieve_internal_relocs (abfd, sec,
8737 link_info->keep_memory);
8739 sec_size = bfd_get_section_limit (abfd, sec);
8740 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8741 if (contents == NULL && sec_size != 0)
8747 /* Sort the source_relocs by target offset. */
8748 src_relocs = relax_info->src_relocs;
8749 qsort (src_relocs, relax_info->src_count,
8750 sizeof (source_reloc), source_reloc_compare);
8751 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8752 internal_reloc_compare);
8754 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
8755 XTENSA_PROP_SEC_NAME, FALSE);
8763 for (i = 0; i < relax_info->src_count; i++)
8765 Elf_Internal_Rela *irel = NULL;
8767 rel = &src_relocs[i];
8768 if (get_l32r_opcode () != rel->opcode)
8770 irel = get_irel_at_offset (sec, internal_relocs,
8771 rel->r_rel.target_offset);
8773 /* If the relocation on this is not a simple R_XTENSA_32 or
8774 R_XTENSA_PLT then do not consider it. This may happen when
8775 the difference of two symbols is used in a literal. */
8776 if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
8777 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
8780 /* If the target_offset for this relocation is the same as the
8781 previous relocation, then we've already considered whether the
8782 literal can be coalesced. Skip to the next one.... */
8783 if (i != 0 && prev_i != -1
8784 && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
8788 if (last_loc_is_prev &&
8789 last_target_offset + 4 != rel->r_rel.target_offset)
8790 last_loc_is_prev = FALSE;
8792 /* Check if the relocation was from an L32R that is being removed
8793 because a CALLX was converted to a direct CALL, and check if
8794 there are no other relocations to the literal. */
8795 if (is_removable_literal (rel, i, src_relocs, relax_info->src_count,
8796 sec, prop_table, ptblsize))
8798 if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
8799 irel, rel, prop_table, ptblsize))
8804 last_target_offset = rel->r_rel.target_offset;
8808 if (!identify_literal_placement (abfd, sec, contents, link_info,
8810 &last_loc_is_prev, irel,
8811 relax_info->src_count - i, rel,
8812 prop_table, ptblsize,
8813 &target_sec_cache, rel->is_abs_literal))
8818 last_target_offset = rel->r_rel.target_offset;
8822 print_removed_literals (stderr, &relax_info->removed_list);
8823 print_action_list (stderr, &relax_info->action_list);
8829 free_section_cache (&target_sec_cache);
8831 release_contents (sec, contents);
8832 release_internal_relocs (sec, internal_relocs);
8837 static Elf_Internal_Rela *
8838 get_irel_at_offset (asection *sec,
8839 Elf_Internal_Rela *internal_relocs,
8843 Elf_Internal_Rela *irel;
8845 Elf_Internal_Rela key;
8847 if (!internal_relocs)
8850 key.r_offset = offset;
8851 irel = bsearch (&key, internal_relocs, sec->reloc_count,
8852 sizeof (Elf_Internal_Rela), internal_reloc_matches);
8856 /* bsearch does not guarantee which will be returned if there are
8857 multiple matches. We need the first that is not an alignment. */
8858 i = irel - internal_relocs;
8861 if (internal_relocs[i-1].r_offset != offset)
8865 for ( ; i < sec->reloc_count; i++)
8867 irel = &internal_relocs[i];
8868 r_type = ELF32_R_TYPE (irel->r_info);
8869 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
8878 is_removable_literal (const source_reloc *rel,
8880 const source_reloc *src_relocs,
8883 property_table_entry *prop_table,
8886 const source_reloc *curr_rel;
8887 property_table_entry *entry;
8892 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8893 sec->vma + rel->r_rel.target_offset);
8894 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8897 for (++i; i < src_count; ++i)
8899 curr_rel = &src_relocs[i];
8900 /* If all others have the same target offset.... */
8901 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
8904 if (!curr_rel->is_null
8905 && !xtensa_is_property_section (curr_rel->source_sec)
8906 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
8914 remove_dead_literal (bfd *abfd,
8916 struct bfd_link_info *link_info,
8917 Elf_Internal_Rela *internal_relocs,
8918 Elf_Internal_Rela *irel,
8920 property_table_entry *prop_table,
8923 property_table_entry *entry;
8924 xtensa_relax_info *relax_info;
8926 relax_info = get_xtensa_relax_info (sec);
8930 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8931 sec->vma + rel->r_rel.target_offset);
8933 /* Mark the unused literal so that it will be removed. */
8934 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
8936 text_action_add (&relax_info->action_list,
8937 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8939 /* If the section is 4-byte aligned, do not add fill. */
8940 if (sec->alignment_power > 2)
8942 int fill_extra_space;
8943 bfd_vma entry_sec_offset;
8945 property_table_entry *the_add_entry;
8949 entry_sec_offset = entry->address - sec->vma + entry->size;
8951 entry_sec_offset = rel->r_rel.target_offset + 4;
8953 /* If the literal range is at the end of the section,
8955 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8957 fill_extra_space = compute_fill_extra_space (the_add_entry);
8959 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8960 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8961 -4, fill_extra_space);
8963 adjust_fill_action (fa, removed_diff);
8965 text_action_add (&relax_info->action_list,
8966 ta_fill, sec, entry_sec_offset, removed_diff);
8969 /* Zero out the relocation on this literal location. */
8972 if (elf_hash_table (link_info)->dynamic_sections_created)
8973 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8975 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8976 pin_internal_relocs (sec, internal_relocs);
8979 /* Do not modify "last_loc_is_prev". */
8985 identify_literal_placement (bfd *abfd,
8988 struct bfd_link_info *link_info,
8989 value_map_hash_table *values,
8990 bfd_boolean *last_loc_is_prev_p,
8991 Elf_Internal_Rela *irel,
8992 int remaining_src_rels,
8994 property_table_entry *prop_table,
8996 section_cache_t *target_sec_cache,
8997 bfd_boolean is_abs_literal)
9001 xtensa_relax_info *relax_info;
9002 bfd_boolean literal_placed = FALSE;
9004 unsigned long value;
9005 bfd_boolean final_static_link;
9006 bfd_size_type sec_size;
9008 relax_info = get_xtensa_relax_info (sec);
9012 sec_size = bfd_get_section_limit (abfd, sec);
9015 (!bfd_link_relocatable (link_info)
9016 && !elf_hash_table (link_info)->dynamic_sections_created);
9018 /* The placement algorithm first checks to see if the literal is
9019 already in the value map. If so and the value map is reachable
9020 from all uses, then the literal is moved to that location. If
9021 not, then we identify the last location where a fresh literal was
9022 placed. If the literal can be safely moved there, then we do so.
9023 If not, then we assume that the literal is not to move and leave
9024 the literal where it is, marking it as the last literal
9027 /* Find the literal value. */
9029 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
9032 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
9033 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
9035 init_literal_value (&val, &r_rel, value, is_abs_literal);
9037 /* Check if we've seen another literal with the same value that
9038 is in the same output section. */
9039 val_map = value_map_get_cached_value (values, &val, final_static_link);
9042 && (r_reloc_get_section (&val_map->loc)->output_section
9043 == sec->output_section)
9044 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
9045 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
9047 /* No change to last_loc_is_prev. */
9048 literal_placed = TRUE;
9051 /* For relocatable links, do not try to move literals. To do it
9052 correctly might increase the number of relocations in an input
9053 section making the default relocatable linking fail. */
9054 if (!bfd_link_relocatable (link_info) && !literal_placed
9055 && values->has_last_loc && !(*last_loc_is_prev_p))
9057 asection *target_sec = r_reloc_get_section (&values->last_loc);
9058 if (target_sec && target_sec->output_section == sec->output_section)
9060 /* Increment the virtual offset. */
9061 r_reloc try_loc = values->last_loc;
9062 try_loc.virtual_offset += 4;
9064 /* There is a last loc that was in the same output section. */
9065 if (relocations_reach (rel, remaining_src_rels, &try_loc)
9066 && move_shared_literal (sec, link_info, rel,
9067 prop_table, ptblsize,
9068 &try_loc, &val, target_sec_cache))
9070 values->last_loc.virtual_offset += 4;
9071 literal_placed = TRUE;
9073 val_map = add_value_map (values, &val, &try_loc,
9076 val_map->loc = try_loc;
9081 if (!literal_placed)
9083 /* Nothing worked, leave the literal alone but update the last loc. */
9084 values->has_last_loc = TRUE;
9085 values->last_loc = rel->r_rel;
9087 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
9089 val_map->loc = rel->r_rel;
9090 *last_loc_is_prev_p = TRUE;
9097 /* Check if the original relocations (presumably on L32R instructions)
9098 identified by reloc[0..N] can be changed to reference the literal
9099 identified by r_rel. If r_rel is out of range for any of the
9100 original relocations, then we don't want to coalesce the original
9101 literal with the one at r_rel. We only check reloc[0..N], where the
9102 offsets are all the same as for reloc[0] (i.e., they're all
9103 referencing the same literal) and where N is also bounded by the
9104 number of remaining entries in the "reloc" array. The "reloc" array
9105 is sorted by target offset so we know all the entries for the same
9106 literal will be contiguous. */
9109 relocations_reach (source_reloc *reloc,
9110 int remaining_relocs,
9111 const r_reloc *r_rel)
9113 bfd_vma from_offset, source_address, dest_address;
9117 if (!r_reloc_is_defined (r_rel))
9120 sec = r_reloc_get_section (r_rel);
9121 from_offset = reloc[0].r_rel.target_offset;
9123 for (i = 0; i < remaining_relocs; i++)
9125 if (reloc[i].r_rel.target_offset != from_offset)
9128 /* Ignore relocations that have been removed. */
9129 if (reloc[i].is_null)
9132 /* The original and new output section for these must be the same
9133 in order to coalesce. */
9134 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
9135 != sec->output_section)
9138 /* Absolute literals in the same output section can always be
9140 if (reloc[i].is_abs_literal)
9143 /* A literal with no PC-relative relocations can be moved anywhere. */
9144 if (reloc[i].opnd != -1)
9146 /* Otherwise, check to see that it fits. */
9147 source_address = (reloc[i].source_sec->output_section->vma
9148 + reloc[i].source_sec->output_offset
9149 + reloc[i].r_rel.rela.r_offset);
9150 dest_address = (sec->output_section->vma
9151 + sec->output_offset
9152 + r_rel->target_offset);
9154 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
9155 source_address, dest_address))
9164 /* Move a literal to another literal location because it is
9165 the same as the other literal value. */
9168 coalesce_shared_literal (asection *sec,
9170 property_table_entry *prop_table,
9174 property_table_entry *entry;
9176 property_table_entry *the_add_entry;
9178 xtensa_relax_info *relax_info;
9180 relax_info = get_xtensa_relax_info (sec);
9184 entry = elf_xtensa_find_property_entry
9185 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
9186 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
9189 /* Mark that the literal will be coalesced. */
9190 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
9192 text_action_add (&relax_info->action_list,
9193 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
9195 /* If the section is 4-byte aligned, do not add fill. */
9196 if (sec->alignment_power > 2)
9198 int fill_extra_space;
9199 bfd_vma entry_sec_offset;
9202 entry_sec_offset = entry->address - sec->vma + entry->size;
9204 entry_sec_offset = rel->r_rel.target_offset + 4;
9206 /* If the literal range is at the end of the section,
9208 fill_extra_space = 0;
9209 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
9211 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9212 fill_extra_space = the_add_entry->size;
9214 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
9215 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
9216 -4, fill_extra_space);
9218 adjust_fill_action (fa, removed_diff);
9220 text_action_add (&relax_info->action_list,
9221 ta_fill, sec, entry_sec_offset, removed_diff);
9228 /* Move a literal to another location. This may actually increase the
9229 total amount of space used because of alignments so we need to do
9230 this carefully. Also, it may make a branch go out of range. */
9233 move_shared_literal (asection *sec,
9234 struct bfd_link_info *link_info,
9236 property_table_entry *prop_table,
9238 const r_reloc *target_loc,
9239 const literal_value *lit_value,
9240 section_cache_t *target_sec_cache)
9242 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
9243 text_action *fa, *target_fa;
9245 xtensa_relax_info *relax_info, *target_relax_info;
9246 asection *target_sec;
9248 ebb_constraint ebb_table;
9249 bfd_boolean relocs_fit;
9251 /* If this routine always returns FALSE, the literals that cannot be
9252 coalesced will not be moved. */
9253 if (elf32xtensa_no_literal_movement)
9256 relax_info = get_xtensa_relax_info (sec);
9260 target_sec = r_reloc_get_section (target_loc);
9261 target_relax_info = get_xtensa_relax_info (target_sec);
9263 /* Literals to undefined sections may not be moved because they
9264 must report an error. */
9265 if (bfd_is_und_section (target_sec))
9268 src_entry = elf_xtensa_find_property_entry
9269 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
9271 if (!section_cache_section (target_sec_cache, target_sec, link_info))
9274 target_entry = elf_xtensa_find_property_entry
9275 (target_sec_cache->ptbl, target_sec_cache->pte_count,
9276 target_sec->vma + target_loc->target_offset);
9281 /* Make sure that we have not broken any branches. */
9284 init_ebb_constraint (&ebb_table);
9285 ebb = &ebb_table.ebb;
9286 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
9287 target_sec_cache->content_length,
9288 target_sec_cache->ptbl, target_sec_cache->pte_count,
9289 target_sec_cache->relocs, target_sec_cache->reloc_count);
9291 /* Propose to add 4 bytes + worst-case alignment size increase to
9293 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
9294 ta_fill, target_loc->target_offset,
9295 -4 - (1 << target_sec->alignment_power), TRUE);
9297 /* Check all of the PC-relative relocations to make sure they still fit. */
9298 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
9299 target_sec_cache->contents,
9300 target_sec_cache->relocs, NULL,
9306 text_action_add_literal (&target_relax_info->action_list,
9307 ta_add_literal, target_loc, lit_value, -4);
9309 if (target_sec->alignment_power > 2 && target_entry != src_entry)
9311 /* May need to add or remove some fill to maintain alignment. */
9312 int fill_extra_space;
9313 bfd_vma entry_sec_offset;
9316 target_entry->address - target_sec->vma + target_entry->size;
9318 /* If the literal range is at the end of the section,
9320 fill_extra_space = 0;
9322 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
9323 target_sec_cache->pte_count,
9325 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9326 fill_extra_space = the_add_entry->size;
9328 target_fa = find_fill_action (&target_relax_info->action_list,
9329 target_sec, entry_sec_offset);
9330 removed_diff = compute_removed_action_diff (target_fa, target_sec,
9331 entry_sec_offset, 4,
9334 adjust_fill_action (target_fa, removed_diff);
9336 text_action_add (&target_relax_info->action_list,
9337 ta_fill, target_sec, entry_sec_offset, removed_diff);
9340 /* Mark that the literal will be moved to the new location. */
9341 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
9343 /* Remove the literal. */
9344 text_action_add (&relax_info->action_list,
9345 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
9347 /* If the section is 4-byte aligned, do not add fill. */
9348 if (sec->alignment_power > 2 && target_entry != src_entry)
9350 int fill_extra_space;
9351 bfd_vma entry_sec_offset;
9354 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
9356 entry_sec_offset = rel->r_rel.target_offset+4;
9358 /* If the literal range is at the end of the section,
9360 fill_extra_space = 0;
9361 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
9363 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9364 fill_extra_space = the_add_entry->size;
9366 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
9367 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
9368 -4, fill_extra_space);
9370 adjust_fill_action (fa, removed_diff);
9372 text_action_add (&relax_info->action_list,
9373 ta_fill, sec, entry_sec_offset, removed_diff);
9380 /* Second relaxation pass. */
9383 action_remove_bytes_fn (splay_tree_node node, void *p)
9385 bfd_size_type *final_size = p;
9386 text_action *action = (text_action *)node->value;
9388 *final_size -= action->removed_bytes;
9392 /* Modify all of the relocations to point to the right spot, and if this
9393 is a relaxable section, delete the unwanted literals and fix the
9397 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
9399 Elf_Internal_Rela *internal_relocs;
9400 xtensa_relax_info *relax_info;
9402 bfd_boolean ok = TRUE;
9404 bfd_boolean rv = FALSE;
9405 bfd_boolean virtual_action;
9406 bfd_size_type sec_size;
9408 sec_size = bfd_get_section_limit (abfd, sec);
9409 relax_info = get_xtensa_relax_info (sec);
9410 BFD_ASSERT (relax_info);
9412 /* First translate any of the fixes that have been added already. */
9413 translate_section_fixes (sec);
9415 /* Handle property sections (e.g., literal tables) specially. */
9416 if (xtensa_is_property_section (sec))
9418 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
9419 return relax_property_section (abfd, sec, link_info);
9422 internal_relocs = retrieve_internal_relocs (abfd, sec,
9423 link_info->keep_memory);
9424 if (!internal_relocs && !action_list_count (&relax_info->action_list))
9427 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9428 if (contents == NULL && sec_size != 0)
9434 if (internal_relocs)
9436 for (i = 0; i < sec->reloc_count; i++)
9438 Elf_Internal_Rela *irel;
9439 xtensa_relax_info *target_relax_info;
9440 bfd_vma source_offset, old_source_offset;
9443 asection *target_sec;
9445 /* Locally change the source address.
9446 Translate the target to the new target address.
9447 If it points to this section and has been removed,
9451 irel = &internal_relocs[i];
9452 source_offset = irel->r_offset;
9453 old_source_offset = source_offset;
9455 r_type = ELF32_R_TYPE (irel->r_info);
9456 r_reloc_init (&r_rel, abfd, irel, contents,
9457 bfd_get_section_limit (abfd, sec));
9459 /* If this section could have changed then we may need to
9460 change the relocation's offset. */
9462 if (relax_info->is_relaxable_literal_section
9463 || relax_info->is_relaxable_asm_section)
9465 pin_internal_relocs (sec, internal_relocs);
9467 if (r_type != R_XTENSA_NONE
9468 && find_removed_literal (&relax_info->removed_list,
9471 /* Remove this relocation. */
9472 if (elf_hash_table (link_info)->dynamic_sections_created)
9473 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
9474 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
9475 irel->r_offset = offset_with_removed_text_map
9476 (&relax_info->action_list, irel->r_offset);
9480 if (r_type == R_XTENSA_ASM_SIMPLIFY)
9482 text_action *action =
9483 find_insn_action (&relax_info->action_list,
9485 if (action && (action->action == ta_convert_longcall
9486 || action->action == ta_remove_longcall))
9488 bfd_reloc_status_type retval;
9489 char *error_message = NULL;
9491 retval = contract_asm_expansion (contents, sec_size,
9492 irel, &error_message);
9493 if (retval != bfd_reloc_ok)
9495 (*link_info->callbacks->reloc_dangerous)
9496 (link_info, error_message, abfd, sec,
9500 /* Update the action so that the code that moves
9501 the contents will do the right thing. */
9502 /* ta_remove_longcall and ta_remove_insn actions are
9503 grouped together in the tree as well as
9504 ta_convert_longcall and ta_none, so that changes below
9505 can be done w/o removing and reinserting action into
9508 if (action->action == ta_remove_longcall)
9509 action->action = ta_remove_insn;
9511 action->action = ta_none;
9512 /* Refresh the info in the r_rel. */
9513 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
9514 r_type = ELF32_R_TYPE (irel->r_info);
9518 source_offset = offset_with_removed_text_map
9519 (&relax_info->action_list, irel->r_offset);
9520 irel->r_offset = source_offset;
9523 /* If the target section could have changed then
9524 we may need to change the relocation's target offset. */
9526 target_sec = r_reloc_get_section (&r_rel);
9528 /* For a reference to a discarded section from a DWARF section,
9529 i.e., where action_discarded is PRETEND, the symbol will
9530 eventually be modified to refer to the kept section (at least if
9531 the kept and discarded sections are the same size). Anticipate
9532 that here and adjust things accordingly. */
9533 if (! elf_xtensa_ignore_discarded_relocs (sec)
9534 && elf_xtensa_action_discarded (sec) == PRETEND
9535 && sec->sec_info_type != SEC_INFO_TYPE_STABS
9536 && target_sec != NULL
9537 && discarded_section (target_sec))
9539 /* It would be natural to call _bfd_elf_check_kept_section
9540 here, but it's not exported from elflink.c. It's also a
9541 fairly expensive check. Adjusting the relocations to the
9542 discarded section is fairly harmless; it will only adjust
9543 some addends and difference values. If it turns out that
9544 _bfd_elf_check_kept_section fails later, it won't matter,
9545 so just compare the section names to find the right group
9547 asection *kept = target_sec->kept_section;
9550 if ((kept->flags & SEC_GROUP) != 0)
9552 asection *first = elf_next_in_group (kept);
9553 asection *s = first;
9558 if (strcmp (s->name, target_sec->name) == 0)
9563 s = elf_next_in_group (s);
9570 && ((target_sec->rawsize != 0
9571 ? target_sec->rawsize : target_sec->size)
9572 == (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9576 target_relax_info = get_xtensa_relax_info (target_sec);
9577 if (target_relax_info
9578 && (target_relax_info->is_relaxable_literal_section
9579 || target_relax_info->is_relaxable_asm_section))
9582 target_sec = translate_reloc (&r_rel, &new_reloc, target_sec);
9584 if (r_type == R_XTENSA_DIFF8
9585 || r_type == R_XTENSA_DIFF16
9586 || r_type == R_XTENSA_DIFF32)
9588 bfd_signed_vma diff_value = 0;
9589 bfd_vma new_end_offset, diff_mask = 0;
9591 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
9593 (*link_info->callbacks->reloc_dangerous)
9594 (link_info, _("invalid relocation address"),
9595 abfd, sec, old_source_offset);
9601 case R_XTENSA_DIFF8:
9603 bfd_get_signed_8 (abfd, &contents[old_source_offset]);
9605 case R_XTENSA_DIFF16:
9607 bfd_get_signed_16 (abfd, &contents[old_source_offset]);
9609 case R_XTENSA_DIFF32:
9611 bfd_get_signed_32 (abfd, &contents[old_source_offset]);
9615 new_end_offset = offset_with_removed_text_map
9616 (&target_relax_info->action_list,
9617 r_rel.target_offset + diff_value);
9618 diff_value = new_end_offset - new_reloc.target_offset;
9622 case R_XTENSA_DIFF8:
9624 bfd_put_signed_8 (abfd, diff_value,
9625 &contents[old_source_offset]);
9627 case R_XTENSA_DIFF16:
9629 bfd_put_signed_16 (abfd, diff_value,
9630 &contents[old_source_offset]);
9632 case R_XTENSA_DIFF32:
9633 diff_mask = 0x7fffffff;
9634 bfd_put_signed_32 (abfd, diff_value,
9635 &contents[old_source_offset]);
9639 /* Check for overflow. Sign bits must be all zeroes or all ones */
9640 if ((diff_value & ~diff_mask) != 0 &&
9641 (diff_value & ~diff_mask) != (-1 & ~diff_mask))
9643 (*link_info->callbacks->reloc_dangerous)
9644 (link_info, _("overflow after relaxation"),
9645 abfd, sec, old_source_offset);
9649 pin_contents (sec, contents);
9652 /* If the relocation still references a section in the same
9653 input file, modify the relocation directly instead of
9654 adding a "fix" record. */
9655 if (target_sec->owner == abfd)
9657 unsigned r_symndx = ELF32_R_SYM (new_reloc.rela.r_info);
9658 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
9659 irel->r_addend = new_reloc.rela.r_addend;
9660 pin_internal_relocs (sec, internal_relocs);
9664 bfd_vma addend_displacement;
9667 addend_displacement =
9668 new_reloc.target_offset + new_reloc.virtual_offset;
9669 fix = reloc_bfd_fix_init (sec, source_offset, r_type,
9671 addend_displacement, TRUE);
9678 if ((relax_info->is_relaxable_literal_section
9679 || relax_info->is_relaxable_asm_section)
9680 && action_list_count (&relax_info->action_list))
9682 /* Walk through the planned actions and build up a table
9683 of move, copy and fill records. Use the move, copy and
9684 fill records to perform the actions once. */
9686 bfd_size_type final_size, copy_size, orig_insn_size;
9687 bfd_byte *scratch = NULL;
9688 bfd_byte *dup_contents = NULL;
9689 bfd_size_type orig_size = sec->size;
9690 bfd_vma orig_dot = 0;
9691 bfd_vma orig_dot_copied = 0; /* Byte copied already from
9692 orig dot in physical memory. */
9693 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
9694 bfd_vma dup_dot = 0;
9696 text_action *action;
9698 final_size = sec->size;
9700 splay_tree_foreach (relax_info->action_list.tree,
9701 action_remove_bytes_fn, &final_size);
9702 scratch = (bfd_byte *) bfd_zmalloc (final_size);
9703 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
9705 /* The dot is the current fill location. */
9707 print_action_list (stderr, &relax_info->action_list);
9710 for (action = action_first (&relax_info->action_list); action;
9711 action = action_next (&relax_info->action_list, action))
9713 virtual_action = FALSE;
9714 if (action->offset > orig_dot)
9716 orig_dot += orig_dot_copied;
9717 orig_dot_copied = 0;
9719 /* Out of the virtual world. */
9722 if (action->offset > orig_dot)
9724 copy_size = action->offset - orig_dot;
9725 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9726 orig_dot += copy_size;
9727 dup_dot += copy_size;
9728 BFD_ASSERT (action->offset == orig_dot);
9730 else if (action->offset < orig_dot)
9732 if (action->action == ta_fill
9733 && action->offset - action->removed_bytes == orig_dot)
9735 /* This is OK because the fill only effects the dup_dot. */
9737 else if (action->action == ta_add_literal)
9739 /* TBD. Might need to handle this. */
9742 if (action->offset == orig_dot)
9744 if (action->virtual_offset > orig_dot_vo)
9746 if (orig_dot_vo == 0)
9748 /* Need to copy virtual_offset bytes. Probably four. */
9749 copy_size = action->virtual_offset - orig_dot_vo;
9750 memmove (&dup_contents[dup_dot],
9751 &contents[orig_dot], copy_size);
9752 orig_dot_copied = copy_size;
9753 dup_dot += copy_size;
9755 virtual_action = TRUE;
9758 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
9760 switch (action->action)
9762 case ta_remove_literal:
9763 case ta_remove_insn:
9764 BFD_ASSERT (action->removed_bytes >= 0);
9765 orig_dot += action->removed_bytes;
9768 case ta_narrow_insn:
9771 memmove (scratch, &contents[orig_dot], orig_insn_size);
9772 BFD_ASSERT (action->removed_bytes == 1);
9773 rv = narrow_instruction (scratch, final_size, 0);
9775 memmove (&dup_contents[dup_dot], scratch, copy_size);
9776 orig_dot += orig_insn_size;
9777 dup_dot += copy_size;
9781 if (action->removed_bytes >= 0)
9782 orig_dot += action->removed_bytes;
9785 /* Already zeroed in dup_contents. Just bump the
9787 dup_dot += (-action->removed_bytes);
9792 BFD_ASSERT (action->removed_bytes == 0);
9795 case ta_convert_longcall:
9796 case ta_remove_longcall:
9797 /* These will be removed or converted before we get here. */
9804 memmove (scratch, &contents[orig_dot], orig_insn_size);
9805 BFD_ASSERT (action->removed_bytes == -1);
9806 rv = widen_instruction (scratch, final_size, 0);
9808 memmove (&dup_contents[dup_dot], scratch, copy_size);
9809 orig_dot += orig_insn_size;
9810 dup_dot += copy_size;
9813 case ta_add_literal:
9816 BFD_ASSERT (action->removed_bytes == -4);
9817 /* TBD -- place the literal value here and insert
9819 memset (&dup_contents[dup_dot], 0, 4);
9820 pin_internal_relocs (sec, internal_relocs);
9821 pin_contents (sec, contents);
9823 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
9824 relax_info, &internal_relocs, &action->value))
9828 orig_dot_vo += copy_size;
9830 orig_dot += orig_insn_size;
9831 dup_dot += copy_size;
9835 /* Not implemented yet. */
9840 BFD_ASSERT (dup_dot <= final_size);
9841 BFD_ASSERT (orig_dot <= orig_size);
9844 orig_dot += orig_dot_copied;
9845 orig_dot_copied = 0;
9847 if (orig_dot != orig_size)
9849 copy_size = orig_size - orig_dot;
9850 BFD_ASSERT (orig_size > orig_dot);
9851 BFD_ASSERT (dup_dot + copy_size == final_size);
9852 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9853 orig_dot += copy_size;
9854 dup_dot += copy_size;
9856 BFD_ASSERT (orig_size == orig_dot);
9857 BFD_ASSERT (final_size == dup_dot);
9859 /* Move the dup_contents back. */
9860 if (final_size > orig_size)
9862 /* Contents need to be reallocated. Swap the dup_contents into
9864 sec->contents = dup_contents;
9866 contents = dup_contents;
9867 pin_contents (sec, contents);
9871 BFD_ASSERT (final_size <= orig_size);
9872 memset (contents, 0, orig_size);
9873 memcpy (contents, dup_contents, final_size);
9874 free (dup_contents);
9877 pin_contents (sec, contents);
9879 if (sec->rawsize == 0)
9880 sec->rawsize = sec->size;
9881 sec->size = final_size;
9885 release_internal_relocs (sec, internal_relocs);
9886 release_contents (sec, contents);
9892 translate_section_fixes (asection *sec)
9894 xtensa_relax_info *relax_info;
9897 relax_info = get_xtensa_relax_info (sec);
9901 for (r = relax_info->fix_list; r != NULL; r = r->next)
9902 if (!translate_reloc_bfd_fix (r))
9909 /* Translate a fix given the mapping in the relax info for the target
9910 section. If it has already been translated, no work is required. */
9913 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
9915 reloc_bfd_fix new_fix;
9917 xtensa_relax_info *relax_info;
9918 removed_literal *removed;
9919 bfd_vma new_offset, target_offset;
9921 if (fix->translated)
9924 sec = fix->target_sec;
9925 target_offset = fix->target_offset;
9927 relax_info = get_xtensa_relax_info (sec);
9930 fix->translated = TRUE;
9936 /* The fix does not need to be translated if the section cannot change. */
9937 if (!relax_info->is_relaxable_literal_section
9938 && !relax_info->is_relaxable_asm_section)
9940 fix->translated = TRUE;
9944 /* If the literal has been moved and this relocation was on an
9945 opcode, then the relocation should move to the new literal
9946 location. Otherwise, the relocation should move within the
9950 if (is_operand_relocation (fix->src_type))
9952 /* Check if the original relocation is against a literal being
9954 removed = find_removed_literal (&relax_info->removed_list,
9962 /* The fact that there is still a relocation to this literal indicates
9963 that the literal is being coalesced, not simply removed. */
9964 BFD_ASSERT (removed->to.abfd != NULL);
9966 /* This was moved to some other address (possibly another section). */
9967 new_sec = r_reloc_get_section (&removed->to);
9971 relax_info = get_xtensa_relax_info (sec);
9973 (!relax_info->is_relaxable_literal_section
9974 && !relax_info->is_relaxable_asm_section))
9976 target_offset = removed->to.target_offset;
9977 new_fix.target_sec = new_sec;
9978 new_fix.target_offset = target_offset;
9979 new_fix.translated = TRUE;
9984 target_offset = removed->to.target_offset;
9985 new_fix.target_sec = new_sec;
9988 /* The target address may have been moved within its section. */
9989 new_offset = offset_with_removed_text (&relax_info->action_list,
9992 new_fix.target_offset = new_offset;
9993 new_fix.target_offset = new_offset;
9994 new_fix.translated = TRUE;
10000 /* Fix up a relocation to take account of removed literals. */
10003 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec)
10005 xtensa_relax_info *relax_info;
10006 removed_literal *removed;
10007 bfd_vma target_offset, base_offset;
10009 *new_rel = *orig_rel;
10011 if (!r_reloc_is_defined (orig_rel))
10014 relax_info = get_xtensa_relax_info (sec);
10015 BFD_ASSERT (relax_info && (relax_info->is_relaxable_literal_section
10016 || relax_info->is_relaxable_asm_section));
10018 target_offset = orig_rel->target_offset;
10021 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
10023 /* Check if the original relocation is against a literal being
10025 removed = find_removed_literal (&relax_info->removed_list,
10028 if (removed && removed->to.abfd)
10032 /* The fact that there is still a relocation to this literal indicates
10033 that the literal is being coalesced, not simply removed. */
10034 BFD_ASSERT (removed->to.abfd != NULL);
10036 /* This was moved to some other address
10037 (possibly in another section). */
10038 *new_rel = removed->to;
10039 new_sec = r_reloc_get_section (new_rel);
10040 if (new_sec != sec)
10043 relax_info = get_xtensa_relax_info (sec);
10045 || (!relax_info->is_relaxable_literal_section
10046 && !relax_info->is_relaxable_asm_section))
10049 target_offset = new_rel->target_offset;
10052 /* Find the base offset of the reloc symbol, excluding any addend from the
10053 reloc or from the section contents (for a partial_inplace reloc). Then
10054 find the adjusted values of the offsets due to relaxation. The base
10055 offset is needed to determine the change to the reloc's addend; the reloc
10056 addend should not be adjusted due to relaxations located before the base
10059 base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend;
10060 if (base_offset <= target_offset)
10062 int base_removed = removed_by_actions_map (&relax_info->action_list,
10063 base_offset, FALSE);
10064 int addend_removed = removed_by_actions_map (&relax_info->action_list,
10065 target_offset, FALSE) -
10068 new_rel->target_offset = target_offset - base_removed - addend_removed;
10069 new_rel->rela.r_addend -= addend_removed;
10073 /* Handle a negative addend. The base offset comes first. */
10074 int tgt_removed = removed_by_actions_map (&relax_info->action_list,
10075 target_offset, FALSE);
10076 int addend_removed = removed_by_actions_map (&relax_info->action_list,
10077 base_offset, FALSE) -
10080 new_rel->target_offset = target_offset - tgt_removed;
10081 new_rel->rela.r_addend += addend_removed;
10088 /* For dynamic links, there may be a dynamic relocation for each
10089 literal. The number of dynamic relocations must be computed in
10090 size_dynamic_sections, which occurs before relaxation. When a
10091 literal is removed, this function checks if there is a corresponding
10092 dynamic relocation and shrinks the size of the appropriate dynamic
10093 relocation section accordingly. At this point, the contents of the
10094 dynamic relocation sections have not yet been filled in, so there's
10095 nothing else that needs to be done. */
10098 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
10100 asection *input_section,
10101 Elf_Internal_Rela *rel)
10103 struct elf_xtensa_link_hash_table *htab;
10104 Elf_Internal_Shdr *symtab_hdr;
10105 struct elf_link_hash_entry **sym_hashes;
10106 unsigned long r_symndx;
10108 struct elf_link_hash_entry *h;
10109 bfd_boolean dynamic_symbol;
10111 htab = elf_xtensa_hash_table (info);
10115 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10116 sym_hashes = elf_sym_hashes (abfd);
10118 r_type = ELF32_R_TYPE (rel->r_info);
10119 r_symndx = ELF32_R_SYM (rel->r_info);
10121 if (r_symndx < symtab_hdr->sh_info)
10124 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
10126 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
10128 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
10129 && (input_section->flags & SEC_ALLOC) != 0
10130 && (dynamic_symbol || bfd_link_pic (info)))
10133 bfd_boolean is_plt = FALSE;
10135 if (dynamic_symbol && r_type == R_XTENSA_PLT)
10137 srel = htab->srelplt;
10141 srel = htab->srelgot;
10143 /* Reduce size of the .rela.* section by one reloc. */
10144 BFD_ASSERT (srel != NULL);
10145 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
10146 srel->size -= sizeof (Elf32_External_Rela);
10150 asection *splt, *sgotplt, *srelgot;
10151 int reloc_index, chunk;
10153 /* Find the PLT reloc index of the entry being removed. This
10154 is computed from the size of ".rela.plt". It is needed to
10155 figure out which PLT chunk to resize. Usually "last index
10156 = size - 1" since the index starts at zero, but in this
10157 context, the size has just been decremented so there's no
10158 need to subtract one. */
10159 reloc_index = srel->size / sizeof (Elf32_External_Rela);
10161 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
10162 splt = elf_xtensa_get_plt_section (info, chunk);
10163 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
10164 BFD_ASSERT (splt != NULL && sgotplt != NULL);
10166 /* Check if an entire PLT chunk has just been eliminated. */
10167 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
10169 /* The two magic GOT entries for that chunk can go away. */
10170 srelgot = htab->srelgot;
10171 BFD_ASSERT (srelgot != NULL);
10172 srelgot->reloc_count -= 2;
10173 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
10174 sgotplt->size -= 8;
10176 /* There should be only one entry left (and it will be
10178 BFD_ASSERT (sgotplt->size == 4);
10179 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
10182 BFD_ASSERT (sgotplt->size >= 4);
10183 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
10185 sgotplt->size -= 4;
10186 splt->size -= PLT_ENTRY_SIZE;
10192 /* Take an r_rel and move it to another section. This usually
10193 requires extending the interal_relocation array and pinning it. If
10194 the original r_rel is from the same BFD, we can complete this here.
10195 Otherwise, we add a fix record to let the final link fix the
10196 appropriate address. Contents and internal relocations for the
10197 section must be pinned after calling this routine. */
10200 move_literal (bfd *abfd,
10201 struct bfd_link_info *link_info,
10204 bfd_byte *contents,
10205 xtensa_relax_info *relax_info,
10206 Elf_Internal_Rela **internal_relocs_p,
10207 const literal_value *lit)
10209 Elf_Internal_Rela *new_relocs = NULL;
10210 size_t new_relocs_count = 0;
10211 Elf_Internal_Rela this_rela;
10212 const r_reloc *r_rel;
10214 r_rel = &lit->r_rel;
10215 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
10217 if (r_reloc_is_const (r_rel))
10218 bfd_put_32 (abfd, lit->value, contents + offset);
10223 reloc_bfd_fix *fix;
10224 unsigned insert_at;
10226 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
10228 /* This is the difficult case. We have to create a fix up. */
10229 this_rela.r_offset = offset;
10230 this_rela.r_info = ELF32_R_INFO (0, r_type);
10231 this_rela.r_addend =
10232 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
10233 bfd_put_32 (abfd, lit->value, contents + offset);
10235 /* Currently, we cannot move relocations during a relocatable link. */
10236 BFD_ASSERT (!bfd_link_relocatable (link_info));
10237 fix = reloc_bfd_fix_init (sec, offset, r_type,
10238 r_reloc_get_section (r_rel),
10239 r_rel->target_offset + r_rel->virtual_offset,
10241 /* We also need to mark that relocations are needed here. */
10242 sec->flags |= SEC_RELOC;
10244 translate_reloc_bfd_fix (fix);
10245 /* This fix has not yet been translated. */
10246 add_fix (sec, fix);
10248 /* Add the relocation. If we have already allocated our own
10249 space for the relocations and we have room for more, then use
10250 it. Otherwise, allocate new space and move the literals. */
10251 insert_at = sec->reloc_count;
10252 for (i = 0; i < sec->reloc_count; ++i)
10254 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
10261 if (*internal_relocs_p != relax_info->allocated_relocs
10262 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
10264 BFD_ASSERT (relax_info->allocated_relocs == NULL
10265 || sec->reloc_count == relax_info->relocs_count);
10267 if (relax_info->allocated_relocs_count == 0)
10268 new_relocs_count = (sec->reloc_count + 2) * 2;
10270 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
10272 new_relocs = (Elf_Internal_Rela *)
10273 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
10277 /* We could handle this more quickly by finding the split point. */
10278 if (insert_at != 0)
10279 memcpy (new_relocs, *internal_relocs_p,
10280 insert_at * sizeof (Elf_Internal_Rela));
10282 new_relocs[insert_at] = this_rela;
10284 if (insert_at != sec->reloc_count)
10285 memcpy (new_relocs + insert_at + 1,
10286 (*internal_relocs_p) + insert_at,
10287 (sec->reloc_count - insert_at)
10288 * sizeof (Elf_Internal_Rela));
10290 if (*internal_relocs_p != relax_info->allocated_relocs)
10292 /* The first time we re-allocate, we can only free the
10293 old relocs if they were allocated with bfd_malloc.
10294 This is not true when keep_memory is in effect. */
10295 if (!link_info->keep_memory)
10296 free (*internal_relocs_p);
10299 free (*internal_relocs_p);
10300 relax_info->allocated_relocs = new_relocs;
10301 relax_info->allocated_relocs_count = new_relocs_count;
10302 elf_section_data (sec)->relocs = new_relocs;
10303 sec->reloc_count++;
10304 relax_info->relocs_count = sec->reloc_count;
10305 *internal_relocs_p = new_relocs;
10309 if (insert_at != sec->reloc_count)
10312 for (idx = sec->reloc_count; idx > insert_at; idx--)
10313 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
10315 (*internal_relocs_p)[insert_at] = this_rela;
10316 sec->reloc_count++;
10317 if (relax_info->allocated_relocs)
10318 relax_info->relocs_count = sec->reloc_count;
10325 /* This is similar to relax_section except that when a target is moved,
10326 we shift addresses up. We also need to modify the size. This
10327 algorithm does NOT allow for relocations into the middle of the
10328 property sections. */
10331 relax_property_section (bfd *abfd,
10333 struct bfd_link_info *link_info)
10335 Elf_Internal_Rela *internal_relocs;
10336 bfd_byte *contents;
10338 bfd_boolean ok = TRUE;
10339 bfd_boolean is_full_prop_section;
10340 size_t last_zfill_target_offset = 0;
10341 asection *last_zfill_target_sec = NULL;
10342 bfd_size_type sec_size;
10343 bfd_size_type entry_size;
10345 sec_size = bfd_get_section_limit (abfd, sec);
10346 internal_relocs = retrieve_internal_relocs (abfd, sec,
10347 link_info->keep_memory);
10348 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
10349 if (contents == NULL && sec_size != 0)
10355 is_full_prop_section = xtensa_is_proptable_section (sec);
10356 if (is_full_prop_section)
10361 if (internal_relocs)
10363 for (i = 0; i < sec->reloc_count; i++)
10365 Elf_Internal_Rela *irel;
10366 xtensa_relax_info *target_relax_info;
10368 asection *target_sec;
10370 bfd_byte *size_p, *flags_p;
10372 /* Locally change the source address.
10373 Translate the target to the new target address.
10374 If it points to this section and has been removed, MOVE IT.
10375 Also, don't forget to modify the associated SIZE at
10378 irel = &internal_relocs[i];
10379 r_type = ELF32_R_TYPE (irel->r_info);
10380 if (r_type == R_XTENSA_NONE)
10383 /* Find the literal value. */
10384 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
10385 size_p = &contents[irel->r_offset + 4];
10387 if (is_full_prop_section)
10388 flags_p = &contents[irel->r_offset + 8];
10389 BFD_ASSERT (irel->r_offset + entry_size <= sec_size);
10391 target_sec = r_reloc_get_section (&val.r_rel);
10392 target_relax_info = get_xtensa_relax_info (target_sec);
10394 if (target_relax_info
10395 && (target_relax_info->is_relaxable_literal_section
10396 || target_relax_info->is_relaxable_asm_section ))
10398 /* Translate the relocation's destination. */
10399 bfd_vma old_offset = val.r_rel.target_offset;
10400 bfd_vma new_offset;
10401 long old_size, new_size;
10402 int removed_by_old_offset =
10403 removed_by_actions_map (&target_relax_info->action_list,
10404 old_offset, FALSE);
10405 new_offset = old_offset - removed_by_old_offset;
10407 /* Assert that we are not out of bounds. */
10408 old_size = bfd_get_32 (abfd, size_p);
10409 new_size = old_size;
10413 /* Only the first zero-sized unreachable entry is
10414 allowed to expand. In this case the new offset
10415 should be the offset before the fill and the new
10416 size is the expansion size. For other zero-sized
10417 entries the resulting size should be zero with an
10418 offset before or after the fill address depending
10419 on whether the expanding unreachable entry
10421 if (last_zfill_target_sec == 0
10422 || last_zfill_target_sec != target_sec
10423 || last_zfill_target_offset != old_offset)
10425 bfd_vma new_end_offset = new_offset;
10427 /* Recompute the new_offset, but this time don't
10428 include any fill inserted by relaxation. */
10429 removed_by_old_offset =
10430 removed_by_actions_map (&target_relax_info->action_list,
10432 new_offset = old_offset - removed_by_old_offset;
10434 /* If it is not unreachable and we have not yet
10435 seen an unreachable at this address, place it
10436 before the fill address. */
10437 if (flags_p && (bfd_get_32 (abfd, flags_p)
10438 & XTENSA_PROP_UNREACHABLE) != 0)
10440 new_size = new_end_offset - new_offset;
10442 last_zfill_target_sec = target_sec;
10443 last_zfill_target_offset = old_offset;
10449 int removed_by_old_offset_size =
10450 removed_by_actions_map (&target_relax_info->action_list,
10451 old_offset + old_size, TRUE);
10452 new_size -= removed_by_old_offset_size - removed_by_old_offset;
10455 if (new_size != old_size)
10457 bfd_put_32 (abfd, new_size, size_p);
10458 pin_contents (sec, contents);
10461 if (new_offset != old_offset)
10463 bfd_vma diff = new_offset - old_offset;
10464 irel->r_addend += diff;
10465 pin_internal_relocs (sec, internal_relocs);
10471 /* Combine adjacent property table entries. This is also done in
10472 finish_dynamic_sections() but at that point it's too late to
10473 reclaim the space in the output section, so we do this twice. */
10475 if (internal_relocs && (!bfd_link_relocatable (link_info)
10476 || xtensa_is_littable_section (sec)))
10478 Elf_Internal_Rela *last_irel = NULL;
10479 Elf_Internal_Rela *irel, *next_rel, *rel_end;
10480 int removed_bytes = 0;
10482 flagword predef_flags;
10484 predef_flags = xtensa_get_property_predef_flags (sec);
10486 /* Walk over memory and relocations at the same time.
10487 This REQUIRES that the internal_relocs be sorted by offset. */
10488 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
10489 internal_reloc_compare);
10491 pin_internal_relocs (sec, internal_relocs);
10492 pin_contents (sec, contents);
10494 next_rel = internal_relocs;
10495 rel_end = internal_relocs + sec->reloc_count;
10497 BFD_ASSERT (sec->size % entry_size == 0);
10499 for (offset = 0; offset < sec->size; offset += entry_size)
10501 Elf_Internal_Rela *offset_rel, *extra_rel;
10502 bfd_vma bytes_to_remove, size, actual_offset;
10503 bfd_boolean remove_this_rel;
10506 /* Find the first relocation for the entry at the current offset.
10507 Adjust the offsets of any extra relocations for the previous
10512 for (irel = next_rel; irel < rel_end; irel++)
10514 if ((irel->r_offset == offset
10515 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
10516 || irel->r_offset > offset)
10521 irel->r_offset -= removed_bytes;
10525 /* Find the next relocation (if there are any left). */
10529 for (irel = offset_rel + 1; irel < rel_end; irel++)
10531 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
10539 /* Check if there are relocations on the current entry. There
10540 should usually be a relocation on the offset field. If there
10541 are relocations on the size or flags, then we can't optimize
10542 this entry. Also, find the next relocation to examine on the
10546 if (offset_rel->r_offset >= offset + entry_size)
10548 next_rel = offset_rel;
10549 /* There are no relocations on the current entry, but we
10550 might still be able to remove it if the size is zero. */
10553 else if (offset_rel->r_offset > offset
10555 && extra_rel->r_offset < offset + entry_size))
10557 /* There is a relocation on the size or flags, so we can't
10558 do anything with this entry. Continue with the next. */
10559 next_rel = offset_rel;
10564 BFD_ASSERT (offset_rel->r_offset == offset);
10565 offset_rel->r_offset -= removed_bytes;
10566 next_rel = offset_rel + 1;
10572 remove_this_rel = FALSE;
10573 bytes_to_remove = 0;
10574 actual_offset = offset - removed_bytes;
10575 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
10577 if (is_full_prop_section)
10578 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
10580 flags = predef_flags;
10583 && (flags & XTENSA_PROP_ALIGN) == 0
10584 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
10586 /* Always remove entries with zero size and no alignment. */
10587 bytes_to_remove = entry_size;
10589 remove_this_rel = TRUE;
10591 else if (offset_rel
10592 && ELF32_R_TYPE (offset_rel->r_info) == R_XTENSA_32)
10596 flagword old_flags;
10598 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
10599 bfd_vma old_address =
10600 (last_irel->r_addend
10601 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
10602 bfd_vma new_address =
10603 (offset_rel->r_addend
10604 + bfd_get_32 (abfd, &contents[actual_offset]));
10605 if (is_full_prop_section)
10606 old_flags = bfd_get_32
10607 (abfd, &contents[last_irel->r_offset + 8]);
10609 old_flags = predef_flags;
10611 if ((ELF32_R_SYM (offset_rel->r_info)
10612 == ELF32_R_SYM (last_irel->r_info))
10613 && old_address + old_size == new_address
10614 && old_flags == flags
10615 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
10616 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
10618 /* Fix the old size. */
10619 bfd_put_32 (abfd, old_size + size,
10620 &contents[last_irel->r_offset + 4]);
10621 bytes_to_remove = entry_size;
10622 remove_this_rel = TRUE;
10625 last_irel = offset_rel;
10628 last_irel = offset_rel;
10631 if (remove_this_rel)
10633 offset_rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
10634 offset_rel->r_offset = 0;
10637 if (bytes_to_remove != 0)
10639 removed_bytes += bytes_to_remove;
10640 if (offset + bytes_to_remove < sec->size)
10641 memmove (&contents[actual_offset],
10642 &contents[actual_offset + bytes_to_remove],
10643 sec->size - offset - bytes_to_remove);
10649 /* Fix up any extra relocations on the last entry. */
10650 for (irel = next_rel; irel < rel_end; irel++)
10651 irel->r_offset -= removed_bytes;
10653 /* Clear the removed bytes. */
10654 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
10656 if (sec->rawsize == 0)
10657 sec->rawsize = sec->size;
10658 sec->size -= removed_bytes;
10660 if (xtensa_is_littable_section (sec))
10662 asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
10664 sgotloc->size -= removed_bytes;
10670 release_internal_relocs (sec, internal_relocs);
10671 release_contents (sec, contents);
10676 /* Third relaxation pass. */
10678 /* Change symbol values to account for removed literals. */
10681 relax_section_symbols (bfd *abfd, asection *sec)
10683 xtensa_relax_info *relax_info;
10684 unsigned int sec_shndx;
10685 Elf_Internal_Shdr *symtab_hdr;
10686 Elf_Internal_Sym *isymbuf;
10687 unsigned i, num_syms, num_locals;
10689 relax_info = get_xtensa_relax_info (sec);
10690 BFD_ASSERT (relax_info);
10692 if (!relax_info->is_relaxable_literal_section
10693 && !relax_info->is_relaxable_asm_section)
10696 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
10698 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10699 isymbuf = retrieve_local_syms (abfd);
10701 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
10702 num_locals = symtab_hdr->sh_info;
10704 /* Adjust the local symbols defined in this section. */
10705 for (i = 0; i < num_locals; i++)
10707 Elf_Internal_Sym *isym = &isymbuf[i];
10709 if (isym->st_shndx == sec_shndx)
10711 bfd_vma orig_addr = isym->st_value;
10712 int removed = removed_by_actions_map (&relax_info->action_list,
10715 isym->st_value -= removed;
10716 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
10718 removed_by_actions_map (&relax_info->action_list,
10719 orig_addr + isym->st_size, FALSE) -
10724 /* Now adjust the global symbols defined in this section. */
10725 for (i = 0; i < (num_syms - num_locals); i++)
10727 struct elf_link_hash_entry *sym_hash;
10729 sym_hash = elf_sym_hashes (abfd)[i];
10731 if (sym_hash->root.type == bfd_link_hash_warning)
10732 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
10734 if ((sym_hash->root.type == bfd_link_hash_defined
10735 || sym_hash->root.type == bfd_link_hash_defweak)
10736 && sym_hash->root.u.def.section == sec)
10738 bfd_vma orig_addr = sym_hash->root.u.def.value;
10739 int removed = removed_by_actions_map (&relax_info->action_list,
10742 sym_hash->root.u.def.value -= removed;
10744 if (sym_hash->type == STT_FUNC)
10746 removed_by_actions_map (&relax_info->action_list,
10747 orig_addr + sym_hash->size, FALSE) -
10756 /* "Fix" handling functions, called while performing relocations. */
10759 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
10761 asection *input_section,
10762 bfd_byte *contents)
10765 asection *sec, *old_sec;
10766 bfd_vma old_offset;
10767 int r_type = ELF32_R_TYPE (rel->r_info);
10768 reloc_bfd_fix *fix;
10770 if (r_type == R_XTENSA_NONE)
10773 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10777 r_reloc_init (&r_rel, input_bfd, rel, contents,
10778 bfd_get_section_limit (input_bfd, input_section));
10779 old_sec = r_reloc_get_section (&r_rel);
10780 old_offset = r_rel.target_offset;
10782 if (!old_sec || !r_reloc_is_defined (&r_rel))
10784 if (r_type != R_XTENSA_ASM_EXPAND)
10786 (*_bfd_error_handler)
10787 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
10788 input_bfd, input_section, rel->r_offset,
10789 elf_howto_table[r_type].name);
10792 /* Leave it be. Resolution will happen in a later stage. */
10796 sec = fix->target_sec;
10797 rel->r_addend += ((sec->output_offset + fix->target_offset)
10798 - (old_sec->output_offset + old_offset));
10805 do_fix_for_final_link (Elf_Internal_Rela *rel,
10807 asection *input_section,
10808 bfd_byte *contents,
10809 bfd_vma *relocationp)
10812 int r_type = ELF32_R_TYPE (rel->r_info);
10813 reloc_bfd_fix *fix;
10814 bfd_vma fixup_diff;
10816 if (r_type == R_XTENSA_NONE)
10819 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10823 sec = fix->target_sec;
10825 fixup_diff = rel->r_addend;
10826 if (elf_howto_table[fix->src_type].partial_inplace)
10828 bfd_vma inplace_val;
10829 BFD_ASSERT (fix->src_offset
10830 < bfd_get_section_limit (input_bfd, input_section));
10831 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
10832 fixup_diff += inplace_val;
10835 *relocationp = (sec->output_section->vma
10836 + sec->output_offset
10837 + fix->target_offset - fixup_diff);
10841 /* Miscellaneous utility functions.... */
10844 elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
10846 struct elf_xtensa_link_hash_table *htab;
10852 htab = elf_xtensa_hash_table (info);
10859 dynobj = elf_hash_table (info)->dynobj;
10860 sprintf (plt_name, ".plt.%u", chunk);
10861 return bfd_get_linker_section (dynobj, plt_name);
10866 elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
10868 struct elf_xtensa_link_hash_table *htab;
10874 htab = elf_xtensa_hash_table (info);
10877 return htab->sgotplt;
10880 dynobj = elf_hash_table (info)->dynobj;
10881 sprintf (got_name, ".got.plt.%u", chunk);
10882 return bfd_get_linker_section (dynobj, got_name);
10886 /* Get the input section for a given symbol index.
10888 . a section symbol, return the section;
10889 . a common symbol, return the common section;
10890 . an undefined symbol, return the undefined section;
10891 . an indirect symbol, follow the links;
10892 . an absolute value, return the absolute section. */
10895 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
10897 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10898 asection *target_sec = NULL;
10899 if (r_symndx < symtab_hdr->sh_info)
10901 Elf_Internal_Sym *isymbuf;
10902 unsigned int section_index;
10904 isymbuf = retrieve_local_syms (abfd);
10905 section_index = isymbuf[r_symndx].st_shndx;
10907 if (section_index == SHN_UNDEF)
10908 target_sec = bfd_und_section_ptr;
10909 else if (section_index == SHN_ABS)
10910 target_sec = bfd_abs_section_ptr;
10911 else if (section_index == SHN_COMMON)
10912 target_sec = bfd_com_section_ptr;
10914 target_sec = bfd_section_from_elf_index (abfd, section_index);
10918 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10919 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
10921 while (h->root.type == bfd_link_hash_indirect
10922 || h->root.type == bfd_link_hash_warning)
10923 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10925 switch (h->root.type)
10927 case bfd_link_hash_defined:
10928 case bfd_link_hash_defweak:
10929 target_sec = h->root.u.def.section;
10931 case bfd_link_hash_common:
10932 target_sec = bfd_com_section_ptr;
10934 case bfd_link_hash_undefined:
10935 case bfd_link_hash_undefweak:
10936 target_sec = bfd_und_section_ptr;
10938 default: /* New indirect warning. */
10939 target_sec = bfd_und_section_ptr;
10947 static struct elf_link_hash_entry *
10948 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
10950 unsigned long indx;
10951 struct elf_link_hash_entry *h;
10952 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10954 if (r_symndx < symtab_hdr->sh_info)
10957 indx = r_symndx - symtab_hdr->sh_info;
10958 h = elf_sym_hashes (abfd)[indx];
10959 while (h->root.type == bfd_link_hash_indirect
10960 || h->root.type == bfd_link_hash_warning)
10961 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10966 /* Get the section-relative offset for a symbol number. */
10969 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
10971 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10972 bfd_vma offset = 0;
10974 if (r_symndx < symtab_hdr->sh_info)
10976 Elf_Internal_Sym *isymbuf;
10977 isymbuf = retrieve_local_syms (abfd);
10978 offset = isymbuf[r_symndx].st_value;
10982 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10983 struct elf_link_hash_entry *h =
10984 elf_sym_hashes (abfd)[indx];
10986 while (h->root.type == bfd_link_hash_indirect
10987 || h->root.type == bfd_link_hash_warning)
10988 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10989 if (h->root.type == bfd_link_hash_defined
10990 || h->root.type == bfd_link_hash_defweak)
10991 offset = h->root.u.def.value;
10998 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
11000 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
11001 struct elf_link_hash_entry *h;
11003 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
11004 if (h && h->root.type == bfd_link_hash_defweak)
11011 pcrel_reloc_fits (xtensa_opcode opc,
11013 bfd_vma self_address,
11014 bfd_vma dest_address)
11016 xtensa_isa isa = xtensa_default_isa;
11017 uint32 valp = dest_address;
11018 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
11019 || xtensa_operand_encode (isa, opc, opnd, &valp))
11026 xtensa_is_property_section (asection *sec)
11028 if (xtensa_is_insntable_section (sec)
11029 || xtensa_is_littable_section (sec)
11030 || xtensa_is_proptable_section (sec))
11038 xtensa_is_insntable_section (asection *sec)
11040 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
11041 || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
11049 xtensa_is_littable_section (asection *sec)
11051 if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
11052 || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
11060 xtensa_is_proptable_section (asection *sec)
11062 if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
11063 || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
11071 internal_reloc_compare (const void *ap, const void *bp)
11073 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
11074 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
11076 if (a->r_offset != b->r_offset)
11077 return (a->r_offset - b->r_offset);
11079 /* We don't need to sort on these criteria for correctness,
11080 but enforcing a more strict ordering prevents unstable qsort
11081 from behaving differently with different implementations.
11082 Without the code below we get correct but different results
11083 on Solaris 2.7 and 2.8. We would like to always produce the
11084 same results no matter the host. */
11086 if (a->r_info != b->r_info)
11087 return (a->r_info - b->r_info);
11089 return (a->r_addend - b->r_addend);
11094 internal_reloc_matches (const void *ap, const void *bp)
11096 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
11097 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
11099 /* Check if one entry overlaps with the other; this shouldn't happen
11100 except when searching for a match. */
11101 return (a->r_offset - b->r_offset);
11105 /* Predicate function used to look up a section in a particular group. */
11108 match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
11110 const char *gname = inf;
11111 const char *group_name = elf_group_name (sec);
11113 return (group_name == gname
11114 || (group_name != NULL
11116 && strcmp (group_name, gname) == 0));
11120 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
11123 xtensa_property_section_name (asection *sec, const char *base_name)
11125 const char *suffix, *group_name;
11126 char *prop_sec_name;
11128 group_name = elf_group_name (sec);
11131 suffix = strrchr (sec->name, '.');
11132 if (suffix == sec->name)
11134 prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
11135 + (suffix ? strlen (suffix) : 0));
11136 strcpy (prop_sec_name, base_name);
11138 strcat (prop_sec_name, suffix);
11140 else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
11142 char *linkonce_kind = 0;
11144 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
11145 linkonce_kind = "x.";
11146 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
11147 linkonce_kind = "p.";
11148 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
11149 linkonce_kind = "prop.";
11153 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
11154 + strlen (linkonce_kind) + 1);
11155 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
11156 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
11158 suffix = sec->name + linkonce_len;
11159 /* For backward compatibility, replace "t." instead of inserting
11160 the new linkonce_kind (but not for "prop" sections). */
11161 if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
11163 strcat (prop_sec_name + linkonce_len, suffix);
11166 prop_sec_name = strdup (base_name);
11168 return prop_sec_name;
11173 xtensa_get_property_section (asection *sec, const char *base_name)
11175 char *prop_sec_name;
11176 asection *prop_sec;
11178 prop_sec_name = xtensa_property_section_name (sec, base_name);
11179 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
11180 match_section_group,
11181 (void *) elf_group_name (sec));
11182 free (prop_sec_name);
11188 xtensa_make_property_section (asection *sec, const char *base_name)
11190 char *prop_sec_name;
11191 asection *prop_sec;
11193 /* Check if the section already exists. */
11194 prop_sec_name = xtensa_property_section_name (sec, base_name);
11195 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
11196 match_section_group,
11197 (void *) elf_group_name (sec));
11198 /* If not, create it. */
11201 flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
11202 flags |= (bfd_get_section_flags (sec->owner, sec)
11203 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
11205 prop_sec = bfd_make_section_anyway_with_flags
11206 (sec->owner, strdup (prop_sec_name), flags);
11210 elf_group_name (prop_sec) = elf_group_name (sec);
11213 free (prop_sec_name);
11219 xtensa_get_property_predef_flags (asection *sec)
11221 if (xtensa_is_insntable_section (sec))
11222 return (XTENSA_PROP_INSN
11223 | XTENSA_PROP_NO_TRANSFORM
11224 | XTENSA_PROP_INSN_NO_REORDER);
11226 if (xtensa_is_littable_section (sec))
11227 return (XTENSA_PROP_LITERAL
11228 | XTENSA_PROP_NO_TRANSFORM
11229 | XTENSA_PROP_INSN_NO_REORDER);
11235 /* Other functions called directly by the linker. */
11238 xtensa_callback_required_dependence (bfd *abfd,
11240 struct bfd_link_info *link_info,
11241 deps_callback_t callback,
11244 Elf_Internal_Rela *internal_relocs;
11245 bfd_byte *contents;
11247 bfd_boolean ok = TRUE;
11248 bfd_size_type sec_size;
11250 sec_size = bfd_get_section_limit (abfd, sec);
11252 /* ".plt*" sections have no explicit relocations but they contain L32R
11253 instructions that reference the corresponding ".got.plt*" sections. */
11254 if ((sec->flags & SEC_LINKER_CREATED) != 0
11255 && CONST_STRNEQ (sec->name, ".plt"))
11259 /* Find the corresponding ".got.plt*" section. */
11260 if (sec->name[4] == '\0')
11261 sgotplt = bfd_get_linker_section (sec->owner, ".got.plt");
11267 BFD_ASSERT (sec->name[4] == '.');
11268 chunk = strtol (&sec->name[5], NULL, 10);
11270 sprintf (got_name, ".got.plt.%u", chunk);
11271 sgotplt = bfd_get_linker_section (sec->owner, got_name);
11273 BFD_ASSERT (sgotplt);
11275 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11276 section referencing a literal at the very beginning of
11277 ".got.plt". This is very close to the real dependence, anyway. */
11278 (*callback) (sec, sec_size, sgotplt, 0, closure);
11281 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11282 when building uclibc, which runs "ld -b binary /dev/null". */
11283 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
11286 internal_relocs = retrieve_internal_relocs (abfd, sec,
11287 link_info->keep_memory);
11288 if (internal_relocs == NULL
11289 || sec->reloc_count == 0)
11292 /* Cache the contents for the duration of this scan. */
11293 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
11294 if (contents == NULL && sec_size != 0)
11300 if (!xtensa_default_isa)
11301 xtensa_default_isa = xtensa_isa_init (0, 0);
11303 for (i = 0; i < sec->reloc_count; i++)
11305 Elf_Internal_Rela *irel = &internal_relocs[i];
11306 if (is_l32r_relocation (abfd, sec, contents, irel))
11309 asection *target_sec;
11310 bfd_vma target_offset;
11312 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
11315 /* L32Rs must be local to the input file. */
11316 if (r_reloc_is_defined (&l32r_rel))
11318 target_sec = r_reloc_get_section (&l32r_rel);
11319 target_offset = l32r_rel.target_offset;
11321 (*callback) (sec, irel->r_offset, target_sec, target_offset,
11327 release_internal_relocs (sec, internal_relocs);
11328 release_contents (sec, contents);
11332 /* The default literal sections should always be marked as "code" (i.e.,
11333 SHF_EXECINSTR). This is particularly important for the Linux kernel
11334 module loader so that the literals are not placed after the text. */
11335 static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
11337 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11338 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11339 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11340 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 },
11341 { NULL, 0, 0, 0, 0 }
11344 #define ELF_TARGET_ID XTENSA_ELF_DATA
11346 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11347 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11348 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11349 #define TARGET_BIG_NAME "elf32-xtensa-be"
11350 #define ELF_ARCH bfd_arch_xtensa
11352 #define ELF_MACHINE_CODE EM_XTENSA
11353 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11356 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
11357 #else /* !XCHAL_HAVE_MMU */
11358 #define ELF_MAXPAGESIZE 1
11359 #endif /* !XCHAL_HAVE_MMU */
11360 #endif /* ELF_ARCH */
11362 #define elf_backend_can_gc_sections 1
11363 #define elf_backend_can_refcount 1
11364 #define elf_backend_plt_readonly 1
11365 #define elf_backend_got_header_size 4
11366 #define elf_backend_want_dynbss 0
11367 #define elf_backend_want_got_plt 1
11369 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11371 #define bfd_elf32_mkobject elf_xtensa_mkobject
11373 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11374 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11375 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11376 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11377 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11378 #define bfd_elf32_bfd_reloc_name_lookup \
11379 elf_xtensa_reloc_name_lookup
11380 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11381 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11383 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11384 #define elf_backend_check_relocs elf_xtensa_check_relocs
11385 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11386 #define elf_backend_discard_info elf_xtensa_discard_info
11387 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11388 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11389 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11390 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11391 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11392 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
11393 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11394 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11395 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11396 #define elf_backend_object_p elf_xtensa_object_p
11397 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11398 #define elf_backend_relocate_section elf_xtensa_relocate_section
11399 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11400 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11401 #define elf_backend_omit_section_dynsym \
11402 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
11403 #define elf_backend_special_sections elf_xtensa_special_sections
11404 #define elf_backend_action_discarded elf_xtensa_action_discarded
11405 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11407 #include "elf32-target.h"