1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright (C) 2003-2019 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 static flagword xtensa_get_property_predef_flags (asection *);
115 /* Other functions called directly by the linker. */
117 typedef void (*deps_callback_t)
118 (asection *, bfd_vma, asection *, bfd_vma, void *);
119 extern bfd_boolean xtensa_callback_required_dependence
120 (bfd *, asection *, struct bfd_link_info *, deps_callback_t, void *);
123 /* Globally visible flag for choosing size optimization of NOP removal
124 instead of branch-target-aware minimization for NOP removal.
125 When nonzero, narrow all instructions and remove all NOPs possible
126 around longcall expansions. */
128 int elf32xtensa_size_opt;
131 /* The "new_section_hook" is used to set up a per-section
132 "xtensa_relax_info" data structure with additional information used
133 during relaxation. */
135 typedef struct xtensa_relax_info_struct xtensa_relax_info;
138 /* The GNU tools do not easily allow extending interfaces to pass around
139 the pointer to the Xtensa ISA information, so instead we add a global
140 variable here (in BFD) that can be used by any of the tools that need
143 xtensa_isa xtensa_default_isa;
146 /* When this is true, relocations may have been modified to refer to
147 symbols from other input files. The per-section list of "fix"
148 records needs to be checked when resolving relocations. */
150 static bfd_boolean relaxing_section = FALSE;
152 /* When this is true, during final links, literals that cannot be
153 coalesced and their relocations may be moved to other sections. */
155 int elf32xtensa_no_literal_movement = 1;
157 /* Place property records for a section into individual property section
158 with xt.prop. prefix. */
160 bfd_boolean elf32xtensa_separate_props = FALSE;
162 /* Rename one of the generic section flags to better document how it
164 /* Whether relocations have been processed. */
165 #define reloc_done sec_flg0
167 static reloc_howto_type elf_howto_table[] =
169 HOWTO (R_XTENSA_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont,
170 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
172 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
173 bfd_elf_xtensa_reloc, "R_XTENSA_32",
174 TRUE, 0xffffffff, 0xffffffff, FALSE),
176 /* Replace a 32-bit value with a value from the runtime linker (only
177 used by linker-generated stub functions). The r_addend value is
178 special: 1 means to substitute a pointer to the runtime linker's
179 dynamic resolver function; 2 means to substitute the link map for
180 the shared object. */
181 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
182 NULL, "R_XTENSA_RTLD", FALSE, 0, 0, FALSE),
184 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
185 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
186 FALSE, 0, 0xffffffff, FALSE),
187 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
188 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
189 FALSE, 0, 0xffffffff, FALSE),
190 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
191 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
192 FALSE, 0, 0xffffffff, FALSE),
193 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
194 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
195 FALSE, 0, 0xffffffff, FALSE),
199 /* Old relocations for backward compatibility. */
200 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
201 bfd_elf_xtensa_reloc, "R_XTENSA_OP0", FALSE, 0, 0, TRUE),
202 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
203 bfd_elf_xtensa_reloc, "R_XTENSA_OP1", FALSE, 0, 0, TRUE),
204 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
205 bfd_elf_xtensa_reloc, "R_XTENSA_OP2", FALSE, 0, 0, TRUE),
207 /* Assembly auto-expansion. */
208 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
209 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND", FALSE, 0, 0, TRUE),
210 /* Relax assembly auto-expansion. */
211 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
212 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY", FALSE, 0, 0, TRUE),
216 HOWTO (R_XTENSA_32_PCREL, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
217 bfd_elf_xtensa_reloc, "R_XTENSA_32_PCREL",
218 FALSE, 0, 0xffffffff, TRUE),
220 /* GNU extension to record C++ vtable hierarchy. */
221 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
222 NULL, "R_XTENSA_GNU_VTINHERIT",
224 /* GNU extension to record C++ vtable member usage. */
225 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
226 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
229 /* Relocations for supporting difference of symbols. */
230 HOWTO (R_XTENSA_DIFF8, 0, 0, 8, FALSE, 0, complain_overflow_signed,
231 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF8", FALSE, 0, 0xff, FALSE),
232 HOWTO (R_XTENSA_DIFF16, 0, 1, 16, FALSE, 0, complain_overflow_signed,
233 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF16", FALSE, 0, 0xffff, FALSE),
234 HOWTO (R_XTENSA_DIFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
235 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF32", FALSE, 0, 0xffffffff, FALSE),
237 /* General immediate operand relocations. */
238 HOWTO (R_XTENSA_SLOT0_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
239 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_OP", FALSE, 0, 0, TRUE),
240 HOWTO (R_XTENSA_SLOT1_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
241 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_OP", FALSE, 0, 0, TRUE),
242 HOWTO (R_XTENSA_SLOT2_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
243 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_OP", FALSE, 0, 0, TRUE),
244 HOWTO (R_XTENSA_SLOT3_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
245 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_OP", FALSE, 0, 0, TRUE),
246 HOWTO (R_XTENSA_SLOT4_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
247 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_OP", FALSE, 0, 0, TRUE),
248 HOWTO (R_XTENSA_SLOT5_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
249 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_OP", FALSE, 0, 0, TRUE),
250 HOWTO (R_XTENSA_SLOT6_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
251 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_OP", FALSE, 0, 0, TRUE),
252 HOWTO (R_XTENSA_SLOT7_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
253 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_OP", FALSE, 0, 0, TRUE),
254 HOWTO (R_XTENSA_SLOT8_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
255 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_OP", FALSE, 0, 0, TRUE),
256 HOWTO (R_XTENSA_SLOT9_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
257 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_OP", FALSE, 0, 0, TRUE),
258 HOWTO (R_XTENSA_SLOT10_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
259 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_OP", FALSE, 0, 0, TRUE),
260 HOWTO (R_XTENSA_SLOT11_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
261 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_OP", FALSE, 0, 0, TRUE),
262 HOWTO (R_XTENSA_SLOT12_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
263 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_OP", FALSE, 0, 0, TRUE),
264 HOWTO (R_XTENSA_SLOT13_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
265 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_OP", FALSE, 0, 0, TRUE),
266 HOWTO (R_XTENSA_SLOT14_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
267 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_OP", FALSE, 0, 0, TRUE),
269 /* "Alternate" relocations. The meaning of these is opcode-specific. */
270 HOWTO (R_XTENSA_SLOT0_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
271 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_ALT", FALSE, 0, 0, TRUE),
272 HOWTO (R_XTENSA_SLOT1_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
273 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_ALT", FALSE, 0, 0, TRUE),
274 HOWTO (R_XTENSA_SLOT2_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
275 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_ALT", FALSE, 0, 0, TRUE),
276 HOWTO (R_XTENSA_SLOT3_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
277 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_ALT", FALSE, 0, 0, TRUE),
278 HOWTO (R_XTENSA_SLOT4_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
279 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_ALT", FALSE, 0, 0, TRUE),
280 HOWTO (R_XTENSA_SLOT5_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
281 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_ALT", FALSE, 0, 0, TRUE),
282 HOWTO (R_XTENSA_SLOT6_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
283 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_ALT", FALSE, 0, 0, TRUE),
284 HOWTO (R_XTENSA_SLOT7_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
285 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_ALT", FALSE, 0, 0, TRUE),
286 HOWTO (R_XTENSA_SLOT8_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
287 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_ALT", FALSE, 0, 0, TRUE),
288 HOWTO (R_XTENSA_SLOT9_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
289 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_ALT", FALSE, 0, 0, TRUE),
290 HOWTO (R_XTENSA_SLOT10_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
291 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_ALT", FALSE, 0, 0, TRUE),
292 HOWTO (R_XTENSA_SLOT11_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
293 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_ALT", FALSE, 0, 0, TRUE),
294 HOWTO (R_XTENSA_SLOT12_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
295 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_ALT", FALSE, 0, 0, TRUE),
296 HOWTO (R_XTENSA_SLOT13_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
297 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_ALT", FALSE, 0, 0, TRUE),
298 HOWTO (R_XTENSA_SLOT14_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
299 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_ALT", FALSE, 0, 0, TRUE),
301 /* TLS relocations. */
302 HOWTO (R_XTENSA_TLSDESC_FN, 0, 2, 32, FALSE, 0, complain_overflow_dont,
303 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_FN",
304 FALSE, 0, 0xffffffff, FALSE),
305 HOWTO (R_XTENSA_TLSDESC_ARG, 0, 2, 32, FALSE, 0, complain_overflow_dont,
306 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_ARG",
307 FALSE, 0, 0xffffffff, FALSE),
308 HOWTO (R_XTENSA_TLS_DTPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
309 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_DTPOFF",
310 FALSE, 0, 0xffffffff, FALSE),
311 HOWTO (R_XTENSA_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
312 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_TPOFF",
313 FALSE, 0, 0xffffffff, FALSE),
314 HOWTO (R_XTENSA_TLS_FUNC, 0, 0, 0, FALSE, 0, complain_overflow_dont,
315 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_FUNC",
317 HOWTO (R_XTENSA_TLS_ARG, 0, 0, 0, FALSE, 0, complain_overflow_dont,
318 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_ARG",
320 HOWTO (R_XTENSA_TLS_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
321 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_CALL",
327 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
332 static reloc_howto_type *
333 elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
334 bfd_reloc_code_real_type code)
339 TRACE ("BFD_RELOC_NONE");
340 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
343 TRACE ("BFD_RELOC_32");
344 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
346 case BFD_RELOC_32_PCREL:
347 TRACE ("BFD_RELOC_32_PCREL");
348 return &elf_howto_table[(unsigned) R_XTENSA_32_PCREL ];
350 case BFD_RELOC_XTENSA_DIFF8:
351 TRACE ("BFD_RELOC_XTENSA_DIFF8");
352 return &elf_howto_table[(unsigned) R_XTENSA_DIFF8 ];
354 case BFD_RELOC_XTENSA_DIFF16:
355 TRACE ("BFD_RELOC_XTENSA_DIFF16");
356 return &elf_howto_table[(unsigned) R_XTENSA_DIFF16 ];
358 case BFD_RELOC_XTENSA_DIFF32:
359 TRACE ("BFD_RELOC_XTENSA_DIFF32");
360 return &elf_howto_table[(unsigned) R_XTENSA_DIFF32 ];
362 case BFD_RELOC_XTENSA_RTLD:
363 TRACE ("BFD_RELOC_XTENSA_RTLD");
364 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
366 case BFD_RELOC_XTENSA_GLOB_DAT:
367 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
368 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
370 case BFD_RELOC_XTENSA_JMP_SLOT:
371 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
372 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
374 case BFD_RELOC_XTENSA_RELATIVE:
375 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
376 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
378 case BFD_RELOC_XTENSA_PLT:
379 TRACE ("BFD_RELOC_XTENSA_PLT");
380 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
382 case BFD_RELOC_XTENSA_OP0:
383 TRACE ("BFD_RELOC_XTENSA_OP0");
384 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
386 case BFD_RELOC_XTENSA_OP1:
387 TRACE ("BFD_RELOC_XTENSA_OP1");
388 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
390 case BFD_RELOC_XTENSA_OP2:
391 TRACE ("BFD_RELOC_XTENSA_OP2");
392 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
394 case BFD_RELOC_XTENSA_ASM_EXPAND:
395 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
396 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
398 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
399 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
400 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
402 case BFD_RELOC_VTABLE_INHERIT:
403 TRACE ("BFD_RELOC_VTABLE_INHERIT");
404 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
406 case BFD_RELOC_VTABLE_ENTRY:
407 TRACE ("BFD_RELOC_VTABLE_ENTRY");
408 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
410 case BFD_RELOC_XTENSA_TLSDESC_FN:
411 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
412 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_FN ];
414 case BFD_RELOC_XTENSA_TLSDESC_ARG:
415 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
416 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_ARG ];
418 case BFD_RELOC_XTENSA_TLS_DTPOFF:
419 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
420 return &elf_howto_table[(unsigned) R_XTENSA_TLS_DTPOFF ];
422 case BFD_RELOC_XTENSA_TLS_TPOFF:
423 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
424 return &elf_howto_table[(unsigned) R_XTENSA_TLS_TPOFF ];
426 case BFD_RELOC_XTENSA_TLS_FUNC:
427 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
428 return &elf_howto_table[(unsigned) R_XTENSA_TLS_FUNC ];
430 case BFD_RELOC_XTENSA_TLS_ARG:
431 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
432 return &elf_howto_table[(unsigned) R_XTENSA_TLS_ARG ];
434 case BFD_RELOC_XTENSA_TLS_CALL:
435 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
436 return &elf_howto_table[(unsigned) R_XTENSA_TLS_CALL ];
439 if (code >= BFD_RELOC_XTENSA_SLOT0_OP
440 && code <= BFD_RELOC_XTENSA_SLOT14_OP)
442 unsigned n = (R_XTENSA_SLOT0_OP +
443 (code - BFD_RELOC_XTENSA_SLOT0_OP));
444 return &elf_howto_table[n];
447 if (code >= BFD_RELOC_XTENSA_SLOT0_ALT
448 && code <= BFD_RELOC_XTENSA_SLOT14_ALT)
450 unsigned n = (R_XTENSA_SLOT0_ALT +
451 (code - BFD_RELOC_XTENSA_SLOT0_ALT));
452 return &elf_howto_table[n];
458 /* xgettext:c-format */
459 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code);
460 bfd_set_error (bfd_error_bad_value);
465 static reloc_howto_type *
466 elf_xtensa_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
471 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
472 if (elf_howto_table[i].name != NULL
473 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
474 return &elf_howto_table[i];
480 /* Given an ELF "rela" relocation, find the corresponding howto and record
481 it in the BFD internal arelent representation of the relocation. */
484 elf_xtensa_info_to_howto_rela (bfd *abfd,
486 Elf_Internal_Rela *dst)
488 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
490 if (r_type >= (unsigned int) R_XTENSA_max)
492 /* xgettext:c-format */
493 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
495 bfd_set_error (bfd_error_bad_value);
498 cache_ptr->howto = &elf_howto_table[r_type];
503 /* Functions for the Xtensa ELF linker. */
505 /* The name of the dynamic interpreter. This is put in the .interp
508 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
510 /* The size in bytes of an entry in the procedure linkage table.
511 (This does _not_ include the space for the literals associated with
514 #define PLT_ENTRY_SIZE 16
516 /* For _really_ large PLTs, we may need to alternate between literals
517 and code to keep the literals within the 256K range of the L32R
518 instructions in the code. It's unlikely that anyone would ever need
519 such a big PLT, but an arbitrary limit on the PLT size would be bad.
520 Thus, we split the PLT into chunks. Since there's very little
521 overhead (2 extra literals) for each chunk, the chunk size is kept
522 small so that the code for handling multiple chunks get used and
523 tested regularly. With 254 entries, there are 1K of literals for
524 each chunk, and that seems like a nice round number. */
526 #define PLT_ENTRIES_PER_CHUNK 254
528 /* PLT entries are actually used as stub functions for lazy symbol
529 resolution. Once the symbol is resolved, the stub function is never
530 invoked. Note: the 32-byte frame size used here cannot be changed
531 without a corresponding change in the runtime linker. */
533 static const bfd_byte elf_xtensa_be_plt_entry[][PLT_ENTRY_SIZE] =
536 0x6c, 0x10, 0x04, /* entry sp, 32 */
537 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
538 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
539 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
540 0x0a, 0x80, 0x00, /* jx a8 */
544 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
545 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
546 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
547 0x0a, 0x80, 0x00, /* jx a8 */
552 static const bfd_byte elf_xtensa_le_plt_entry[][PLT_ENTRY_SIZE] =
555 0x36, 0x41, 0x00, /* entry sp, 32 */
556 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
557 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
558 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
559 0xa0, 0x08, 0x00, /* jx a8 */
563 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
564 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
565 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
566 0xa0, 0x08, 0x00, /* jx a8 */
571 /* The size of the thread control block. */
574 struct elf_xtensa_link_hash_entry
576 struct elf_link_hash_entry elf;
578 bfd_signed_vma tlsfunc_refcount;
580 #define GOT_UNKNOWN 0
582 #define GOT_TLS_GD 2 /* global or local dynamic */
583 #define GOT_TLS_IE 4 /* initial or local exec */
584 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
585 unsigned char tls_type;
588 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
590 struct elf_xtensa_obj_tdata
592 struct elf_obj_tdata root;
594 /* tls_type for each local got entry. */
595 char *local_got_tls_type;
597 bfd_signed_vma *local_tlsfunc_refcounts;
600 #define elf_xtensa_tdata(abfd) \
601 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
603 #define elf_xtensa_local_got_tls_type(abfd) \
604 (elf_xtensa_tdata (abfd)->local_got_tls_type)
606 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
607 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
609 #define is_xtensa_elf(bfd) \
610 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
611 && elf_tdata (bfd) != NULL \
612 && elf_object_id (bfd) == XTENSA_ELF_DATA)
615 elf_xtensa_mkobject (bfd *abfd)
617 return bfd_elf_allocate_object (abfd, sizeof (struct elf_xtensa_obj_tdata),
621 /* Xtensa ELF linker hash table. */
623 struct elf_xtensa_link_hash_table
625 struct elf_link_hash_table elf;
627 /* Short-cuts to get to dynamic linker sections. */
629 asection *spltlittbl;
631 /* Total count of PLT relocations seen during check_relocs.
632 The actual PLT code must be split into multiple sections and all
633 the sections have to be created before size_dynamic_sections,
634 where we figure out the exact number of PLT entries that will be
635 needed. It is OK if this count is an overestimate, e.g., some
636 relocations may be removed by GC. */
639 struct elf_xtensa_link_hash_entry *tlsbase;
642 /* Get the Xtensa ELF linker hash table from a link_info structure. */
644 #define elf_xtensa_hash_table(p) \
645 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
646 == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
648 /* Create an entry in an Xtensa ELF linker hash table. */
650 static struct bfd_hash_entry *
651 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry *entry,
652 struct bfd_hash_table *table,
655 /* Allocate the structure if it has not already been allocated by a
659 entry = bfd_hash_allocate (table,
660 sizeof (struct elf_xtensa_link_hash_entry));
665 /* Call the allocation method of the superclass. */
666 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
669 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (entry);
670 eh->tlsfunc_refcount = 0;
671 eh->tls_type = GOT_UNKNOWN;
677 /* Create an Xtensa ELF linker hash table. */
679 static struct bfd_link_hash_table *
680 elf_xtensa_link_hash_table_create (bfd *abfd)
682 struct elf_link_hash_entry *tlsbase;
683 struct elf_xtensa_link_hash_table *ret;
684 bfd_size_type amt = sizeof (struct elf_xtensa_link_hash_table);
686 ret = bfd_zmalloc (amt);
690 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
691 elf_xtensa_link_hash_newfunc,
692 sizeof (struct elf_xtensa_link_hash_entry),
699 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
701 tlsbase = elf_link_hash_lookup (&ret->elf, "_TLS_MODULE_BASE_",
703 tlsbase->root.type = bfd_link_hash_new;
704 tlsbase->root.u.undef.abfd = NULL;
705 tlsbase->non_elf = 0;
706 ret->tlsbase = elf_xtensa_hash_entry (tlsbase);
707 ret->tlsbase->tls_type = GOT_UNKNOWN;
709 return &ret->elf.root;
712 /* Copy the extra info we tack onto an elf_link_hash_entry. */
715 elf_xtensa_copy_indirect_symbol (struct bfd_link_info *info,
716 struct elf_link_hash_entry *dir,
717 struct elf_link_hash_entry *ind)
719 struct elf_xtensa_link_hash_entry *edir, *eind;
721 edir = elf_xtensa_hash_entry (dir);
722 eind = elf_xtensa_hash_entry (ind);
724 if (ind->root.type == bfd_link_hash_indirect)
726 edir->tlsfunc_refcount += eind->tlsfunc_refcount;
727 eind->tlsfunc_refcount = 0;
729 if (dir->got.refcount <= 0)
731 edir->tls_type = eind->tls_type;
732 eind->tls_type = GOT_UNKNOWN;
736 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
739 static inline bfd_boolean
740 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry *h,
741 struct bfd_link_info *info)
743 /* Check if we should do dynamic things to this symbol. The
744 "ignore_protected" argument need not be set, because Xtensa code
745 does not require special handling of STV_PROTECTED to make function
746 pointer comparisons work properly. The PLT addresses are never
747 used for function pointers. */
749 return _bfd_elf_dynamic_symbol_p (h, info, 0);
754 property_table_compare (const void *ap, const void *bp)
756 const property_table_entry *a = (const property_table_entry *) ap;
757 const property_table_entry *b = (const property_table_entry *) bp;
759 if (a->address == b->address)
761 if (a->size != b->size)
762 return (a->size - b->size);
764 if ((a->flags & XTENSA_PROP_ALIGN) != (b->flags & XTENSA_PROP_ALIGN))
765 return ((b->flags & XTENSA_PROP_ALIGN)
766 - (a->flags & XTENSA_PROP_ALIGN));
768 if ((a->flags & XTENSA_PROP_ALIGN)
769 && (GET_XTENSA_PROP_ALIGNMENT (a->flags)
770 != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
771 return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
772 - GET_XTENSA_PROP_ALIGNMENT (b->flags));
774 if ((a->flags & XTENSA_PROP_UNREACHABLE)
775 != (b->flags & XTENSA_PROP_UNREACHABLE))
776 return ((b->flags & XTENSA_PROP_UNREACHABLE)
777 - (a->flags & XTENSA_PROP_UNREACHABLE));
779 return (a->flags - b->flags);
782 return (a->address - b->address);
787 property_table_matches (const void *ap, const void *bp)
789 const property_table_entry *a = (const property_table_entry *) ap;
790 const property_table_entry *b = (const property_table_entry *) bp;
792 /* Check if one entry overlaps with the other. */
793 if ((b->address >= a->address && b->address < (a->address + a->size))
794 || (a->address >= b->address && a->address < (b->address + b->size)))
797 return (a->address - b->address);
801 /* Get the literal table or property table entries for the given
802 section. Sets TABLE_P and returns the number of entries. On
803 error, returns a negative value. */
806 xtensa_read_table_entries (bfd *abfd,
808 property_table_entry **table_p,
809 const char *sec_name,
810 bfd_boolean output_addr)
812 asection *table_section;
813 bfd_size_type table_size = 0;
814 bfd_byte *table_data;
815 property_table_entry *blocks;
816 int blk, block_count;
817 bfd_size_type num_records;
818 Elf_Internal_Rela *internal_relocs, *irel, *rel_end;
819 bfd_vma section_addr, off;
820 flagword predef_flags;
821 bfd_size_type table_entry_size, section_limit;
824 || !(section->flags & SEC_ALLOC)
825 || (section->flags & SEC_DEBUGGING))
831 table_section = xtensa_get_property_section (section, sec_name);
833 table_size = table_section->size;
841 predef_flags = xtensa_get_property_predef_flags (table_section);
842 table_entry_size = 12;
844 table_entry_size -= 4;
846 num_records = table_size / table_entry_size;
847 table_data = retrieve_contents (abfd, table_section, TRUE);
848 blocks = (property_table_entry *)
849 bfd_malloc (num_records * sizeof (property_table_entry));
853 section_addr = section->output_section->vma + section->output_offset;
855 section_addr = section->vma;
857 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
858 if (internal_relocs && !table_section->reloc_done)
860 qsort (internal_relocs, table_section->reloc_count,
861 sizeof (Elf_Internal_Rela), internal_reloc_compare);
862 irel = internal_relocs;
867 section_limit = bfd_get_section_limit (abfd, section);
868 rel_end = internal_relocs + table_section->reloc_count;
870 for (off = 0; off < table_size; off += table_entry_size)
872 bfd_vma address = bfd_get_32 (abfd, table_data + off);
874 /* Skip any relocations before the current offset. This should help
875 avoid confusion caused by unexpected relocations for the preceding
878 (irel->r_offset < off
879 || (irel->r_offset == off
880 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_NONE)))
887 if (irel && irel->r_offset == off)
890 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
891 BFD_ASSERT (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32);
893 if (get_elf_r_symndx_section (abfd, r_symndx) != section)
896 sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
897 BFD_ASSERT (sym_off == 0);
898 address += (section_addr + sym_off + irel->r_addend);
902 if (address < section_addr
903 || address >= section_addr + section_limit)
907 blocks[block_count].address = address;
908 blocks[block_count].size = bfd_get_32 (abfd, table_data + off + 4);
910 blocks[block_count].flags = predef_flags;
912 blocks[block_count].flags = bfd_get_32 (abfd, table_data + off + 8);
916 release_contents (table_section, table_data);
917 release_internal_relocs (table_section, internal_relocs);
921 /* Now sort them into address order for easy reference. */
922 qsort (blocks, block_count, sizeof (property_table_entry),
923 property_table_compare);
925 /* Check that the table contents are valid. Problems may occur,
926 for example, if an unrelocated object file is stripped. */
927 for (blk = 1; blk < block_count; blk++)
929 /* The only circumstance where two entries may legitimately
930 have the same address is when one of them is a zero-size
931 placeholder to mark a place where fill can be inserted.
932 The zero-size entry should come first. */
933 if (blocks[blk - 1].address == blocks[blk].address &&
934 blocks[blk - 1].size != 0)
936 /* xgettext:c-format */
937 _bfd_error_handler (_("%pB(%pA): invalid property table"),
939 bfd_set_error (bfd_error_bad_value);
951 static property_table_entry *
952 elf_xtensa_find_property_entry (property_table_entry *property_table,
953 int property_table_size,
956 property_table_entry entry;
957 property_table_entry *rv;
959 if (property_table_size == 0)
962 entry.address = addr;
966 rv = bsearch (&entry, property_table, property_table_size,
967 sizeof (property_table_entry), property_table_matches);
973 elf_xtensa_in_literal_pool (property_table_entry *lit_table,
977 if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
984 /* Look through the relocs for a section during the first phase, and
985 calculate needed space in the dynamic reloc sections. */
988 elf_xtensa_check_relocs (bfd *abfd,
989 struct bfd_link_info *info,
991 const Elf_Internal_Rela *relocs)
993 struct elf_xtensa_link_hash_table *htab;
994 Elf_Internal_Shdr *symtab_hdr;
995 struct elf_link_hash_entry **sym_hashes;
996 const Elf_Internal_Rela *rel;
997 const Elf_Internal_Rela *rel_end;
999 if (bfd_link_relocatable (info) || (sec->flags & SEC_ALLOC) == 0)
1002 BFD_ASSERT (is_xtensa_elf (abfd));
1004 htab = elf_xtensa_hash_table (info);
1008 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1009 sym_hashes = elf_sym_hashes (abfd);
1011 rel_end = relocs + sec->reloc_count;
1012 for (rel = relocs; rel < rel_end; rel++)
1014 unsigned int r_type;
1016 struct elf_link_hash_entry *h = NULL;
1017 struct elf_xtensa_link_hash_entry *eh;
1018 int tls_type, old_tls_type;
1019 bfd_boolean is_got = FALSE;
1020 bfd_boolean is_plt = FALSE;
1021 bfd_boolean is_tlsfunc = FALSE;
1023 r_symndx = ELF32_R_SYM (rel->r_info);
1024 r_type = ELF32_R_TYPE (rel->r_info);
1026 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1028 /* xgettext:c-format */
1029 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1034 if (r_symndx >= symtab_hdr->sh_info)
1036 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1037 while (h->root.type == bfd_link_hash_indirect
1038 || h->root.type == bfd_link_hash_warning)
1039 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1041 eh = elf_xtensa_hash_entry (h);
1045 case R_XTENSA_TLSDESC_FN:
1046 if (bfd_link_pic (info))
1048 tls_type = GOT_TLS_GD;
1053 tls_type = GOT_TLS_IE;
1056 case R_XTENSA_TLSDESC_ARG:
1057 if (bfd_link_pic (info))
1059 tls_type = GOT_TLS_GD;
1064 tls_type = GOT_TLS_IE;
1065 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1070 case R_XTENSA_TLS_DTPOFF:
1071 if (bfd_link_pic (info))
1072 tls_type = GOT_TLS_GD;
1074 tls_type = GOT_TLS_IE;
1077 case R_XTENSA_TLS_TPOFF:
1078 tls_type = GOT_TLS_IE;
1079 if (bfd_link_pic (info))
1080 info->flags |= DF_STATIC_TLS;
1081 if (bfd_link_pic (info) || h)
1086 tls_type = GOT_NORMAL;
1091 tls_type = GOT_NORMAL;
1095 case R_XTENSA_GNU_VTINHERIT:
1096 /* This relocation describes the C++ object vtable hierarchy.
1097 Reconstruct it for later use during GC. */
1098 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1102 case R_XTENSA_GNU_VTENTRY:
1103 /* This relocation describes which C++ vtable entries are actually
1104 used. Record for later use during GC. */
1105 BFD_ASSERT (h != NULL);
1107 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1112 /* Nothing to do for any other relocations. */
1120 if (h->plt.refcount <= 0)
1123 h->plt.refcount = 1;
1126 h->plt.refcount += 1;
1128 /* Keep track of the total PLT relocation count even if we
1129 don't yet know whether the dynamic sections will be
1131 htab->plt_reloc_count += 1;
1133 if (elf_hash_table (info)->dynamic_sections_created)
1135 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1141 if (h->got.refcount <= 0)
1142 h->got.refcount = 1;
1144 h->got.refcount += 1;
1148 eh->tlsfunc_refcount += 1;
1150 old_tls_type = eh->tls_type;
1154 /* Allocate storage the first time. */
1155 if (elf_local_got_refcounts (abfd) == NULL)
1157 bfd_size_type size = symtab_hdr->sh_info;
1160 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1163 elf_local_got_refcounts (abfd) = (bfd_signed_vma *) mem;
1165 mem = bfd_zalloc (abfd, size);
1168 elf_xtensa_local_got_tls_type (abfd) = (char *) mem;
1170 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1173 elf_xtensa_local_tlsfunc_refcounts (abfd)
1174 = (bfd_signed_vma *) mem;
1177 /* This is a global offset table entry for a local symbol. */
1178 if (is_got || is_plt)
1179 elf_local_got_refcounts (abfd) [r_symndx] += 1;
1182 elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx] += 1;
1184 old_tls_type = elf_xtensa_local_got_tls_type (abfd) [r_symndx];
1187 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1188 tls_type |= old_tls_type;
1189 /* If a TLS symbol is accessed using IE at least once,
1190 there is no point to use a dynamic model for it. */
1191 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1192 && ((old_tls_type & GOT_TLS_GD) == 0
1193 || (tls_type & GOT_TLS_IE) == 0))
1195 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_GD))
1196 tls_type = old_tls_type;
1197 else if ((old_tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_GD))
1198 tls_type |= old_tls_type;
1202 /* xgettext:c-format */
1203 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1205 h ? h->root.root.string : "<local>");
1210 if (old_tls_type != tls_type)
1213 eh->tls_type = tls_type;
1215 elf_xtensa_local_got_tls_type (abfd) [r_symndx] = tls_type;
1224 elf_xtensa_make_sym_local (struct bfd_link_info *info,
1225 struct elf_link_hash_entry *h)
1227 if (bfd_link_pic (info))
1229 if (h->plt.refcount > 0)
1231 /* For shared objects, there's no need for PLT entries for local
1232 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1233 if (h->got.refcount < 0)
1234 h->got.refcount = 0;
1235 h->got.refcount += h->plt.refcount;
1236 h->plt.refcount = 0;
1241 /* Don't need any dynamic relocations at all. */
1242 h->plt.refcount = 0;
1243 h->got.refcount = 0;
1249 elf_xtensa_hide_symbol (struct bfd_link_info *info,
1250 struct elf_link_hash_entry *h,
1251 bfd_boolean force_local)
1253 /* For a shared link, move the plt refcount to the got refcount to leave
1254 space for RELATIVE relocs. */
1255 elf_xtensa_make_sym_local (info, h);
1257 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
1261 /* Return the section that should be marked against GC for a given
1265 elf_xtensa_gc_mark_hook (asection *sec,
1266 struct bfd_link_info *info,
1267 Elf_Internal_Rela *rel,
1268 struct elf_link_hash_entry *h,
1269 Elf_Internal_Sym *sym)
1271 /* Property sections are marked "KEEP" in the linker scripts, but they
1272 should not cause other sections to be marked. (This approach relies
1273 on elf_xtensa_discard_info to remove property table entries that
1274 describe discarded sections. Alternatively, it might be more
1275 efficient to avoid using "KEEP" in the linker scripts and instead use
1276 the gc_mark_extra_sections hook to mark only the property sections
1277 that describe marked sections. That alternative does not work well
1278 with the current property table sections, which do not correspond
1279 one-to-one with the sections they describe, but that should be fixed
1281 if (xtensa_is_property_section (sec))
1285 switch (ELF32_R_TYPE (rel->r_info))
1287 case R_XTENSA_GNU_VTINHERIT:
1288 case R_XTENSA_GNU_VTENTRY:
1292 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1296 /* Create all the dynamic sections. */
1299 elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1301 struct elf_xtensa_link_hash_table *htab;
1302 flagword flags, noalloc_flags;
1304 htab = elf_xtensa_hash_table (info);
1308 /* First do all the standard stuff. */
1309 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
1312 /* Create any extra PLT sections in case check_relocs has already
1313 been called on all the non-dynamic input files. */
1314 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1317 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
1318 | SEC_LINKER_CREATED | SEC_READONLY);
1319 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
1321 /* Mark the ".got.plt" section READONLY. */
1322 if (htab->elf.sgotplt == NULL
1323 || ! bfd_set_section_flags (dynobj, htab->elf.sgotplt, flags))
1326 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1327 htab->sgotloc = bfd_make_section_anyway_with_flags (dynobj, ".got.loc",
1329 if (htab->sgotloc == NULL
1330 || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
1333 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1334 htab->spltlittbl = bfd_make_section_anyway_with_flags (dynobj, ".xt.lit.plt",
1336 if (htab->spltlittbl == NULL
1337 || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
1345 add_extra_plt_sections (struct bfd_link_info *info, int count)
1347 bfd *dynobj = elf_hash_table (info)->dynobj;
1350 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1351 ".got.plt" sections. */
1352 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1358 /* Stop when we find a section has already been created. */
1359 if (elf_xtensa_get_plt_section (info, chunk))
1362 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1363 | SEC_LINKER_CREATED | SEC_READONLY);
1365 sname = (char *) bfd_malloc (10);
1366 sprintf (sname, ".plt.%u", chunk);
1367 s = bfd_make_section_anyway_with_flags (dynobj, sname, flags | SEC_CODE);
1369 || ! bfd_set_section_alignment (dynobj, s, 2))
1372 sname = (char *) bfd_malloc (14);
1373 sprintf (sname, ".got.plt.%u", chunk);
1374 s = bfd_make_section_anyway_with_flags (dynobj, sname, flags);
1376 || ! bfd_set_section_alignment (dynobj, s, 2))
1384 /* Adjust a symbol defined by a dynamic object and referenced by a
1385 regular object. The current definition is in some section of the
1386 dynamic object, but we're not including those sections. We have to
1387 change the definition to something the rest of the link can
1391 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1392 struct elf_link_hash_entry *h)
1394 /* If this is a weak symbol, and there is a real definition, the
1395 processor independent code will have arranged for us to see the
1396 real definition first, and we can just use the same value. */
1397 if (h->is_weakalias)
1399 struct elf_link_hash_entry *def = weakdef (h);
1400 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1401 h->root.u.def.section = def->root.u.def.section;
1402 h->root.u.def.value = def->root.u.def.value;
1406 /* This is a reference to a symbol defined by a dynamic object. The
1407 reference must go through the GOT, so there's no need for COPY relocs,
1415 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry *h, void *arg)
1417 struct bfd_link_info *info;
1418 struct elf_xtensa_link_hash_table *htab;
1419 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (h);
1421 if (h->root.type == bfd_link_hash_indirect)
1424 info = (struct bfd_link_info *) arg;
1425 htab = elf_xtensa_hash_table (info);
1429 /* If we saw any use of an IE model for this symbol, we can then optimize
1430 away GOT entries for any TLSDESC_FN relocs. */
1431 if ((eh->tls_type & GOT_TLS_IE) != 0)
1433 BFD_ASSERT (h->got.refcount >= eh->tlsfunc_refcount);
1434 h->got.refcount -= eh->tlsfunc_refcount;
1437 if (! elf_xtensa_dynamic_symbol_p (h, info))
1438 elf_xtensa_make_sym_local (info, h);
1440 if (! elf_xtensa_dynamic_symbol_p (h, info)
1441 && h->root.type == bfd_link_hash_undefweak)
1444 if (h->plt.refcount > 0)
1445 htab->elf.srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1447 if (h->got.refcount > 0)
1448 htab->elf.srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
1455 elf_xtensa_allocate_local_got_size (struct bfd_link_info *info)
1457 struct elf_xtensa_link_hash_table *htab;
1460 htab = elf_xtensa_hash_table (info);
1464 for (i = info->input_bfds; i; i = i->link.next)
1466 bfd_signed_vma *local_got_refcounts;
1467 bfd_size_type j, cnt;
1468 Elf_Internal_Shdr *symtab_hdr;
1470 local_got_refcounts = elf_local_got_refcounts (i);
1471 if (!local_got_refcounts)
1474 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1475 cnt = symtab_hdr->sh_info;
1477 for (j = 0; j < cnt; ++j)
1479 /* If we saw any use of an IE model for this symbol, we can
1480 then optimize away GOT entries for any TLSDESC_FN relocs. */
1481 if ((elf_xtensa_local_got_tls_type (i) [j] & GOT_TLS_IE) != 0)
1483 bfd_signed_vma *tlsfunc_refcount
1484 = &elf_xtensa_local_tlsfunc_refcounts (i) [j];
1485 BFD_ASSERT (local_got_refcounts[j] >= *tlsfunc_refcount);
1486 local_got_refcounts[j] -= *tlsfunc_refcount;
1489 if (local_got_refcounts[j] > 0)
1490 htab->elf.srelgot->size += (local_got_refcounts[j]
1491 * sizeof (Elf32_External_Rela));
1497 /* Set the sizes of the dynamic sections. */
1500 elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1501 struct bfd_link_info *info)
1503 struct elf_xtensa_link_hash_table *htab;
1505 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1506 bfd_boolean relplt, relgot;
1507 int plt_entries, plt_chunks, chunk;
1512 htab = elf_xtensa_hash_table (info);
1516 dynobj = elf_hash_table (info)->dynobj;
1519 srelgot = htab->elf.srelgot;
1520 srelplt = htab->elf.srelplt;
1522 if (elf_hash_table (info)->dynamic_sections_created)
1524 BFD_ASSERT (htab->elf.srelgot != NULL
1525 && htab->elf.srelplt != NULL
1526 && htab->elf.sgot != NULL
1527 && htab->spltlittbl != NULL
1528 && htab->sgotloc != NULL);
1530 /* Set the contents of the .interp section to the interpreter. */
1531 if (bfd_link_executable (info) && !info->nointerp)
1533 s = bfd_get_linker_section (dynobj, ".interp");
1536 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1537 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1540 /* Allocate room for one word in ".got". */
1541 htab->elf.sgot->size = 4;
1543 /* Allocate space in ".rela.got" for literals that reference global
1544 symbols and space in ".rela.plt" for literals that have PLT
1546 elf_link_hash_traverse (elf_hash_table (info),
1547 elf_xtensa_allocate_dynrelocs,
1550 /* If we are generating a shared object, we also need space in
1551 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1552 reference local symbols. */
1553 if (bfd_link_pic (info))
1554 elf_xtensa_allocate_local_got_size (info);
1556 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1557 each PLT entry, we need the PLT code plus a 4-byte literal.
1558 For each chunk of ".plt", we also need two more 4-byte
1559 literals, two corresponding entries in ".rela.got", and an
1560 8-byte entry in ".xt.lit.plt". */
1561 spltlittbl = htab->spltlittbl;
1562 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
1564 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1566 /* Iterate over all the PLT chunks, including any extra sections
1567 created earlier because the initial count of PLT relocations
1568 was an overestimate. */
1570 (splt = elf_xtensa_get_plt_section (info, chunk)) != NULL;
1575 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
1576 BFD_ASSERT (sgotplt != NULL);
1578 if (chunk < plt_chunks - 1)
1579 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1580 else if (chunk == plt_chunks - 1)
1581 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1585 if (chunk_entries != 0)
1587 sgotplt->size = 4 * (chunk_entries + 2);
1588 splt->size = PLT_ENTRY_SIZE * chunk_entries;
1589 srelgot->size += 2 * sizeof (Elf32_External_Rela);
1590 spltlittbl->size += 8;
1599 /* Allocate space in ".got.loc" to match the total size of all the
1601 sgotloc = htab->sgotloc;
1602 sgotloc->size = spltlittbl->size;
1603 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
1605 if (abfd->flags & DYNAMIC)
1607 for (s = abfd->sections; s != NULL; s = s->next)
1609 if (! discarded_section (s)
1610 && xtensa_is_littable_section (s)
1612 sgotloc->size += s->size;
1617 /* Allocate memory for dynamic sections. */
1620 for (s = dynobj->sections; s != NULL; s = s->next)
1624 if ((s->flags & SEC_LINKER_CREATED) == 0)
1627 /* It's OK to base decisions on the section name, because none
1628 of the dynobj section names depend upon the input files. */
1629 name = bfd_get_section_name (dynobj, s);
1631 if (CONST_STRNEQ (name, ".rela"))
1635 if (strcmp (name, ".rela.plt") == 0)
1637 else if (strcmp (name, ".rela.got") == 0)
1640 /* We use the reloc_count field as a counter if we need
1641 to copy relocs into the output file. */
1645 else if (! CONST_STRNEQ (name, ".plt.")
1646 && ! CONST_STRNEQ (name, ".got.plt.")
1647 && strcmp (name, ".got") != 0
1648 && strcmp (name, ".plt") != 0
1649 && strcmp (name, ".got.plt") != 0
1650 && strcmp (name, ".xt.lit.plt") != 0
1651 && strcmp (name, ".got.loc") != 0)
1653 /* It's not one of our sections, so don't allocate space. */
1659 /* If we don't need this section, strip it from the output
1660 file. We must create the ".plt*" and ".got.plt*"
1661 sections in create_dynamic_sections and/or check_relocs
1662 based on a conservative estimate of the PLT relocation
1663 count, because the sections must be created before the
1664 linker maps input sections to output sections. The
1665 linker does that before size_dynamic_sections, where we
1666 compute the exact size of the PLT, so there may be more
1667 of these sections than are actually needed. */
1668 s->flags |= SEC_EXCLUDE;
1670 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
1672 /* Allocate memory for the section contents. */
1673 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1674 if (s->contents == NULL)
1679 if (elf_hash_table (info)->dynamic_sections_created)
1681 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1682 known until finish_dynamic_sections, but we need to get the relocs
1683 in place before they are sorted. */
1684 for (chunk = 0; chunk < plt_chunks; chunk++)
1686 Elf_Internal_Rela irela;
1690 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1693 loc = (srelgot->contents
1694 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1695 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1696 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1697 loc + sizeof (Elf32_External_Rela));
1698 srelgot->reloc_count += 2;
1701 /* Add some entries to the .dynamic section. We fill in the
1702 values later, in elf_xtensa_finish_dynamic_sections, but we
1703 must add the entries now so that we get the correct size for
1704 the .dynamic section. The DT_DEBUG entry is filled in by the
1705 dynamic linker and used by the debugger. */
1706 #define add_dynamic_entry(TAG, VAL) \
1707 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1709 if (bfd_link_executable (info))
1711 if (!add_dynamic_entry (DT_DEBUG, 0))
1717 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1718 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1719 || !add_dynamic_entry (DT_JMPREL, 0))
1725 if (!add_dynamic_entry (DT_RELA, 0)
1726 || !add_dynamic_entry (DT_RELASZ, 0)
1727 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1731 if (!add_dynamic_entry (DT_PLTGOT, 0)
1732 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1733 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1736 #undef add_dynamic_entry
1742 elf_xtensa_always_size_sections (bfd *output_bfd,
1743 struct bfd_link_info *info)
1745 struct elf_xtensa_link_hash_table *htab;
1748 htab = elf_xtensa_hash_table (info);
1752 tls_sec = htab->elf.tls_sec;
1754 if (tls_sec && (htab->tlsbase->tls_type & GOT_TLS_ANY) != 0)
1756 struct elf_link_hash_entry *tlsbase = &htab->tlsbase->elf;
1757 struct bfd_link_hash_entry *bh = &tlsbase->root;
1758 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
1760 tlsbase->type = STT_TLS;
1761 if (!(_bfd_generic_link_add_one_symbol
1762 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1763 tls_sec, 0, NULL, FALSE,
1764 bed->collect, &bh)))
1766 tlsbase->def_regular = 1;
1767 tlsbase->other = STV_HIDDEN;
1768 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1775 /* Return the base VMA address which should be subtracted from real addresses
1776 when resolving @dtpoff relocation.
1777 This is PT_TLS segment p_vaddr. */
1780 dtpoff_base (struct bfd_link_info *info)
1782 /* If tls_sec is NULL, we should have signalled an error already. */
1783 if (elf_hash_table (info)->tls_sec == NULL)
1785 return elf_hash_table (info)->tls_sec->vma;
1788 /* Return the relocation value for @tpoff relocation
1789 if STT_TLS virtual address is ADDRESS. */
1792 tpoff (struct bfd_link_info *info, bfd_vma address)
1794 struct elf_link_hash_table *htab = elf_hash_table (info);
1797 /* If tls_sec is NULL, we should have signalled an error already. */
1798 if (htab->tls_sec == NULL)
1800 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
1801 return address - htab->tls_sec->vma + base;
1804 /* Perform the specified relocation. The instruction at (contents + address)
1805 is modified to set one operand to represent the value in "relocation". The
1806 operand position is determined by the relocation type recorded in the
1809 #define CALL_SEGMENT_BITS (30)
1810 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1812 static bfd_reloc_status_type
1813 elf_xtensa_do_reloc (reloc_howto_type *howto,
1815 asection *input_section,
1819 bfd_boolean is_weak_undef,
1820 char **error_message)
1823 xtensa_opcode opcode;
1824 xtensa_isa isa = xtensa_default_isa;
1825 static xtensa_insnbuf ibuff = NULL;
1826 static xtensa_insnbuf sbuff = NULL;
1827 bfd_vma self_address;
1828 bfd_size_type input_size;
1834 ibuff = xtensa_insnbuf_alloc (isa);
1835 sbuff = xtensa_insnbuf_alloc (isa);
1838 input_size = bfd_get_section_limit (abfd, input_section);
1840 /* Calculate the PC address for this instruction. */
1841 self_address = (input_section->output_section->vma
1842 + input_section->output_offset
1845 switch (howto->type)
1848 case R_XTENSA_DIFF8:
1849 case R_XTENSA_DIFF16:
1850 case R_XTENSA_DIFF32:
1851 case R_XTENSA_TLS_FUNC:
1852 case R_XTENSA_TLS_ARG:
1853 case R_XTENSA_TLS_CALL:
1854 return bfd_reloc_ok;
1856 case R_XTENSA_ASM_EXPAND:
1859 /* Check for windowed CALL across a 1GB boundary. */
1860 opcode = get_expanded_call_opcode (contents + address,
1861 input_size - address, 0);
1862 if (is_windowed_call_opcode (opcode))
1864 if ((self_address >> CALL_SEGMENT_BITS)
1865 != (relocation >> CALL_SEGMENT_BITS))
1867 *error_message = "windowed longcall crosses 1GB boundary; "
1869 return bfd_reloc_dangerous;
1873 return bfd_reloc_ok;
1875 case R_XTENSA_ASM_SIMPLIFY:
1877 /* Convert the L32R/CALLX to CALL. */
1878 bfd_reloc_status_type retval =
1879 elf_xtensa_do_asm_simplify (contents, address, input_size,
1881 if (retval != bfd_reloc_ok)
1882 return bfd_reloc_dangerous;
1884 /* The CALL needs to be relocated. Continue below for that part. */
1887 howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
1894 x = bfd_get_32 (abfd, contents + address);
1896 bfd_put_32 (abfd, x, contents + address);
1898 return bfd_reloc_ok;
1900 case R_XTENSA_32_PCREL:
1901 bfd_put_32 (abfd, relocation - self_address, contents + address);
1902 return bfd_reloc_ok;
1905 case R_XTENSA_TLSDESC_FN:
1906 case R_XTENSA_TLSDESC_ARG:
1907 case R_XTENSA_TLS_DTPOFF:
1908 case R_XTENSA_TLS_TPOFF:
1909 bfd_put_32 (abfd, relocation, contents + address);
1910 return bfd_reloc_ok;
1913 /* Only instruction slot-specific relocations handled below.... */
1914 slot = get_relocation_slot (howto->type);
1915 if (slot == XTENSA_UNDEFINED)
1917 *error_message = "unexpected relocation";
1918 return bfd_reloc_dangerous;
1921 /* Read the instruction into a buffer and decode the opcode. */
1922 xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
1923 input_size - address);
1924 fmt = xtensa_format_decode (isa, ibuff);
1925 if (fmt == XTENSA_UNDEFINED)
1927 *error_message = "cannot decode instruction format";
1928 return bfd_reloc_dangerous;
1931 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
1933 opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
1934 if (opcode == XTENSA_UNDEFINED)
1936 *error_message = "cannot decode instruction opcode";
1937 return bfd_reloc_dangerous;
1940 /* Check for opcode-specific "alternate" relocations. */
1941 if (is_alt_relocation (howto->type))
1943 if (opcode == get_l32r_opcode ())
1945 /* Handle the special-case of non-PC-relative L32R instructions. */
1946 bfd *output_bfd = input_section->output_section->owner;
1947 asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
1950 *error_message = "relocation references missing .lit4 section";
1951 return bfd_reloc_dangerous;
1953 self_address = ((lit4_sec->vma & ~0xfff)
1954 + 0x40000 - 3); /* -3 to compensate for do_reloc */
1955 newval = relocation;
1958 else if (opcode == get_const16_opcode ())
1960 /* ALT used for high 16 bits.
1961 Ignore 32-bit overflow. */
1962 newval = (relocation >> 16) & 0xffff;
1967 /* No other "alternate" relocations currently defined. */
1968 *error_message = "unexpected relocation";
1969 return bfd_reloc_dangerous;
1972 else /* Not an "alternate" relocation.... */
1974 if (opcode == get_const16_opcode ())
1976 newval = relocation & 0xffff;
1981 /* ...normal PC-relative relocation.... */
1983 /* Determine which operand is being relocated. */
1984 opnd = get_relocation_opnd (opcode, howto->type);
1985 if (opnd == XTENSA_UNDEFINED)
1987 *error_message = "unexpected relocation";
1988 return bfd_reloc_dangerous;
1991 if (!howto->pc_relative)
1993 *error_message = "expected PC-relative relocation";
1994 return bfd_reloc_dangerous;
1997 newval = relocation;
2001 /* Apply the relocation. */
2002 if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
2003 || xtensa_operand_encode (isa, opcode, opnd, &newval)
2004 || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
2007 const char *opname = xtensa_opcode_name (isa, opcode);
2010 msg = "cannot encode";
2011 if (is_direct_call_opcode (opcode))
2013 if ((relocation & 0x3) != 0)
2014 msg = "misaligned call target";
2016 msg = "call target out of range";
2018 else if (opcode == get_l32r_opcode ())
2020 if ((relocation & 0x3) != 0)
2021 msg = "misaligned literal target";
2022 else if (is_alt_relocation (howto->type))
2023 msg = "literal target out of range (too many literals)";
2024 else if (self_address > relocation)
2025 msg = "literal target out of range (try using text-section-literals)";
2027 msg = "literal placed after use";
2030 *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
2031 return bfd_reloc_dangerous;
2034 /* Check for calls across 1GB boundaries. */
2035 if (is_direct_call_opcode (opcode)
2036 && is_windowed_call_opcode (opcode))
2038 if ((self_address >> CALL_SEGMENT_BITS)
2039 != (relocation >> CALL_SEGMENT_BITS))
2042 "windowed call crosses 1GB boundary; return may fail";
2043 return bfd_reloc_dangerous;
2047 /* Write the modified instruction back out of the buffer. */
2048 xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
2049 xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
2050 input_size - address);
2051 return bfd_reloc_ok;
2056 vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
2058 /* To reduce the size of the memory leak,
2059 we only use a single message buffer. */
2060 static bfd_size_type alloc_size = 0;
2061 static char *message = NULL;
2062 bfd_size_type orig_len, len = 0;
2063 bfd_boolean is_append;
2066 va_start (ap, arglen);
2068 is_append = (origmsg == message);
2070 orig_len = strlen (origmsg);
2071 len = orig_len + strlen (fmt) + arglen + 20;
2072 if (len > alloc_size)
2074 message = (char *) bfd_realloc_or_free (message, len);
2077 if (message != NULL)
2080 memcpy (message, origmsg, orig_len);
2081 vsprintf (message + orig_len, fmt, ap);
2088 /* This function is registered as the "special_function" in the
2089 Xtensa howto for handling simplify operations.
2090 bfd_perform_relocation / bfd_install_relocation use it to
2091 perform (install) the specified relocation. Since this replaces the code
2092 in bfd_perform_relocation, it is basically an Xtensa-specific,
2093 stripped-down version of bfd_perform_relocation. */
2095 static bfd_reloc_status_type
2096 bfd_elf_xtensa_reloc (bfd *abfd,
2097 arelent *reloc_entry,
2100 asection *input_section,
2102 char **error_message)
2105 bfd_reloc_status_type flag;
2106 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2107 bfd_vma output_base = 0;
2108 reloc_howto_type *howto = reloc_entry->howto;
2109 asection *reloc_target_output_section;
2110 bfd_boolean is_weak_undef;
2112 if (!xtensa_default_isa)
2113 xtensa_default_isa = xtensa_isa_init (0, 0);
2115 /* ELF relocs are against symbols. If we are producing relocatable
2116 output, and the reloc is against an external symbol, the resulting
2117 reloc will also be against the same symbol. In such a case, we
2118 don't want to change anything about the way the reloc is handled,
2119 since it will all be done at final link time. This test is similar
2120 to what bfd_elf_generic_reloc does except that it lets relocs with
2121 howto->partial_inplace go through even if the addend is non-zero.
2122 (The real problem is that partial_inplace is set for XTENSA_32
2123 relocs to begin with, but that's a long story and there's little we
2124 can do about it now....) */
2126 if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
2128 reloc_entry->address += input_section->output_offset;
2129 return bfd_reloc_ok;
2132 /* Is the address of the relocation really within the section? */
2133 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2134 return bfd_reloc_outofrange;
2136 /* Work out which section the relocation is targeted at and the
2137 initial relocation command value. */
2139 /* Get symbol value. (Common symbols are special.) */
2140 if (bfd_is_com_section (symbol->section))
2143 relocation = symbol->value;
2145 reloc_target_output_section = symbol->section->output_section;
2147 /* Convert input-section-relative symbol value to absolute. */
2148 if ((output_bfd && !howto->partial_inplace)
2149 || reloc_target_output_section == NULL)
2152 output_base = reloc_target_output_section->vma;
2154 relocation += output_base + symbol->section->output_offset;
2156 /* Add in supplied addend. */
2157 relocation += reloc_entry->addend;
2159 /* Here the variable relocation holds the final address of the
2160 symbol we are relocating against, plus any addend. */
2163 if (!howto->partial_inplace)
2165 /* This is a partial relocation, and we want to apply the relocation
2166 to the reloc entry rather than the raw data. Everything except
2167 relocations against section symbols has already been handled
2170 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
2171 reloc_entry->addend = relocation;
2172 reloc_entry->address += input_section->output_offset;
2173 return bfd_reloc_ok;
2177 reloc_entry->address += input_section->output_offset;
2178 reloc_entry->addend = 0;
2182 is_weak_undef = (bfd_is_und_section (symbol->section)
2183 && (symbol->flags & BSF_WEAK) != 0);
2184 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
2185 (bfd_byte *) data, (bfd_vma) octets,
2186 is_weak_undef, error_message);
2188 if (flag == bfd_reloc_dangerous)
2190 /* Add the symbol name to the error message. */
2191 if (! *error_message)
2192 *error_message = "";
2193 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
2194 strlen (symbol->name) + 17,
2196 (unsigned long) reloc_entry->addend);
2203 /* Set up an entry in the procedure linkage table. */
2206 elf_xtensa_create_plt_entry (struct bfd_link_info *info,
2208 unsigned reloc_index)
2210 asection *splt, *sgotplt;
2211 bfd_vma plt_base, got_base;
2212 bfd_vma code_offset, lit_offset, abi_offset;
2215 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
2216 splt = elf_xtensa_get_plt_section (info, chunk);
2217 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
2218 BFD_ASSERT (splt != NULL && sgotplt != NULL);
2220 plt_base = splt->output_section->vma + splt->output_offset;
2221 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
2223 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
2224 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
2226 /* Fill in the literal entry. This is the offset of the dynamic
2227 relocation entry. */
2228 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
2229 sgotplt->contents + lit_offset);
2231 /* Fill in the entry in the procedure linkage table. */
2232 memcpy (splt->contents + code_offset,
2233 (bfd_big_endian (output_bfd)
2234 ? elf_xtensa_be_plt_entry[XSHAL_ABI != XTHAL_ABI_WINDOWED]
2235 : elf_xtensa_le_plt_entry[XSHAL_ABI != XTHAL_ABI_WINDOWED]),
2237 abi_offset = XSHAL_ABI == XTHAL_ABI_WINDOWED ? 3 : 0;
2238 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
2239 plt_base + code_offset + abi_offset),
2240 splt->contents + code_offset + abi_offset + 1);
2241 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
2242 plt_base + code_offset + abi_offset + 3),
2243 splt->contents + code_offset + abi_offset + 4);
2244 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
2245 plt_base + code_offset + abi_offset + 6),
2246 splt->contents + code_offset + abi_offset + 7);
2248 return plt_base + code_offset;
2252 static bfd_boolean get_indirect_call_dest_reg (xtensa_opcode, unsigned *);
2255 replace_tls_insn (Elf_Internal_Rela *rel,
2257 asection *input_section,
2259 bfd_boolean is_ld_model,
2260 char **error_message)
2262 static xtensa_insnbuf ibuff = NULL;
2263 static xtensa_insnbuf sbuff = NULL;
2264 xtensa_isa isa = xtensa_default_isa;
2266 xtensa_opcode old_op, new_op;
2267 bfd_size_type input_size;
2269 unsigned dest_reg, src_reg;
2273 ibuff = xtensa_insnbuf_alloc (isa);
2274 sbuff = xtensa_insnbuf_alloc (isa);
2277 input_size = bfd_get_section_limit (abfd, input_section);
2279 /* Read the instruction into a buffer and decode the opcode. */
2280 xtensa_insnbuf_from_chars (isa, ibuff, contents + rel->r_offset,
2281 input_size - rel->r_offset);
2282 fmt = xtensa_format_decode (isa, ibuff);
2283 if (fmt == XTENSA_UNDEFINED)
2285 *error_message = "cannot decode instruction format";
2289 BFD_ASSERT (xtensa_format_num_slots (isa, fmt) == 1);
2290 xtensa_format_get_slot (isa, fmt, 0, ibuff, sbuff);
2292 old_op = xtensa_opcode_decode (isa, fmt, 0, sbuff);
2293 if (old_op == XTENSA_UNDEFINED)
2295 *error_message = "cannot decode instruction opcode";
2299 r_type = ELF32_R_TYPE (rel->r_info);
2302 case R_XTENSA_TLS_FUNC:
2303 case R_XTENSA_TLS_ARG:
2304 if (old_op != get_l32r_opcode ()
2305 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2306 sbuff, &dest_reg) != 0)
2308 *error_message = "cannot extract L32R destination for TLS access";
2313 case R_XTENSA_TLS_CALL:
2314 if (! get_indirect_call_dest_reg (old_op, &dest_reg)
2315 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2316 sbuff, &src_reg) != 0)
2318 *error_message = "cannot extract CALLXn operands for TLS access";
2331 case R_XTENSA_TLS_FUNC:
2332 case R_XTENSA_TLS_ARG:
2333 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2334 versions of Xtensa). */
2335 new_op = xtensa_opcode_lookup (isa, "nop");
2336 if (new_op == XTENSA_UNDEFINED)
2338 new_op = xtensa_opcode_lookup (isa, "or");
2339 if (new_op == XTENSA_UNDEFINED
2340 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2341 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2343 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2345 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2348 *error_message = "cannot encode OR for TLS access";
2354 if (xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0)
2356 *error_message = "cannot encode NOP for TLS access";
2362 case R_XTENSA_TLS_CALL:
2363 /* Read THREADPTR into the CALLX's return value register. */
2364 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2365 if (new_op == XTENSA_UNDEFINED
2366 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2367 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2368 sbuff, dest_reg + 2) != 0)
2370 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2380 case R_XTENSA_TLS_FUNC:
2381 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2382 if (new_op == XTENSA_UNDEFINED
2383 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2384 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2385 sbuff, dest_reg) != 0)
2387 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2392 case R_XTENSA_TLS_ARG:
2393 /* Nothing to do. Keep the original L32R instruction. */
2396 case R_XTENSA_TLS_CALL:
2397 /* Add the CALLX's src register (holding the THREADPTR value)
2398 to the first argument register (holding the offset) and put
2399 the result in the CALLX's return value register. */
2400 new_op = xtensa_opcode_lookup (isa, "add");
2401 if (new_op == XTENSA_UNDEFINED
2402 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2403 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2404 sbuff, dest_reg + 2) != 0
2405 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2406 sbuff, dest_reg + 2) != 0
2407 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2408 sbuff, src_reg) != 0)
2410 *error_message = "cannot encode ADD for TLS access";
2417 xtensa_format_set_slot (isa, fmt, 0, ibuff, sbuff);
2418 xtensa_insnbuf_to_chars (isa, ibuff, contents + rel->r_offset,
2419 input_size - rel->r_offset);
2425 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2426 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2427 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2428 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2429 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2430 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2431 || (R_TYPE) == R_XTENSA_TLS_ARG \
2432 || (R_TYPE) == R_XTENSA_TLS_CALL)
2434 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2435 both relocatable and final links. */
2438 elf_xtensa_relocate_section (bfd *output_bfd,
2439 struct bfd_link_info *info,
2441 asection *input_section,
2443 Elf_Internal_Rela *relocs,
2444 Elf_Internal_Sym *local_syms,
2445 asection **local_sections)
2447 struct elf_xtensa_link_hash_table *htab;
2448 Elf_Internal_Shdr *symtab_hdr;
2449 Elf_Internal_Rela *rel;
2450 Elf_Internal_Rela *relend;
2451 struct elf_link_hash_entry **sym_hashes;
2452 property_table_entry *lit_table = 0;
2454 char *local_got_tls_types;
2455 char *error_message = NULL;
2456 bfd_size_type input_size;
2459 if (!xtensa_default_isa)
2460 xtensa_default_isa = xtensa_isa_init (0, 0);
2462 if (!is_xtensa_elf (input_bfd))
2464 bfd_set_error (bfd_error_wrong_format);
2468 htab = elf_xtensa_hash_table (info);
2472 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2473 sym_hashes = elf_sym_hashes (input_bfd);
2474 local_got_tls_types = elf_xtensa_local_got_tls_type (input_bfd);
2476 if (elf_hash_table (info)->dynamic_sections_created)
2478 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
2479 &lit_table, XTENSA_LIT_SEC_NAME,
2485 input_size = bfd_get_section_limit (input_bfd, input_section);
2488 relend = relocs + input_section->reloc_count;
2489 for (; rel < relend; rel++)
2492 reloc_howto_type *howto;
2493 unsigned long r_symndx;
2494 struct elf_link_hash_entry *h;
2495 Elf_Internal_Sym *sym;
2500 bfd_reloc_status_type r;
2501 bfd_boolean is_weak_undef;
2502 bfd_boolean unresolved_reloc;
2504 bfd_boolean dynamic_symbol;
2506 r_type = ELF32_R_TYPE (rel->r_info);
2507 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2508 || r_type == (int) R_XTENSA_GNU_VTENTRY)
2511 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2513 bfd_set_error (bfd_error_bad_value);
2516 howto = &elf_howto_table[r_type];
2518 r_symndx = ELF32_R_SYM (rel->r_info);
2523 is_weak_undef = FALSE;
2524 unresolved_reloc = FALSE;
2527 if (howto->partial_inplace && !bfd_link_relocatable (info))
2529 /* Because R_XTENSA_32 was made partial_inplace to fix some
2530 problems with DWARF info in partial links, there may be
2531 an addend stored in the contents. Take it out of there
2532 and move it back into the addend field of the reloc. */
2533 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2534 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2537 if (r_symndx < symtab_hdr->sh_info)
2539 sym = local_syms + r_symndx;
2540 sym_type = ELF32_ST_TYPE (sym->st_info);
2541 sec = local_sections[r_symndx];
2542 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2546 bfd_boolean ignored;
2548 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2549 r_symndx, symtab_hdr, sym_hashes,
2551 unresolved_reloc, warned, ignored);
2554 && !unresolved_reloc
2555 && h->root.type == bfd_link_hash_undefweak)
2556 is_weak_undef = TRUE;
2561 if (sec != NULL && discarded_section (sec))
2562 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2563 rel, 1, relend, howto, 0, contents);
2565 if (bfd_link_relocatable (info))
2568 asection * sym_sec = get_elf_r_symndx_section (input_bfd, r_symndx);
2570 /* This is a relocatable link.
2571 1) If the reloc is against a section symbol, adjust
2572 according to the output section.
2573 2) If there is a new target for this relocation,
2574 the new target will be in the same output section.
2575 We adjust the relocation by the output section
2578 if (relaxing_section)
2580 /* Check if this references a section in another input file. */
2581 if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2586 dest_addr = sym_sec->output_section->vma + sym_sec->output_offset
2587 + get_elf_r_symndx_offset (input_bfd, r_symndx) + rel->r_addend;
2589 if (r_type == R_XTENSA_ASM_SIMPLIFY)
2591 error_message = NULL;
2592 /* Convert ASM_SIMPLIFY into the simpler relocation
2593 so that they never escape a relaxing link. */
2594 r = contract_asm_expansion (contents, input_size, rel,
2596 if (r != bfd_reloc_ok)
2597 (*info->callbacks->reloc_dangerous)
2598 (info, error_message,
2599 input_bfd, input_section, rel->r_offset);
2601 r_type = ELF32_R_TYPE (rel->r_info);
2604 /* This is a relocatable link, so we don't have to change
2605 anything unless the reloc is against a section symbol,
2606 in which case we have to adjust according to where the
2607 section symbol winds up in the output section. */
2608 if (r_symndx < symtab_hdr->sh_info)
2610 sym = local_syms + r_symndx;
2611 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2613 sec = local_sections[r_symndx];
2614 rel->r_addend += sec->output_offset + sym->st_value;
2618 /* If there is an addend with a partial_inplace howto,
2619 then move the addend to the contents. This is a hack
2620 to work around problems with DWARF in relocatable links
2621 with some previous version of BFD. Now we can't easily get
2622 rid of the hack without breaking backward compatibility.... */
2624 howto = &elf_howto_table[r_type];
2625 if (howto->partial_inplace && rel->r_addend)
2627 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2628 rel->r_addend, contents,
2629 rel->r_offset, FALSE,
2635 /* Put the correct bits in the target instruction, even
2636 though the relocation will still be present in the output
2637 file. This makes disassembly clearer, as well as
2638 allowing loadable kernel modules to work without needing
2639 relocations on anything other than calls and l32r's. */
2641 /* If it is not in the same section, there is nothing we can do. */
2642 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP &&
2643 sym_sec->output_section == input_section->output_section)
2645 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2646 dest_addr, contents,
2647 rel->r_offset, FALSE,
2651 if (r != bfd_reloc_ok)
2652 (*info->callbacks->reloc_dangerous)
2653 (info, error_message,
2654 input_bfd, input_section, rel->r_offset);
2656 /* Done with work for relocatable link; continue with next reloc. */
2660 /* This is a final link. */
2662 if (relaxing_section)
2664 /* Check if this references a section in another input file. */
2665 do_fix_for_final_link (rel, input_bfd, input_section, contents,
2669 /* Sanity check the address. */
2670 if (rel->r_offset >= input_size
2671 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2674 /* xgettext:c-format */
2675 (_("%pB(%pA+%#" PRIx64 "): "
2676 "relocation offset out of range (size=%#" PRIx64 ")"),
2677 input_bfd, input_section, (uint64_t) rel->r_offset,
2678 (uint64_t) input_size);
2679 bfd_set_error (bfd_error_bad_value);
2684 name = h->root.root.string;
2687 name = (bfd_elf_string_from_elf_section
2688 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2689 if (name == NULL || *name == '\0')
2690 name = bfd_section_name (input_bfd, sec);
2693 if (r_symndx != STN_UNDEF
2694 && r_type != R_XTENSA_NONE
2696 || h->root.type == bfd_link_hash_defined
2697 || h->root.type == bfd_link_hash_defweak)
2698 && IS_XTENSA_TLS_RELOC (r_type) != (sym_type == STT_TLS))
2701 ((sym_type == STT_TLS
2702 /* xgettext:c-format */
2703 ? _("%pB(%pA+%#" PRIx64 "): %s used with TLS symbol %s")
2704 /* xgettext:c-format */
2705 : _("%pB(%pA+%#" PRIx64 "): %s used with non-TLS symbol %s")),
2708 (uint64_t) rel->r_offset,
2713 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
2715 tls_type = GOT_UNKNOWN;
2717 tls_type = elf_xtensa_hash_entry (h)->tls_type;
2718 else if (local_got_tls_types)
2719 tls_type = local_got_tls_types [r_symndx];
2725 if (elf_hash_table (info)->dynamic_sections_created
2726 && (input_section->flags & SEC_ALLOC) != 0
2727 && (dynamic_symbol || bfd_link_pic (info)))
2729 Elf_Internal_Rela outrel;
2733 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2734 srel = htab->elf.srelplt;
2736 srel = htab->elf.srelgot;
2738 BFD_ASSERT (srel != NULL);
2741 _bfd_elf_section_offset (output_bfd, info,
2742 input_section, rel->r_offset);
2744 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2745 memset (&outrel, 0, sizeof outrel);
2748 outrel.r_offset += (input_section->output_section->vma
2749 + input_section->output_offset);
2751 /* Complain if the relocation is in a read-only section
2752 and not in a literal pool. */
2753 if ((input_section->flags & SEC_READONLY) != 0
2754 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
2758 _("dynamic relocation in read-only section");
2759 (*info->callbacks->reloc_dangerous)
2760 (info, error_message,
2761 input_bfd, input_section, rel->r_offset);
2766 outrel.r_addend = rel->r_addend;
2769 if (r_type == R_XTENSA_32)
2772 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2775 else /* r_type == R_XTENSA_PLT */
2778 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2780 /* Create the PLT entry and set the initial
2781 contents of the literal entry to the address of
2784 elf_xtensa_create_plt_entry (info, output_bfd,
2787 unresolved_reloc = FALSE;
2789 else if (!is_weak_undef)
2791 /* Generate a RELATIVE relocation. */
2792 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2793 outrel.r_addend = 0;
2801 loc = (srel->contents
2802 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2803 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2804 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2807 else if (r_type == R_XTENSA_ASM_EXPAND && dynamic_symbol)
2809 /* This should only happen for non-PIC code, which is not
2810 supposed to be used on systems with dynamic linking.
2811 Just ignore these relocations. */
2816 case R_XTENSA_TLS_TPOFF:
2817 /* Switch to LE model for local symbols in an executable. */
2818 if (! bfd_link_pic (info) && ! dynamic_symbol)
2820 relocation = tpoff (info, relocation);
2825 case R_XTENSA_TLSDESC_FN:
2826 case R_XTENSA_TLSDESC_ARG:
2828 if (r_type == R_XTENSA_TLSDESC_FN)
2830 if (! bfd_link_pic (info) || (tls_type & GOT_TLS_IE) != 0)
2831 r_type = R_XTENSA_NONE;
2833 else if (r_type == R_XTENSA_TLSDESC_ARG)
2835 if (bfd_link_pic (info))
2837 if ((tls_type & GOT_TLS_IE) != 0)
2838 r_type = R_XTENSA_TLS_TPOFF;
2842 r_type = R_XTENSA_TLS_TPOFF;
2843 if (! dynamic_symbol)
2845 relocation = tpoff (info, relocation);
2851 if (r_type == R_XTENSA_NONE)
2852 /* Nothing to do here; skip to the next reloc. */
2855 if (! elf_hash_table (info)->dynamic_sections_created)
2858 _("TLS relocation invalid without dynamic sections");
2859 (*info->callbacks->reloc_dangerous)
2860 (info, error_message,
2861 input_bfd, input_section, rel->r_offset);
2865 Elf_Internal_Rela outrel;
2867 asection *srel = htab->elf.srelgot;
2870 outrel.r_offset = (input_section->output_section->vma
2871 + input_section->output_offset
2874 /* Complain if the relocation is in a read-only section
2875 and not in a literal pool. */
2876 if ((input_section->flags & SEC_READONLY) != 0
2877 && ! elf_xtensa_in_literal_pool (lit_table, ltblsize,
2881 _("dynamic relocation in read-only section");
2882 (*info->callbacks->reloc_dangerous)
2883 (info, error_message,
2884 input_bfd, input_section, rel->r_offset);
2887 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2889 outrel.r_addend = relocation - dtpoff_base (info);
2891 outrel.r_addend = 0;
2894 outrel.r_info = ELF32_R_INFO (indx, r_type);
2896 unresolved_reloc = FALSE;
2899 loc = (srel->contents
2900 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2901 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2902 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2908 case R_XTENSA_TLS_DTPOFF:
2909 if (! bfd_link_pic (info))
2910 /* Switch from LD model to LE model. */
2911 relocation = tpoff (info, relocation);
2913 relocation -= dtpoff_base (info);
2916 case R_XTENSA_TLS_FUNC:
2917 case R_XTENSA_TLS_ARG:
2918 case R_XTENSA_TLS_CALL:
2919 /* Check if optimizing to IE or LE model. */
2920 if ((tls_type & GOT_TLS_IE) != 0)
2922 bfd_boolean is_ld_model =
2923 (h && elf_xtensa_hash_entry (h) == htab->tlsbase);
2924 if (! replace_tls_insn (rel, input_bfd, input_section, contents,
2925 is_ld_model, &error_message))
2926 (*info->callbacks->reloc_dangerous)
2927 (info, error_message,
2928 input_bfd, input_section, rel->r_offset);
2930 if (r_type != R_XTENSA_TLS_ARG || is_ld_model)
2932 /* Skip subsequent relocations on the same instruction. */
2933 while (rel + 1 < relend && rel[1].r_offset == rel->r_offset)
2940 if (elf_hash_table (info)->dynamic_sections_created
2941 && dynamic_symbol && (is_operand_relocation (r_type)
2942 || r_type == R_XTENSA_32_PCREL))
2945 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
2946 strlen (name) + 2, name);
2947 (*info->callbacks->reloc_dangerous)
2948 (info, error_message, input_bfd, input_section, rel->r_offset);
2954 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2955 because such sections are not SEC_ALLOC and thus ld.so will
2956 not process them. */
2957 if (unresolved_reloc
2958 && !((input_section->flags & SEC_DEBUGGING) != 0
2960 && _bfd_elf_section_offset (output_bfd, info, input_section,
2961 rel->r_offset) != (bfd_vma) -1)
2964 /* xgettext:c-format */
2965 (_("%pB(%pA+%#" PRIx64 "): "
2966 "unresolvable %s relocation against symbol `%s'"),
2969 (uint64_t) rel->r_offset,
2975 /* TLS optimizations may have changed r_type; update "howto". */
2976 howto = &elf_howto_table[r_type];
2978 /* There's no point in calling bfd_perform_relocation here.
2979 Just go directly to our "special function". */
2980 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2981 relocation + rel->r_addend,
2982 contents, rel->r_offset, is_weak_undef,
2985 if (r != bfd_reloc_ok && !warned)
2987 BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
2988 BFD_ASSERT (error_message != NULL);
2990 if (rel->r_addend == 0)
2991 error_message = vsprint_msg (error_message, ": %s",
2992 strlen (name) + 2, name);
2994 error_message = vsprint_msg (error_message, ": (%s+0x%x)",
2996 name, (int) rel->r_addend);
2998 (*info->callbacks->reloc_dangerous)
2999 (info, error_message, input_bfd, input_section, rel->r_offset);
3006 input_section->reloc_done = TRUE;
3012 /* Finish up dynamic symbol handling. There's not much to do here since
3013 the PLT and GOT entries are all set up by relocate_section. */
3016 elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
3017 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3018 struct elf_link_hash_entry *h,
3019 Elf_Internal_Sym *sym)
3021 if (h->needs_plt && !h->def_regular)
3023 /* Mark the symbol as undefined, rather than as defined in
3024 the .plt section. Leave the value alone. */
3025 sym->st_shndx = SHN_UNDEF;
3026 /* If the symbol is weak, we do need to clear the value.
3027 Otherwise, the PLT entry would provide a definition for
3028 the symbol even if the symbol wasn't defined anywhere,
3029 and so the symbol would never be NULL. */
3030 if (!h->ref_regular_nonweak)
3034 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3035 if (h == elf_hash_table (info)->hdynamic
3036 || h == elf_hash_table (info)->hgot)
3037 sym->st_shndx = SHN_ABS;
3043 /* Combine adjacent literal table entries in the output. Adjacent
3044 entries within each input section may have been removed during
3045 relaxation, but we repeat the process here, even though it's too late
3046 to shrink the output section, because it's important to minimize the
3047 number of literal table entries to reduce the start-up work for the
3048 runtime linker. Returns the number of remaining table entries or -1
3052 elf_xtensa_combine_prop_entries (bfd *output_bfd,
3057 property_table_entry *table;
3058 bfd_size_type section_size, sgotloc_size;
3062 section_size = sxtlit->size;
3063 BFD_ASSERT (section_size % 8 == 0);
3064 num = section_size / 8;
3066 sgotloc_size = sgotloc->size;
3067 if (sgotloc_size != section_size)
3070 (_("internal inconsistency in size of .got.loc section"));
3074 table = bfd_malloc (num * sizeof (property_table_entry));
3078 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3079 propagates to the output section, where it doesn't really apply and
3080 where it breaks the following call to bfd_malloc_and_get_section. */
3081 sxtlit->flags &= ~SEC_IN_MEMORY;
3083 if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
3091 /* There should never be any relocations left at this point, so this
3092 is quite a bit easier than what is done during relaxation. */
3094 /* Copy the raw contents into a property table array and sort it. */
3096 for (n = 0; n < num; n++)
3098 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
3099 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
3102 qsort (table, num, sizeof (property_table_entry), property_table_compare);
3104 for (n = 0; n < num; n++)
3106 bfd_boolean remove_entry = FALSE;
3108 if (table[n].size == 0)
3109 remove_entry = TRUE;
3111 && (table[n-1].address + table[n-1].size == table[n].address))
3113 table[n-1].size += table[n].size;
3114 remove_entry = TRUE;
3119 for (m = n; m < num - 1; m++)
3121 table[m].address = table[m+1].address;
3122 table[m].size = table[m+1].size;
3130 /* Copy the data back to the raw contents. */
3132 for (n = 0; n < num; n++)
3134 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
3135 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
3139 /* Clear the removed bytes. */
3140 if ((bfd_size_type) (num * 8) < section_size)
3141 memset (&contents[num * 8], 0, section_size - num * 8);
3143 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
3147 /* Copy the contents to ".got.loc". */
3148 memcpy (sgotloc->contents, contents, section_size);
3156 /* Finish up the dynamic sections. */
3159 elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
3160 struct bfd_link_info *info)
3162 struct elf_xtensa_link_hash_table *htab;
3164 asection *sdyn, *srelplt, *srelgot, *sgot, *sxtlit, *sgotloc;
3165 Elf32_External_Dyn *dyncon, *dynconend;
3166 int num_xtlit_entries = 0;
3168 if (! elf_hash_table (info)->dynamic_sections_created)
3171 htab = elf_xtensa_hash_table (info);
3175 dynobj = elf_hash_table (info)->dynobj;
3176 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3177 BFD_ASSERT (sdyn != NULL);
3179 /* Set the first entry in the global offset table to the address of
3180 the dynamic section. */
3181 sgot = htab->elf.sgot;
3184 BFD_ASSERT (sgot->size == 4);
3186 bfd_put_32 (output_bfd, 0, sgot->contents);
3188 bfd_put_32 (output_bfd,
3189 sdyn->output_section->vma + sdyn->output_offset,
3193 srelplt = htab->elf.srelplt;
3194 srelgot = htab->elf.srelgot;
3195 if (srelplt && srelplt->size != 0)
3197 asection *sgotplt, *spltlittbl;
3198 int chunk, plt_chunks, plt_entries;
3199 Elf_Internal_Rela irela;
3201 unsigned rtld_reloc;
3203 spltlittbl = htab->spltlittbl;
3204 BFD_ASSERT (srelgot != NULL && spltlittbl != NULL);
3206 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3207 of them follow immediately after.... */
3208 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
3210 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3211 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3212 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
3215 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
3217 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
3219 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
3221 for (chunk = 0; chunk < plt_chunks; chunk++)
3223 int chunk_entries = 0;
3225 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
3226 BFD_ASSERT (sgotplt != NULL);
3228 /* Emit special RTLD relocations for the first two entries in
3229 each chunk of the .got.plt section. */
3231 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3232 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3233 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3234 irela.r_offset = (sgotplt->output_section->vma
3235 + sgotplt->output_offset);
3236 irela.r_addend = 1; /* tell rtld to set value to resolver function */
3237 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3239 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3241 /* Next literal immediately follows the first. */
3242 loc += sizeof (Elf32_External_Rela);
3243 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3244 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3245 irela.r_offset = (sgotplt->output_section->vma
3246 + sgotplt->output_offset + 4);
3247 /* Tell rtld to set value to object's link map. */
3249 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3251 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3253 /* Fill in the literal table. */
3254 if (chunk < plt_chunks - 1)
3255 chunk_entries = PLT_ENTRIES_PER_CHUNK;
3257 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
3259 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
3260 bfd_put_32 (output_bfd,
3261 sgotplt->output_section->vma + sgotplt->output_offset,
3262 spltlittbl->contents + (chunk * 8) + 0);
3263 bfd_put_32 (output_bfd,
3264 8 + (chunk_entries * 4),
3265 spltlittbl->contents + (chunk * 8) + 4);
3268 /* The .xt.lit.plt section has just been modified. This must
3269 happen before the code below which combines adjacent literal
3270 table entries, and the .xt.lit.plt contents have to be forced to
3272 if (! bfd_set_section_contents (output_bfd,
3273 spltlittbl->output_section,
3274 spltlittbl->contents,
3275 spltlittbl->output_offset,
3278 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3279 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
3282 /* All the dynamic relocations have been emitted at this point.
3283 Make sure the relocation sections are the correct size. */
3284 if ((srelgot && srelgot->size != (sizeof (Elf32_External_Rela)
3285 * srelgot->reloc_count))
3286 || (srelplt && srelplt->size != (sizeof (Elf32_External_Rela)
3287 * srelplt->reloc_count)))
3290 /* Combine adjacent literal table entries. */
3291 BFD_ASSERT (! bfd_link_relocatable (info));
3292 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
3293 sgotloc = htab->sgotloc;
3294 BFD_ASSERT (sgotloc);
3298 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
3299 if (num_xtlit_entries < 0)
3303 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3304 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3305 for (; dyncon < dynconend; dyncon++)
3307 Elf_Internal_Dyn dyn;
3309 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3316 case DT_XTENSA_GOT_LOC_SZ:
3317 dyn.d_un.d_val = num_xtlit_entries;
3320 case DT_XTENSA_GOT_LOC_OFF:
3321 dyn.d_un.d_ptr = (htab->sgotloc->output_section->vma
3322 + htab->sgotloc->output_offset);
3326 dyn.d_un.d_ptr = (htab->elf.sgot->output_section->vma
3327 + htab->elf.sgot->output_offset);
3331 dyn.d_un.d_ptr = (htab->elf.srelplt->output_section->vma
3332 + htab->elf.srelplt->output_offset);
3336 dyn.d_un.d_val = htab->elf.srelplt->size;
3340 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3347 /* Functions for dealing with the e_flags field. */
3349 /* Merge backend specific data from an object file to the output
3350 object file when linking. */
3353 elf_xtensa_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3355 bfd *obfd = info->output_bfd;
3356 unsigned out_mach, in_mach;
3357 flagword out_flag, in_flag;
3359 /* Check if we have the same endianness. */
3360 if (!_bfd_generic_verify_endian_match (ibfd, info))
3363 /* Don't even pretend to support mixed-format linking. */
3364 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3365 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3368 out_flag = elf_elfheader (obfd)->e_flags;
3369 in_flag = elf_elfheader (ibfd)->e_flags;
3371 out_mach = out_flag & EF_XTENSA_MACH;
3372 in_mach = in_flag & EF_XTENSA_MACH;
3373 if (out_mach != in_mach)
3376 /* xgettext:c-format */
3377 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3378 ibfd, out_mach, in_mach);
3379 bfd_set_error (bfd_error_wrong_format);
3383 if (! elf_flags_init (obfd))
3385 elf_flags_init (obfd) = TRUE;
3386 elf_elfheader (obfd)->e_flags = in_flag;
3388 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3389 && bfd_get_arch_info (obfd)->the_default)
3390 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3391 bfd_get_mach (ibfd));
3396 if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
3397 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
3399 if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
3400 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
3407 elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
3409 BFD_ASSERT (!elf_flags_init (abfd)
3410 || elf_elfheader (abfd)->e_flags == flags);
3412 elf_elfheader (abfd)->e_flags |= flags;
3413 elf_flags_init (abfd) = TRUE;
3420 elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
3422 FILE *f = (FILE *) farg;
3423 flagword e_flags = elf_elfheader (abfd)->e_flags;
3425 fprintf (f, "\nXtensa header:\n");
3426 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
3427 fprintf (f, "\nMachine = Base\n");
3429 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
3431 fprintf (f, "Insn tables = %s\n",
3432 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
3434 fprintf (f, "Literal tables = %s\n",
3435 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
3437 return _bfd_elf_print_private_bfd_data (abfd, farg);
3441 /* Set the right machine number for an Xtensa ELF file. */
3444 elf_xtensa_object_p (bfd *abfd)
3447 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
3452 mach = bfd_mach_xtensa;
3458 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
3463 /* The final processing done just before writing out an Xtensa ELF object
3464 file. This gets the Xtensa architecture right based on the machine
3468 elf_xtensa_final_write_processing (bfd *abfd,
3469 bfd_boolean linker ATTRIBUTE_UNUSED)
3474 switch (mach = bfd_get_mach (abfd))
3476 case bfd_mach_xtensa:
3477 val = E_XTENSA_MACH;
3483 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
3484 elf_elfheader (abfd)->e_flags |= val;
3488 static enum elf_reloc_type_class
3489 elf_xtensa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3490 const asection *rel_sec ATTRIBUTE_UNUSED,
3491 const Elf_Internal_Rela *rela)
3493 switch ((int) ELF32_R_TYPE (rela->r_info))
3495 case R_XTENSA_RELATIVE:
3496 return reloc_class_relative;
3497 case R_XTENSA_JMP_SLOT:
3498 return reloc_class_plt;
3500 return reloc_class_normal;
3506 elf_xtensa_discard_info_for_section (bfd *abfd,
3507 struct elf_reloc_cookie *cookie,
3508 struct bfd_link_info *info,
3512 bfd_vma offset, actual_offset;
3513 bfd_size_type removed_bytes = 0;
3514 bfd_size_type entry_size;
3516 if (sec->output_section
3517 && bfd_is_abs_section (sec->output_section))
3520 if (xtensa_is_proptable_section (sec))
3525 if (sec->size == 0 || sec->size % entry_size != 0)
3528 contents = retrieve_contents (abfd, sec, info->keep_memory);
3532 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
3535 release_contents (sec, contents);
3539 /* Sort the relocations. They should already be in order when
3540 relaxation is enabled, but it might not be. */
3541 qsort (cookie->rels, sec->reloc_count, sizeof (Elf_Internal_Rela),
3542 internal_reloc_compare);
3544 cookie->rel = cookie->rels;
3545 cookie->relend = cookie->rels + sec->reloc_count;
3547 for (offset = 0; offset < sec->size; offset += entry_size)
3549 actual_offset = offset - removed_bytes;
3551 /* The ...symbol_deleted_p function will skip over relocs but it
3552 won't adjust their offsets, so do that here. */
3553 while (cookie->rel < cookie->relend
3554 && cookie->rel->r_offset < offset)
3556 cookie->rel->r_offset -= removed_bytes;
3560 while (cookie->rel < cookie->relend
3561 && cookie->rel->r_offset == offset)
3563 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
3565 /* Remove the table entry. (If the reloc type is NONE, then
3566 the entry has already been merged with another and deleted
3567 during relaxation.) */
3568 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
3570 /* Shift the contents up. */
3571 if (offset + entry_size < sec->size)
3572 memmove (&contents[actual_offset],
3573 &contents[actual_offset + entry_size],
3574 sec->size - offset - entry_size);
3575 removed_bytes += entry_size;
3578 /* Remove this relocation. */
3579 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3582 /* Adjust the relocation offset for previous removals. This
3583 should not be done before calling ...symbol_deleted_p
3584 because it might mess up the offset comparisons there.
3585 Make sure the offset doesn't underflow in the case where
3586 the first entry is removed. */
3587 if (cookie->rel->r_offset >= removed_bytes)
3588 cookie->rel->r_offset -= removed_bytes;
3590 cookie->rel->r_offset = 0;
3596 if (removed_bytes != 0)
3598 /* Adjust any remaining relocs (shouldn't be any). */
3599 for (; cookie->rel < cookie->relend; cookie->rel++)
3601 if (cookie->rel->r_offset >= removed_bytes)
3602 cookie->rel->r_offset -= removed_bytes;
3604 cookie->rel->r_offset = 0;
3607 /* Clear the removed bytes. */
3608 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
3610 pin_contents (sec, contents);
3611 pin_internal_relocs (sec, cookie->rels);
3614 if (sec->rawsize == 0)
3615 sec->rawsize = sec->size;
3616 sec->size -= removed_bytes;
3618 if (xtensa_is_littable_section (sec))
3620 asection *sgotloc = elf_xtensa_hash_table (info)->sgotloc;
3622 sgotloc->size -= removed_bytes;
3627 release_contents (sec, contents);
3628 release_internal_relocs (sec, cookie->rels);
3631 return (removed_bytes != 0);
3636 elf_xtensa_discard_info (bfd *abfd,
3637 struct elf_reloc_cookie *cookie,
3638 struct bfd_link_info *info)
3641 bfd_boolean changed = FALSE;
3643 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3645 if (xtensa_is_property_section (sec))
3647 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
3657 elf_xtensa_ignore_discarded_relocs (asection *sec)
3659 return xtensa_is_property_section (sec);
3664 elf_xtensa_action_discarded (asection *sec)
3666 if (strcmp (".xt_except_table", sec->name) == 0)
3669 if (strcmp (".xt_except_desc", sec->name) == 0)
3672 return _bfd_elf_default_action_discarded (sec);
3676 /* Support for core dump NOTE sections. */
3679 elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3684 /* The size for Xtensa is variable, so don't try to recognize the format
3685 based on the size. Just assume this is GNU/Linux. */
3688 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3691 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
3695 size = note->descsz - offset - 4;
3697 /* Make a ".reg/999" section. */
3698 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3699 size, note->descpos + offset);
3704 elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3706 switch (note->descsz)
3711 case 128: /* GNU/Linux elf_prpsinfo */
3712 elf_tdata (abfd)->core->program
3713 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3714 elf_tdata (abfd)->core->command
3715 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3718 /* Note that for some reason, a spurious space is tacked
3719 onto the end of the args in some (at least one anyway)
3720 implementations, so strip it off if it exists. */
3723 char *command = elf_tdata (abfd)->core->command;
3724 int n = strlen (command);
3726 if (0 < n && command[n - 1] == ' ')
3727 command[n - 1] = '\0';
3734 /* Generic Xtensa configurability stuff. */
3736 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3737 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3738 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3739 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3740 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3741 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3742 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3743 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3746 init_call_opcodes (void)
3748 if (callx0_op == XTENSA_UNDEFINED)
3750 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3751 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3752 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3753 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3754 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3755 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3756 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3757 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3763 is_indirect_call_opcode (xtensa_opcode opcode)
3765 init_call_opcodes ();
3766 return (opcode == callx0_op
3767 || opcode == callx4_op
3768 || opcode == callx8_op
3769 || opcode == callx12_op);
3774 is_direct_call_opcode (xtensa_opcode opcode)
3776 init_call_opcodes ();
3777 return (opcode == call0_op
3778 || opcode == call4_op
3779 || opcode == call8_op
3780 || opcode == call12_op);
3785 is_windowed_call_opcode (xtensa_opcode opcode)
3787 init_call_opcodes ();
3788 return (opcode == call4_op
3789 || opcode == call8_op
3790 || opcode == call12_op
3791 || opcode == callx4_op
3792 || opcode == callx8_op
3793 || opcode == callx12_op);
3798 get_indirect_call_dest_reg (xtensa_opcode opcode, unsigned *pdst)
3800 unsigned dst = (unsigned) -1;
3802 init_call_opcodes ();
3803 if (opcode == callx0_op)
3805 else if (opcode == callx4_op)
3807 else if (opcode == callx8_op)
3809 else if (opcode == callx12_op)
3812 if (dst == (unsigned) -1)
3820 static xtensa_opcode
3821 get_const16_opcode (void)
3823 static bfd_boolean done_lookup = FALSE;
3824 static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3827 const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3830 return const16_opcode;
3834 static xtensa_opcode
3835 get_l32r_opcode (void)
3837 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
3838 static bfd_boolean done_lookup = FALSE;
3842 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
3850 l32r_offset (bfd_vma addr, bfd_vma pc)
3854 offset = addr - ((pc+3) & -4);
3855 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3856 offset = (signed int) offset >> 2;
3857 BFD_ASSERT ((signed int) offset >> 16 == -1);
3863 get_relocation_opnd (xtensa_opcode opcode, int r_type)
3865 xtensa_isa isa = xtensa_default_isa;
3866 int last_immed, last_opnd, opi;
3868 if (opcode == XTENSA_UNDEFINED)
3869 return XTENSA_UNDEFINED;
3871 /* Find the last visible PC-relative immediate operand for the opcode.
3872 If there are no PC-relative immediates, then choose the last visible
3873 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3874 last_immed = XTENSA_UNDEFINED;
3875 last_opnd = xtensa_opcode_num_operands (isa, opcode);
3876 for (opi = last_opnd - 1; opi >= 0; opi--)
3878 if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
3880 if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
3885 if (last_immed == XTENSA_UNDEFINED
3886 && xtensa_operand_is_register (isa, opcode, opi) == 0)
3890 return XTENSA_UNDEFINED;
3892 /* If the operand number was specified in an old-style relocation,
3893 check for consistency with the operand computed above. */
3894 if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
3896 int reloc_opnd = r_type - R_XTENSA_OP0;
3897 if (reloc_opnd != last_immed)
3898 return XTENSA_UNDEFINED;
3906 get_relocation_slot (int r_type)
3916 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
3917 return r_type - R_XTENSA_SLOT0_OP;
3918 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
3919 return r_type - R_XTENSA_SLOT0_ALT;
3923 return XTENSA_UNDEFINED;
3927 /* Get the opcode for a relocation. */
3929 static xtensa_opcode
3930 get_relocation_opcode (bfd *abfd,
3933 Elf_Internal_Rela *irel)
3935 static xtensa_insnbuf ibuff = NULL;
3936 static xtensa_insnbuf sbuff = NULL;
3937 xtensa_isa isa = xtensa_default_isa;
3941 if (contents == NULL)
3942 return XTENSA_UNDEFINED;
3944 if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
3945 return XTENSA_UNDEFINED;
3949 ibuff = xtensa_insnbuf_alloc (isa);
3950 sbuff = xtensa_insnbuf_alloc (isa);
3953 /* Decode the instruction. */
3954 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
3955 sec->size - irel->r_offset);
3956 fmt = xtensa_format_decode (isa, ibuff);
3957 slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
3958 if (slot == XTENSA_UNDEFINED)
3959 return XTENSA_UNDEFINED;
3960 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
3961 return xtensa_opcode_decode (isa, fmt, slot, sbuff);
3966 is_l32r_relocation (bfd *abfd,
3969 Elf_Internal_Rela *irel)
3971 xtensa_opcode opcode;
3972 if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
3974 opcode = get_relocation_opcode (abfd, sec, contents, irel);
3975 return (opcode == get_l32r_opcode ());
3979 static bfd_size_type
3980 get_asm_simplify_size (bfd_byte *contents,
3981 bfd_size_type content_len,
3982 bfd_size_type offset)
3984 bfd_size_type insnlen, size = 0;
3986 /* Decode the size of the next two instructions. */
3987 insnlen = insn_decode_len (contents, content_len, offset);
3993 insnlen = insn_decode_len (contents, content_len, offset + size);
4003 is_alt_relocation (int r_type)
4005 return (r_type >= R_XTENSA_SLOT0_ALT
4006 && r_type <= R_XTENSA_SLOT14_ALT);
4011 is_operand_relocation (int r_type)
4021 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4023 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4032 #define MIN_INSN_LENGTH 2
4034 /* Return 0 if it fails to decode. */
4037 insn_decode_len (bfd_byte *contents,
4038 bfd_size_type content_len,
4039 bfd_size_type offset)
4042 xtensa_isa isa = xtensa_default_isa;
4044 static xtensa_insnbuf ibuff = NULL;
4046 if (offset + MIN_INSN_LENGTH > content_len)
4050 ibuff = xtensa_insnbuf_alloc (isa);
4051 xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
4052 content_len - offset);
4053 fmt = xtensa_format_decode (isa, ibuff);
4054 if (fmt == XTENSA_UNDEFINED)
4056 insn_len = xtensa_format_length (isa, fmt);
4057 if (insn_len == XTENSA_UNDEFINED)
4063 /* Decode the opcode for a single slot instruction.
4064 Return 0 if it fails to decode or the instruction is multi-slot. */
4067 insn_decode_opcode (bfd_byte *contents,
4068 bfd_size_type content_len,
4069 bfd_size_type offset,
4072 xtensa_isa isa = xtensa_default_isa;
4074 static xtensa_insnbuf insnbuf = NULL;
4075 static xtensa_insnbuf slotbuf = NULL;
4077 if (offset + MIN_INSN_LENGTH > content_len)
4078 return XTENSA_UNDEFINED;
4080 if (insnbuf == NULL)
4082 insnbuf = xtensa_insnbuf_alloc (isa);
4083 slotbuf = xtensa_insnbuf_alloc (isa);
4086 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4087 content_len - offset);
4088 fmt = xtensa_format_decode (isa, insnbuf);
4089 if (fmt == XTENSA_UNDEFINED)
4090 return XTENSA_UNDEFINED;
4092 if (slot >= xtensa_format_num_slots (isa, fmt))
4093 return XTENSA_UNDEFINED;
4095 xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4096 return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4100 /* The offset is the offset in the contents.
4101 The address is the address of that offset. */
4104 check_branch_target_aligned (bfd_byte *contents,
4105 bfd_size_type content_length,
4109 bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
4112 return check_branch_target_aligned_address (address, insn_len);
4117 check_loop_aligned (bfd_byte *contents,
4118 bfd_size_type content_length,
4122 bfd_size_type loop_len, insn_len;
4123 xtensa_opcode opcode;
4125 opcode = insn_decode_opcode (contents, content_length, offset, 0);
4126 if (opcode == XTENSA_UNDEFINED
4127 || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
4133 loop_len = insn_decode_len (contents, content_length, offset);
4134 insn_len = insn_decode_len (contents, content_length, offset + loop_len);
4135 if (loop_len == 0 || insn_len == 0)
4141 return check_branch_target_aligned_address (address + loop_len, insn_len);
4146 check_branch_target_aligned_address (bfd_vma addr, int len)
4149 return (addr % 8 == 0);
4150 return ((addr >> 2) == ((addr + len - 1) >> 2));
4154 /* Instruction widening and narrowing. */
4156 /* When FLIX is available we need to access certain instructions only
4157 when they are 16-bit or 24-bit instructions. This table caches
4158 information about such instructions by walking through all the
4159 opcodes and finding the smallest single-slot format into which each
4162 static xtensa_format *op_single_fmt_table = NULL;
4166 init_op_single_format_table (void)
4168 xtensa_isa isa = xtensa_default_isa;
4169 xtensa_insnbuf ibuf;
4170 xtensa_opcode opcode;
4174 if (op_single_fmt_table)
4177 ibuf = xtensa_insnbuf_alloc (isa);
4178 num_opcodes = xtensa_isa_num_opcodes (isa);
4180 op_single_fmt_table = (xtensa_format *)
4181 bfd_malloc (sizeof (xtensa_format) * num_opcodes);
4182 for (opcode = 0; opcode < num_opcodes; opcode++)
4184 op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
4185 for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
4187 if (xtensa_format_num_slots (isa, fmt) == 1
4188 && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
4190 xtensa_opcode old_fmt = op_single_fmt_table[opcode];
4191 int fmt_length = xtensa_format_length (isa, fmt);
4192 if (old_fmt == XTENSA_UNDEFINED
4193 || fmt_length < xtensa_format_length (isa, old_fmt))
4194 op_single_fmt_table[opcode] = fmt;
4198 xtensa_insnbuf_free (isa, ibuf);
4202 static xtensa_format
4203 get_single_format (xtensa_opcode opcode)
4205 init_op_single_format_table ();
4206 return op_single_fmt_table[opcode];
4210 /* For the set of narrowable instructions we do NOT include the
4211 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4212 involved during linker relaxation that may require these to
4213 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4214 requires special case code to ensure it only works when op1 == op2. */
4222 struct string_pair narrowable[] =
4225 { "addi", "addi.n" },
4226 { "addmi", "addi.n" },
4227 { "l32i", "l32i.n" },
4228 { "movi", "movi.n" },
4230 { "retw", "retw.n" },
4231 { "s32i", "s32i.n" },
4232 { "or", "mov.n" } /* special case only when op1 == op2 */
4235 struct string_pair widenable[] =
4238 { "addi", "addi.n" },
4239 { "addmi", "addi.n" },
4240 { "beqz", "beqz.n" },
4241 { "bnez", "bnez.n" },
4242 { "l32i", "l32i.n" },
4243 { "movi", "movi.n" },
4245 { "retw", "retw.n" },
4246 { "s32i", "s32i.n" },
4247 { "or", "mov.n" } /* special case only when op1 == op2 */
4251 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4252 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4253 return the instruction buffer holding the narrow instruction. Otherwise,
4254 return 0. The set of valid narrowing are specified by a string table
4255 but require some special case operand checks in some cases. */
4257 static xtensa_insnbuf
4258 can_narrow_instruction (xtensa_insnbuf slotbuf,
4260 xtensa_opcode opcode)
4262 xtensa_isa isa = xtensa_default_isa;
4263 xtensa_format o_fmt;
4266 static xtensa_insnbuf o_insnbuf = NULL;
4267 static xtensa_insnbuf o_slotbuf = NULL;
4269 if (o_insnbuf == NULL)
4271 o_insnbuf = xtensa_insnbuf_alloc (isa);
4272 o_slotbuf = xtensa_insnbuf_alloc (isa);
4275 for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
4277 bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
4279 if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
4281 uint32 value, newval;
4282 int i, operand_count, o_operand_count;
4283 xtensa_opcode o_opcode;
4285 /* Address does not matter in this case. We might need to
4286 fix it to handle branches/jumps. */
4287 bfd_vma self_address = 0;
4289 o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
4290 if (o_opcode == XTENSA_UNDEFINED)
4292 o_fmt = get_single_format (o_opcode);
4293 if (o_fmt == XTENSA_UNDEFINED)
4296 if (xtensa_format_length (isa, fmt) != 3
4297 || xtensa_format_length (isa, o_fmt) != 2)
4300 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4301 operand_count = xtensa_opcode_num_operands (isa, opcode);
4302 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4304 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4309 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4314 uint32 rawval0, rawval1, rawval2;
4316 if (o_operand_count + 1 != operand_count
4317 || xtensa_operand_get_field (isa, opcode, 0,
4318 fmt, 0, slotbuf, &rawval0) != 0
4319 || xtensa_operand_get_field (isa, opcode, 1,
4320 fmt, 0, slotbuf, &rawval1) != 0
4321 || xtensa_operand_get_field (isa, opcode, 2,
4322 fmt, 0, slotbuf, &rawval2) != 0
4323 || rawval1 != rawval2
4324 || rawval0 == rawval1 /* it is a nop */)
4328 for (i = 0; i < o_operand_count; ++i)
4330 if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
4332 || xtensa_operand_decode (isa, opcode, i, &value))
4335 /* PC-relative branches need adjustment, but
4336 the PC-rel operand will always have a relocation. */
4338 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4340 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4341 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4346 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4356 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4357 the action in-place directly into the contents and return TRUE. Otherwise,
4358 the return value is FALSE and the contents are not modified. */
4361 narrow_instruction (bfd_byte *contents,
4362 bfd_size_type content_length,
4363 bfd_size_type offset)
4365 xtensa_opcode opcode;
4366 bfd_size_type insn_len;
4367 xtensa_isa isa = xtensa_default_isa;
4369 xtensa_insnbuf o_insnbuf;
4371 static xtensa_insnbuf insnbuf = NULL;
4372 static xtensa_insnbuf slotbuf = NULL;
4374 if (insnbuf == NULL)
4376 insnbuf = xtensa_insnbuf_alloc (isa);
4377 slotbuf = xtensa_insnbuf_alloc (isa);
4380 BFD_ASSERT (offset < content_length);
4382 if (content_length < 2)
4385 /* We will hand-code a few of these for a little while.
4386 These have all been specified in the assembler aleady. */
4387 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4388 content_length - offset);
4389 fmt = xtensa_format_decode (isa, insnbuf);
4390 if (xtensa_format_num_slots (isa, fmt) != 1)
4393 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4396 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4397 if (opcode == XTENSA_UNDEFINED)
4399 insn_len = xtensa_format_length (isa, fmt);
4400 if (insn_len > content_length)
4403 o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
4406 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4407 content_length - offset);
4415 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4416 "density" instruction to a standard 3-byte instruction. If it is valid,
4417 return the instruction buffer holding the wide instruction. Otherwise,
4418 return 0. The set of valid widenings are specified by a string table
4419 but require some special case operand checks in some cases. */
4421 static xtensa_insnbuf
4422 can_widen_instruction (xtensa_insnbuf slotbuf,
4424 xtensa_opcode opcode)
4426 xtensa_isa isa = xtensa_default_isa;
4427 xtensa_format o_fmt;
4430 static xtensa_insnbuf o_insnbuf = NULL;
4431 static xtensa_insnbuf o_slotbuf = NULL;
4433 if (o_insnbuf == NULL)
4435 o_insnbuf = xtensa_insnbuf_alloc (isa);
4436 o_slotbuf = xtensa_insnbuf_alloc (isa);
4439 for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
4441 bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
4442 bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
4443 || strcmp ("bnez", widenable[opi].wide) == 0);
4445 if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
4447 uint32 value, newval;
4448 int i, operand_count, o_operand_count, check_operand_count;
4449 xtensa_opcode o_opcode;
4451 /* Address does not matter in this case. We might need to fix it
4452 to handle branches/jumps. */
4453 bfd_vma self_address = 0;
4455 o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
4456 if (o_opcode == XTENSA_UNDEFINED)
4458 o_fmt = get_single_format (o_opcode);
4459 if (o_fmt == XTENSA_UNDEFINED)
4462 if (xtensa_format_length (isa, fmt) != 2
4463 || xtensa_format_length (isa, o_fmt) != 3)
4466 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4467 operand_count = xtensa_opcode_num_operands (isa, opcode);
4468 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4469 check_operand_count = o_operand_count;
4471 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4476 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4481 uint32 rawval0, rawval1;
4483 if (o_operand_count != operand_count + 1
4484 || xtensa_operand_get_field (isa, opcode, 0,
4485 fmt, 0, slotbuf, &rawval0) != 0
4486 || xtensa_operand_get_field (isa, opcode, 1,
4487 fmt, 0, slotbuf, &rawval1) != 0
4488 || rawval0 == rawval1 /* it is a nop */)
4492 check_operand_count--;
4494 for (i = 0; i < check_operand_count; i++)
4497 if (is_or && i == o_operand_count - 1)
4499 if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
4501 || xtensa_operand_decode (isa, opcode, new_i, &value))
4504 /* PC-relative branches need adjustment, but
4505 the PC-rel operand will always have a relocation. */
4507 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4509 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4510 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4515 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4525 /* Attempt to widen an instruction. If the widening is valid, perform
4526 the action in-place directly into the contents and return TRUE. Otherwise,
4527 the return value is FALSE and the contents are not modified. */
4530 widen_instruction (bfd_byte *contents,
4531 bfd_size_type content_length,
4532 bfd_size_type offset)
4534 xtensa_opcode opcode;
4535 bfd_size_type insn_len;
4536 xtensa_isa isa = xtensa_default_isa;
4538 xtensa_insnbuf o_insnbuf;
4540 static xtensa_insnbuf insnbuf = NULL;
4541 static xtensa_insnbuf slotbuf = NULL;
4543 if (insnbuf == NULL)
4545 insnbuf = xtensa_insnbuf_alloc (isa);
4546 slotbuf = xtensa_insnbuf_alloc (isa);
4549 BFD_ASSERT (offset < content_length);
4551 if (content_length < 2)
4554 /* We will hand-code a few of these for a little while.
4555 These have all been specified in the assembler aleady. */
4556 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4557 content_length - offset);
4558 fmt = xtensa_format_decode (isa, insnbuf);
4559 if (xtensa_format_num_slots (isa, fmt) != 1)
4562 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4565 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4566 if (opcode == XTENSA_UNDEFINED)
4568 insn_len = xtensa_format_length (isa, fmt);
4569 if (insn_len > content_length)
4572 o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
4575 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4576 content_length - offset);
4583 /* Code for transforming CALLs at link-time. */
4585 static bfd_reloc_status_type
4586 elf_xtensa_do_asm_simplify (bfd_byte *contents,
4588 bfd_vma content_length,
4589 char **error_message)
4591 static xtensa_insnbuf insnbuf = NULL;
4592 static xtensa_insnbuf slotbuf = NULL;
4593 xtensa_format core_format = XTENSA_UNDEFINED;
4594 xtensa_opcode opcode;
4595 xtensa_opcode direct_call_opcode;
4596 xtensa_isa isa = xtensa_default_isa;
4597 bfd_byte *chbuf = contents + address;
4600 if (insnbuf == NULL)
4602 insnbuf = xtensa_insnbuf_alloc (isa);
4603 slotbuf = xtensa_insnbuf_alloc (isa);
4606 if (content_length < address)
4608 *error_message = _("attempt to convert L32R/CALLX to CALL failed");
4609 return bfd_reloc_other;
4612 opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
4613 direct_call_opcode = swap_callx_for_call_opcode (opcode);
4614 if (direct_call_opcode == XTENSA_UNDEFINED)
4616 *error_message = _("attempt to convert L32R/CALLX to CALL failed");
4617 return bfd_reloc_other;
4620 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4621 core_format = xtensa_format_lookup (isa, "x24");
4622 opcode = xtensa_opcode_lookup (isa, "or");
4623 xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
4624 for (opn = 0; opn < 3; opn++)
4627 xtensa_operand_encode (isa, opcode, opn, ®no);
4628 xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
4631 xtensa_format_encode (isa, core_format, insnbuf);
4632 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4633 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
4635 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4636 xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
4637 xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
4639 xtensa_format_encode (isa, core_format, insnbuf);
4640 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4641 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
4642 content_length - address - 3);
4644 return bfd_reloc_ok;
4648 static bfd_reloc_status_type
4649 contract_asm_expansion (bfd_byte *contents,
4650 bfd_vma content_length,
4651 Elf_Internal_Rela *irel,
4652 char **error_message)
4654 bfd_reloc_status_type retval =
4655 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
4658 if (retval != bfd_reloc_ok)
4659 return bfd_reloc_dangerous;
4661 /* Update the irel->r_offset field so that the right immediate and
4662 the right instruction are modified during the relocation. */
4663 irel->r_offset += 3;
4664 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
4665 return bfd_reloc_ok;
4669 static xtensa_opcode
4670 swap_callx_for_call_opcode (xtensa_opcode opcode)
4672 init_call_opcodes ();
4674 if (opcode == callx0_op) return call0_op;
4675 if (opcode == callx4_op) return call4_op;
4676 if (opcode == callx8_op) return call8_op;
4677 if (opcode == callx12_op) return call12_op;
4679 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4680 return XTENSA_UNDEFINED;
4684 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4685 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4686 If not, return XTENSA_UNDEFINED. */
4688 #define L32R_TARGET_REG_OPERAND 0
4689 #define CONST16_TARGET_REG_OPERAND 0
4690 #define CALLN_SOURCE_OPERAND 0
4692 static xtensa_opcode
4693 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
4695 static xtensa_insnbuf insnbuf = NULL;
4696 static xtensa_insnbuf slotbuf = NULL;
4698 xtensa_opcode opcode;
4699 xtensa_isa isa = xtensa_default_isa;
4700 uint32 regno, const16_regno, call_regno;
4703 if (insnbuf == NULL)
4705 insnbuf = xtensa_insnbuf_alloc (isa);
4706 slotbuf = xtensa_insnbuf_alloc (isa);
4709 xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4710 fmt = xtensa_format_decode (isa, insnbuf);
4711 if (fmt == XTENSA_UNDEFINED
4712 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4713 return XTENSA_UNDEFINED;
4715 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4716 if (opcode == XTENSA_UNDEFINED)
4717 return XTENSA_UNDEFINED;
4719 if (opcode == get_l32r_opcode ())
4722 *p_uses_l32r = TRUE;
4723 if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4724 fmt, 0, slotbuf, ®no)
4725 || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4727 return XTENSA_UNDEFINED;
4729 else if (opcode == get_const16_opcode ())
4732 *p_uses_l32r = FALSE;
4733 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4734 fmt, 0, slotbuf, ®no)
4735 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4737 return XTENSA_UNDEFINED;
4739 /* Check that the next instruction is also CONST16. */
4740 offset += xtensa_format_length (isa, fmt);
4741 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4742 fmt = xtensa_format_decode (isa, insnbuf);
4743 if (fmt == XTENSA_UNDEFINED
4744 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4745 return XTENSA_UNDEFINED;
4746 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4747 if (opcode != get_const16_opcode ())
4748 return XTENSA_UNDEFINED;
4750 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4751 fmt, 0, slotbuf, &const16_regno)
4752 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4754 || const16_regno != regno)
4755 return XTENSA_UNDEFINED;
4758 return XTENSA_UNDEFINED;
4760 /* Next instruction should be an CALLXn with operand 0 == regno. */
4761 offset += xtensa_format_length (isa, fmt);
4762 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4763 fmt = xtensa_format_decode (isa, insnbuf);
4764 if (fmt == XTENSA_UNDEFINED
4765 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4766 return XTENSA_UNDEFINED;
4767 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4768 if (opcode == XTENSA_UNDEFINED
4769 || !is_indirect_call_opcode (opcode))
4770 return XTENSA_UNDEFINED;
4772 if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4773 fmt, 0, slotbuf, &call_regno)
4774 || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4776 return XTENSA_UNDEFINED;
4778 if (call_regno != regno)
4779 return XTENSA_UNDEFINED;
4785 /* Data structures used during relaxation. */
4787 /* r_reloc: relocation values. */
4789 /* Through the relaxation process, we need to keep track of the values
4790 that will result from evaluating relocations. The standard ELF
4791 relocation structure is not sufficient for this purpose because we're
4792 operating on multiple input files at once, so we need to know which
4793 input file a relocation refers to. The r_reloc structure thus
4794 records both the input file (bfd) and ELF relocation.
4796 For efficiency, an r_reloc also contains a "target_offset" field to
4797 cache the target-section-relative offset value that is represented by
4800 The r_reloc also contains a virtual offset that allows multiple
4801 inserted literals to be placed at the same "address" with
4802 different offsets. */
4804 typedef struct r_reloc_struct r_reloc;
4806 struct r_reloc_struct
4809 Elf_Internal_Rela rela;
4810 bfd_vma target_offset;
4811 bfd_vma virtual_offset;
4815 /* The r_reloc structure is included by value in literal_value, but not
4816 every literal_value has an associated relocation -- some are simple
4817 constants. In such cases, we set all the fields in the r_reloc
4818 struct to zero. The r_reloc_is_const function should be used to
4819 detect this case. */
4822 r_reloc_is_const (const r_reloc *r_rel)
4824 return (r_rel->abfd == NULL);
4829 r_reloc_get_target_offset (const r_reloc *r_rel)
4831 bfd_vma target_offset;
4832 unsigned long r_symndx;
4834 BFD_ASSERT (!r_reloc_is_const (r_rel));
4835 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4836 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4837 return (target_offset + r_rel->rela.r_addend);
4841 static struct elf_link_hash_entry *
4842 r_reloc_get_hash_entry (const r_reloc *r_rel)
4844 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4845 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4850 r_reloc_get_section (const r_reloc *r_rel)
4852 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4853 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4858 r_reloc_is_defined (const r_reloc *r_rel)
4864 sec = r_reloc_get_section (r_rel);
4865 if (sec == bfd_abs_section_ptr
4866 || sec == bfd_com_section_ptr
4867 || sec == bfd_und_section_ptr)
4874 r_reloc_init (r_reloc *r_rel,
4876 Elf_Internal_Rela *irel,
4878 bfd_size_type content_length)
4881 reloc_howto_type *howto;
4885 r_rel->rela = *irel;
4887 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
4888 r_rel->virtual_offset = 0;
4889 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
4890 howto = &elf_howto_table[r_type];
4891 if (howto->partial_inplace)
4893 bfd_vma inplace_val;
4894 BFD_ASSERT (r_rel->rela.r_offset < content_length);
4896 inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
4897 r_rel->target_offset += inplace_val;
4901 memset (r_rel, 0, sizeof (r_reloc));
4908 print_r_reloc (FILE *fp, const r_reloc *r_rel)
4910 if (r_reloc_is_defined (r_rel))
4912 asection *sec = r_reloc_get_section (r_rel);
4913 fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
4915 else if (r_reloc_get_hash_entry (r_rel))
4916 fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
4918 fprintf (fp, " ?? + ");
4920 fprintf_vma (fp, r_rel->target_offset);
4921 if (r_rel->virtual_offset)
4923 fprintf (fp, " + ");
4924 fprintf_vma (fp, r_rel->virtual_offset);
4933 /* source_reloc: relocations that reference literals. */
4935 /* To determine whether literals can be coalesced, we need to first
4936 record all the relocations that reference the literals. The
4937 source_reloc structure below is used for this purpose. The
4938 source_reloc entries are kept in a per-literal-section array, sorted
4939 by offset within the literal section (i.e., target offset).
4941 The source_sec and r_rel.rela.r_offset fields identify the source of
4942 the relocation. The r_rel field records the relocation value, i.e.,
4943 the offset of the literal being referenced. The opnd field is needed
4944 to determine the range of the immediate field to which the relocation
4945 applies, so we can determine whether another literal with the same
4946 value is within range. The is_null field is true when the relocation
4947 is being removed (e.g., when an L32R is being removed due to a CALLX
4948 that is converted to a direct CALL). */
4950 typedef struct source_reloc_struct source_reloc;
4952 struct source_reloc_struct
4954 asection *source_sec;
4956 xtensa_opcode opcode;
4958 bfd_boolean is_null;
4959 bfd_boolean is_abs_literal;
4964 init_source_reloc (source_reloc *reloc,
4965 asection *source_sec,
4966 const r_reloc *r_rel,
4967 xtensa_opcode opcode,
4969 bfd_boolean is_abs_literal)
4971 reloc->source_sec = source_sec;
4972 reloc->r_rel = *r_rel;
4973 reloc->opcode = opcode;
4975 reloc->is_null = FALSE;
4976 reloc->is_abs_literal = is_abs_literal;
4980 /* Find the source_reloc for a particular source offset and relocation
4981 type. Note that the array is sorted by _target_ offset, so this is
4982 just a linear search. */
4984 static source_reloc *
4985 find_source_reloc (source_reloc *src_relocs,
4988 Elf_Internal_Rela *irel)
4992 for (i = 0; i < src_count; i++)
4994 if (src_relocs[i].source_sec == sec
4995 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
4996 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
4997 == ELF32_R_TYPE (irel->r_info)))
4998 return &src_relocs[i];
5006 source_reloc_compare (const void *ap, const void *bp)
5008 const source_reloc *a = (const source_reloc *) ap;
5009 const source_reloc *b = (const source_reloc *) bp;
5011 if (a->r_rel.target_offset != b->r_rel.target_offset)
5012 return (a->r_rel.target_offset - b->r_rel.target_offset);
5014 /* We don't need to sort on these criteria for correctness,
5015 but enforcing a more strict ordering prevents unstable qsort
5016 from behaving differently with different implementations.
5017 Without the code below we get correct but different results
5018 on Solaris 2.7 and 2.8. We would like to always produce the
5019 same results no matter the host. */
5021 if ((!a->is_null) - (!b->is_null))
5022 return ((!a->is_null) - (!b->is_null));
5023 return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
5027 /* Literal values and value hash tables. */
5029 /* Literals with the same value can be coalesced. The literal_value
5030 structure records the value of a literal: the "r_rel" field holds the
5031 information from the relocation on the literal (if there is one) and
5032 the "value" field holds the contents of the literal word itself.
5034 The value_map structure records a literal value along with the
5035 location of a literal holding that value. The value_map hash table
5036 is indexed by the literal value, so that we can quickly check if a
5037 particular literal value has been seen before and is thus a candidate
5040 typedef struct literal_value_struct literal_value;
5041 typedef struct value_map_struct value_map;
5042 typedef struct value_map_hash_table_struct value_map_hash_table;
5044 struct literal_value_struct
5047 unsigned long value;
5048 bfd_boolean is_abs_literal;
5051 struct value_map_struct
5053 literal_value val; /* The literal value. */
5054 r_reloc loc; /* Location of the literal. */
5058 struct value_map_hash_table_struct
5060 unsigned bucket_count;
5061 value_map **buckets;
5063 bfd_boolean has_last_loc;
5069 init_literal_value (literal_value *lit,
5070 const r_reloc *r_rel,
5071 unsigned long value,
5072 bfd_boolean is_abs_literal)
5074 lit->r_rel = *r_rel;
5076 lit->is_abs_literal = is_abs_literal;
5081 literal_value_equal (const literal_value *src1,
5082 const literal_value *src2,
5083 bfd_boolean final_static_link)
5085 struct elf_link_hash_entry *h1, *h2;
5087 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
5090 if (r_reloc_is_const (&src1->r_rel))
5091 return (src1->value == src2->value);
5093 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
5094 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
5097 if (src1->r_rel.target_offset != src2->r_rel.target_offset)
5100 if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
5103 if (src1->value != src2->value)
5106 /* Now check for the same section (if defined) or the same elf_hash
5107 (if undefined or weak). */
5108 h1 = r_reloc_get_hash_entry (&src1->r_rel);
5109 h2 = r_reloc_get_hash_entry (&src2->r_rel);
5110 if (r_reloc_is_defined (&src1->r_rel)
5111 && (final_static_link
5112 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
5113 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
5115 if (r_reloc_get_section (&src1->r_rel)
5116 != r_reloc_get_section (&src2->r_rel))
5121 /* Require that the hash entries (i.e., symbols) be identical. */
5122 if (h1 != h2 || h1 == 0)
5126 if (src1->is_abs_literal != src2->is_abs_literal)
5133 /* Must be power of 2. */
5134 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5136 static value_map_hash_table *
5137 value_map_hash_table_init (void)
5139 value_map_hash_table *values;
5141 values = (value_map_hash_table *)
5142 bfd_zmalloc (sizeof (value_map_hash_table));
5143 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
5145 values->buckets = (value_map **)
5146 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
5147 if (values->buckets == NULL)
5152 values->has_last_loc = FALSE;
5159 value_map_hash_table_delete (value_map_hash_table *table)
5161 free (table->buckets);
5167 hash_bfd_vma (bfd_vma val)
5169 return (val >> 2) + (val >> 10);
5174 literal_value_hash (const literal_value *src)
5178 hash_val = hash_bfd_vma (src->value);
5179 if (!r_reloc_is_const (&src->r_rel))
5183 hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
5184 hash_val += hash_bfd_vma (src->r_rel.target_offset);
5185 hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
5187 /* Now check for the same section and the same elf_hash. */
5188 if (r_reloc_is_defined (&src->r_rel))
5189 sec_or_hash = r_reloc_get_section (&src->r_rel);
5191 sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
5192 hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
5198 /* Check if the specified literal_value has been seen before. */
5201 value_map_get_cached_value (value_map_hash_table *map,
5202 const literal_value *val,
5203 bfd_boolean final_static_link)
5209 idx = literal_value_hash (val);
5210 idx = idx & (map->bucket_count - 1);
5211 bucket = map->buckets[idx];
5212 for (map_e = bucket; map_e; map_e = map_e->next)
5214 if (literal_value_equal (&map_e->val, val, final_static_link))
5221 /* Record a new literal value. It is illegal to call this if VALUE
5222 already has an entry here. */
5225 add_value_map (value_map_hash_table *map,
5226 const literal_value *val,
5228 bfd_boolean final_static_link)
5230 value_map **bucket_p;
5233 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
5236 bfd_set_error (bfd_error_no_memory);
5240 BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
5244 idx = literal_value_hash (val);
5245 idx = idx & (map->bucket_count - 1);
5246 bucket_p = &map->buckets[idx];
5248 val_e->next = *bucket_p;
5251 /* FIXME: Consider resizing the hash table if we get too many entries. */
5257 /* Lists of text actions (ta_) for narrowing, widening, longcall
5258 conversion, space fill, code & literal removal, etc. */
5260 /* The following text actions are generated:
5262 "ta_remove_insn" remove an instruction or instructions
5263 "ta_remove_longcall" convert longcall to call
5264 "ta_convert_longcall" convert longcall to nop/call
5265 "ta_narrow_insn" narrow a wide instruction
5266 "ta_widen" widen a narrow instruction
5267 "ta_fill" add fill or remove fill
5268 removed < 0 is a fill; branches to the fill address will be
5269 changed to address + fill size (e.g., address - removed)
5270 removed >= 0 branches to the fill address will stay unchanged
5271 "ta_remove_literal" remove a literal; this action is
5272 indicated when a literal is removed
5274 "ta_add_literal" insert a new literal; this action is
5275 indicated when a literal has been moved.
5276 It may use a virtual_offset because
5277 multiple literals can be placed at the
5280 For each of these text actions, we also record the number of bytes
5281 removed by performing the text action. In the case of a "ta_widen"
5282 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5284 typedef struct text_action_struct text_action;
5285 typedef struct text_action_list_struct text_action_list;
5286 typedef enum text_action_enum_t text_action_t;
5288 enum text_action_enum_t
5291 ta_remove_insn, /* removed = -size */
5292 ta_remove_longcall, /* removed = -size */
5293 ta_convert_longcall, /* removed = 0 */
5294 ta_narrow_insn, /* removed = -1 */
5295 ta_widen_insn, /* removed = +1 */
5296 ta_fill, /* removed = +size */
5302 /* Structure for a text action record. */
5303 struct text_action_struct
5305 text_action_t action;
5306 asection *sec; /* Optional */
5308 bfd_vma virtual_offset; /* Zero except for adding literals. */
5310 literal_value value; /* Only valid when adding literals. */
5313 struct removal_by_action_entry_struct
5318 int eq_removed_before_fill;
5320 typedef struct removal_by_action_entry_struct removal_by_action_entry;
5322 struct removal_by_action_map_struct
5325 removal_by_action_entry *entry;
5327 typedef struct removal_by_action_map_struct removal_by_action_map;
5330 /* List of all of the actions taken on a text section. */
5331 struct text_action_list_struct
5335 removal_by_action_map map;
5339 static text_action *
5340 find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
5344 /* It is not necessary to fill at the end of a section. */
5345 if (sec->size == offset)
5351 splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
5353 return (text_action *)node->value;
5359 compute_removed_action_diff (const text_action *ta,
5363 int removable_space)
5366 int current_removed = 0;
5369 current_removed = ta->removed_bytes;
5371 BFD_ASSERT (ta == NULL || ta->offset == offset);
5372 BFD_ASSERT (ta == NULL || ta->action == ta_fill);
5374 /* It is not necessary to fill at the end of a section. Clean this up. */
5375 if (sec->size == offset)
5376 new_removed = removable_space - 0;
5380 int added = -removed - current_removed;
5381 /* Ignore multiples of the section alignment. */
5382 added = ((1 << sec->alignment_power) - 1) & added;
5383 new_removed = (-added);
5385 /* Modify for removable. */
5386 space = removable_space - new_removed;
5387 new_removed = (removable_space
5388 - (((1 << sec->alignment_power) - 1) & space));
5390 return (new_removed - current_removed);
5395 adjust_fill_action (text_action *ta, int fill_diff)
5397 ta->removed_bytes += fill_diff;
5402 text_action_compare (splay_tree_key a, splay_tree_key b)
5404 text_action *pa = (text_action *)a;
5405 text_action *pb = (text_action *)b;
5406 static const int action_priority[] =
5410 [ta_convert_longcall] = 2,
5411 [ta_narrow_insn] = 3,
5412 [ta_remove_insn] = 4,
5413 [ta_remove_longcall] = 5,
5414 [ta_remove_literal] = 6,
5415 [ta_widen_insn] = 7,
5416 [ta_add_literal] = 8,
5419 if (pa->offset == pb->offset)
5421 if (pa->action == pb->action)
5423 return action_priority[pa->action] - action_priority[pb->action];
5426 return pa->offset < pb->offset ? -1 : 1;
5429 static text_action *
5430 action_first (text_action_list *action_list)
5432 splay_tree_node node = splay_tree_min (action_list->tree);
5433 return node ? (text_action *)node->value : NULL;
5436 static text_action *
5437 action_next (text_action_list *action_list, text_action *action)
5439 splay_tree_node node = splay_tree_successor (action_list->tree,
5440 (splay_tree_key)action);
5441 return node ? (text_action *)node->value : NULL;
5444 /* Add a modification action to the text. For the case of adding or
5445 removing space, modify any current fill and assume that
5446 "unreachable_space" bytes can be freely contracted. Note that a
5447 negative removed value is a fill. */
5450 text_action_add (text_action_list *l,
5451 text_action_t action,
5459 /* It is not necessary to fill at the end of a section. */
5460 if (action == ta_fill && sec->size == offset)
5463 /* It is not necessary to fill 0 bytes. */
5464 if (action == ta_fill && removed == 0)
5470 if (action == ta_fill)
5472 splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a);
5476 ta = (text_action *)node->value;
5477 ta->removed_bytes += removed;
5482 BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)&a) == NULL);
5484 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5485 ta->action = action;
5487 ta->offset = offset;
5488 ta->removed_bytes = removed;
5489 splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
5495 text_action_add_literal (text_action_list *l,
5496 text_action_t action,
5498 const literal_value *value,
5502 asection *sec = r_reloc_get_section (loc);
5503 bfd_vma offset = loc->target_offset;
5504 bfd_vma virtual_offset = loc->virtual_offset;
5506 BFD_ASSERT (action == ta_add_literal);
5508 /* Create a new record and fill it up. */
5509 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5510 ta->action = action;
5512 ta->offset = offset;
5513 ta->virtual_offset = virtual_offset;
5515 ta->removed_bytes = removed;
5517 BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)ta) == NULL);
5518 splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta);
5523 /* Find the total offset adjustment for the relaxations specified by
5524 text_actions, beginning from a particular starting action. This is
5525 typically used from offset_with_removed_text to search an entire list of
5526 actions, but it may also be called directly when adjusting adjacent offsets
5527 so that each search may begin where the previous one left off. */
5530 removed_by_actions (text_action_list *action_list,
5531 text_action **p_start_action,
5533 bfd_boolean before_fill)
5538 r = *p_start_action;
5541 splay_tree_node node = splay_tree_lookup (action_list->tree,
5543 BFD_ASSERT (node != NULL && r == (text_action *)node->value);
5548 if (r->offset > offset)
5551 if (r->offset == offset
5552 && (before_fill || r->action != ta_fill || r->removed_bytes >= 0))
5555 removed += r->removed_bytes;
5557 r = action_next (action_list, r);
5560 *p_start_action = r;
5566 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
5568 text_action *r = action_first (action_list);
5570 return offset - removed_by_actions (action_list, &r, offset, FALSE);
5575 action_list_count (text_action_list *action_list)
5577 return action_list->count;
5580 typedef struct map_action_fn_context_struct map_action_fn_context;
5581 struct map_action_fn_context_struct
5584 removal_by_action_map map;
5585 bfd_boolean eq_complete;
5589 map_action_fn (splay_tree_node node, void *p)
5591 map_action_fn_context *ctx = p;
5592 text_action *r = (text_action *)node->value;
5593 removal_by_action_entry *ientry = ctx->map.entry + ctx->map.n_entries;
5595 if (ctx->map.n_entries && (ientry - 1)->offset == r->offset)
5601 ++ctx->map.n_entries;
5602 ctx->eq_complete = FALSE;
5603 ientry->offset = r->offset;
5604 ientry->eq_removed_before_fill = ctx->removed;
5607 if (!ctx->eq_complete)
5609 if (r->action != ta_fill || r->removed_bytes >= 0)
5611 ientry->eq_removed = ctx->removed;
5612 ctx->eq_complete = TRUE;
5615 ientry->eq_removed = ctx->removed + r->removed_bytes;
5618 ctx->removed += r->removed_bytes;
5619 ientry->removed = ctx->removed;
5624 map_removal_by_action (text_action_list *action_list)
5626 map_action_fn_context ctx;
5629 ctx.map.n_entries = 0;
5630 ctx.map.entry = bfd_malloc (action_list_count (action_list) *
5631 sizeof (removal_by_action_entry));
5632 ctx.eq_complete = FALSE;
5634 splay_tree_foreach (action_list->tree, map_action_fn, &ctx);
5635 action_list->map = ctx.map;
5639 removed_by_actions_map (text_action_list *action_list, bfd_vma offset,
5640 bfd_boolean before_fill)
5644 if (!action_list->map.entry)
5645 map_removal_by_action (action_list);
5647 if (!action_list->map.n_entries)
5651 b = action_list->map.n_entries;
5655 unsigned c = (a + b) / 2;
5657 if (action_list->map.entry[c].offset <= offset)
5663 if (action_list->map.entry[a].offset < offset)
5665 return action_list->map.entry[a].removed;
5667 else if (action_list->map.entry[a].offset == offset)
5669 return before_fill ?
5670 action_list->map.entry[a].eq_removed_before_fill :
5671 action_list->map.entry[a].eq_removed;
5680 offset_with_removed_text_map (text_action_list *action_list, bfd_vma offset)
5682 int removed = removed_by_actions_map (action_list, offset, FALSE);
5683 return offset - removed;
5687 /* The find_insn_action routine will only find non-fill actions. */
5689 static text_action *
5690 find_insn_action (text_action_list *action_list, bfd_vma offset)
5692 static const text_action_t action[] =
5694 ta_convert_longcall,
5704 for (i = 0; i < sizeof (action) / sizeof (*action); ++i)
5706 splay_tree_node node;
5708 a.action = action[i];
5709 node = splay_tree_lookup (action_list->tree, (splay_tree_key)&a);
5711 return (text_action *)node->value;
5720 print_action (FILE *fp, text_action *r)
5722 const char *t = "unknown";
5725 case ta_remove_insn:
5726 t = "remove_insn"; break;
5727 case ta_remove_longcall:
5728 t = "remove_longcall"; break;
5729 case ta_convert_longcall:
5730 t = "convert_longcall"; break;
5731 case ta_narrow_insn:
5732 t = "narrow_insn"; break;
5734 t = "widen_insn"; break;
5739 case ta_remove_literal:
5740 t = "remove_literal"; break;
5741 case ta_add_literal:
5742 t = "add_literal"; break;
5745 fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
5746 r->sec->owner->filename,
5747 r->sec->name, (unsigned long) r->offset, t, r->removed_bytes);
5751 print_action_list_fn (splay_tree_node node, void *p)
5753 text_action *r = (text_action *)node->value;
5755 print_action (p, r);
5760 print_action_list (FILE *fp, text_action_list *action_list)
5762 fprintf (fp, "Text Action\n");
5763 splay_tree_foreach (action_list->tree, print_action_list_fn, fp);
5769 /* Lists of literals being coalesced or removed. */
5771 /* In the usual case, the literal identified by "from" is being
5772 coalesced with another literal identified by "to". If the literal is
5773 unused and is being removed altogether, "to.abfd" will be NULL.
5774 The removed_literal entries are kept on a per-section list, sorted
5775 by the "from" offset field. */
5777 typedef struct removed_literal_struct removed_literal;
5778 typedef struct removed_literal_map_entry_struct removed_literal_map_entry;
5779 typedef struct removed_literal_list_struct removed_literal_list;
5781 struct removed_literal_struct
5785 removed_literal *next;
5788 struct removed_literal_map_entry_struct
5791 removed_literal *literal;
5794 struct removed_literal_list_struct
5796 removed_literal *head;
5797 removed_literal *tail;
5800 removed_literal_map_entry *map;
5804 /* Record that the literal at "from" is being removed. If "to" is not
5805 NULL, the "from" literal is being coalesced with the "to" literal. */
5808 add_removed_literal (removed_literal_list *removed_list,
5809 const r_reloc *from,
5812 removed_literal *r, *new_r, *next_r;
5814 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
5816 new_r->from = *from;
5820 new_r->to.abfd = NULL;
5823 r = removed_list->head;
5826 removed_list->head = new_r;
5827 removed_list->tail = new_r;
5829 /* Special check for common case of append. */
5830 else if (removed_list->tail->from.target_offset < from->target_offset)
5832 removed_list->tail->next = new_r;
5833 removed_list->tail = new_r;
5837 while (r->from.target_offset < from->target_offset && r->next)
5843 new_r->next = next_r;
5845 removed_list->tail = new_r;
5850 map_removed_literal (removed_literal_list *removed_list)
5854 removed_literal_map_entry *map = NULL;
5855 removed_literal *r = removed_list->head;
5857 for (i = 0; r; ++i, r = r->next)
5861 n_map = (n_map * 2) + 2;
5862 map = bfd_realloc (map, n_map * sizeof (*map));
5864 map[i].addr = r->from.target_offset;
5867 removed_list->map = map;
5868 removed_list->n_map = i;
5872 removed_literal_compare (const void *a, const void *b)
5874 const removed_literal_map_entry *pa = a;
5875 const removed_literal_map_entry *pb = b;
5877 if (pa->addr == pb->addr)
5880 return pa->addr < pb->addr ? -1 : 1;
5883 /* Check if the list of removed literals contains an entry for the
5884 given address. Return the entry if found. */
5886 static removed_literal *
5887 find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
5889 removed_literal_map_entry *p;
5890 removed_literal *r = NULL;
5892 if (removed_list->map == NULL)
5893 map_removed_literal (removed_list);
5895 p = bsearch (&addr, removed_list->map, removed_list->n_map,
5896 sizeof (*removed_list->map), removed_literal_compare);
5899 while (p != removed_list->map && (p - 1)->addr == addr)
5910 print_removed_literals (FILE *fp, removed_literal_list *removed_list)
5913 r = removed_list->head;
5915 fprintf (fp, "Removed Literals\n");
5916 for (; r != NULL; r = r->next)
5918 print_r_reloc (fp, &r->from);
5919 fprintf (fp, " => ");
5920 if (r->to.abfd == NULL)
5921 fprintf (fp, "REMOVED");
5923 print_r_reloc (fp, &r->to);
5931 /* Per-section data for relaxation. */
5933 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
5935 struct xtensa_relax_info_struct
5937 bfd_boolean is_relaxable_literal_section;
5938 bfd_boolean is_relaxable_asm_section;
5939 int visited; /* Number of times visited. */
5941 source_reloc *src_relocs; /* Array[src_count]. */
5943 int src_next; /* Next src_relocs entry to assign. */
5945 removed_literal_list removed_list;
5946 text_action_list action_list;
5948 reloc_bfd_fix *fix_list;
5949 reloc_bfd_fix *fix_array;
5950 unsigned fix_array_count;
5952 /* Support for expanding the reloc array that is stored
5953 in the section structure. If the relocations have been
5954 reallocated, the newly allocated relocations will be referenced
5955 here along with the actual size allocated. The relocation
5956 count will always be found in the section structure. */
5957 Elf_Internal_Rela *allocated_relocs;
5958 unsigned relocs_count;
5959 unsigned allocated_relocs_count;
5962 struct elf_xtensa_section_data
5964 struct bfd_elf_section_data elf;
5965 xtensa_relax_info relax_info;
5970 elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
5972 if (!sec->used_by_bfd)
5974 struct elf_xtensa_section_data *sdata;
5975 bfd_size_type amt = sizeof (*sdata);
5977 sdata = bfd_zalloc (abfd, amt);
5980 sec->used_by_bfd = sdata;
5983 return _bfd_elf_new_section_hook (abfd, sec);
5987 static xtensa_relax_info *
5988 get_xtensa_relax_info (asection *sec)
5990 struct elf_xtensa_section_data *section_data;
5992 /* No info available if no section or if it is an output section. */
5993 if (!sec || sec == sec->output_section)
5996 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
5997 return §ion_data->relax_info;
6002 init_xtensa_relax_info (asection *sec)
6004 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6006 relax_info->is_relaxable_literal_section = FALSE;
6007 relax_info->is_relaxable_asm_section = FALSE;
6008 relax_info->visited = 0;
6010 relax_info->src_relocs = NULL;
6011 relax_info->src_count = 0;
6012 relax_info->src_next = 0;
6014 relax_info->removed_list.head = NULL;
6015 relax_info->removed_list.tail = NULL;
6017 relax_info->action_list.tree = splay_tree_new (text_action_compare,
6019 relax_info->action_list.map.n_entries = 0;
6020 relax_info->action_list.map.entry = NULL;
6022 relax_info->fix_list = NULL;
6023 relax_info->fix_array = NULL;
6024 relax_info->fix_array_count = 0;
6026 relax_info->allocated_relocs = NULL;
6027 relax_info->relocs_count = 0;
6028 relax_info->allocated_relocs_count = 0;
6032 /* Coalescing literals may require a relocation to refer to a section in
6033 a different input file, but the standard relocation information
6034 cannot express that. Instead, the reloc_bfd_fix structures are used
6035 to "fix" the relocations that refer to sections in other input files.
6036 These structures are kept on per-section lists. The "src_type" field
6037 records the relocation type in case there are multiple relocations on
6038 the same location. FIXME: This is ugly; an alternative might be to
6039 add new symbols with the "owner" field to some other input file. */
6041 struct reloc_bfd_fix_struct
6045 unsigned src_type; /* Relocation type. */
6047 asection *target_sec;
6048 bfd_vma target_offset;
6049 bfd_boolean translated;
6051 reloc_bfd_fix *next;
6055 static reloc_bfd_fix *
6056 reloc_bfd_fix_init (asection *src_sec,
6059 asection *target_sec,
6060 bfd_vma target_offset,
6061 bfd_boolean translated)
6065 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
6066 fix->src_sec = src_sec;
6067 fix->src_offset = src_offset;
6068 fix->src_type = src_type;
6069 fix->target_sec = target_sec;
6070 fix->target_offset = target_offset;
6071 fix->translated = translated;
6078 add_fix (asection *src_sec, reloc_bfd_fix *fix)
6080 xtensa_relax_info *relax_info;
6082 relax_info = get_xtensa_relax_info (src_sec);
6083 fix->next = relax_info->fix_list;
6084 relax_info->fix_list = fix;
6089 fix_compare (const void *ap, const void *bp)
6091 const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
6092 const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
6094 if (a->src_offset != b->src_offset)
6095 return (a->src_offset - b->src_offset);
6096 return (a->src_type - b->src_type);
6101 cache_fix_array (asection *sec)
6103 unsigned i, count = 0;
6105 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6107 if (relax_info == NULL)
6109 if (relax_info->fix_list == NULL)
6112 for (r = relax_info->fix_list; r != NULL; r = r->next)
6115 relax_info->fix_array =
6116 (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
6117 relax_info->fix_array_count = count;
6119 r = relax_info->fix_list;
6120 for (i = 0; i < count; i++, r = r->next)
6122 relax_info->fix_array[count - 1 - i] = *r;
6123 relax_info->fix_array[count - 1 - i].next = NULL;
6126 qsort (relax_info->fix_array, relax_info->fix_array_count,
6127 sizeof (reloc_bfd_fix), fix_compare);
6131 static reloc_bfd_fix *
6132 get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
6134 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6138 if (relax_info == NULL)
6140 if (relax_info->fix_list == NULL)
6143 if (relax_info->fix_array == NULL)
6144 cache_fix_array (sec);
6146 key.src_offset = offset;
6147 key.src_type = type;
6148 rv = bsearch (&key, relax_info->fix_array, relax_info->fix_array_count,
6149 sizeof (reloc_bfd_fix), fix_compare);
6154 /* Section caching. */
6156 typedef struct section_cache_struct section_cache_t;
6158 struct section_cache_struct
6162 bfd_byte *contents; /* Cache of the section contents. */
6163 bfd_size_type content_length;
6165 property_table_entry *ptbl; /* Cache of the section property table. */
6168 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6169 unsigned reloc_count;
6174 init_section_cache (section_cache_t *sec_cache)
6176 memset (sec_cache, 0, sizeof (*sec_cache));
6181 free_section_cache (section_cache_t *sec_cache)
6185 release_contents (sec_cache->sec, sec_cache->contents);
6186 release_internal_relocs (sec_cache->sec, sec_cache->relocs);
6187 if (sec_cache->ptbl)
6188 free (sec_cache->ptbl);
6194 section_cache_section (section_cache_t *sec_cache,
6196 struct bfd_link_info *link_info)
6199 property_table_entry *prop_table = NULL;
6201 bfd_byte *contents = NULL;
6202 Elf_Internal_Rela *internal_relocs = NULL;
6203 bfd_size_type sec_size;
6207 if (sec == sec_cache->sec)
6211 sec_size = bfd_get_section_limit (abfd, sec);
6213 /* Get the contents. */
6214 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6215 if (contents == NULL && sec_size != 0)
6218 /* Get the relocations. */
6219 internal_relocs = retrieve_internal_relocs (abfd, sec,
6220 link_info->keep_memory);
6222 /* Get the entry table. */
6223 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6224 XTENSA_PROP_SEC_NAME, FALSE);
6228 /* Fill in the new section cache. */
6229 free_section_cache (sec_cache);
6230 init_section_cache (sec_cache);
6232 sec_cache->sec = sec;
6233 sec_cache->contents = contents;
6234 sec_cache->content_length = sec_size;
6235 sec_cache->relocs = internal_relocs;
6236 sec_cache->reloc_count = sec->reloc_count;
6237 sec_cache->pte_count = ptblsize;
6238 sec_cache->ptbl = prop_table;
6243 release_contents (sec, contents);
6244 release_internal_relocs (sec, internal_relocs);
6251 /* Extended basic blocks. */
6253 /* An ebb_struct represents an Extended Basic Block. Within this
6254 range, we guarantee that all instructions are decodable, the
6255 property table entries are contiguous, and no property table
6256 specifies a segment that cannot have instructions moved. This
6257 structure contains caches of the contents, property table and
6258 relocations for the specified section for easy use. The range is
6259 specified by ranges of indices for the byte offset, property table
6260 offsets and relocation offsets. These must be consistent. */
6262 typedef struct ebb_struct ebb_t;
6268 bfd_byte *contents; /* Cache of the section contents. */
6269 bfd_size_type content_length;
6271 property_table_entry *ptbl; /* Cache of the section property table. */
6274 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6275 unsigned reloc_count;
6277 bfd_vma start_offset; /* Offset in section. */
6278 unsigned start_ptbl_idx; /* Offset in the property table. */
6279 unsigned start_reloc_idx; /* Offset in the relocations. */
6282 unsigned end_ptbl_idx;
6283 unsigned end_reloc_idx;
6285 bfd_boolean ends_section; /* Is this the last ebb in a section? */
6287 /* The unreachable property table at the end of this set of blocks;
6288 NULL if the end is not an unreachable block. */
6289 property_table_entry *ends_unreachable;
6293 enum ebb_target_enum
6296 EBB_DESIRE_TGT_ALIGN,
6297 EBB_REQUIRE_TGT_ALIGN,
6298 EBB_REQUIRE_LOOP_ALIGN,
6303 /* proposed_action_struct is similar to the text_action_struct except
6304 that is represents a potential transformation, not one that will
6305 occur. We build a list of these for an extended basic block
6306 and use them to compute the actual actions desired. We must be
6307 careful that the entire set of actual actions we perform do not
6308 break any relocations that would fit if the actions were not
6311 typedef struct proposed_action_struct proposed_action;
6313 struct proposed_action_struct
6315 enum ebb_target_enum align_type; /* for the target alignment */
6316 bfd_vma alignment_pow;
6317 text_action_t action;
6320 bfd_boolean do_action; /* If false, then we will not perform the action. */
6324 /* The ebb_constraint_struct keeps a set of proposed actions for an
6325 extended basic block. */
6327 typedef struct ebb_constraint_struct ebb_constraint;
6329 struct ebb_constraint_struct
6332 bfd_boolean start_movable;
6334 /* Bytes of extra space at the beginning if movable. */
6335 int start_extra_space;
6337 enum ebb_target_enum start_align;
6339 bfd_boolean end_movable;
6341 /* Bytes of extra space at the end if movable. */
6342 int end_extra_space;
6344 unsigned action_count;
6345 unsigned action_allocated;
6347 /* Array of proposed actions. */
6348 proposed_action *actions;
6350 /* Action alignments -- one for each proposed action. */
6351 enum ebb_target_enum *action_aligns;
6356 init_ebb_constraint (ebb_constraint *c)
6358 memset (c, 0, sizeof (ebb_constraint));
6363 free_ebb_constraint (ebb_constraint *c)
6371 init_ebb (ebb_t *ebb,
6374 bfd_size_type content_length,
6375 property_table_entry *prop_table,
6377 Elf_Internal_Rela *internal_relocs,
6378 unsigned reloc_count)
6380 memset (ebb, 0, sizeof (ebb_t));
6382 ebb->contents = contents;
6383 ebb->content_length = content_length;
6384 ebb->ptbl = prop_table;
6385 ebb->pte_count = ptblsize;
6386 ebb->relocs = internal_relocs;
6387 ebb->reloc_count = reloc_count;
6388 ebb->start_offset = 0;
6389 ebb->end_offset = ebb->content_length - 1;
6390 ebb->start_ptbl_idx = 0;
6391 ebb->end_ptbl_idx = ptblsize;
6392 ebb->start_reloc_idx = 0;
6393 ebb->end_reloc_idx = reloc_count;
6397 /* Extend the ebb to all decodable contiguous sections. The algorithm
6398 for building a basic block around an instruction is to push it
6399 forward until we hit the end of a section, an unreachable block or
6400 a block that cannot be transformed. Then we push it backwards
6401 searching for similar conditions. */
6403 static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
6404 static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
6405 static bfd_size_type insn_block_decodable_len
6406 (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
6409 extend_ebb_bounds (ebb_t *ebb)
6411 if (!extend_ebb_bounds_forward (ebb))
6413 if (!extend_ebb_bounds_backward (ebb))
6420 extend_ebb_bounds_forward (ebb_t *ebb)
6422 property_table_entry *the_entry, *new_entry;
6424 the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6426 /* Stop when (1) we cannot decode an instruction, (2) we are at
6427 the end of the property tables, (3) we hit a non-contiguous property
6428 table entry, (4) we hit a NO_TRANSFORM region. */
6433 bfd_size_type insn_block_len;
6435 entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
6437 insn_block_decodable_len (ebb->contents, ebb->content_length,
6439 entry_end - ebb->end_offset);
6440 if (insn_block_len != (entry_end - ebb->end_offset))
6443 /* xgettext:c-format */
6444 (_("%pB(%pA+%#" PRIx64 "): could not decode instruction; "
6445 "possible configuration mismatch"),
6446 ebb->sec->owner, ebb->sec,
6447 (uint64_t) (ebb->end_offset + insn_block_len));
6450 ebb->end_offset += insn_block_len;
6452 if (ebb->end_offset == ebb->sec->size)
6453 ebb->ends_section = TRUE;
6455 /* Update the reloc counter. */
6456 while (ebb->end_reloc_idx + 1 < ebb->reloc_count
6457 && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
6460 ebb->end_reloc_idx++;
6463 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6466 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6467 if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
6468 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6469 || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
6472 if (the_entry->address + the_entry->size != new_entry->address)
6475 the_entry = new_entry;
6476 ebb->end_ptbl_idx++;
6479 /* Quick check for an unreachable or end of file just at the end. */
6480 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6482 if (ebb->end_offset == ebb->content_length)
6483 ebb->ends_section = TRUE;
6487 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6488 if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
6489 && the_entry->address + the_entry->size == new_entry->address)
6490 ebb->ends_unreachable = new_entry;
6493 /* Any other ending requires exact alignment. */
6499 extend_ebb_bounds_backward (ebb_t *ebb)
6501 property_table_entry *the_entry, *new_entry;
6503 the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6505 /* Stop when (1) we cannot decode the instructions in the current entry.
6506 (2) we are at the beginning of the property tables, (3) we hit a
6507 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6511 bfd_vma block_begin;
6512 bfd_size_type insn_block_len;
6514 block_begin = the_entry->address - ebb->sec->vma;
6516 insn_block_decodable_len (ebb->contents, ebb->content_length,
6518 ebb->start_offset - block_begin);
6519 if (insn_block_len != ebb->start_offset - block_begin)
6522 /* xgettext:c-format */
6523 (_("%pB(%pA+%#" PRIx64 "): could not decode instruction; "
6524 "possible configuration mismatch"),
6525 ebb->sec->owner, ebb->sec,
6526 (uint64_t) (ebb->end_offset + insn_block_len));
6529 ebb->start_offset -= insn_block_len;
6531 /* Update the reloc counter. */
6532 while (ebb->start_reloc_idx > 0
6533 && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
6534 >= ebb->start_offset))
6536 ebb->start_reloc_idx--;
6539 if (ebb->start_ptbl_idx == 0)
6542 new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
6543 if ((new_entry->flags & XTENSA_PROP_INSN) == 0
6544 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6545 || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
6547 if (new_entry->address + new_entry->size != the_entry->address)
6550 the_entry = new_entry;
6551 ebb->start_ptbl_idx--;
6557 static bfd_size_type
6558 insn_block_decodable_len (bfd_byte *contents,
6559 bfd_size_type content_len,
6560 bfd_vma block_offset,
6561 bfd_size_type block_len)
6563 bfd_vma offset = block_offset;
6565 while (offset < block_offset + block_len)
6567 bfd_size_type insn_len = 0;
6569 insn_len = insn_decode_len (contents, content_len, offset);
6571 return (offset - block_offset);
6574 return (offset - block_offset);
6579 ebb_propose_action (ebb_constraint *c,
6580 enum ebb_target_enum align_type,
6581 bfd_vma alignment_pow,
6582 text_action_t action,
6585 bfd_boolean do_action)
6587 proposed_action *act;
6589 if (c->action_allocated <= c->action_count)
6591 unsigned new_allocated, i;
6592 proposed_action *new_actions;
6594 new_allocated = (c->action_count + 2) * 2;
6595 new_actions = (proposed_action *)
6596 bfd_zmalloc (sizeof (proposed_action) * new_allocated);
6598 for (i = 0; i < c->action_count; i++)
6599 new_actions[i] = c->actions[i];
6602 c->actions = new_actions;
6603 c->action_allocated = new_allocated;
6606 act = &c->actions[c->action_count];
6607 act->align_type = align_type;
6608 act->alignment_pow = alignment_pow;
6609 act->action = action;
6610 act->offset = offset;
6611 act->removed_bytes = removed_bytes;
6612 act->do_action = do_action;
6618 /* Access to internal relocations, section contents and symbols. */
6620 /* During relaxation, we need to modify relocations, section contents,
6621 and symbol definitions, and we need to keep the original values from
6622 being reloaded from the input files, i.e., we need to "pin" the
6623 modified values in memory. We also want to continue to observe the
6624 setting of the "keep-memory" flag. The following functions wrap the
6625 standard BFD functions to take care of this for us. */
6627 static Elf_Internal_Rela *
6628 retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6630 Elf_Internal_Rela *internal_relocs;
6632 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6635 internal_relocs = elf_section_data (sec)->relocs;
6636 if (internal_relocs == NULL)
6637 internal_relocs = (_bfd_elf_link_read_relocs
6638 (abfd, sec, NULL, NULL, keep_memory));
6639 return internal_relocs;
6644 pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6646 elf_section_data (sec)->relocs = internal_relocs;
6651 release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6654 && elf_section_data (sec)->relocs != internal_relocs)
6655 free (internal_relocs);
6660 retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6663 bfd_size_type sec_size;
6665 sec_size = bfd_get_section_limit (abfd, sec);
6666 contents = elf_section_data (sec)->this_hdr.contents;
6668 if (contents == NULL && sec_size != 0)
6670 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
6677 elf_section_data (sec)->this_hdr.contents = contents;
6684 pin_contents (asection *sec, bfd_byte *contents)
6686 elf_section_data (sec)->this_hdr.contents = contents;
6691 release_contents (asection *sec, bfd_byte *contents)
6693 if (contents && elf_section_data (sec)->this_hdr.contents != contents)
6698 static Elf_Internal_Sym *
6699 retrieve_local_syms (bfd *input_bfd)
6701 Elf_Internal_Shdr *symtab_hdr;
6702 Elf_Internal_Sym *isymbuf;
6705 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6706 locsymcount = symtab_hdr->sh_info;
6708 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6709 if (isymbuf == NULL && locsymcount != 0)
6710 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
6713 /* Save the symbols for this input file so they won't be read again. */
6714 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
6715 symtab_hdr->contents = (unsigned char *) isymbuf;
6721 /* Code for link-time relaxation. */
6723 /* Initialization for relaxation: */
6724 static bfd_boolean analyze_relocations (struct bfd_link_info *);
6725 static bfd_boolean find_relaxable_sections
6726 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
6727 static bfd_boolean collect_source_relocs
6728 (bfd *, asection *, struct bfd_link_info *);
6729 static bfd_boolean is_resolvable_asm_expansion
6730 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
6732 static Elf_Internal_Rela *find_associated_l32r_irel
6733 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
6734 static bfd_boolean compute_text_actions
6735 (bfd *, asection *, struct bfd_link_info *);
6736 static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
6737 static bfd_boolean compute_ebb_actions (ebb_constraint *);
6738 typedef struct reloc_range_list_struct reloc_range_list;
6739 static bfd_boolean check_section_ebb_pcrels_fit
6740 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
6741 reloc_range_list *, const ebb_constraint *,
6742 const xtensa_opcode *);
6743 static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
6744 static void text_action_add_proposed
6745 (text_action_list *, const ebb_constraint *, asection *);
6748 static bfd_boolean compute_removed_literals
6749 (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
6750 static Elf_Internal_Rela *get_irel_at_offset
6751 (asection *, Elf_Internal_Rela *, bfd_vma);
6752 static bfd_boolean is_removable_literal
6753 (const source_reloc *, int, const source_reloc *, int, asection *,
6754 property_table_entry *, int);
6755 static bfd_boolean remove_dead_literal
6756 (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
6757 Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
6758 static bfd_boolean identify_literal_placement
6759 (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
6760 value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
6761 source_reloc *, property_table_entry *, int, section_cache_t *,
6763 static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
6764 static bfd_boolean coalesce_shared_literal
6765 (asection *, source_reloc *, property_table_entry *, int, value_map *);
6766 static bfd_boolean move_shared_literal
6767 (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
6768 int, const r_reloc *, const literal_value *, section_cache_t *);
6771 static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
6772 static bfd_boolean translate_section_fixes (asection *);
6773 static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
6774 static asection *translate_reloc (const r_reloc *, r_reloc *, asection *);
6775 static void shrink_dynamic_reloc_sections
6776 (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
6777 static bfd_boolean move_literal
6778 (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
6779 xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
6780 static bfd_boolean relax_property_section
6781 (bfd *, asection *, struct bfd_link_info *);
6784 static bfd_boolean relax_section_symbols (bfd *, asection *);
6788 elf_xtensa_relax_section (bfd *abfd,
6790 struct bfd_link_info *link_info,
6793 static value_map_hash_table *values = NULL;
6794 static bfd_boolean relocations_analyzed = FALSE;
6795 xtensa_relax_info *relax_info;
6797 if (!relocations_analyzed)
6799 /* Do some overall initialization for relaxation. */
6800 values = value_map_hash_table_init ();
6803 relaxing_section = TRUE;
6804 if (!analyze_relocations (link_info))
6806 relocations_analyzed = TRUE;
6810 /* Don't mess with linker-created sections. */
6811 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6814 relax_info = get_xtensa_relax_info (sec);
6815 BFD_ASSERT (relax_info != NULL);
6817 switch (relax_info->visited)
6820 /* Note: It would be nice to fold this pass into
6821 analyze_relocations, but it is important for this step that the
6822 sections be examined in link order. */
6823 if (!compute_removed_literals (abfd, sec, link_info, values))
6830 value_map_hash_table_delete (values);
6832 if (!relax_section (abfd, sec, link_info))
6838 if (!relax_section_symbols (abfd, sec))
6843 relax_info->visited++;
6848 /* Initialization for relaxation. */
6850 /* This function is called once at the start of relaxation. It scans
6851 all the input sections and marks the ones that are relaxable (i.e.,
6852 literal sections with L32R relocations against them), and then
6853 collects source_reloc information for all the relocations against
6854 those relaxable sections. During this process, it also detects
6855 longcalls, i.e., calls relaxed by the assembler into indirect
6856 calls, that can be optimized back into direct calls. Within each
6857 extended basic block (ebb) containing an optimized longcall, it
6858 computes a set of "text actions" that can be performed to remove
6859 the L32R associated with the longcall while optionally preserving
6860 branch target alignments. */
6863 analyze_relocations (struct bfd_link_info *link_info)
6867 bfd_boolean is_relaxable = FALSE;
6869 /* Initialize the per-section relaxation info. */
6870 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
6871 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6873 init_xtensa_relax_info (sec);
6876 /* Mark relaxable sections (and count relocations against each one). */
6877 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
6878 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6880 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
6884 /* Bail out if there are no relaxable sections. */
6888 /* Allocate space for source_relocs. */
6889 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
6890 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6892 xtensa_relax_info *relax_info;
6894 relax_info = get_xtensa_relax_info (sec);
6895 if (relax_info->is_relaxable_literal_section
6896 || relax_info->is_relaxable_asm_section)
6898 relax_info->src_relocs = (source_reloc *)
6899 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
6902 relax_info->src_count = 0;
6905 /* Collect info on relocations against each relaxable section. */
6906 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
6907 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6909 if (!collect_source_relocs (abfd, sec, link_info))
6913 /* Compute the text actions. */
6914 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
6915 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6917 if (!compute_text_actions (abfd, sec, link_info))
6925 /* Find all the sections that might be relaxed. The motivation for
6926 this pass is that collect_source_relocs() needs to record _all_ the
6927 relocations that target each relaxable section. That is expensive
6928 and unnecessary unless the target section is actually going to be
6929 relaxed. This pass identifies all such sections by checking if
6930 they have L32Rs pointing to them. In the process, the total number
6931 of relocations targeting each section is also counted so that we
6932 know how much space to allocate for source_relocs against each
6933 relaxable literal section. */
6936 find_relaxable_sections (bfd *abfd,
6938 struct bfd_link_info *link_info,
6939 bfd_boolean *is_relaxable_p)
6941 Elf_Internal_Rela *internal_relocs;
6943 bfd_boolean ok = TRUE;
6945 xtensa_relax_info *source_relax_info;
6946 bfd_boolean is_l32r_reloc;
6948 internal_relocs = retrieve_internal_relocs (abfd, sec,
6949 link_info->keep_memory);
6950 if (internal_relocs == NULL)
6953 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6954 if (contents == NULL && sec->size != 0)
6960 source_relax_info = get_xtensa_relax_info (sec);
6961 for (i = 0; i < sec->reloc_count; i++)
6963 Elf_Internal_Rela *irel = &internal_relocs[i];
6965 asection *target_sec;
6966 xtensa_relax_info *target_relax_info;
6968 /* If this section has not already been marked as "relaxable", and
6969 if it contains any ASM_EXPAND relocations (marking expanded
6970 longcalls) that can be optimized into direct calls, then mark
6971 the section as "relaxable". */
6972 if (source_relax_info
6973 && !source_relax_info->is_relaxable_asm_section
6974 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
6976 bfd_boolean is_reachable = FALSE;
6977 if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
6978 link_info, &is_reachable)
6981 source_relax_info->is_relaxable_asm_section = TRUE;
6982 *is_relaxable_p = TRUE;
6986 r_reloc_init (&r_rel, abfd, irel, contents,
6987 bfd_get_section_limit (abfd, sec));
6989 target_sec = r_reloc_get_section (&r_rel);
6990 target_relax_info = get_xtensa_relax_info (target_sec);
6991 if (!target_relax_info)
6994 /* Count PC-relative operand relocations against the target section.
6995 Note: The conditions tested here must match the conditions under
6996 which init_source_reloc is called in collect_source_relocs(). */
6997 is_l32r_reloc = FALSE;
6998 if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
7000 xtensa_opcode opcode =
7001 get_relocation_opcode (abfd, sec, contents, irel);
7002 if (opcode != XTENSA_UNDEFINED)
7004 is_l32r_reloc = (opcode == get_l32r_opcode ());
7005 if (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
7007 target_relax_info->src_count++;
7011 if (is_l32r_reloc && r_reloc_is_defined (&r_rel))
7013 /* Mark the target section as relaxable. */
7014 target_relax_info->is_relaxable_literal_section = TRUE;
7015 *is_relaxable_p = TRUE;
7020 release_contents (sec, contents);
7021 release_internal_relocs (sec, internal_relocs);
7026 /* Record _all_ the relocations that point to relaxable sections, and
7027 get rid of ASM_EXPAND relocs by either converting them to
7028 ASM_SIMPLIFY or by removing them. */
7031 collect_source_relocs (bfd *abfd,
7033 struct bfd_link_info *link_info)
7035 Elf_Internal_Rela *internal_relocs;
7037 bfd_boolean ok = TRUE;
7039 bfd_size_type sec_size;
7041 internal_relocs = retrieve_internal_relocs (abfd, sec,
7042 link_info->keep_memory);
7043 if (internal_relocs == NULL)
7046 sec_size = bfd_get_section_limit (abfd, sec);
7047 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7048 if (contents == NULL && sec_size != 0)
7054 /* Record relocations against relaxable literal sections. */
7055 for (i = 0; i < sec->reloc_count; i++)
7057 Elf_Internal_Rela *irel = &internal_relocs[i];
7059 asection *target_sec;
7060 xtensa_relax_info *target_relax_info;
7062 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7064 target_sec = r_reloc_get_section (&r_rel);
7065 target_relax_info = get_xtensa_relax_info (target_sec);
7067 if (target_relax_info
7068 && (target_relax_info->is_relaxable_literal_section
7069 || target_relax_info->is_relaxable_asm_section))
7071 xtensa_opcode opcode = XTENSA_UNDEFINED;
7073 bfd_boolean is_abs_literal = FALSE;
7075 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7077 /* None of the current alternate relocs are PC-relative,
7078 and only PC-relative relocs matter here. However, we
7079 still need to record the opcode for literal
7081 opcode = get_relocation_opcode (abfd, sec, contents, irel);
7082 if (opcode == get_l32r_opcode ())
7084 is_abs_literal = TRUE;
7088 opcode = XTENSA_UNDEFINED;
7090 else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
7092 opcode = get_relocation_opcode (abfd, sec, contents, irel);
7093 opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7096 if (opcode != XTENSA_UNDEFINED)
7098 int src_next = target_relax_info->src_next++;
7099 source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
7101 init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
7107 /* Now get rid of ASM_EXPAND relocations. At this point, the
7108 src_relocs array for the target literal section may still be
7109 incomplete, but it must at least contain the entries for the L32R
7110 relocations associated with ASM_EXPANDs because they were just
7111 added in the preceding loop over the relocations. */
7113 for (i = 0; i < sec->reloc_count; i++)
7115 Elf_Internal_Rela *irel = &internal_relocs[i];
7116 bfd_boolean is_reachable;
7118 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
7124 Elf_Internal_Rela *l32r_irel;
7126 asection *target_sec;
7127 xtensa_relax_info *target_relax_info;
7129 /* Mark the source_reloc for the L32R so that it will be
7130 removed in compute_removed_literals(), along with the
7131 associated literal. */
7132 l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
7133 irel, internal_relocs);
7134 if (l32r_irel == NULL)
7137 r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
7139 target_sec = r_reloc_get_section (&r_rel);
7140 target_relax_info = get_xtensa_relax_info (target_sec);
7142 if (target_relax_info
7143 && (target_relax_info->is_relaxable_literal_section
7144 || target_relax_info->is_relaxable_asm_section))
7146 source_reloc *s_reloc;
7148 /* Search the source_relocs for the entry corresponding to
7149 the l32r_irel. Note: The src_relocs array is not yet
7150 sorted, but it wouldn't matter anyway because we're
7151 searching by source offset instead of target offset. */
7152 s_reloc = find_source_reloc (target_relax_info->src_relocs,
7153 target_relax_info->src_next,
7155 BFD_ASSERT (s_reloc);
7156 s_reloc->is_null = TRUE;
7159 /* Convert this reloc to ASM_SIMPLIFY. */
7160 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7161 R_XTENSA_ASM_SIMPLIFY);
7162 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7164 pin_internal_relocs (sec, internal_relocs);
7168 /* It is resolvable but doesn't reach. We resolve now
7169 by eliminating the relocation -- the call will remain
7170 expanded into L32R/CALLX. */
7171 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7172 pin_internal_relocs (sec, internal_relocs);
7177 release_contents (sec, contents);
7178 release_internal_relocs (sec, internal_relocs);
7183 /* Return TRUE if the asm expansion can be resolved. Generally it can
7184 be resolved on a final link or when a partial link locates it in the
7185 same section as the target. Set "is_reachable" flag if the target of
7186 the call is within the range of a direct call, given the current VMA
7187 for this section and the target section. */
7190 is_resolvable_asm_expansion (bfd *abfd,
7193 Elf_Internal_Rela *irel,
7194 struct bfd_link_info *link_info,
7195 bfd_boolean *is_reachable_p)
7197 asection *target_sec;
7198 bfd_vma target_offset;
7200 xtensa_opcode opcode, direct_call_opcode;
7201 bfd_vma self_address;
7202 bfd_vma dest_address;
7203 bfd_boolean uses_l32r;
7204 bfd_size_type sec_size;
7206 *is_reachable_p = FALSE;
7208 if (contents == NULL)
7211 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
7214 sec_size = bfd_get_section_limit (abfd, sec);
7215 opcode = get_expanded_call_opcode (contents + irel->r_offset,
7216 sec_size - irel->r_offset, &uses_l32r);
7217 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7221 direct_call_opcode = swap_callx_for_call_opcode (opcode);
7222 if (direct_call_opcode == XTENSA_UNDEFINED)
7225 /* Check and see that the target resolves. */
7226 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7227 if (!r_reloc_is_defined (&r_rel))
7230 target_sec = r_reloc_get_section (&r_rel);
7231 target_offset = r_rel.target_offset;
7233 /* If the target is in a shared library, then it doesn't reach. This
7234 isn't supposed to come up because the compiler should never generate
7235 non-PIC calls on systems that use shared libraries, but the linker
7236 shouldn't crash regardless. */
7237 if (!target_sec->output_section)
7240 /* For relocatable sections, we can only simplify when the output
7241 section of the target is the same as the output section of the
7243 if (bfd_link_relocatable (link_info)
7244 && (target_sec->output_section != sec->output_section
7245 || is_reloc_sym_weak (abfd, irel)))
7248 if (target_sec->output_section != sec->output_section)
7250 /* If the two sections are sufficiently far away that relaxation
7251 might take the call out of range, we can't simplify. For
7252 example, a positive displacement call into another memory
7253 could get moved to a lower address due to literal removal,
7254 but the destination won't move, and so the displacment might
7257 If the displacement is negative, assume the destination could
7258 move as far back as the start of the output section. The
7259 self_address will be at least as far into the output section
7260 as it is prior to relaxation.
7262 If the displacement is postive, assume the destination will be in
7263 it's pre-relaxed location (because relaxation only makes sections
7264 smaller). The self_address could go all the way to the beginning
7265 of the output section. */
7267 dest_address = target_sec->output_section->vma;
7268 self_address = sec->output_section->vma;
7270 if (sec->output_section->vma > target_sec->output_section->vma)
7271 self_address += sec->output_offset + irel->r_offset + 3;
7273 dest_address += bfd_get_section_limit (abfd, target_sec->output_section);
7274 /* Call targets should be four-byte aligned. */
7275 dest_address = (dest_address + 3) & ~3;
7280 self_address = (sec->output_section->vma
7281 + sec->output_offset + irel->r_offset + 3);
7282 dest_address = (target_sec->output_section->vma
7283 + target_sec->output_offset + target_offset);
7286 *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
7287 self_address, dest_address);
7289 if ((self_address >> CALL_SEGMENT_BITS) !=
7290 (dest_address >> CALL_SEGMENT_BITS))
7297 static Elf_Internal_Rela *
7298 find_associated_l32r_irel (bfd *abfd,
7301 Elf_Internal_Rela *other_irel,
7302 Elf_Internal_Rela *internal_relocs)
7306 for (i = 0; i < sec->reloc_count; i++)
7308 Elf_Internal_Rela *irel = &internal_relocs[i];
7310 if (irel == other_irel)
7312 if (irel->r_offset != other_irel->r_offset)
7314 if (is_l32r_relocation (abfd, sec, contents, irel))
7322 static xtensa_opcode *
7323 build_reloc_opcodes (bfd *abfd,
7326 Elf_Internal_Rela *internal_relocs)
7329 xtensa_opcode *reloc_opcodes =
7330 (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
7331 for (i = 0; i < sec->reloc_count; i++)
7333 Elf_Internal_Rela *irel = &internal_relocs[i];
7334 reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
7336 return reloc_opcodes;
7339 struct reloc_range_struct
7342 bfd_boolean add; /* TRUE if start of a range, FALSE otherwise. */
7343 /* Original irel index in the array of relocations for a section. */
7344 unsigned irel_index;
7346 typedef struct reloc_range_struct reloc_range;
7348 typedef struct reloc_range_list_entry_struct reloc_range_list_entry;
7349 struct reloc_range_list_entry_struct
7351 reloc_range_list_entry *next;
7352 reloc_range_list_entry *prev;
7353 Elf_Internal_Rela *irel;
7354 xtensa_opcode opcode;
7358 struct reloc_range_list_struct
7360 /* The rest of the structure is only meaningful when ok is TRUE. */
7363 unsigned n_range; /* Number of range markers. */
7364 reloc_range *range; /* Sorted range markers. */
7366 unsigned first; /* Index of a first range element in the list. */
7367 unsigned last; /* One past index of a last range element in the list. */
7369 unsigned n_list; /* Number of list elements. */
7370 reloc_range_list_entry *reloc; /* */
7371 reloc_range_list_entry list_root;
7375 reloc_range_compare (const void *a, const void *b)
7377 const reloc_range *ra = a;
7378 const reloc_range *rb = b;
7380 if (ra->addr != rb->addr)
7381 return ra->addr < rb->addr ? -1 : 1;
7382 if (ra->add != rb->add)
7383 return ra->add ? -1 : 1;
7388 build_reloc_ranges (bfd *abfd, asection *sec,
7390 Elf_Internal_Rela *internal_relocs,
7391 xtensa_opcode *reloc_opcodes,
7392 reloc_range_list *list)
7397 reloc_range *ranges = NULL;
7398 reloc_range_list_entry *reloc =
7399 bfd_malloc (sec->reloc_count * sizeof (*reloc));
7401 memset (list, 0, sizeof (*list));
7404 for (i = 0; i < sec->reloc_count; i++)
7406 Elf_Internal_Rela *irel = &internal_relocs[i];
7407 int r_type = ELF32_R_TYPE (irel->r_info);
7408 reloc_howto_type *howto = &elf_howto_table[r_type];
7411 if (r_type == R_XTENSA_ASM_SIMPLIFY
7412 || r_type == R_XTENSA_32_PCREL
7413 || !howto->pc_relative)
7416 r_reloc_init (&r_rel, abfd, irel, contents,
7417 bfd_get_section_limit (abfd, sec));
7419 if (r_reloc_get_section (&r_rel) != sec)
7424 max_n = (max_n + 2) * 2;
7425 ranges = bfd_realloc (ranges, max_n * sizeof (*ranges));
7428 ranges[n].addr = irel->r_offset;
7429 ranges[n + 1].addr = r_rel.target_offset;
7431 ranges[n].add = ranges[n].addr < ranges[n + 1].addr;
7432 ranges[n + 1].add = !ranges[n].add;
7434 ranges[n].irel_index = i;
7435 ranges[n + 1].irel_index = i;
7439 reloc[i].irel = irel;
7441 /* Every relocation won't possibly be checked in the optimized version of
7442 check_section_ebb_pcrels_fit, so this needs to be done here. */
7443 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7445 /* None of the current alternate relocs are PC-relative,
7446 and only PC-relative relocs matter here. */
7450 xtensa_opcode opcode;
7454 opcode = reloc_opcodes[i];
7456 opcode = get_relocation_opcode (abfd, sec, contents, irel);
7458 if (opcode == XTENSA_UNDEFINED)
7464 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7465 if (opnum == XTENSA_UNDEFINED)
7471 /* Record relocation opcode and opnum as we've calculated them
7472 anyway and they won't change. */
7473 reloc[i].opcode = opcode;
7474 reloc[i].opnum = opnum;
7480 ranges = bfd_realloc (ranges, n * sizeof (*ranges));
7481 qsort (ranges, n, sizeof (*ranges), reloc_range_compare);
7484 list->range = ranges;
7485 list->reloc = reloc;
7486 list->list_root.prev = &list->list_root;
7487 list->list_root.next = &list->list_root;
7496 static void reloc_range_list_append (reloc_range_list *list,
7497 unsigned irel_index)
7499 reloc_range_list_entry *entry = list->reloc + irel_index;
7501 entry->prev = list->list_root.prev;
7502 entry->next = &list->list_root;
7503 entry->prev->next = entry;
7504 entry->next->prev = entry;
7508 static void reloc_range_list_remove (reloc_range_list *list,
7509 unsigned irel_index)
7511 reloc_range_list_entry *entry = list->reloc + irel_index;
7513 entry->next->prev = entry->prev;
7514 entry->prev->next = entry->next;
7518 /* Update relocation list object so that it lists all relocations that cross
7519 [first; last] range. Range bounds should not decrease with successive
7521 static void reloc_range_list_update_range (reloc_range_list *list,
7522 bfd_vma first, bfd_vma last)
7524 /* This should not happen: EBBs are iterated from lower addresses to higher.
7525 But even if that happens there's no need to break: just flush current list
7526 and start from scratch. */
7527 if ((list->last > 0 && list->range[list->last - 1].addr > last) ||
7528 (list->first > 0 && list->range[list->first - 1].addr >= first))
7533 list->list_root.next = &list->list_root;
7534 list->list_root.prev = &list->list_root;
7535 fprintf (stderr, "%s: move backwards requested\n", __func__);
7538 for (; list->last < list->n_range &&
7539 list->range[list->last].addr <= last; ++list->last)
7540 if (list->range[list->last].add)
7541 reloc_range_list_append (list, list->range[list->last].irel_index);
7543 for (; list->first < list->n_range &&
7544 list->range[list->first].addr < first; ++list->first)
7545 if (!list->range[list->first].add)
7546 reloc_range_list_remove (list, list->range[list->first].irel_index);
7549 static void free_reloc_range_list (reloc_range_list *list)
7555 /* The compute_text_actions function will build a list of potential
7556 transformation actions for code in the extended basic block of each
7557 longcall that is optimized to a direct call. From this list we
7558 generate a set of actions to actually perform that optimizes for
7559 space and, if not using size_opt, maintains branch target
7562 These actions to be performed are placed on a per-section list.
7563 The actual changes are performed by relax_section() in the second
7567 compute_text_actions (bfd *abfd,
7569 struct bfd_link_info *link_info)
7571 xtensa_opcode *reloc_opcodes = NULL;
7572 xtensa_relax_info *relax_info;
7574 Elf_Internal_Rela *internal_relocs;
7575 bfd_boolean ok = TRUE;
7577 property_table_entry *prop_table = 0;
7579 bfd_size_type sec_size;
7580 reloc_range_list relevant_relocs;
7582 relax_info = get_xtensa_relax_info (sec);
7583 BFD_ASSERT (relax_info);
7584 BFD_ASSERT (relax_info->src_next == relax_info->src_count);
7586 /* Do nothing if the section contains no optimized longcalls. */
7587 if (!relax_info->is_relaxable_asm_section)
7590 internal_relocs = retrieve_internal_relocs (abfd, sec,
7591 link_info->keep_memory);
7593 if (internal_relocs)
7594 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7595 internal_reloc_compare);
7597 sec_size = bfd_get_section_limit (abfd, sec);
7598 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7599 if (contents == NULL && sec_size != 0)
7605 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7606 XTENSA_PROP_SEC_NAME, FALSE);
7613 /* Precompute the opcode for each relocation. */
7614 reloc_opcodes = build_reloc_opcodes (abfd, sec, contents, internal_relocs);
7616 build_reloc_ranges (abfd, sec, contents, internal_relocs, reloc_opcodes,
7619 for (i = 0; i < sec->reloc_count; i++)
7621 Elf_Internal_Rela *irel = &internal_relocs[i];
7623 property_table_entry *the_entry;
7626 ebb_constraint ebb_table;
7627 bfd_size_type simplify_size;
7629 if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
7631 r_offset = irel->r_offset;
7633 simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
7634 if (simplify_size == 0)
7637 /* xgettext:c-format */
7638 (_("%pB(%pA+%#" PRIx64 "): could not decode instruction for "
7639 "XTENSA_ASM_SIMPLIFY relocation; "
7640 "possible configuration mismatch"),
7641 sec->owner, sec, (uint64_t) r_offset);
7645 /* If the instruction table is not around, then don't do this
7647 the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7648 sec->vma + irel->r_offset);
7649 if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
7651 text_action_add (&relax_info->action_list,
7652 ta_convert_longcall, sec, r_offset,
7657 /* If the next longcall happens to be at the same address as an
7658 unreachable section of size 0, then skip forward. */
7659 ptbl_idx = the_entry - prop_table;
7660 while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
7661 && the_entry->size == 0
7662 && ptbl_idx + 1 < ptblsize
7663 && (prop_table[ptbl_idx + 1].address
7664 == prop_table[ptbl_idx].address))
7670 if (the_entry->flags & XTENSA_PROP_NO_TRANSFORM)
7671 /* NO_REORDER is OK */
7674 init_ebb_constraint (&ebb_table);
7675 ebb = &ebb_table.ebb;
7676 init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
7677 internal_relocs, sec->reloc_count);
7678 ebb->start_offset = r_offset + simplify_size;
7679 ebb->end_offset = r_offset + simplify_size;
7680 ebb->start_ptbl_idx = ptbl_idx;
7681 ebb->end_ptbl_idx = ptbl_idx;
7682 ebb->start_reloc_idx = i;
7683 ebb->end_reloc_idx = i;
7685 if (!extend_ebb_bounds (ebb)
7686 || !compute_ebb_proposed_actions (&ebb_table)
7687 || !compute_ebb_actions (&ebb_table)
7688 || !check_section_ebb_pcrels_fit (abfd, sec, contents,
7691 &ebb_table, reloc_opcodes)
7692 || !check_section_ebb_reduces (&ebb_table))
7694 /* If anything goes wrong or we get unlucky and something does
7695 not fit, with our plan because of expansion between
7696 critical branches, just convert to a NOP. */
7698 text_action_add (&relax_info->action_list,
7699 ta_convert_longcall, sec, r_offset, 0);
7700 i = ebb_table.ebb.end_reloc_idx;
7701 free_ebb_constraint (&ebb_table);
7705 text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
7707 /* Update the index so we do not go looking at the relocations
7708 we have already processed. */
7709 i = ebb_table.ebb.end_reloc_idx;
7710 free_ebb_constraint (&ebb_table);
7713 free_reloc_range_list (&relevant_relocs);
7716 if (action_list_count (&relax_info->action_list))
7717 print_action_list (stderr, &relax_info->action_list);
7721 release_contents (sec, contents);
7722 release_internal_relocs (sec, internal_relocs);
7726 free (reloc_opcodes);
7732 /* Do not widen an instruction if it is preceeded by a
7733 loop opcode. It might cause misalignment. */
7736 prev_instr_is_a_loop (bfd_byte *contents,
7737 bfd_size_type content_length,
7738 bfd_size_type offset)
7740 xtensa_opcode prev_opcode;
7744 prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
7745 return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
7749 /* Find all of the possible actions for an extended basic block. */
7752 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
7754 const ebb_t *ebb = &ebb_table->ebb;
7755 unsigned rel_idx = ebb->start_reloc_idx;
7756 property_table_entry *entry, *start_entry, *end_entry;
7758 xtensa_isa isa = xtensa_default_isa;
7760 static xtensa_insnbuf insnbuf = NULL;
7761 static xtensa_insnbuf slotbuf = NULL;
7763 if (insnbuf == NULL)
7765 insnbuf = xtensa_insnbuf_alloc (isa);
7766 slotbuf = xtensa_insnbuf_alloc (isa);
7769 start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
7770 end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
7772 for (entry = start_entry; entry <= end_entry; entry++)
7774 bfd_vma start_offset, end_offset;
7775 bfd_size_type insn_len;
7777 start_offset = entry->address - ebb->sec->vma;
7778 end_offset = entry->address + entry->size - ebb->sec->vma;
7780 if (entry == start_entry)
7781 start_offset = ebb->start_offset;
7782 if (entry == end_entry)
7783 end_offset = ebb->end_offset;
7784 offset = start_offset;
7786 if (offset == entry->address - ebb->sec->vma
7787 && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
7789 enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
7790 BFD_ASSERT (offset != end_offset);
7791 if (offset == end_offset)
7794 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
7799 if (check_branch_target_aligned_address (offset, insn_len))
7800 align_type = EBB_REQUIRE_TGT_ALIGN;
7802 ebb_propose_action (ebb_table, align_type, 0,
7803 ta_none, offset, 0, TRUE);
7806 while (offset != end_offset)
7808 Elf_Internal_Rela *irel;
7809 xtensa_opcode opcode;
7811 while (rel_idx < ebb->end_reloc_idx
7812 && (ebb->relocs[rel_idx].r_offset < offset
7813 || (ebb->relocs[rel_idx].r_offset == offset
7814 && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
7815 != R_XTENSA_ASM_SIMPLIFY))))
7818 /* Check for longcall. */
7819 irel = &ebb->relocs[rel_idx];
7820 if (irel->r_offset == offset
7821 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
7823 bfd_size_type simplify_size;
7825 simplify_size = get_asm_simplify_size (ebb->contents,
7826 ebb->content_length,
7828 if (simplify_size == 0)
7831 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7832 ta_convert_longcall, offset, 0, TRUE);
7834 offset += simplify_size;
7838 if (offset + MIN_INSN_LENGTH > ebb->content_length)
7840 xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
7841 ebb->content_length - offset);
7842 fmt = xtensa_format_decode (isa, insnbuf);
7843 if (fmt == XTENSA_UNDEFINED)
7845 insn_len = xtensa_format_length (isa, fmt);
7846 if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
7849 if (xtensa_format_num_slots (isa, fmt) != 1)
7855 xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7856 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7857 if (opcode == XTENSA_UNDEFINED)
7860 if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
7861 && (entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7862 && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
7864 /* Add an instruction narrow action. */
7865 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7866 ta_narrow_insn, offset, 0, FALSE);
7868 else if ((entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7869 && can_widen_instruction (slotbuf, fmt, opcode) != 0
7870 && ! prev_instr_is_a_loop (ebb->contents,
7871 ebb->content_length, offset))
7873 /* Add an instruction widen action. */
7874 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7875 ta_widen_insn, offset, 0, FALSE);
7877 else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
7879 /* Check for branch targets. */
7880 ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
7881 ta_none, offset, 0, TRUE);
7888 if (ebb->ends_unreachable)
7890 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7891 ta_fill, ebb->end_offset, 0, TRUE);
7898 /* xgettext:c-format */
7899 (_("%pB(%pA+%#" PRIx64 "): could not decode instruction; "
7900 "possible configuration mismatch"),
7901 ebb->sec->owner, ebb->sec, (uint64_t) offset);
7906 /* After all of the information has collected about the
7907 transformations possible in an EBB, compute the appropriate actions
7908 here in compute_ebb_actions. We still must check later to make
7909 sure that the actions do not break any relocations. The algorithm
7910 used here is pretty greedy. Basically, it removes as many no-ops
7911 as possible so that the end of the EBB has the same alignment
7912 characteristics as the original. First, it uses narrowing, then
7913 fill space at the end of the EBB, and finally widenings. If that
7914 does not work, it tries again with one fewer no-op removed. The
7915 optimization will only be performed if all of the branch targets
7916 that were aligned before transformation are also aligned after the
7919 When the size_opt flag is set, ignore the branch target alignments,
7920 narrow all wide instructions, and remove all no-ops unless the end
7921 of the EBB prevents it. */
7924 compute_ebb_actions (ebb_constraint *ebb_table)
7928 int removed_bytes = 0;
7929 ebb_t *ebb = &ebb_table->ebb;
7930 unsigned seg_idx_start = 0;
7931 unsigned seg_idx_end = 0;
7933 /* We perform this like the assembler relaxation algorithm: Start by
7934 assuming all instructions are narrow and all no-ops removed; then
7937 /* For each segment of this that has a solid constraint, check to
7938 see if there are any combinations that will keep the constraint.
7940 for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
7942 bfd_boolean requires_text_end_align = FALSE;
7943 unsigned longcall_count = 0;
7944 unsigned longcall_convert_count = 0;
7945 unsigned narrowable_count = 0;
7946 unsigned narrowable_convert_count = 0;
7947 unsigned widenable_count = 0;
7948 unsigned widenable_convert_count = 0;
7950 proposed_action *action = NULL;
7951 int align = (1 << ebb_table->ebb.sec->alignment_power);
7953 seg_idx_start = seg_idx_end;
7955 for (i = seg_idx_start; i < ebb_table->action_count; i++)
7957 action = &ebb_table->actions[i];
7958 if (action->action == ta_convert_longcall)
7960 if (action->action == ta_narrow_insn)
7962 if (action->action == ta_widen_insn)
7964 if (action->action == ta_fill)
7966 if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
7968 if (action->align_type == EBB_REQUIRE_TGT_ALIGN
7969 && !elf32xtensa_size_opt)
7974 if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
7975 requires_text_end_align = TRUE;
7977 if (elf32xtensa_size_opt && !requires_text_end_align
7978 && action->align_type != EBB_REQUIRE_LOOP_ALIGN
7979 && action->align_type != EBB_REQUIRE_TGT_ALIGN)
7981 longcall_convert_count = longcall_count;
7982 narrowable_convert_count = narrowable_count;
7983 widenable_convert_count = 0;
7987 /* There is a constraint. Convert the max number of longcalls. */
7988 narrowable_convert_count = 0;
7989 longcall_convert_count = 0;
7990 widenable_convert_count = 0;
7992 for (j = 0; j < longcall_count; j++)
7994 int removed = (longcall_count - j) * 3 & (align - 1);
7995 unsigned desire_narrow = (align - removed) & (align - 1);
7996 unsigned desire_widen = removed;
7997 if (desire_narrow <= narrowable_count)
7999 narrowable_convert_count = desire_narrow;
8000 narrowable_convert_count +=
8001 (align * ((narrowable_count - narrowable_convert_count)
8003 longcall_convert_count = (longcall_count - j);
8004 widenable_convert_count = 0;
8007 if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
8009 narrowable_convert_count = 0;
8010 longcall_convert_count = longcall_count - j;
8011 widenable_convert_count = desire_widen;
8017 /* Now the number of conversions are saved. Do them. */
8018 for (i = seg_idx_start; i < seg_idx_end; i++)
8020 action = &ebb_table->actions[i];
8021 switch (action->action)
8023 case ta_convert_longcall:
8024 if (longcall_convert_count != 0)
8026 action->action = ta_remove_longcall;
8027 action->do_action = TRUE;
8028 action->removed_bytes += 3;
8029 longcall_convert_count--;
8032 case ta_narrow_insn:
8033 if (narrowable_convert_count != 0)
8035 action->do_action = TRUE;
8036 action->removed_bytes += 1;
8037 narrowable_convert_count--;
8041 if (widenable_convert_count != 0)
8043 action->do_action = TRUE;
8044 action->removed_bytes -= 1;
8045 widenable_convert_count--;
8054 /* Now we move on to some local opts. Try to remove each of the
8055 remaining longcalls. */
8057 if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
8060 for (i = 0; i < ebb_table->action_count; i++)
8062 int old_removed_bytes = removed_bytes;
8063 proposed_action *action = &ebb_table->actions[i];
8065 if (action->do_action && action->action == ta_convert_longcall)
8067 bfd_boolean bad_alignment = FALSE;
8069 for (j = i + 1; j < ebb_table->action_count; j++)
8071 proposed_action *new_action = &ebb_table->actions[j];
8072 bfd_vma offset = new_action->offset;
8073 if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
8075 if (!check_branch_target_aligned
8076 (ebb_table->ebb.contents,
8077 ebb_table->ebb.content_length,
8078 offset, offset - removed_bytes))
8080 bad_alignment = TRUE;
8084 if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
8086 if (!check_loop_aligned (ebb_table->ebb.contents,
8087 ebb_table->ebb.content_length,
8089 offset - removed_bytes))
8091 bad_alignment = TRUE;
8095 if (new_action->action == ta_narrow_insn
8096 && !new_action->do_action
8097 && ebb_table->ebb.sec->alignment_power == 2)
8099 /* Narrow an instruction and we are done. */
8100 new_action->do_action = TRUE;
8101 new_action->removed_bytes += 1;
8102 bad_alignment = FALSE;
8105 if (new_action->action == ta_widen_insn
8106 && new_action->do_action
8107 && ebb_table->ebb.sec->alignment_power == 2)
8109 /* Narrow an instruction and we are done. */
8110 new_action->do_action = FALSE;
8111 new_action->removed_bytes += 1;
8112 bad_alignment = FALSE;
8115 if (new_action->do_action)
8116 removed_bytes += new_action->removed_bytes;
8120 action->removed_bytes += 3;
8121 action->action = ta_remove_longcall;
8122 action->do_action = TRUE;
8125 removed_bytes = old_removed_bytes;
8126 if (action->do_action)
8127 removed_bytes += action->removed_bytes;
8132 for (i = 0; i < ebb_table->action_count; ++i)
8134 proposed_action *action = &ebb_table->actions[i];
8135 if (action->do_action)
8136 removed_bytes += action->removed_bytes;
8139 if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
8140 && ebb->ends_unreachable)
8142 proposed_action *action;
8146 BFD_ASSERT (ebb_table->action_count != 0);
8147 action = &ebb_table->actions[ebb_table->action_count - 1];
8148 BFD_ASSERT (action->action == ta_fill);
8149 BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
8151 extra_space = xtensa_compute_fill_extra_space (ebb->ends_unreachable);
8152 br = action->removed_bytes + removed_bytes + extra_space;
8153 br = br & ((1 << ebb->sec->alignment_power ) - 1);
8155 action->removed_bytes = extra_space - br;
8161 /* The xlate_map is a sorted array of address mappings designed to
8162 answer the offset_with_removed_text() query with a binary search instead
8163 of a linear search through the section's action_list. */
8165 typedef struct xlate_map_entry xlate_map_entry_t;
8166 typedef struct xlate_map xlate_map_t;
8168 struct xlate_map_entry
8170 bfd_vma orig_address;
8171 bfd_vma new_address;
8177 unsigned entry_count;
8178 xlate_map_entry_t *entry;
8183 xlate_compare (const void *a_v, const void *b_v)
8185 const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
8186 const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
8187 if (a->orig_address < b->orig_address)
8189 if (a->orig_address > (b->orig_address + b->size - 1))
8196 xlate_offset_with_removed_text (const xlate_map_t *map,
8197 text_action_list *action_list,
8201 xlate_map_entry_t *e;
8202 struct xlate_map_entry se;
8205 return offset_with_removed_text (action_list, offset);
8207 if (map->entry_count == 0)
8210 se.orig_address = offset;
8211 r = bsearch (&se, map->entry, map->entry_count,
8212 sizeof (xlate_map_entry_t), &xlate_compare);
8213 e = (xlate_map_entry_t *) r;
8215 /* There could be a jump past the end of the section,
8216 allow it using the last xlate map entry to translate its address. */
8219 e = map->entry + map->entry_count - 1;
8220 if (xlate_compare (&se, e) <= 0)
8223 BFD_ASSERT (e != NULL);
8226 return e->new_address - e->orig_address + offset;
8229 typedef struct xlate_map_context_struct xlate_map_context;
8230 struct xlate_map_context_struct
8233 xlate_map_entry_t *current_entry;
8238 xlate_map_fn (splay_tree_node node, void *p)
8240 text_action *r = (text_action *)node->value;
8241 xlate_map_context *ctx = p;
8242 unsigned orig_size = 0;
8247 case ta_remove_insn:
8248 case ta_convert_longcall:
8249 case ta_remove_literal:
8250 case ta_add_literal:
8252 case ta_remove_longcall:
8255 case ta_narrow_insn:
8264 ctx->current_entry->size =
8265 r->offset + orig_size - ctx->current_entry->orig_address;
8266 if (ctx->current_entry->size != 0)
8268 ctx->current_entry++;
8269 ctx->map->entry_count++;
8271 ctx->current_entry->orig_address = r->offset + orig_size;
8272 ctx->removed += r->removed_bytes;
8273 ctx->current_entry->new_address = r->offset + orig_size - ctx->removed;
8274 ctx->current_entry->size = 0;
8278 /* Build a binary searchable offset translation map from a section's
8281 static xlate_map_t *
8282 build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
8284 text_action_list *action_list = &relax_info->action_list;
8285 unsigned num_actions = 0;
8286 xlate_map_context ctx;
8288 ctx.map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
8290 if (ctx.map == NULL)
8293 num_actions = action_list_count (action_list);
8294 ctx.map->entry = (xlate_map_entry_t *)
8295 bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
8296 if (ctx.map->entry == NULL)
8301 ctx.map->entry_count = 0;
8304 ctx.current_entry = &ctx.map->entry[0];
8306 ctx.current_entry->orig_address = 0;
8307 ctx.current_entry->new_address = 0;
8308 ctx.current_entry->size = 0;
8310 splay_tree_foreach (action_list->tree, xlate_map_fn, &ctx);
8312 ctx.current_entry->size = (bfd_get_section_limit (sec->owner, sec)
8313 - ctx.current_entry->orig_address);
8314 if (ctx.current_entry->size != 0)
8315 ctx.map->entry_count++;
8321 /* Free an offset translation map. */
8324 free_xlate_map (xlate_map_t *map)
8326 if (map && map->entry)
8333 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8334 relocations in a section will fit if a proposed set of actions
8338 check_section_ebb_pcrels_fit (bfd *abfd,
8341 Elf_Internal_Rela *internal_relocs,
8342 reloc_range_list *relevant_relocs,
8343 const ebb_constraint *constraint,
8344 const xtensa_opcode *reloc_opcodes)
8347 unsigned n = sec->reloc_count;
8348 Elf_Internal_Rela *irel;
8349 xlate_map_t *xmap = NULL;
8350 bfd_boolean ok = TRUE;
8351 xtensa_relax_info *relax_info;
8352 reloc_range_list_entry *entry = NULL;
8354 relax_info = get_xtensa_relax_info (sec);
8356 if (relax_info && sec->reloc_count > 100)
8358 xmap = build_xlate_map (sec, relax_info);
8359 /* NULL indicates out of memory, but the slow version
8360 can still be used. */
8363 if (relevant_relocs && constraint->action_count)
8365 if (!relevant_relocs->ok)
8372 bfd_vma min_offset, max_offset;
8373 min_offset = max_offset = constraint->actions[0].offset;
8375 for (i = 1; i < constraint->action_count; ++i)
8377 proposed_action *action = &constraint->actions[i];
8378 bfd_vma offset = action->offset;
8380 if (offset < min_offset)
8381 min_offset = offset;
8382 if (offset > max_offset)
8383 max_offset = offset;
8385 reloc_range_list_update_range (relevant_relocs, min_offset,
8387 n = relevant_relocs->n_list;
8388 entry = &relevant_relocs->list_root;
8393 relevant_relocs = NULL;
8396 for (i = 0; i < n; i++)
8399 bfd_vma orig_self_offset, orig_target_offset;
8400 bfd_vma self_offset, target_offset;
8402 reloc_howto_type *howto;
8403 int self_removed_bytes, target_removed_bytes;
8405 if (relevant_relocs)
8407 entry = entry->next;
8412 irel = internal_relocs + i;
8414 r_type = ELF32_R_TYPE (irel->r_info);
8416 howto = &elf_howto_table[r_type];
8417 /* We maintain the required invariant: PC-relative relocations
8418 that fit before linking must fit after linking. Thus we only
8419 need to deal with relocations to the same section that are
8421 if (r_type == R_XTENSA_ASM_SIMPLIFY
8422 || r_type == R_XTENSA_32_PCREL
8423 || !howto->pc_relative)
8426 r_reloc_init (&r_rel, abfd, irel, contents,
8427 bfd_get_section_limit (abfd, sec));
8429 if (r_reloc_get_section (&r_rel) != sec)
8432 orig_self_offset = irel->r_offset;
8433 orig_target_offset = r_rel.target_offset;
8435 self_offset = orig_self_offset;
8436 target_offset = orig_target_offset;
8441 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8444 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8445 orig_target_offset);
8448 self_removed_bytes = 0;
8449 target_removed_bytes = 0;
8451 for (j = 0; j < constraint->action_count; ++j)
8453 proposed_action *action = &constraint->actions[j];
8454 bfd_vma offset = action->offset;
8455 int removed_bytes = action->removed_bytes;
8456 if (offset < orig_self_offset
8457 || (offset == orig_self_offset && action->action == ta_fill
8458 && action->removed_bytes < 0))
8459 self_removed_bytes += removed_bytes;
8460 if (offset < orig_target_offset
8461 || (offset == orig_target_offset && action->action == ta_fill
8462 && action->removed_bytes < 0))
8463 target_removed_bytes += removed_bytes;
8465 self_offset -= self_removed_bytes;
8466 target_offset -= target_removed_bytes;
8468 /* Try to encode it. Get the operand and check. */
8469 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
8471 /* None of the current alternate relocs are PC-relative,
8472 and only PC-relative relocs matter here. */
8476 xtensa_opcode opcode;
8479 if (relevant_relocs)
8481 opcode = entry->opcode;
8482 opnum = entry->opnum;
8487 opcode = reloc_opcodes[relevant_relocs ?
8488 (unsigned)(entry - relevant_relocs->reloc) : i];
8490 opcode = get_relocation_opcode (abfd, sec, contents, irel);
8491 if (opcode == XTENSA_UNDEFINED)
8497 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
8498 if (opnum == XTENSA_UNDEFINED)
8505 if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
8514 free_xlate_map (xmap);
8521 check_section_ebb_reduces (const ebb_constraint *constraint)
8526 for (i = 0; i < constraint->action_count; i++)
8528 const proposed_action *action = &constraint->actions[i];
8529 if (action->do_action)
8530 removed += action->removed_bytes;
8540 text_action_add_proposed (text_action_list *l,
8541 const ebb_constraint *ebb_table,
8546 for (i = 0; i < ebb_table->action_count; i++)
8548 proposed_action *action = &ebb_table->actions[i];
8550 if (!action->do_action)
8552 switch (action->action)
8554 case ta_remove_insn:
8555 case ta_remove_longcall:
8556 case ta_convert_longcall:
8557 case ta_narrow_insn:
8560 case ta_remove_literal:
8561 text_action_add (l, action->action, sec, action->offset,
8562 action->removed_bytes);
8575 xtensa_compute_fill_extra_space (property_table_entry *entry)
8577 int fill_extra_space;
8582 if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
8585 fill_extra_space = entry->size;
8586 if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
8588 /* Fill bytes for alignment:
8589 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8590 int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
8591 int nsm = (1 << pow) - 1;
8592 bfd_vma addr = entry->address + entry->size;
8593 bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
8594 fill_extra_space += align_fill;
8596 return fill_extra_space;
8600 /* First relaxation pass. */
8602 /* If the section contains relaxable literals, check each literal to
8603 see if it has the same value as another literal that has already
8604 been seen, either in the current section or a previous one. If so,
8605 add an entry to the per-section list of removed literals. The
8606 actual changes are deferred until the next pass. */
8609 compute_removed_literals (bfd *abfd,
8611 struct bfd_link_info *link_info,
8612 value_map_hash_table *values)
8614 xtensa_relax_info *relax_info;
8616 Elf_Internal_Rela *internal_relocs;
8617 source_reloc *src_relocs, *rel;
8618 bfd_boolean ok = TRUE;
8619 property_table_entry *prop_table = NULL;
8622 bfd_boolean last_loc_is_prev = FALSE;
8623 bfd_vma last_target_offset = 0;
8624 section_cache_t target_sec_cache;
8625 bfd_size_type sec_size;
8627 init_section_cache (&target_sec_cache);
8629 /* Do nothing if it is not a relaxable literal section. */
8630 relax_info = get_xtensa_relax_info (sec);
8631 BFD_ASSERT (relax_info);
8632 if (!relax_info->is_relaxable_literal_section)
8635 internal_relocs = retrieve_internal_relocs (abfd, sec,
8636 link_info->keep_memory);
8638 sec_size = bfd_get_section_limit (abfd, sec);
8639 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8640 if (contents == NULL && sec_size != 0)
8646 /* Sort the source_relocs by target offset. */
8647 src_relocs = relax_info->src_relocs;
8648 qsort (src_relocs, relax_info->src_count,
8649 sizeof (source_reloc), source_reloc_compare);
8650 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8651 internal_reloc_compare);
8653 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
8654 XTENSA_PROP_SEC_NAME, FALSE);
8662 for (i = 0; i < relax_info->src_count; i++)
8664 Elf_Internal_Rela *irel = NULL;
8666 rel = &src_relocs[i];
8667 if (get_l32r_opcode () != rel->opcode)
8669 irel = get_irel_at_offset (sec, internal_relocs,
8670 rel->r_rel.target_offset);
8672 /* If the relocation on this is not a simple R_XTENSA_32 or
8673 R_XTENSA_PLT then do not consider it. This may happen when
8674 the difference of two symbols is used in a literal. */
8675 if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
8676 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
8679 /* If the target_offset for this relocation is the same as the
8680 previous relocation, then we've already considered whether the
8681 literal can be coalesced. Skip to the next one.... */
8682 if (i != 0 && prev_i != -1
8683 && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
8687 if (last_loc_is_prev &&
8688 last_target_offset + 4 != rel->r_rel.target_offset)
8689 last_loc_is_prev = FALSE;
8691 /* Check if the relocation was from an L32R that is being removed
8692 because a CALLX was converted to a direct CALL, and check if
8693 there are no other relocations to the literal. */
8694 if (is_removable_literal (rel, i, src_relocs, relax_info->src_count,
8695 sec, prop_table, ptblsize))
8697 if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
8698 irel, rel, prop_table, ptblsize))
8703 last_target_offset = rel->r_rel.target_offset;
8707 if (!identify_literal_placement (abfd, sec, contents, link_info,
8709 &last_loc_is_prev, irel,
8710 relax_info->src_count - i, rel,
8711 prop_table, ptblsize,
8712 &target_sec_cache, rel->is_abs_literal))
8717 last_target_offset = rel->r_rel.target_offset;
8721 print_removed_literals (stderr, &relax_info->removed_list);
8722 print_action_list (stderr, &relax_info->action_list);
8728 free_section_cache (&target_sec_cache);
8730 release_contents (sec, contents);
8731 release_internal_relocs (sec, internal_relocs);
8736 static Elf_Internal_Rela *
8737 get_irel_at_offset (asection *sec,
8738 Elf_Internal_Rela *internal_relocs,
8742 Elf_Internal_Rela *irel;
8744 Elf_Internal_Rela key;
8746 if (!internal_relocs)
8749 key.r_offset = offset;
8750 irel = bsearch (&key, internal_relocs, sec->reloc_count,
8751 sizeof (Elf_Internal_Rela), internal_reloc_matches);
8755 /* bsearch does not guarantee which will be returned if there are
8756 multiple matches. We need the first that is not an alignment. */
8757 i = irel - internal_relocs;
8760 if (internal_relocs[i-1].r_offset != offset)
8764 for ( ; i < sec->reloc_count; i++)
8766 irel = &internal_relocs[i];
8767 r_type = ELF32_R_TYPE (irel->r_info);
8768 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
8777 is_removable_literal (const source_reloc *rel,
8779 const source_reloc *src_relocs,
8782 property_table_entry *prop_table,
8785 const source_reloc *curr_rel;
8786 property_table_entry *entry;
8791 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8792 sec->vma + rel->r_rel.target_offset);
8793 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8796 for (++i; i < src_count; ++i)
8798 curr_rel = &src_relocs[i];
8799 /* If all others have the same target offset.... */
8800 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
8803 if (!curr_rel->is_null
8804 && !xtensa_is_property_section (curr_rel->source_sec)
8805 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
8813 remove_dead_literal (bfd *abfd,
8815 struct bfd_link_info *link_info,
8816 Elf_Internal_Rela *internal_relocs,
8817 Elf_Internal_Rela *irel,
8819 property_table_entry *prop_table,
8822 property_table_entry *entry;
8823 xtensa_relax_info *relax_info;
8825 relax_info = get_xtensa_relax_info (sec);
8829 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8830 sec->vma + rel->r_rel.target_offset);
8832 /* Mark the unused literal so that it will be removed. */
8833 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
8835 text_action_add (&relax_info->action_list,
8836 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8838 /* If the section is 4-byte aligned, do not add fill. */
8839 if (sec->alignment_power > 2)
8841 int fill_extra_space;
8842 bfd_vma entry_sec_offset;
8844 property_table_entry *the_add_entry;
8848 entry_sec_offset = entry->address - sec->vma + entry->size;
8850 entry_sec_offset = rel->r_rel.target_offset + 4;
8852 /* If the literal range is at the end of the section,
8854 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8856 fill_extra_space = xtensa_compute_fill_extra_space (the_add_entry);
8858 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8859 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8860 -4, fill_extra_space);
8862 adjust_fill_action (fa, removed_diff);
8864 text_action_add (&relax_info->action_list,
8865 ta_fill, sec, entry_sec_offset, removed_diff);
8868 /* Zero out the relocation on this literal location. */
8871 if (elf_hash_table (link_info)->dynamic_sections_created)
8872 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8874 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8875 pin_internal_relocs (sec, internal_relocs);
8878 /* Do not modify "last_loc_is_prev". */
8884 identify_literal_placement (bfd *abfd,
8887 struct bfd_link_info *link_info,
8888 value_map_hash_table *values,
8889 bfd_boolean *last_loc_is_prev_p,
8890 Elf_Internal_Rela *irel,
8891 int remaining_src_rels,
8893 property_table_entry *prop_table,
8895 section_cache_t *target_sec_cache,
8896 bfd_boolean is_abs_literal)
8900 xtensa_relax_info *relax_info;
8901 bfd_boolean literal_placed = FALSE;
8903 unsigned long value;
8904 bfd_boolean final_static_link;
8905 bfd_size_type sec_size;
8907 relax_info = get_xtensa_relax_info (sec);
8911 sec_size = bfd_get_section_limit (abfd, sec);
8914 (!bfd_link_relocatable (link_info)
8915 && !elf_hash_table (link_info)->dynamic_sections_created);
8917 /* The placement algorithm first checks to see if the literal is
8918 already in the value map. If so and the value map is reachable
8919 from all uses, then the literal is moved to that location. If
8920 not, then we identify the last location where a fresh literal was
8921 placed. If the literal can be safely moved there, then we do so.
8922 If not, then we assume that the literal is not to move and leave
8923 the literal where it is, marking it as the last literal
8926 /* Find the literal value. */
8928 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8931 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
8932 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
8934 init_literal_value (&val, &r_rel, value, is_abs_literal);
8936 /* Check if we've seen another literal with the same value that
8937 is in the same output section. */
8938 val_map = value_map_get_cached_value (values, &val, final_static_link);
8941 && (r_reloc_get_section (&val_map->loc)->output_section
8942 == sec->output_section)
8943 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
8944 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
8946 /* No change to last_loc_is_prev. */
8947 literal_placed = TRUE;
8950 /* For relocatable links, do not try to move literals. To do it
8951 correctly might increase the number of relocations in an input
8952 section making the default relocatable linking fail. */
8953 if (!bfd_link_relocatable (link_info) && !literal_placed
8954 && values->has_last_loc && !(*last_loc_is_prev_p))
8956 asection *target_sec = r_reloc_get_section (&values->last_loc);
8957 if (target_sec && target_sec->output_section == sec->output_section)
8959 /* Increment the virtual offset. */
8960 r_reloc try_loc = values->last_loc;
8961 try_loc.virtual_offset += 4;
8963 /* There is a last loc that was in the same output section. */
8964 if (relocations_reach (rel, remaining_src_rels, &try_loc)
8965 && move_shared_literal (sec, link_info, rel,
8966 prop_table, ptblsize,
8967 &try_loc, &val, target_sec_cache))
8969 values->last_loc.virtual_offset += 4;
8970 literal_placed = TRUE;
8972 val_map = add_value_map (values, &val, &try_loc,
8975 val_map->loc = try_loc;
8980 if (!literal_placed)
8982 /* Nothing worked, leave the literal alone but update the last loc. */
8983 values->has_last_loc = TRUE;
8984 values->last_loc = rel->r_rel;
8986 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
8988 val_map->loc = rel->r_rel;
8989 *last_loc_is_prev_p = TRUE;
8996 /* Check if the original relocations (presumably on L32R instructions)
8997 identified by reloc[0..N] can be changed to reference the literal
8998 identified by r_rel. If r_rel is out of range for any of the
8999 original relocations, then we don't want to coalesce the original
9000 literal with the one at r_rel. We only check reloc[0..N], where the
9001 offsets are all the same as for reloc[0] (i.e., they're all
9002 referencing the same literal) and where N is also bounded by the
9003 number of remaining entries in the "reloc" array. The "reloc" array
9004 is sorted by target offset so we know all the entries for the same
9005 literal will be contiguous. */
9008 relocations_reach (source_reloc *reloc,
9009 int remaining_relocs,
9010 const r_reloc *r_rel)
9012 bfd_vma from_offset, source_address, dest_address;
9016 if (!r_reloc_is_defined (r_rel))
9019 sec = r_reloc_get_section (r_rel);
9020 from_offset = reloc[0].r_rel.target_offset;
9022 for (i = 0; i < remaining_relocs; i++)
9024 if (reloc[i].r_rel.target_offset != from_offset)
9027 /* Ignore relocations that have been removed. */
9028 if (reloc[i].is_null)
9031 /* The original and new output section for these must be the same
9032 in order to coalesce. */
9033 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
9034 != sec->output_section)
9037 /* Absolute literals in the same output section can always be
9039 if (reloc[i].is_abs_literal)
9042 /* A literal with no PC-relative relocations can be moved anywhere. */
9043 if (reloc[i].opnd != -1)
9045 /* Otherwise, check to see that it fits. */
9046 source_address = (reloc[i].source_sec->output_section->vma
9047 + reloc[i].source_sec->output_offset
9048 + reloc[i].r_rel.rela.r_offset);
9049 dest_address = (sec->output_section->vma
9050 + sec->output_offset
9051 + r_rel->target_offset);
9053 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
9054 source_address, dest_address))
9063 /* Move a literal to another literal location because it is
9064 the same as the other literal value. */
9067 coalesce_shared_literal (asection *sec,
9069 property_table_entry *prop_table,
9073 property_table_entry *entry;
9075 property_table_entry *the_add_entry;
9077 xtensa_relax_info *relax_info;
9079 relax_info = get_xtensa_relax_info (sec);
9083 entry = elf_xtensa_find_property_entry
9084 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
9085 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
9088 /* Mark that the literal will be coalesced. */
9089 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
9091 text_action_add (&relax_info->action_list,
9092 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
9094 /* If the section is 4-byte aligned, do not add fill. */
9095 if (sec->alignment_power > 2)
9097 int fill_extra_space;
9098 bfd_vma entry_sec_offset;
9101 entry_sec_offset = entry->address - sec->vma + entry->size;
9103 entry_sec_offset = rel->r_rel.target_offset + 4;
9105 /* If the literal range is at the end of the section,
9107 fill_extra_space = 0;
9108 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
9110 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9111 fill_extra_space = the_add_entry->size;
9113 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
9114 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
9115 -4, fill_extra_space);
9117 adjust_fill_action (fa, removed_diff);
9119 text_action_add (&relax_info->action_list,
9120 ta_fill, sec, entry_sec_offset, removed_diff);
9127 /* Move a literal to another location. This may actually increase the
9128 total amount of space used because of alignments so we need to do
9129 this carefully. Also, it may make a branch go out of range. */
9132 move_shared_literal (asection *sec,
9133 struct bfd_link_info *link_info,
9135 property_table_entry *prop_table,
9137 const r_reloc *target_loc,
9138 const literal_value *lit_value,
9139 section_cache_t *target_sec_cache)
9141 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
9142 text_action *fa, *target_fa;
9144 xtensa_relax_info *relax_info, *target_relax_info;
9145 asection *target_sec;
9147 ebb_constraint ebb_table;
9148 bfd_boolean relocs_fit;
9150 /* If this routine always returns FALSE, the literals that cannot be
9151 coalesced will not be moved. */
9152 if (elf32xtensa_no_literal_movement)
9155 relax_info = get_xtensa_relax_info (sec);
9159 target_sec = r_reloc_get_section (target_loc);
9160 target_relax_info = get_xtensa_relax_info (target_sec);
9162 /* Literals to undefined sections may not be moved because they
9163 must report an error. */
9164 if (bfd_is_und_section (target_sec))
9167 src_entry = elf_xtensa_find_property_entry
9168 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
9170 if (!section_cache_section (target_sec_cache, target_sec, link_info))
9173 target_entry = elf_xtensa_find_property_entry
9174 (target_sec_cache->ptbl, target_sec_cache->pte_count,
9175 target_sec->vma + target_loc->target_offset);
9180 /* Make sure that we have not broken any branches. */
9183 init_ebb_constraint (&ebb_table);
9184 ebb = &ebb_table.ebb;
9185 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
9186 target_sec_cache->content_length,
9187 target_sec_cache->ptbl, target_sec_cache->pte_count,
9188 target_sec_cache->relocs, target_sec_cache->reloc_count);
9190 /* Propose to add 4 bytes + worst-case alignment size increase to
9192 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
9193 ta_fill, target_loc->target_offset,
9194 -4 - (1 << target_sec->alignment_power), TRUE);
9196 /* Check all of the PC-relative relocations to make sure they still fit. */
9197 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
9198 target_sec_cache->contents,
9199 target_sec_cache->relocs, NULL,
9205 text_action_add_literal (&target_relax_info->action_list,
9206 ta_add_literal, target_loc, lit_value, -4);
9208 if (target_sec->alignment_power > 2 && target_entry != src_entry)
9210 /* May need to add or remove some fill to maintain alignment. */
9211 int fill_extra_space;
9212 bfd_vma entry_sec_offset;
9215 target_entry->address - target_sec->vma + target_entry->size;
9217 /* If the literal range is at the end of the section,
9219 fill_extra_space = 0;
9221 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
9222 target_sec_cache->pte_count,
9224 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9225 fill_extra_space = the_add_entry->size;
9227 target_fa = find_fill_action (&target_relax_info->action_list,
9228 target_sec, entry_sec_offset);
9229 removed_diff = compute_removed_action_diff (target_fa, target_sec,
9230 entry_sec_offset, 4,
9233 adjust_fill_action (target_fa, removed_diff);
9235 text_action_add (&target_relax_info->action_list,
9236 ta_fill, target_sec, entry_sec_offset, removed_diff);
9239 /* Mark that the literal will be moved to the new location. */
9240 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
9242 /* Remove the literal. */
9243 text_action_add (&relax_info->action_list,
9244 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
9246 /* If the section is 4-byte aligned, do not add fill. */
9247 if (sec->alignment_power > 2 && target_entry != src_entry)
9249 int fill_extra_space;
9250 bfd_vma entry_sec_offset;
9253 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
9255 entry_sec_offset = rel->r_rel.target_offset+4;
9257 /* If the literal range is at the end of the section,
9259 fill_extra_space = 0;
9260 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
9262 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
9263 fill_extra_space = the_add_entry->size;
9265 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
9266 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
9267 -4, fill_extra_space);
9269 adjust_fill_action (fa, removed_diff);
9271 text_action_add (&relax_info->action_list,
9272 ta_fill, sec, entry_sec_offset, removed_diff);
9279 /* Second relaxation pass. */
9282 action_remove_bytes_fn (splay_tree_node node, void *p)
9284 bfd_size_type *final_size = p;
9285 text_action *action = (text_action *)node->value;
9287 *final_size -= action->removed_bytes;
9291 /* Modify all of the relocations to point to the right spot, and if this
9292 is a relaxable section, delete the unwanted literals and fix the
9296 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
9298 Elf_Internal_Rela *internal_relocs;
9299 xtensa_relax_info *relax_info;
9301 bfd_boolean ok = TRUE;
9303 bfd_boolean rv = FALSE;
9304 bfd_boolean virtual_action;
9305 bfd_size_type sec_size;
9307 sec_size = bfd_get_section_limit (abfd, sec);
9308 relax_info = get_xtensa_relax_info (sec);
9309 BFD_ASSERT (relax_info);
9311 /* First translate any of the fixes that have been added already. */
9312 translate_section_fixes (sec);
9314 /* Handle property sections (e.g., literal tables) specially. */
9315 if (xtensa_is_property_section (sec))
9317 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
9318 return relax_property_section (abfd, sec, link_info);
9321 internal_relocs = retrieve_internal_relocs (abfd, sec,
9322 link_info->keep_memory);
9323 if (!internal_relocs && !action_list_count (&relax_info->action_list))
9326 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9327 if (contents == NULL && sec_size != 0)
9333 if (internal_relocs)
9335 for (i = 0; i < sec->reloc_count; i++)
9337 Elf_Internal_Rela *irel;
9338 xtensa_relax_info *target_relax_info;
9339 bfd_vma source_offset, old_source_offset;
9342 asection *target_sec;
9344 /* Locally change the source address.
9345 Translate the target to the new target address.
9346 If it points to this section and has been removed,
9350 irel = &internal_relocs[i];
9351 source_offset = irel->r_offset;
9352 old_source_offset = source_offset;
9354 r_type = ELF32_R_TYPE (irel->r_info);
9355 r_reloc_init (&r_rel, abfd, irel, contents,
9356 bfd_get_section_limit (abfd, sec));
9358 /* If this section could have changed then we may need to
9359 change the relocation's offset. */
9361 if (relax_info->is_relaxable_literal_section
9362 || relax_info->is_relaxable_asm_section)
9364 pin_internal_relocs (sec, internal_relocs);
9366 if (r_type != R_XTENSA_NONE
9367 && find_removed_literal (&relax_info->removed_list,
9370 /* Remove this relocation. */
9371 if (elf_hash_table (link_info)->dynamic_sections_created)
9372 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
9373 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
9374 irel->r_offset = offset_with_removed_text_map
9375 (&relax_info->action_list, irel->r_offset);
9379 if (r_type == R_XTENSA_ASM_SIMPLIFY)
9381 text_action *action =
9382 find_insn_action (&relax_info->action_list,
9384 if (action && (action->action == ta_convert_longcall
9385 || action->action == ta_remove_longcall))
9387 bfd_reloc_status_type retval;
9388 char *error_message = NULL;
9390 retval = contract_asm_expansion (contents, sec_size,
9391 irel, &error_message);
9392 if (retval != bfd_reloc_ok)
9394 (*link_info->callbacks->reloc_dangerous)
9395 (link_info, error_message, abfd, sec,
9399 /* Update the action so that the code that moves
9400 the contents will do the right thing. */
9401 /* ta_remove_longcall and ta_remove_insn actions are
9402 grouped together in the tree as well as
9403 ta_convert_longcall and ta_none, so that changes below
9404 can be done w/o removing and reinserting action into
9407 if (action->action == ta_remove_longcall)
9408 action->action = ta_remove_insn;
9410 action->action = ta_none;
9411 /* Refresh the info in the r_rel. */
9412 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
9413 r_type = ELF32_R_TYPE (irel->r_info);
9417 source_offset = offset_with_removed_text_map
9418 (&relax_info->action_list, irel->r_offset);
9419 irel->r_offset = source_offset;
9422 /* If the target section could have changed then
9423 we may need to change the relocation's target offset. */
9425 target_sec = r_reloc_get_section (&r_rel);
9427 /* For a reference to a discarded section from a DWARF section,
9428 i.e., where action_discarded is PRETEND, the symbol will
9429 eventually be modified to refer to the kept section (at least if
9430 the kept and discarded sections are the same size). Anticipate
9431 that here and adjust things accordingly. */
9432 if (! elf_xtensa_ignore_discarded_relocs (sec)
9433 && elf_xtensa_action_discarded (sec) == PRETEND
9434 && sec->sec_info_type != SEC_INFO_TYPE_STABS
9435 && target_sec != NULL
9436 && discarded_section (target_sec))
9438 /* It would be natural to call _bfd_elf_check_kept_section
9439 here, but it's not exported from elflink.c. It's also a
9440 fairly expensive check. Adjusting the relocations to the
9441 discarded section is fairly harmless; it will only adjust
9442 some addends and difference values. If it turns out that
9443 _bfd_elf_check_kept_section fails later, it won't matter,
9444 so just compare the section names to find the right group
9446 asection *kept = target_sec->kept_section;
9449 if ((kept->flags & SEC_GROUP) != 0)
9451 asection *first = elf_next_in_group (kept);
9452 asection *s = first;
9457 if (strcmp (s->name, target_sec->name) == 0)
9462 s = elf_next_in_group (s);
9469 && ((target_sec->rawsize != 0
9470 ? target_sec->rawsize : target_sec->size)
9471 == (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9475 target_relax_info = get_xtensa_relax_info (target_sec);
9476 if (target_relax_info
9477 && (target_relax_info->is_relaxable_literal_section
9478 || target_relax_info->is_relaxable_asm_section))
9481 target_sec = translate_reloc (&r_rel, &new_reloc, target_sec);
9483 if (r_type == R_XTENSA_DIFF8
9484 || r_type == R_XTENSA_DIFF16
9485 || r_type == R_XTENSA_DIFF32)
9487 bfd_signed_vma diff_value = 0;
9488 bfd_vma new_end_offset, diff_mask = 0;
9490 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
9492 (*link_info->callbacks->reloc_dangerous)
9493 (link_info, _("invalid relocation address"),
9494 abfd, sec, old_source_offset);
9500 case R_XTENSA_DIFF8:
9502 bfd_get_signed_8 (abfd, &contents[old_source_offset]);
9504 case R_XTENSA_DIFF16:
9506 bfd_get_signed_16 (abfd, &contents[old_source_offset]);
9508 case R_XTENSA_DIFF32:
9510 bfd_get_signed_32 (abfd, &contents[old_source_offset]);
9514 new_end_offset = offset_with_removed_text_map
9515 (&target_relax_info->action_list,
9516 r_rel.target_offset + diff_value);
9517 diff_value = new_end_offset - new_reloc.target_offset;
9521 case R_XTENSA_DIFF8:
9523 bfd_put_signed_8 (abfd, diff_value,
9524 &contents[old_source_offset]);
9526 case R_XTENSA_DIFF16:
9528 bfd_put_signed_16 (abfd, diff_value,
9529 &contents[old_source_offset]);
9531 case R_XTENSA_DIFF32:
9532 diff_mask = 0x7fffffff;
9533 bfd_put_signed_32 (abfd, diff_value,
9534 &contents[old_source_offset]);
9538 /* Check for overflow. Sign bits must be all zeroes or all ones */
9539 if ((diff_value & ~diff_mask) != 0 &&
9540 (diff_value & ~diff_mask) != (-1 & ~diff_mask))
9542 (*link_info->callbacks->reloc_dangerous)
9543 (link_info, _("overflow after relaxation"),
9544 abfd, sec, old_source_offset);
9548 pin_contents (sec, contents);
9551 /* If the relocation still references a section in the same
9552 input file, modify the relocation directly instead of
9553 adding a "fix" record. */
9554 if (target_sec->owner == abfd)
9556 unsigned r_symndx = ELF32_R_SYM (new_reloc.rela.r_info);
9557 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
9558 irel->r_addend = new_reloc.rela.r_addend;
9559 pin_internal_relocs (sec, internal_relocs);
9563 bfd_vma addend_displacement;
9566 addend_displacement =
9567 new_reloc.target_offset + new_reloc.virtual_offset;
9568 fix = reloc_bfd_fix_init (sec, source_offset, r_type,
9570 addend_displacement, TRUE);
9577 if ((relax_info->is_relaxable_literal_section
9578 || relax_info->is_relaxable_asm_section)
9579 && action_list_count (&relax_info->action_list))
9581 /* Walk through the planned actions and build up a table
9582 of move, copy and fill records. Use the move, copy and
9583 fill records to perform the actions once. */
9585 bfd_size_type final_size, copy_size, orig_insn_size;
9586 bfd_byte *scratch = NULL;
9587 bfd_byte *dup_contents = NULL;
9588 bfd_size_type orig_size = sec->size;
9589 bfd_vma orig_dot = 0;
9590 bfd_vma orig_dot_copied = 0; /* Byte copied already from
9591 orig dot in physical memory. */
9592 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
9593 bfd_vma dup_dot = 0;
9595 text_action *action;
9597 final_size = sec->size;
9599 splay_tree_foreach (relax_info->action_list.tree,
9600 action_remove_bytes_fn, &final_size);
9601 scratch = (bfd_byte *) bfd_zmalloc (final_size);
9602 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
9604 /* The dot is the current fill location. */
9606 print_action_list (stderr, &relax_info->action_list);
9609 for (action = action_first (&relax_info->action_list); action;
9610 action = action_next (&relax_info->action_list, action))
9612 virtual_action = FALSE;
9613 if (action->offset > orig_dot)
9615 orig_dot += orig_dot_copied;
9616 orig_dot_copied = 0;
9618 /* Out of the virtual world. */
9621 if (action->offset > orig_dot)
9623 copy_size = action->offset - orig_dot;
9624 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9625 orig_dot += copy_size;
9626 dup_dot += copy_size;
9627 BFD_ASSERT (action->offset == orig_dot);
9629 else if (action->offset < orig_dot)
9631 if (action->action == ta_fill
9632 && action->offset - action->removed_bytes == orig_dot)
9634 /* This is OK because the fill only effects the dup_dot. */
9636 else if (action->action == ta_add_literal)
9638 /* TBD. Might need to handle this. */
9641 if (action->offset == orig_dot)
9643 if (action->virtual_offset > orig_dot_vo)
9645 if (orig_dot_vo == 0)
9647 /* Need to copy virtual_offset bytes. Probably four. */
9648 copy_size = action->virtual_offset - orig_dot_vo;
9649 memmove (&dup_contents[dup_dot],
9650 &contents[orig_dot], copy_size);
9651 orig_dot_copied = copy_size;
9652 dup_dot += copy_size;
9654 virtual_action = TRUE;
9657 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
9659 switch (action->action)
9661 case ta_remove_literal:
9662 case ta_remove_insn:
9663 BFD_ASSERT (action->removed_bytes >= 0);
9664 orig_dot += action->removed_bytes;
9667 case ta_narrow_insn:
9670 memmove (scratch, &contents[orig_dot], orig_insn_size);
9671 BFD_ASSERT (action->removed_bytes == 1);
9672 rv = narrow_instruction (scratch, final_size, 0);
9674 memmove (&dup_contents[dup_dot], scratch, copy_size);
9675 orig_dot += orig_insn_size;
9676 dup_dot += copy_size;
9680 if (action->removed_bytes >= 0)
9681 orig_dot += action->removed_bytes;
9684 /* Already zeroed in dup_contents. Just bump the
9686 dup_dot += (-action->removed_bytes);
9691 BFD_ASSERT (action->removed_bytes == 0);
9694 case ta_convert_longcall:
9695 case ta_remove_longcall:
9696 /* These will be removed or converted before we get here. */
9703 memmove (scratch, &contents[orig_dot], orig_insn_size);
9704 BFD_ASSERT (action->removed_bytes == -1);
9705 rv = widen_instruction (scratch, final_size, 0);
9707 memmove (&dup_contents[dup_dot], scratch, copy_size);
9708 orig_dot += orig_insn_size;
9709 dup_dot += copy_size;
9712 case ta_add_literal:
9715 BFD_ASSERT (action->removed_bytes == -4);
9716 /* TBD -- place the literal value here and insert
9718 memset (&dup_contents[dup_dot], 0, 4);
9719 pin_internal_relocs (sec, internal_relocs);
9720 pin_contents (sec, contents);
9722 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
9723 relax_info, &internal_relocs, &action->value))
9727 orig_dot_vo += copy_size;
9729 orig_dot += orig_insn_size;
9730 dup_dot += copy_size;
9734 /* Not implemented yet. */
9739 BFD_ASSERT (dup_dot <= final_size);
9740 BFD_ASSERT (orig_dot <= orig_size);
9743 orig_dot += orig_dot_copied;
9744 orig_dot_copied = 0;
9746 if (orig_dot != orig_size)
9748 copy_size = orig_size - orig_dot;
9749 BFD_ASSERT (orig_size > orig_dot);
9750 BFD_ASSERT (dup_dot + copy_size == final_size);
9751 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9752 orig_dot += copy_size;
9753 dup_dot += copy_size;
9755 BFD_ASSERT (orig_size == orig_dot);
9756 BFD_ASSERT (final_size == dup_dot);
9758 /* Move the dup_contents back. */
9759 if (final_size > orig_size)
9761 /* Contents need to be reallocated. Swap the dup_contents into
9763 sec->contents = dup_contents;
9765 contents = dup_contents;
9766 pin_contents (sec, contents);
9770 BFD_ASSERT (final_size <= orig_size);
9771 memset (contents, 0, orig_size);
9772 memcpy (contents, dup_contents, final_size);
9773 free (dup_contents);
9776 pin_contents (sec, contents);
9778 if (sec->rawsize == 0)
9779 sec->rawsize = sec->size;
9780 sec->size = final_size;
9784 release_internal_relocs (sec, internal_relocs);
9785 release_contents (sec, contents);
9791 translate_section_fixes (asection *sec)
9793 xtensa_relax_info *relax_info;
9796 relax_info = get_xtensa_relax_info (sec);
9800 for (r = relax_info->fix_list; r != NULL; r = r->next)
9801 if (!translate_reloc_bfd_fix (r))
9808 /* Translate a fix given the mapping in the relax info for the target
9809 section. If it has already been translated, no work is required. */
9812 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
9814 reloc_bfd_fix new_fix;
9816 xtensa_relax_info *relax_info;
9817 removed_literal *removed;
9818 bfd_vma new_offset, target_offset;
9820 if (fix->translated)
9823 sec = fix->target_sec;
9824 target_offset = fix->target_offset;
9826 relax_info = get_xtensa_relax_info (sec);
9829 fix->translated = TRUE;
9835 /* The fix does not need to be translated if the section cannot change. */
9836 if (!relax_info->is_relaxable_literal_section
9837 && !relax_info->is_relaxable_asm_section)
9839 fix->translated = TRUE;
9843 /* If the literal has been moved and this relocation was on an
9844 opcode, then the relocation should move to the new literal
9845 location. Otherwise, the relocation should move within the
9849 if (is_operand_relocation (fix->src_type))
9851 /* Check if the original relocation is against a literal being
9853 removed = find_removed_literal (&relax_info->removed_list,
9861 /* The fact that there is still a relocation to this literal indicates
9862 that the literal is being coalesced, not simply removed. */
9863 BFD_ASSERT (removed->to.abfd != NULL);
9865 /* This was moved to some other address (possibly another section). */
9866 new_sec = r_reloc_get_section (&removed->to);
9870 relax_info = get_xtensa_relax_info (sec);
9872 (!relax_info->is_relaxable_literal_section
9873 && !relax_info->is_relaxable_asm_section))
9875 target_offset = removed->to.target_offset;
9876 new_fix.target_sec = new_sec;
9877 new_fix.target_offset = target_offset;
9878 new_fix.translated = TRUE;
9883 target_offset = removed->to.target_offset;
9884 new_fix.target_sec = new_sec;
9887 /* The target address may have been moved within its section. */
9888 new_offset = offset_with_removed_text (&relax_info->action_list,
9891 new_fix.target_offset = new_offset;
9892 new_fix.target_offset = new_offset;
9893 new_fix.translated = TRUE;
9899 /* Fix up a relocation to take account of removed literals. */
9902 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec)
9904 xtensa_relax_info *relax_info;
9905 removed_literal *removed;
9906 bfd_vma target_offset, base_offset;
9908 *new_rel = *orig_rel;
9910 if (!r_reloc_is_defined (orig_rel))
9913 relax_info = get_xtensa_relax_info (sec);
9914 BFD_ASSERT (relax_info && (relax_info->is_relaxable_literal_section
9915 || relax_info->is_relaxable_asm_section));
9917 target_offset = orig_rel->target_offset;
9920 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
9922 /* Check if the original relocation is against a literal being
9924 removed = find_removed_literal (&relax_info->removed_list,
9927 if (removed && removed->to.abfd)
9931 /* The fact that there is still a relocation to this literal indicates
9932 that the literal is being coalesced, not simply removed. */
9933 BFD_ASSERT (removed->to.abfd != NULL);
9935 /* This was moved to some other address
9936 (possibly in another section). */
9937 *new_rel = removed->to;
9938 new_sec = r_reloc_get_section (new_rel);
9942 relax_info = get_xtensa_relax_info (sec);
9944 || (!relax_info->is_relaxable_literal_section
9945 && !relax_info->is_relaxable_asm_section))
9948 target_offset = new_rel->target_offset;
9951 /* Find the base offset of the reloc symbol, excluding any addend from the
9952 reloc or from the section contents (for a partial_inplace reloc). Then
9953 find the adjusted values of the offsets due to relaxation. The base
9954 offset is needed to determine the change to the reloc's addend; the reloc
9955 addend should not be adjusted due to relaxations located before the base
9958 base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend;
9959 if (base_offset <= target_offset)
9961 int base_removed = removed_by_actions_map (&relax_info->action_list,
9962 base_offset, FALSE);
9963 int addend_removed = removed_by_actions_map (&relax_info->action_list,
9964 target_offset, FALSE) -
9967 new_rel->target_offset = target_offset - base_removed - addend_removed;
9968 new_rel->rela.r_addend -= addend_removed;
9972 /* Handle a negative addend. The base offset comes first. */
9973 int tgt_removed = removed_by_actions_map (&relax_info->action_list,
9974 target_offset, FALSE);
9975 int addend_removed = removed_by_actions_map (&relax_info->action_list,
9976 base_offset, FALSE) -
9979 new_rel->target_offset = target_offset - tgt_removed;
9980 new_rel->rela.r_addend += addend_removed;
9987 /* For dynamic links, there may be a dynamic relocation for each
9988 literal. The number of dynamic relocations must be computed in
9989 size_dynamic_sections, which occurs before relaxation. When a
9990 literal is removed, this function checks if there is a corresponding
9991 dynamic relocation and shrinks the size of the appropriate dynamic
9992 relocation section accordingly. At this point, the contents of the
9993 dynamic relocation sections have not yet been filled in, so there's
9994 nothing else that needs to be done. */
9997 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
9999 asection *input_section,
10000 Elf_Internal_Rela *rel)
10002 struct elf_xtensa_link_hash_table *htab;
10003 Elf_Internal_Shdr *symtab_hdr;
10004 struct elf_link_hash_entry **sym_hashes;
10005 unsigned long r_symndx;
10007 struct elf_link_hash_entry *h;
10008 bfd_boolean dynamic_symbol;
10010 htab = elf_xtensa_hash_table (info);
10014 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10015 sym_hashes = elf_sym_hashes (abfd);
10017 r_type = ELF32_R_TYPE (rel->r_info);
10018 r_symndx = ELF32_R_SYM (rel->r_info);
10020 if (r_symndx < symtab_hdr->sh_info)
10023 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
10025 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
10027 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
10028 && (input_section->flags & SEC_ALLOC) != 0
10029 && (dynamic_symbol || bfd_link_pic (info))
10030 && (!h || h->root.type != bfd_link_hash_undefweak
10031 || (dynamic_symbol && bfd_link_dll (info))))
10034 bfd_boolean is_plt = FALSE;
10036 if (dynamic_symbol && r_type == R_XTENSA_PLT)
10038 srel = htab->elf.srelplt;
10042 srel = htab->elf.srelgot;
10044 /* Reduce size of the .rela.* section by one reloc. */
10045 BFD_ASSERT (srel != NULL);
10046 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
10047 srel->size -= sizeof (Elf32_External_Rela);
10051 asection *splt, *sgotplt, *srelgot;
10052 int reloc_index, chunk;
10054 /* Find the PLT reloc index of the entry being removed. This
10055 is computed from the size of ".rela.plt". It is needed to
10056 figure out which PLT chunk to resize. Usually "last index
10057 = size - 1" since the index starts at zero, but in this
10058 context, the size has just been decremented so there's no
10059 need to subtract one. */
10060 reloc_index = srel->size / sizeof (Elf32_External_Rela);
10062 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
10063 splt = elf_xtensa_get_plt_section (info, chunk);
10064 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
10065 BFD_ASSERT (splt != NULL && sgotplt != NULL);
10067 /* Check if an entire PLT chunk has just been eliminated. */
10068 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
10070 /* The two magic GOT entries for that chunk can go away. */
10071 srelgot = htab->elf.srelgot;
10072 BFD_ASSERT (srelgot != NULL);
10073 srelgot->reloc_count -= 2;
10074 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
10075 sgotplt->size -= 8;
10077 /* There should be only one entry left (and it will be
10079 BFD_ASSERT (sgotplt->size == 4);
10080 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
10083 BFD_ASSERT (sgotplt->size >= 4);
10084 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
10086 sgotplt->size -= 4;
10087 splt->size -= PLT_ENTRY_SIZE;
10093 /* Take an r_rel and move it to another section. This usually
10094 requires extending the interal_relocation array and pinning it. If
10095 the original r_rel is from the same BFD, we can complete this here.
10096 Otherwise, we add a fix record to let the final link fix the
10097 appropriate address. Contents and internal relocations for the
10098 section must be pinned after calling this routine. */
10101 move_literal (bfd *abfd,
10102 struct bfd_link_info *link_info,
10105 bfd_byte *contents,
10106 xtensa_relax_info *relax_info,
10107 Elf_Internal_Rela **internal_relocs_p,
10108 const literal_value *lit)
10110 Elf_Internal_Rela *new_relocs = NULL;
10111 size_t new_relocs_count = 0;
10112 Elf_Internal_Rela this_rela;
10113 const r_reloc *r_rel;
10115 r_rel = &lit->r_rel;
10116 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
10118 if (r_reloc_is_const (r_rel))
10119 bfd_put_32 (abfd, lit->value, contents + offset);
10124 reloc_bfd_fix *fix;
10125 unsigned insert_at;
10127 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
10129 /* This is the difficult case. We have to create a fix up. */
10130 this_rela.r_offset = offset;
10131 this_rela.r_info = ELF32_R_INFO (0, r_type);
10132 this_rela.r_addend =
10133 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
10134 bfd_put_32 (abfd, lit->value, contents + offset);
10136 /* Currently, we cannot move relocations during a relocatable link. */
10137 BFD_ASSERT (!bfd_link_relocatable (link_info));
10138 fix = reloc_bfd_fix_init (sec, offset, r_type,
10139 r_reloc_get_section (r_rel),
10140 r_rel->target_offset + r_rel->virtual_offset,
10142 /* We also need to mark that relocations are needed here. */
10143 sec->flags |= SEC_RELOC;
10145 translate_reloc_bfd_fix (fix);
10146 /* This fix has not yet been translated. */
10147 add_fix (sec, fix);
10149 /* Add the relocation. If we have already allocated our own
10150 space for the relocations and we have room for more, then use
10151 it. Otherwise, allocate new space and move the literals. */
10152 insert_at = sec->reloc_count;
10153 for (i = 0; i < sec->reloc_count; ++i)
10155 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
10162 if (*internal_relocs_p != relax_info->allocated_relocs
10163 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
10165 BFD_ASSERT (relax_info->allocated_relocs == NULL
10166 || sec->reloc_count == relax_info->relocs_count);
10168 if (relax_info->allocated_relocs_count == 0)
10169 new_relocs_count = (sec->reloc_count + 2) * 2;
10171 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
10173 new_relocs = (Elf_Internal_Rela *)
10174 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
10178 /* We could handle this more quickly by finding the split point. */
10179 if (insert_at != 0)
10180 memcpy (new_relocs, *internal_relocs_p,
10181 insert_at * sizeof (Elf_Internal_Rela));
10183 new_relocs[insert_at] = this_rela;
10185 if (insert_at != sec->reloc_count)
10186 memcpy (new_relocs + insert_at + 1,
10187 (*internal_relocs_p) + insert_at,
10188 (sec->reloc_count - insert_at)
10189 * sizeof (Elf_Internal_Rela));
10191 if (*internal_relocs_p != relax_info->allocated_relocs)
10193 /* The first time we re-allocate, we can only free the
10194 old relocs if they were allocated with bfd_malloc.
10195 This is not true when keep_memory is in effect. */
10196 if (!link_info->keep_memory)
10197 free (*internal_relocs_p);
10200 free (*internal_relocs_p);
10201 relax_info->allocated_relocs = new_relocs;
10202 relax_info->allocated_relocs_count = new_relocs_count;
10203 elf_section_data (sec)->relocs = new_relocs;
10204 sec->reloc_count++;
10205 relax_info->relocs_count = sec->reloc_count;
10206 *internal_relocs_p = new_relocs;
10210 if (insert_at != sec->reloc_count)
10213 for (idx = sec->reloc_count; idx > insert_at; idx--)
10214 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
10216 (*internal_relocs_p)[insert_at] = this_rela;
10217 sec->reloc_count++;
10218 if (relax_info->allocated_relocs)
10219 relax_info->relocs_count = sec->reloc_count;
10226 /* This is similar to relax_section except that when a target is moved,
10227 we shift addresses up. We also need to modify the size. This
10228 algorithm does NOT allow for relocations into the middle of the
10229 property sections. */
10232 relax_property_section (bfd *abfd,
10234 struct bfd_link_info *link_info)
10236 Elf_Internal_Rela *internal_relocs;
10237 bfd_byte *contents;
10239 bfd_boolean ok = TRUE;
10240 bfd_boolean is_full_prop_section;
10241 size_t last_zfill_target_offset = 0;
10242 asection *last_zfill_target_sec = NULL;
10243 bfd_size_type sec_size;
10244 bfd_size_type entry_size;
10246 sec_size = bfd_get_section_limit (abfd, sec);
10247 internal_relocs = retrieve_internal_relocs (abfd, sec,
10248 link_info->keep_memory);
10249 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
10250 if (contents == NULL && sec_size != 0)
10256 is_full_prop_section = xtensa_is_proptable_section (sec);
10257 if (is_full_prop_section)
10262 if (internal_relocs)
10264 for (i = 0; i < sec->reloc_count; i++)
10266 Elf_Internal_Rela *irel;
10267 xtensa_relax_info *target_relax_info;
10269 asection *target_sec;
10271 bfd_byte *size_p, *flags_p;
10273 /* Locally change the source address.
10274 Translate the target to the new target address.
10275 If it points to this section and has been removed, MOVE IT.
10276 Also, don't forget to modify the associated SIZE at
10279 irel = &internal_relocs[i];
10280 r_type = ELF32_R_TYPE (irel->r_info);
10281 if (r_type == R_XTENSA_NONE)
10284 /* Find the literal value. */
10285 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
10286 size_p = &contents[irel->r_offset + 4];
10288 if (is_full_prop_section)
10289 flags_p = &contents[irel->r_offset + 8];
10290 BFD_ASSERT (irel->r_offset + entry_size <= sec_size);
10292 target_sec = r_reloc_get_section (&val.r_rel);
10293 target_relax_info = get_xtensa_relax_info (target_sec);
10295 if (target_relax_info
10296 && (target_relax_info->is_relaxable_literal_section
10297 || target_relax_info->is_relaxable_asm_section ))
10299 /* Translate the relocation's destination. */
10300 bfd_vma old_offset = val.r_rel.target_offset;
10301 bfd_vma new_offset;
10302 long old_size, new_size;
10303 int removed_by_old_offset =
10304 removed_by_actions_map (&target_relax_info->action_list,
10305 old_offset, FALSE);
10306 new_offset = old_offset - removed_by_old_offset;
10308 /* Assert that we are not out of bounds. */
10309 old_size = bfd_get_32 (abfd, size_p);
10310 new_size = old_size;
10314 /* Only the first zero-sized unreachable entry is
10315 allowed to expand. In this case the new offset
10316 should be the offset before the fill and the new
10317 size is the expansion size. For other zero-sized
10318 entries the resulting size should be zero with an
10319 offset before or after the fill address depending
10320 on whether the expanding unreachable entry
10322 if (last_zfill_target_sec == 0
10323 || last_zfill_target_sec != target_sec
10324 || last_zfill_target_offset != old_offset)
10326 bfd_vma new_end_offset = new_offset;
10328 /* Recompute the new_offset, but this time don't
10329 include any fill inserted by relaxation. */
10330 removed_by_old_offset =
10331 removed_by_actions_map (&target_relax_info->action_list,
10333 new_offset = old_offset - removed_by_old_offset;
10335 /* If it is not unreachable and we have not yet
10336 seen an unreachable at this address, place it
10337 before the fill address. */
10338 if (flags_p && (bfd_get_32 (abfd, flags_p)
10339 & XTENSA_PROP_UNREACHABLE) != 0)
10341 new_size = new_end_offset - new_offset;
10343 last_zfill_target_sec = target_sec;
10344 last_zfill_target_offset = old_offset;
10350 int removed_by_old_offset_size =
10351 removed_by_actions_map (&target_relax_info->action_list,
10352 old_offset + old_size, TRUE);
10353 new_size -= removed_by_old_offset_size - removed_by_old_offset;
10356 if (new_size != old_size)
10358 bfd_put_32 (abfd, new_size, size_p);
10359 pin_contents (sec, contents);
10362 if (new_offset != old_offset)
10364 bfd_vma diff = new_offset - old_offset;
10365 irel->r_addend += diff;
10366 pin_internal_relocs (sec, internal_relocs);
10372 /* Combine adjacent property table entries. This is also done in
10373 finish_dynamic_sections() but at that point it's too late to
10374 reclaim the space in the output section, so we do this twice. */
10376 if (internal_relocs && (!bfd_link_relocatable (link_info)
10377 || xtensa_is_littable_section (sec)))
10379 Elf_Internal_Rela *last_irel = NULL;
10380 Elf_Internal_Rela *irel, *next_rel, *rel_end;
10381 int removed_bytes = 0;
10383 flagword predef_flags;
10385 predef_flags = xtensa_get_property_predef_flags (sec);
10387 /* Walk over memory and relocations at the same time.
10388 This REQUIRES that the internal_relocs be sorted by offset. */
10389 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
10390 internal_reloc_compare);
10392 pin_internal_relocs (sec, internal_relocs);
10393 pin_contents (sec, contents);
10395 next_rel = internal_relocs;
10396 rel_end = internal_relocs + sec->reloc_count;
10398 BFD_ASSERT (sec->size % entry_size == 0);
10400 for (offset = 0; offset < sec->size; offset += entry_size)
10402 Elf_Internal_Rela *offset_rel, *extra_rel;
10403 bfd_vma bytes_to_remove, size, actual_offset;
10404 bfd_boolean remove_this_rel;
10407 /* Find the first relocation for the entry at the current offset.
10408 Adjust the offsets of any extra relocations for the previous
10413 for (irel = next_rel; irel < rel_end; irel++)
10415 if ((irel->r_offset == offset
10416 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
10417 || irel->r_offset > offset)
10422 irel->r_offset -= removed_bytes;
10426 /* Find the next relocation (if there are any left). */
10430 for (irel = offset_rel + 1; irel < rel_end; irel++)
10432 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
10440 /* Check if there are relocations on the current entry. There
10441 should usually be a relocation on the offset field. If there
10442 are relocations on the size or flags, then we can't optimize
10443 this entry. Also, find the next relocation to examine on the
10447 if (offset_rel->r_offset >= offset + entry_size)
10449 next_rel = offset_rel;
10450 /* There are no relocations on the current entry, but we
10451 might still be able to remove it if the size is zero. */
10454 else if (offset_rel->r_offset > offset
10456 && extra_rel->r_offset < offset + entry_size))
10458 /* There is a relocation on the size or flags, so we can't
10459 do anything with this entry. Continue with the next. */
10460 next_rel = offset_rel;
10465 BFD_ASSERT (offset_rel->r_offset == offset);
10466 offset_rel->r_offset -= removed_bytes;
10467 next_rel = offset_rel + 1;
10473 remove_this_rel = FALSE;
10474 bytes_to_remove = 0;
10475 actual_offset = offset - removed_bytes;
10476 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
10478 if (is_full_prop_section)
10479 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
10481 flags = predef_flags;
10484 && (flags & XTENSA_PROP_ALIGN) == 0
10485 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
10487 /* Always remove entries with zero size and no alignment. */
10488 bytes_to_remove = entry_size;
10490 remove_this_rel = TRUE;
10492 else if (offset_rel
10493 && ELF32_R_TYPE (offset_rel->r_info) == R_XTENSA_32)
10497 flagword old_flags;
10499 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
10500 bfd_vma old_address =
10501 (last_irel->r_addend
10502 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
10503 bfd_vma new_address =
10504 (offset_rel->r_addend
10505 + bfd_get_32 (abfd, &contents[actual_offset]));
10506 if (is_full_prop_section)
10507 old_flags = bfd_get_32
10508 (abfd, &contents[last_irel->r_offset + 8]);
10510 old_flags = predef_flags;
10512 if ((ELF32_R_SYM (offset_rel->r_info)
10513 == ELF32_R_SYM (last_irel->r_info))
10514 && old_address + old_size == new_address
10515 && old_flags == flags
10516 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
10517 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
10519 /* Fix the old size. */
10520 bfd_put_32 (abfd, old_size + size,
10521 &contents[last_irel->r_offset + 4]);
10522 bytes_to_remove = entry_size;
10523 remove_this_rel = TRUE;
10526 last_irel = offset_rel;
10529 last_irel = offset_rel;
10532 if (remove_this_rel)
10534 offset_rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
10535 offset_rel->r_offset = 0;
10538 if (bytes_to_remove != 0)
10540 removed_bytes += bytes_to_remove;
10541 if (offset + bytes_to_remove < sec->size)
10542 memmove (&contents[actual_offset],
10543 &contents[actual_offset + bytes_to_remove],
10544 sec->size - offset - bytes_to_remove);
10550 /* Fix up any extra relocations on the last entry. */
10551 for (irel = next_rel; irel < rel_end; irel++)
10552 irel->r_offset -= removed_bytes;
10554 /* Clear the removed bytes. */
10555 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
10557 if (sec->rawsize == 0)
10558 sec->rawsize = sec->size;
10559 sec->size -= removed_bytes;
10561 if (xtensa_is_littable_section (sec))
10563 asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
10565 sgotloc->size -= removed_bytes;
10571 release_internal_relocs (sec, internal_relocs);
10572 release_contents (sec, contents);
10577 /* Third relaxation pass. */
10579 /* Change symbol values to account for removed literals. */
10582 relax_section_symbols (bfd *abfd, asection *sec)
10584 xtensa_relax_info *relax_info;
10585 unsigned int sec_shndx;
10586 Elf_Internal_Shdr *symtab_hdr;
10587 Elf_Internal_Sym *isymbuf;
10588 unsigned i, num_syms, num_locals;
10590 relax_info = get_xtensa_relax_info (sec);
10591 BFD_ASSERT (relax_info);
10593 if (!relax_info->is_relaxable_literal_section
10594 && !relax_info->is_relaxable_asm_section)
10597 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
10599 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10600 isymbuf = retrieve_local_syms (abfd);
10602 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
10603 num_locals = symtab_hdr->sh_info;
10605 /* Adjust the local symbols defined in this section. */
10606 for (i = 0; i < num_locals; i++)
10608 Elf_Internal_Sym *isym = &isymbuf[i];
10610 if (isym->st_shndx == sec_shndx)
10612 bfd_vma orig_addr = isym->st_value;
10613 int removed = removed_by_actions_map (&relax_info->action_list,
10616 isym->st_value -= removed;
10617 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
10619 removed_by_actions_map (&relax_info->action_list,
10620 orig_addr + isym->st_size, FALSE) -
10625 /* Now adjust the global symbols defined in this section. */
10626 for (i = 0; i < (num_syms - num_locals); i++)
10628 struct elf_link_hash_entry *sym_hash;
10630 sym_hash = elf_sym_hashes (abfd)[i];
10632 if (sym_hash->root.type == bfd_link_hash_warning)
10633 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
10635 if ((sym_hash->root.type == bfd_link_hash_defined
10636 || sym_hash->root.type == bfd_link_hash_defweak)
10637 && sym_hash->root.u.def.section == sec)
10639 bfd_vma orig_addr = sym_hash->root.u.def.value;
10640 int removed = removed_by_actions_map (&relax_info->action_list,
10643 sym_hash->root.u.def.value -= removed;
10645 if (sym_hash->type == STT_FUNC)
10647 removed_by_actions_map (&relax_info->action_list,
10648 orig_addr + sym_hash->size, FALSE) -
10657 /* "Fix" handling functions, called while performing relocations. */
10660 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
10662 asection *input_section,
10663 bfd_byte *contents)
10666 asection *sec, *old_sec;
10667 bfd_vma old_offset;
10668 int r_type = ELF32_R_TYPE (rel->r_info);
10669 reloc_bfd_fix *fix;
10671 if (r_type == R_XTENSA_NONE)
10674 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10678 r_reloc_init (&r_rel, input_bfd, rel, contents,
10679 bfd_get_section_limit (input_bfd, input_section));
10680 old_sec = r_reloc_get_section (&r_rel);
10681 old_offset = r_rel.target_offset;
10683 if (!old_sec || !r_reloc_is_defined (&r_rel))
10685 if (r_type != R_XTENSA_ASM_EXPAND)
10688 /* xgettext:c-format */
10689 (_("%pB(%pA+%#" PRIx64 "): unexpected fix for %s relocation"),
10690 input_bfd, input_section, (uint64_t) rel->r_offset,
10691 elf_howto_table[r_type].name);
10694 /* Leave it be. Resolution will happen in a later stage. */
10698 sec = fix->target_sec;
10699 rel->r_addend += ((sec->output_offset + fix->target_offset)
10700 - (old_sec->output_offset + old_offset));
10707 do_fix_for_final_link (Elf_Internal_Rela *rel,
10709 asection *input_section,
10710 bfd_byte *contents,
10711 bfd_vma *relocationp)
10714 int r_type = ELF32_R_TYPE (rel->r_info);
10715 reloc_bfd_fix *fix;
10716 bfd_vma fixup_diff;
10718 if (r_type == R_XTENSA_NONE)
10721 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10725 sec = fix->target_sec;
10727 fixup_diff = rel->r_addend;
10728 if (elf_howto_table[fix->src_type].partial_inplace)
10730 bfd_vma inplace_val;
10731 BFD_ASSERT (fix->src_offset
10732 < bfd_get_section_limit (input_bfd, input_section));
10733 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
10734 fixup_diff += inplace_val;
10737 *relocationp = (sec->output_section->vma
10738 + sec->output_offset
10739 + fix->target_offset - fixup_diff);
10743 /* Miscellaneous utility functions.... */
10746 elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
10752 return elf_hash_table (info)->splt;
10754 dynobj = elf_hash_table (info)->dynobj;
10755 sprintf (plt_name, ".plt.%u", chunk);
10756 return bfd_get_linker_section (dynobj, plt_name);
10761 elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
10767 return elf_hash_table (info)->sgotplt;
10769 dynobj = elf_hash_table (info)->dynobj;
10770 sprintf (got_name, ".got.plt.%u", chunk);
10771 return bfd_get_linker_section (dynobj, got_name);
10775 /* Get the input section for a given symbol index.
10777 . a section symbol, return the section;
10778 . a common symbol, return the common section;
10779 . an undefined symbol, return the undefined section;
10780 . an indirect symbol, follow the links;
10781 . an absolute value, return the absolute section. */
10784 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
10786 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10787 asection *target_sec = NULL;
10788 if (r_symndx < symtab_hdr->sh_info)
10790 Elf_Internal_Sym *isymbuf;
10791 unsigned int section_index;
10793 isymbuf = retrieve_local_syms (abfd);
10794 section_index = isymbuf[r_symndx].st_shndx;
10796 if (section_index == SHN_UNDEF)
10797 target_sec = bfd_und_section_ptr;
10798 else if (section_index == SHN_ABS)
10799 target_sec = bfd_abs_section_ptr;
10800 else if (section_index == SHN_COMMON)
10801 target_sec = bfd_com_section_ptr;
10803 target_sec = bfd_section_from_elf_index (abfd, section_index);
10807 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10808 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
10810 while (h->root.type == bfd_link_hash_indirect
10811 || h->root.type == bfd_link_hash_warning)
10812 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10814 switch (h->root.type)
10816 case bfd_link_hash_defined:
10817 case bfd_link_hash_defweak:
10818 target_sec = h->root.u.def.section;
10820 case bfd_link_hash_common:
10821 target_sec = bfd_com_section_ptr;
10823 case bfd_link_hash_undefined:
10824 case bfd_link_hash_undefweak:
10825 target_sec = bfd_und_section_ptr;
10827 default: /* New indirect warning. */
10828 target_sec = bfd_und_section_ptr;
10836 static struct elf_link_hash_entry *
10837 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
10839 unsigned long indx;
10840 struct elf_link_hash_entry *h;
10841 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10843 if (r_symndx < symtab_hdr->sh_info)
10846 indx = r_symndx - symtab_hdr->sh_info;
10847 h = elf_sym_hashes (abfd)[indx];
10848 while (h->root.type == bfd_link_hash_indirect
10849 || h->root.type == bfd_link_hash_warning)
10850 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10855 /* Get the section-relative offset for a symbol number. */
10858 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
10860 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10861 bfd_vma offset = 0;
10863 if (r_symndx < symtab_hdr->sh_info)
10865 Elf_Internal_Sym *isymbuf;
10866 isymbuf = retrieve_local_syms (abfd);
10867 offset = isymbuf[r_symndx].st_value;
10871 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10872 struct elf_link_hash_entry *h =
10873 elf_sym_hashes (abfd)[indx];
10875 while (h->root.type == bfd_link_hash_indirect
10876 || h->root.type == bfd_link_hash_warning)
10877 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10878 if (h->root.type == bfd_link_hash_defined
10879 || h->root.type == bfd_link_hash_defweak)
10880 offset = h->root.u.def.value;
10887 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
10889 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
10890 struct elf_link_hash_entry *h;
10892 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
10893 if (h && h->root.type == bfd_link_hash_defweak)
10900 pcrel_reloc_fits (xtensa_opcode opc,
10902 bfd_vma self_address,
10903 bfd_vma dest_address)
10905 xtensa_isa isa = xtensa_default_isa;
10906 uint32 valp = dest_address;
10907 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
10908 || xtensa_operand_encode (isa, opc, opnd, &valp))
10915 xtensa_is_property_section (asection *sec)
10917 if (xtensa_is_insntable_section (sec)
10918 || xtensa_is_littable_section (sec)
10919 || xtensa_is_proptable_section (sec))
10927 xtensa_is_insntable_section (asection *sec)
10929 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
10930 || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
10938 xtensa_is_littable_section (asection *sec)
10940 if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
10941 || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
10949 xtensa_is_proptable_section (asection *sec)
10951 if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
10952 || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
10960 internal_reloc_compare (const void *ap, const void *bp)
10962 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10963 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10965 if (a->r_offset != b->r_offset)
10966 return (a->r_offset - b->r_offset);
10968 /* We don't need to sort on these criteria for correctness,
10969 but enforcing a more strict ordering prevents unstable qsort
10970 from behaving differently with different implementations.
10971 Without the code below we get correct but different results
10972 on Solaris 2.7 and 2.8. We would like to always produce the
10973 same results no matter the host. */
10975 if (a->r_info != b->r_info)
10976 return (a->r_info - b->r_info);
10978 return (a->r_addend - b->r_addend);
10983 internal_reloc_matches (const void *ap, const void *bp)
10985 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10986 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10988 /* Check if one entry overlaps with the other; this shouldn't happen
10989 except when searching for a match. */
10990 return (a->r_offset - b->r_offset);
10994 /* Predicate function used to look up a section in a particular group. */
10997 match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
10999 const char *gname = inf;
11000 const char *group_name = elf_group_name (sec);
11002 return (group_name == gname
11003 || (group_name != NULL
11005 && strcmp (group_name, gname) == 0));
11010 xtensa_add_names (const char *base, const char *suffix)
11014 size_t base_len = strlen (base);
11015 size_t suffix_len = strlen (suffix);
11016 char *str = bfd_malloc (base_len + suffix_len + 1);
11018 memcpy (str, base, base_len);
11019 memcpy (str + base_len, suffix, suffix_len + 1);
11024 return strdup (base);
11028 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
11031 xtensa_property_section_name (asection *sec, const char *base_name,
11032 bfd_boolean separate_sections)
11034 const char *suffix, *group_name;
11035 char *prop_sec_name;
11037 group_name = elf_group_name (sec);
11040 suffix = strrchr (sec->name, '.');
11041 if (suffix == sec->name)
11043 prop_sec_name = xtensa_add_names (base_name, suffix);
11045 else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
11047 char *linkonce_kind = 0;
11049 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
11050 linkonce_kind = "x.";
11051 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
11052 linkonce_kind = "p.";
11053 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
11054 linkonce_kind = "prop.";
11058 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
11059 + strlen (linkonce_kind) + 1);
11060 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
11061 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
11063 suffix = sec->name + linkonce_len;
11064 /* For backward compatibility, replace "t." instead of inserting
11065 the new linkonce_kind (but not for "prop" sections). */
11066 if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
11068 strcat (prop_sec_name + linkonce_len, suffix);
11072 prop_sec_name = xtensa_add_names (base_name,
11073 separate_sections ? sec->name : NULL);
11076 return prop_sec_name;
11081 xtensa_get_separate_property_section (asection *sec, const char *base_name,
11082 bfd_boolean separate_section)
11084 char *prop_sec_name;
11085 asection *prop_sec;
11087 prop_sec_name = xtensa_property_section_name (sec, base_name,
11089 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
11090 match_section_group,
11091 (void *) elf_group_name (sec));
11092 free (prop_sec_name);
11097 xtensa_get_property_section (asection *sec, const char *base_name)
11099 asection *prop_sec;
11101 /* Try individual property section first. */
11102 prop_sec = xtensa_get_separate_property_section (sec, base_name, TRUE);
11104 /* Refer to a common property section if individual is not present. */
11106 prop_sec = xtensa_get_separate_property_section (sec, base_name, FALSE);
11113 xtensa_make_property_section (asection *sec, const char *base_name)
11115 char *prop_sec_name;
11116 asection *prop_sec;
11118 /* Check if the section already exists. */
11119 prop_sec_name = xtensa_property_section_name (sec, base_name,
11120 elf32xtensa_separate_props);
11121 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
11122 match_section_group,
11123 (void *) elf_group_name (sec));
11124 /* If not, create it. */
11127 flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
11128 flags |= (bfd_get_section_flags (sec->owner, sec)
11129 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
11131 prop_sec = bfd_make_section_anyway_with_flags
11132 (sec->owner, strdup (prop_sec_name), flags);
11136 elf_group_name (prop_sec) = elf_group_name (sec);
11139 free (prop_sec_name);
11145 xtensa_get_property_predef_flags (asection *sec)
11147 if (xtensa_is_insntable_section (sec))
11148 return (XTENSA_PROP_INSN
11149 | XTENSA_PROP_NO_TRANSFORM
11150 | XTENSA_PROP_INSN_NO_REORDER);
11152 if (xtensa_is_littable_section (sec))
11153 return (XTENSA_PROP_LITERAL
11154 | XTENSA_PROP_NO_TRANSFORM
11155 | XTENSA_PROP_INSN_NO_REORDER);
11161 /* Other functions called directly by the linker. */
11164 xtensa_callback_required_dependence (bfd *abfd,
11166 struct bfd_link_info *link_info,
11167 deps_callback_t callback,
11170 Elf_Internal_Rela *internal_relocs;
11171 bfd_byte *contents;
11173 bfd_boolean ok = TRUE;
11174 bfd_size_type sec_size;
11176 sec_size = bfd_get_section_limit (abfd, sec);
11178 /* ".plt*" sections have no explicit relocations but they contain L32R
11179 instructions that reference the corresponding ".got.plt*" sections. */
11180 if ((sec->flags & SEC_LINKER_CREATED) != 0
11181 && CONST_STRNEQ (sec->name, ".plt"))
11185 /* Find the corresponding ".got.plt*" section. */
11186 if (sec->name[4] == '\0')
11187 sgotplt = elf_hash_table (link_info)->sgotplt;
11193 BFD_ASSERT (sec->name[4] == '.');
11194 chunk = strtol (&sec->name[5], NULL, 10);
11196 sprintf (got_name, ".got.plt.%u", chunk);
11197 sgotplt = bfd_get_linker_section (sec->owner, got_name);
11199 BFD_ASSERT (sgotplt);
11201 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11202 section referencing a literal at the very beginning of
11203 ".got.plt". This is very close to the real dependence, anyway. */
11204 (*callback) (sec, sec_size, sgotplt, 0, closure);
11207 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11208 when building uclibc, which runs "ld -b binary /dev/null". */
11209 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
11212 internal_relocs = retrieve_internal_relocs (abfd, sec,
11213 link_info->keep_memory);
11214 if (internal_relocs == NULL
11215 || sec->reloc_count == 0)
11218 /* Cache the contents for the duration of this scan. */
11219 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
11220 if (contents == NULL && sec_size != 0)
11226 if (!xtensa_default_isa)
11227 xtensa_default_isa = xtensa_isa_init (0, 0);
11229 for (i = 0; i < sec->reloc_count; i++)
11231 Elf_Internal_Rela *irel = &internal_relocs[i];
11232 if (is_l32r_relocation (abfd, sec, contents, irel))
11235 asection *target_sec;
11236 bfd_vma target_offset;
11238 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
11241 /* L32Rs must be local to the input file. */
11242 if (r_reloc_is_defined (&l32r_rel))
11244 target_sec = r_reloc_get_section (&l32r_rel);
11245 target_offset = l32r_rel.target_offset;
11247 (*callback) (sec, irel->r_offset, target_sec, target_offset,
11253 release_internal_relocs (sec, internal_relocs);
11254 release_contents (sec, contents);
11258 /* The default literal sections should always be marked as "code" (i.e.,
11259 SHF_EXECINSTR). This is particularly important for the Linux kernel
11260 module loader so that the literals are not placed after the text. */
11261 static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
11263 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11264 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11265 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
11266 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 },
11267 { NULL, 0, 0, 0, 0 }
11270 #define ELF_TARGET_ID XTENSA_ELF_DATA
11272 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11273 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11274 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11275 #define TARGET_BIG_NAME "elf32-xtensa-be"
11276 #define ELF_ARCH bfd_arch_xtensa
11278 #define ELF_MACHINE_CODE EM_XTENSA
11279 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11281 #define ELF_MAXPAGESIZE 0x1000
11282 #endif /* ELF_ARCH */
11284 #define elf_backend_can_gc_sections 1
11285 #define elf_backend_can_refcount 1
11286 #define elf_backend_plt_readonly 1
11287 #define elf_backend_got_header_size 4
11288 #define elf_backend_want_dynbss 0
11289 #define elf_backend_want_got_plt 1
11290 #define elf_backend_dtrel_excludes_plt 1
11292 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11294 #define bfd_elf32_mkobject elf_xtensa_mkobject
11296 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11297 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11298 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11299 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11300 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11301 #define bfd_elf32_bfd_reloc_name_lookup \
11302 elf_xtensa_reloc_name_lookup
11303 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11304 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11306 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11307 #define elf_backend_check_relocs elf_xtensa_check_relocs
11308 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11309 #define elf_backend_discard_info elf_xtensa_discard_info
11310 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11311 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11312 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11313 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11314 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11315 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11316 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11317 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11318 #define elf_backend_object_p elf_xtensa_object_p
11319 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11320 #define elf_backend_relocate_section elf_xtensa_relocate_section
11321 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11322 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11323 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11324 #define elf_backend_special_sections elf_xtensa_special_sections
11325 #define elf_backend_action_discarded elf_xtensa_action_discarded
11326 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11328 #include "elf32-target.h"