1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 3 of the
10 License, or (at your option) any later version.
12 This program is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
31 #include "elf/xtensa.h"
32 #include "xtensa-isa.h"
33 #include "xtensa-config.h"
35 #define XTENSA_NO_NOP_REMOVAL 0
37 /* Local helper functions. */
39 static bfd_boolean add_extra_plt_sections (struct bfd_link_info *, int);
40 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
41 static bfd_reloc_status_type bfd_elf_xtensa_reloc
42 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
43 static bfd_boolean do_fix_for_relocatable_link
44 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *);
45 static void do_fix_for_final_link
46 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *, bfd_vma *);
48 /* Local functions to handle Xtensa configurability. */
50 static bfd_boolean is_indirect_call_opcode (xtensa_opcode);
51 static bfd_boolean is_direct_call_opcode (xtensa_opcode);
52 static bfd_boolean is_windowed_call_opcode (xtensa_opcode);
53 static xtensa_opcode get_const16_opcode (void);
54 static xtensa_opcode get_l32r_opcode (void);
55 static bfd_vma l32r_offset (bfd_vma, bfd_vma);
56 static int get_relocation_opnd (xtensa_opcode, int);
57 static int get_relocation_slot (int);
58 static xtensa_opcode get_relocation_opcode
59 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
60 static bfd_boolean is_l32r_relocation
61 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
62 static bfd_boolean is_alt_relocation (int);
63 static bfd_boolean is_operand_relocation (int);
64 static bfd_size_type insn_decode_len
65 (bfd_byte *, bfd_size_type, bfd_size_type);
66 static xtensa_opcode insn_decode_opcode
67 (bfd_byte *, bfd_size_type, bfd_size_type, int);
68 static bfd_boolean check_branch_target_aligned
69 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
70 static bfd_boolean check_loop_aligned
71 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
72 static bfd_boolean check_branch_target_aligned_address (bfd_vma, int);
73 static bfd_size_type get_asm_simplify_size
74 (bfd_byte *, bfd_size_type, bfd_size_type);
76 /* Functions for link-time code simplifications. */
78 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
79 (bfd_byte *, bfd_vma, bfd_vma, char **);
80 static bfd_reloc_status_type contract_asm_expansion
81 (bfd_byte *, bfd_vma, Elf_Internal_Rela *, char **);
82 static xtensa_opcode swap_callx_for_call_opcode (xtensa_opcode);
83 static xtensa_opcode get_expanded_call_opcode (bfd_byte *, int, bfd_boolean *);
85 /* Access to internal relocations, section contents and symbols. */
87 static Elf_Internal_Rela *retrieve_internal_relocs
88 (bfd *, asection *, bfd_boolean);
89 static void pin_internal_relocs (asection *, Elf_Internal_Rela *);
90 static void release_internal_relocs (asection *, Elf_Internal_Rela *);
91 static bfd_byte *retrieve_contents (bfd *, asection *, bfd_boolean);
92 static void pin_contents (asection *, bfd_byte *);
93 static void release_contents (asection *, bfd_byte *);
94 static Elf_Internal_Sym *retrieve_local_syms (bfd *);
96 /* Miscellaneous utility functions. */
98 static asection *elf_xtensa_get_plt_section (struct bfd_link_info *, int);
99 static asection *elf_xtensa_get_gotplt_section (struct bfd_link_info *, int);
100 static asection *get_elf_r_symndx_section (bfd *, unsigned long);
101 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
102 (bfd *, unsigned long);
103 static bfd_vma get_elf_r_symndx_offset (bfd *, unsigned long);
104 static bfd_boolean is_reloc_sym_weak (bfd *, Elf_Internal_Rela *);
105 static bfd_boolean pcrel_reloc_fits (xtensa_opcode, int, bfd_vma, bfd_vma);
106 static bfd_boolean xtensa_is_property_section (asection *);
107 static bfd_boolean xtensa_is_insntable_section (asection *);
108 static bfd_boolean xtensa_is_littable_section (asection *);
109 static bfd_boolean xtensa_is_proptable_section (asection *);
110 static int internal_reloc_compare (const void *, const void *);
111 static int internal_reloc_matches (const void *, const void *);
112 static asection *xtensa_get_property_section (asection *, const char *);
113 extern asection *xtensa_make_property_section (asection *, const char *);
114 static flagword xtensa_get_property_predef_flags (asection *);
116 /* Other functions called directly by the linker. */
118 typedef void (*deps_callback_t)
119 (asection *, bfd_vma, asection *, bfd_vma, void *);
120 extern bfd_boolean xtensa_callback_required_dependence
121 (bfd *, asection *, struct bfd_link_info *, deps_callback_t, void *);
124 /* Globally visible flag for choosing size optimization of NOP removal
125 instead of branch-target-aware minimization for NOP removal.
126 When nonzero, narrow all instructions and remove all NOPs possible
127 around longcall expansions. */
129 int elf32xtensa_size_opt;
132 /* The "new_section_hook" is used to set up a per-section
133 "xtensa_relax_info" data structure with additional information used
134 during relaxation. */
136 typedef struct xtensa_relax_info_struct xtensa_relax_info;
139 /* The GNU tools do not easily allow extending interfaces to pass around
140 the pointer to the Xtensa ISA information, so instead we add a global
141 variable here (in BFD) that can be used by any of the tools that need
144 xtensa_isa xtensa_default_isa;
147 /* When this is true, relocations may have been modified to refer to
148 symbols from other input files. The per-section list of "fix"
149 records needs to be checked when resolving relocations. */
151 static bfd_boolean relaxing_section = FALSE;
153 /* When this is true, during final links, literals that cannot be
154 coalesced and their relocations may be moved to other sections. */
156 int elf32xtensa_no_literal_movement = 1;
158 /* Rename one of the generic section flags to better document how it
160 /* Whether relocations have been processed. */
161 #define reloc_done sec_flg0
163 static reloc_howto_type elf_howto_table[] =
165 HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
166 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
168 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
169 bfd_elf_xtensa_reloc, "R_XTENSA_32",
170 TRUE, 0xffffffff, 0xffffffff, FALSE),
172 /* Replace a 32-bit value with a value from the runtime linker (only
173 used by linker-generated stub functions). The r_addend value is
174 special: 1 means to substitute a pointer to the runtime linker's
175 dynamic resolver function; 2 means to substitute the link map for
176 the shared object. */
177 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
178 NULL, "R_XTENSA_RTLD", FALSE, 0, 0, FALSE),
180 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
181 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
182 FALSE, 0, 0xffffffff, FALSE),
183 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
184 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
185 FALSE, 0, 0xffffffff, FALSE),
186 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
187 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
188 FALSE, 0, 0xffffffff, FALSE),
189 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
190 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
191 FALSE, 0, 0xffffffff, FALSE),
195 /* Old relocations for backward compatibility. */
196 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
197 bfd_elf_xtensa_reloc, "R_XTENSA_OP0", FALSE, 0, 0, TRUE),
198 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
199 bfd_elf_xtensa_reloc, "R_XTENSA_OP1", FALSE, 0, 0, TRUE),
200 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
201 bfd_elf_xtensa_reloc, "R_XTENSA_OP2", FALSE, 0, 0, TRUE),
203 /* Assembly auto-expansion. */
204 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
205 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND", FALSE, 0, 0, TRUE),
206 /* Relax assembly auto-expansion. */
207 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
208 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY", FALSE, 0, 0, TRUE),
212 HOWTO (R_XTENSA_32_PCREL, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
213 bfd_elf_xtensa_reloc, "R_XTENSA_32_PCREL",
214 FALSE, 0, 0xffffffff, TRUE),
216 /* GNU extension to record C++ vtable hierarchy. */
217 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
218 NULL, "R_XTENSA_GNU_VTINHERIT",
220 /* GNU extension to record C++ vtable member usage. */
221 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
222 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
225 /* Relocations for supporting difference of symbols. */
226 HOWTO (R_XTENSA_DIFF8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
227 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF8", FALSE, 0, 0xff, FALSE),
228 HOWTO (R_XTENSA_DIFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
229 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF16", FALSE, 0, 0xffff, FALSE),
230 HOWTO (R_XTENSA_DIFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
231 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF32", FALSE, 0, 0xffffffff, FALSE),
233 /* General immediate operand relocations. */
234 HOWTO (R_XTENSA_SLOT0_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
235 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_OP", FALSE, 0, 0, TRUE),
236 HOWTO (R_XTENSA_SLOT1_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
237 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_OP", FALSE, 0, 0, TRUE),
238 HOWTO (R_XTENSA_SLOT2_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
239 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_OP", FALSE, 0, 0, TRUE),
240 HOWTO (R_XTENSA_SLOT3_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
241 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_OP", FALSE, 0, 0, TRUE),
242 HOWTO (R_XTENSA_SLOT4_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
243 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_OP", FALSE, 0, 0, TRUE),
244 HOWTO (R_XTENSA_SLOT5_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
245 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_OP", FALSE, 0, 0, TRUE),
246 HOWTO (R_XTENSA_SLOT6_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
247 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_OP", FALSE, 0, 0, TRUE),
248 HOWTO (R_XTENSA_SLOT7_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
249 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_OP", FALSE, 0, 0, TRUE),
250 HOWTO (R_XTENSA_SLOT8_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
251 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_OP", FALSE, 0, 0, TRUE),
252 HOWTO (R_XTENSA_SLOT9_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
253 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_OP", FALSE, 0, 0, TRUE),
254 HOWTO (R_XTENSA_SLOT10_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
255 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_OP", FALSE, 0, 0, TRUE),
256 HOWTO (R_XTENSA_SLOT11_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
257 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_OP", FALSE, 0, 0, TRUE),
258 HOWTO (R_XTENSA_SLOT12_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
259 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_OP", FALSE, 0, 0, TRUE),
260 HOWTO (R_XTENSA_SLOT13_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
261 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_OP", FALSE, 0, 0, TRUE),
262 HOWTO (R_XTENSA_SLOT14_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
263 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_OP", FALSE, 0, 0, TRUE),
265 /* "Alternate" relocations. The meaning of these is opcode-specific. */
266 HOWTO (R_XTENSA_SLOT0_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
267 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_ALT", FALSE, 0, 0, TRUE),
268 HOWTO (R_XTENSA_SLOT1_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
269 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_ALT", FALSE, 0, 0, TRUE),
270 HOWTO (R_XTENSA_SLOT2_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
271 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_ALT", FALSE, 0, 0, TRUE),
272 HOWTO (R_XTENSA_SLOT3_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
273 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_ALT", FALSE, 0, 0, TRUE),
274 HOWTO (R_XTENSA_SLOT4_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
275 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_ALT", FALSE, 0, 0, TRUE),
276 HOWTO (R_XTENSA_SLOT5_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
277 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_ALT", FALSE, 0, 0, TRUE),
278 HOWTO (R_XTENSA_SLOT6_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
279 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_ALT", FALSE, 0, 0, TRUE),
280 HOWTO (R_XTENSA_SLOT7_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
281 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_ALT", FALSE, 0, 0, TRUE),
282 HOWTO (R_XTENSA_SLOT8_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
283 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_ALT", FALSE, 0, 0, TRUE),
284 HOWTO (R_XTENSA_SLOT9_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
285 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_ALT", FALSE, 0, 0, TRUE),
286 HOWTO (R_XTENSA_SLOT10_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
287 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_ALT", FALSE, 0, 0, TRUE),
288 HOWTO (R_XTENSA_SLOT11_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
289 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_ALT", FALSE, 0, 0, TRUE),
290 HOWTO (R_XTENSA_SLOT12_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
291 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_ALT", FALSE, 0, 0, TRUE),
292 HOWTO (R_XTENSA_SLOT13_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
293 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_ALT", FALSE, 0, 0, TRUE),
294 HOWTO (R_XTENSA_SLOT14_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
295 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_ALT", FALSE, 0, 0, TRUE),
297 /* TLS relocations. */
298 HOWTO (R_XTENSA_TLSDESC_FN, 0, 2, 32, FALSE, 0, complain_overflow_dont,
299 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_FN",
300 FALSE, 0, 0xffffffff, FALSE),
301 HOWTO (R_XTENSA_TLSDESC_ARG, 0, 2, 32, FALSE, 0, complain_overflow_dont,
302 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_ARG",
303 FALSE, 0, 0xffffffff, FALSE),
304 HOWTO (R_XTENSA_TLS_DTPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
305 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_DTPOFF",
306 FALSE, 0, 0xffffffff, FALSE),
307 HOWTO (R_XTENSA_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
308 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_TPOFF",
309 FALSE, 0, 0xffffffff, FALSE),
310 HOWTO (R_XTENSA_TLS_FUNC, 0, 0, 0, FALSE, 0, complain_overflow_dont,
311 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_FUNC",
313 HOWTO (R_XTENSA_TLS_ARG, 0, 0, 0, FALSE, 0, complain_overflow_dont,
314 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_ARG",
316 HOWTO (R_XTENSA_TLS_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
317 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_CALL",
323 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
328 static reloc_howto_type *
329 elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
330 bfd_reloc_code_real_type code)
335 TRACE ("BFD_RELOC_NONE");
336 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
339 TRACE ("BFD_RELOC_32");
340 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
342 case BFD_RELOC_32_PCREL:
343 TRACE ("BFD_RELOC_32_PCREL");
344 return &elf_howto_table[(unsigned) R_XTENSA_32_PCREL ];
346 case BFD_RELOC_XTENSA_DIFF8:
347 TRACE ("BFD_RELOC_XTENSA_DIFF8");
348 return &elf_howto_table[(unsigned) R_XTENSA_DIFF8 ];
350 case BFD_RELOC_XTENSA_DIFF16:
351 TRACE ("BFD_RELOC_XTENSA_DIFF16");
352 return &elf_howto_table[(unsigned) R_XTENSA_DIFF16 ];
354 case BFD_RELOC_XTENSA_DIFF32:
355 TRACE ("BFD_RELOC_XTENSA_DIFF32");
356 return &elf_howto_table[(unsigned) R_XTENSA_DIFF32 ];
358 case BFD_RELOC_XTENSA_RTLD:
359 TRACE ("BFD_RELOC_XTENSA_RTLD");
360 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
362 case BFD_RELOC_XTENSA_GLOB_DAT:
363 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
364 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
366 case BFD_RELOC_XTENSA_JMP_SLOT:
367 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
368 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
370 case BFD_RELOC_XTENSA_RELATIVE:
371 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
372 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
374 case BFD_RELOC_XTENSA_PLT:
375 TRACE ("BFD_RELOC_XTENSA_PLT");
376 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
378 case BFD_RELOC_XTENSA_OP0:
379 TRACE ("BFD_RELOC_XTENSA_OP0");
380 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
382 case BFD_RELOC_XTENSA_OP1:
383 TRACE ("BFD_RELOC_XTENSA_OP1");
384 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
386 case BFD_RELOC_XTENSA_OP2:
387 TRACE ("BFD_RELOC_XTENSA_OP2");
388 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
390 case BFD_RELOC_XTENSA_ASM_EXPAND:
391 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
392 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
394 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
395 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
396 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
398 case BFD_RELOC_VTABLE_INHERIT:
399 TRACE ("BFD_RELOC_VTABLE_INHERIT");
400 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
402 case BFD_RELOC_VTABLE_ENTRY:
403 TRACE ("BFD_RELOC_VTABLE_ENTRY");
404 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
406 case BFD_RELOC_XTENSA_TLSDESC_FN:
407 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
408 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_FN ];
410 case BFD_RELOC_XTENSA_TLSDESC_ARG:
411 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
412 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_ARG ];
414 case BFD_RELOC_XTENSA_TLS_DTPOFF:
415 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
416 return &elf_howto_table[(unsigned) R_XTENSA_TLS_DTPOFF ];
418 case BFD_RELOC_XTENSA_TLS_TPOFF:
419 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
420 return &elf_howto_table[(unsigned) R_XTENSA_TLS_TPOFF ];
422 case BFD_RELOC_XTENSA_TLS_FUNC:
423 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
424 return &elf_howto_table[(unsigned) R_XTENSA_TLS_FUNC ];
426 case BFD_RELOC_XTENSA_TLS_ARG:
427 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
428 return &elf_howto_table[(unsigned) R_XTENSA_TLS_ARG ];
430 case BFD_RELOC_XTENSA_TLS_CALL:
431 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
432 return &elf_howto_table[(unsigned) R_XTENSA_TLS_CALL ];
435 if (code >= BFD_RELOC_XTENSA_SLOT0_OP
436 && code <= BFD_RELOC_XTENSA_SLOT14_OP)
438 unsigned n = (R_XTENSA_SLOT0_OP +
439 (code - BFD_RELOC_XTENSA_SLOT0_OP));
440 return &elf_howto_table[n];
443 if (code >= BFD_RELOC_XTENSA_SLOT0_ALT
444 && code <= BFD_RELOC_XTENSA_SLOT14_ALT)
446 unsigned n = (R_XTENSA_SLOT0_ALT +
447 (code - BFD_RELOC_XTENSA_SLOT0_ALT));
448 return &elf_howto_table[n];
458 static reloc_howto_type *
459 elf_xtensa_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
464 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
465 if (elf_howto_table[i].name != NULL
466 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
467 return &elf_howto_table[i];
473 /* Given an ELF "rela" relocation, find the corresponding howto and record
474 it in the BFD internal arelent representation of the relocation. */
477 elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
479 Elf_Internal_Rela *dst)
481 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
483 BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max);
484 cache_ptr->howto = &elf_howto_table[r_type];
488 /* Functions for the Xtensa ELF linker. */
490 /* The name of the dynamic interpreter. This is put in the .interp
493 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
495 /* The size in bytes of an entry in the procedure linkage table.
496 (This does _not_ include the space for the literals associated with
499 #define PLT_ENTRY_SIZE 16
501 /* For _really_ large PLTs, we may need to alternate between literals
502 and code to keep the literals within the 256K range of the L32R
503 instructions in the code. It's unlikely that anyone would ever need
504 such a big PLT, but an arbitrary limit on the PLT size would be bad.
505 Thus, we split the PLT into chunks. Since there's very little
506 overhead (2 extra literals) for each chunk, the chunk size is kept
507 small so that the code for handling multiple chunks get used and
508 tested regularly. With 254 entries, there are 1K of literals for
509 each chunk, and that seems like a nice round number. */
511 #define PLT_ENTRIES_PER_CHUNK 254
513 /* PLT entries are actually used as stub functions for lazy symbol
514 resolution. Once the symbol is resolved, the stub function is never
515 invoked. Note: the 32-byte frame size used here cannot be changed
516 without a corresponding change in the runtime linker. */
518 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
520 0x6c, 0x10, 0x04, /* entry sp, 32 */
521 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
522 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
523 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
524 0x0a, 0x80, 0x00, /* jx a8 */
528 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
530 0x36, 0x41, 0x00, /* entry sp, 32 */
531 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
532 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
533 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
534 0xa0, 0x08, 0x00, /* jx a8 */
538 /* The size of the thread control block. */
541 struct elf_xtensa_link_hash_entry
543 struct elf_link_hash_entry elf;
545 bfd_signed_vma tlsfunc_refcount;
547 #define GOT_UNKNOWN 0
549 #define GOT_TLS_GD 2 /* global or local dynamic */
550 #define GOT_TLS_IE 4 /* initial or local exec */
551 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
552 unsigned char tls_type;
555 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
557 struct elf_xtensa_obj_tdata
559 struct elf_obj_tdata root;
561 /* tls_type for each local got entry. */
562 char *local_got_tls_type;
564 bfd_signed_vma *local_tlsfunc_refcounts;
567 #define elf_xtensa_tdata(abfd) \
568 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
570 #define elf_xtensa_local_got_tls_type(abfd) \
571 (elf_xtensa_tdata (abfd)->local_got_tls_type)
573 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
574 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
576 #define is_xtensa_elf(bfd) \
577 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
578 && elf_tdata (bfd) != NULL \
579 && elf_object_id (bfd) == XTENSA_ELF_DATA)
582 elf_xtensa_mkobject (bfd *abfd)
584 return bfd_elf_allocate_object (abfd, sizeof (struct elf_xtensa_obj_tdata),
588 /* Xtensa ELF linker hash table. */
590 struct elf_xtensa_link_hash_table
592 struct elf_link_hash_table elf;
594 /* Short-cuts to get to dynamic linker sections. */
601 asection *spltlittbl;
603 /* Total count of PLT relocations seen during check_relocs.
604 The actual PLT code must be split into multiple sections and all
605 the sections have to be created before size_dynamic_sections,
606 where we figure out the exact number of PLT entries that will be
607 needed. It is OK if this count is an overestimate, e.g., some
608 relocations may be removed by GC. */
611 struct elf_xtensa_link_hash_entry *tlsbase;
614 /* Get the Xtensa ELF linker hash table from a link_info structure. */
616 #define elf_xtensa_hash_table(p) \
617 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
618 == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
620 /* Create an entry in an Xtensa ELF linker hash table. */
622 static struct bfd_hash_entry *
623 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry *entry,
624 struct bfd_hash_table *table,
627 /* Allocate the structure if it has not already been allocated by a
631 entry = bfd_hash_allocate (table,
632 sizeof (struct elf_xtensa_link_hash_entry));
637 /* Call the allocation method of the superclass. */
638 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
641 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (entry);
642 eh->tlsfunc_refcount = 0;
643 eh->tls_type = GOT_UNKNOWN;
649 /* Create an Xtensa ELF linker hash table. */
651 static struct bfd_link_hash_table *
652 elf_xtensa_link_hash_table_create (bfd *abfd)
654 struct elf_link_hash_entry *tlsbase;
655 struct elf_xtensa_link_hash_table *ret;
656 bfd_size_type amt = sizeof (struct elf_xtensa_link_hash_table);
658 ret = bfd_malloc (amt);
662 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
663 elf_xtensa_link_hash_newfunc,
664 sizeof (struct elf_xtensa_link_hash_entry),
677 ret->spltlittbl = NULL;
679 ret->plt_reloc_count = 0;
681 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
683 tlsbase = elf_link_hash_lookup (&ret->elf, "_TLS_MODULE_BASE_",
685 tlsbase->root.type = bfd_link_hash_new;
686 tlsbase->root.u.undef.abfd = NULL;
687 tlsbase->non_elf = 0;
688 ret->tlsbase = elf_xtensa_hash_entry (tlsbase);
689 ret->tlsbase->tls_type = GOT_UNKNOWN;
691 return &ret->elf.root;
694 /* Copy the extra info we tack onto an elf_link_hash_entry. */
697 elf_xtensa_copy_indirect_symbol (struct bfd_link_info *info,
698 struct elf_link_hash_entry *dir,
699 struct elf_link_hash_entry *ind)
701 struct elf_xtensa_link_hash_entry *edir, *eind;
703 edir = elf_xtensa_hash_entry (dir);
704 eind = elf_xtensa_hash_entry (ind);
706 if (ind->root.type == bfd_link_hash_indirect)
708 edir->tlsfunc_refcount += eind->tlsfunc_refcount;
709 eind->tlsfunc_refcount = 0;
711 if (dir->got.refcount <= 0)
713 edir->tls_type = eind->tls_type;
714 eind->tls_type = GOT_UNKNOWN;
718 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
721 static inline bfd_boolean
722 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry *h,
723 struct bfd_link_info *info)
725 /* Check if we should do dynamic things to this symbol. The
726 "ignore_protected" argument need not be set, because Xtensa code
727 does not require special handling of STV_PROTECTED to make function
728 pointer comparisons work properly. The PLT addresses are never
729 used for function pointers. */
731 return _bfd_elf_dynamic_symbol_p (h, info, 0);
736 property_table_compare (const void *ap, const void *bp)
738 const property_table_entry *a = (const property_table_entry *) ap;
739 const property_table_entry *b = (const property_table_entry *) bp;
741 if (a->address == b->address)
743 if (a->size != b->size)
744 return (a->size - b->size);
746 if ((a->flags & XTENSA_PROP_ALIGN) != (b->flags & XTENSA_PROP_ALIGN))
747 return ((b->flags & XTENSA_PROP_ALIGN)
748 - (a->flags & XTENSA_PROP_ALIGN));
750 if ((a->flags & XTENSA_PROP_ALIGN)
751 && (GET_XTENSA_PROP_ALIGNMENT (a->flags)
752 != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
753 return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
754 - GET_XTENSA_PROP_ALIGNMENT (b->flags));
756 if ((a->flags & XTENSA_PROP_UNREACHABLE)
757 != (b->flags & XTENSA_PROP_UNREACHABLE))
758 return ((b->flags & XTENSA_PROP_UNREACHABLE)
759 - (a->flags & XTENSA_PROP_UNREACHABLE));
761 return (a->flags - b->flags);
764 return (a->address - b->address);
769 property_table_matches (const void *ap, const void *bp)
771 const property_table_entry *a = (const property_table_entry *) ap;
772 const property_table_entry *b = (const property_table_entry *) bp;
774 /* Check if one entry overlaps with the other. */
775 if ((b->address >= a->address && b->address < (a->address + a->size))
776 || (a->address >= b->address && a->address < (b->address + b->size)))
779 return (a->address - b->address);
783 /* Get the literal table or property table entries for the given
784 section. Sets TABLE_P and returns the number of entries. On
785 error, returns a negative value. */
788 xtensa_read_table_entries (bfd *abfd,
790 property_table_entry **table_p,
791 const char *sec_name,
792 bfd_boolean output_addr)
794 asection *table_section;
795 bfd_size_type table_size = 0;
796 bfd_byte *table_data;
797 property_table_entry *blocks;
798 int blk, block_count;
799 bfd_size_type num_records;
800 Elf_Internal_Rela *internal_relocs, *irel, *rel_end;
801 bfd_vma section_addr, off;
802 flagword predef_flags;
803 bfd_size_type table_entry_size, section_limit;
806 || !(section->flags & SEC_ALLOC)
807 || (section->flags & SEC_DEBUGGING))
813 table_section = xtensa_get_property_section (section, sec_name);
815 table_size = table_section->size;
823 predef_flags = xtensa_get_property_predef_flags (table_section);
824 table_entry_size = 12;
826 table_entry_size -= 4;
828 num_records = table_size / table_entry_size;
829 table_data = retrieve_contents (abfd, table_section, TRUE);
830 blocks = (property_table_entry *)
831 bfd_malloc (num_records * sizeof (property_table_entry));
835 section_addr = section->output_section->vma + section->output_offset;
837 section_addr = section->vma;
839 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
840 if (internal_relocs && !table_section->reloc_done)
842 qsort (internal_relocs, table_section->reloc_count,
843 sizeof (Elf_Internal_Rela), internal_reloc_compare);
844 irel = internal_relocs;
849 section_limit = bfd_get_section_limit (abfd, section);
850 rel_end = internal_relocs + table_section->reloc_count;
852 for (off = 0; off < table_size; off += table_entry_size)
854 bfd_vma address = bfd_get_32 (abfd, table_data + off);
856 /* Skip any relocations before the current offset. This should help
857 avoid confusion caused by unexpected relocations for the preceding
860 (irel->r_offset < off
861 || (irel->r_offset == off
862 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_NONE)))
869 if (irel && irel->r_offset == off)
872 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
873 BFD_ASSERT (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32);
875 if (get_elf_r_symndx_section (abfd, r_symndx) != section)
878 sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
879 BFD_ASSERT (sym_off == 0);
880 address += (section_addr + sym_off + irel->r_addend);
884 if (address < section_addr
885 || address >= section_addr + section_limit)
889 blocks[block_count].address = address;
890 blocks[block_count].size = bfd_get_32 (abfd, table_data + off + 4);
892 blocks[block_count].flags = predef_flags;
894 blocks[block_count].flags = bfd_get_32 (abfd, table_data + off + 8);
898 release_contents (table_section, table_data);
899 release_internal_relocs (table_section, internal_relocs);
903 /* Now sort them into address order for easy reference. */
904 qsort (blocks, block_count, sizeof (property_table_entry),
905 property_table_compare);
907 /* Check that the table contents are valid. Problems may occur,
908 for example, if an unrelocated object file is stripped. */
909 for (blk = 1; blk < block_count; blk++)
911 /* The only circumstance where two entries may legitimately
912 have the same address is when one of them is a zero-size
913 placeholder to mark a place where fill can be inserted.
914 The zero-size entry should come first. */
915 if (blocks[blk - 1].address == blocks[blk].address &&
916 blocks[blk - 1].size != 0)
918 (*_bfd_error_handler) (_("%B(%A): invalid property table"),
920 bfd_set_error (bfd_error_bad_value);
932 static property_table_entry *
933 elf_xtensa_find_property_entry (property_table_entry *property_table,
934 int property_table_size,
937 property_table_entry entry;
938 property_table_entry *rv;
940 if (property_table_size == 0)
943 entry.address = addr;
947 rv = bsearch (&entry, property_table, property_table_size,
948 sizeof (property_table_entry), property_table_matches);
954 elf_xtensa_in_literal_pool (property_table_entry *lit_table,
958 if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
965 /* Look through the relocs for a section during the first phase, and
966 calculate needed space in the dynamic reloc sections. */
969 elf_xtensa_check_relocs (bfd *abfd,
970 struct bfd_link_info *info,
972 const Elf_Internal_Rela *relocs)
974 struct elf_xtensa_link_hash_table *htab;
975 Elf_Internal_Shdr *symtab_hdr;
976 struct elf_link_hash_entry **sym_hashes;
977 const Elf_Internal_Rela *rel;
978 const Elf_Internal_Rela *rel_end;
980 if (info->relocatable || (sec->flags & SEC_ALLOC) == 0)
983 BFD_ASSERT (is_xtensa_elf (abfd));
985 htab = elf_xtensa_hash_table (info);
989 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
990 sym_hashes = elf_sym_hashes (abfd);
992 rel_end = relocs + sec->reloc_count;
993 for (rel = relocs; rel < rel_end; rel++)
996 unsigned long r_symndx;
997 struct elf_link_hash_entry *h = NULL;
998 struct elf_xtensa_link_hash_entry *eh;
999 int tls_type, old_tls_type;
1000 bfd_boolean is_got = FALSE;
1001 bfd_boolean is_plt = FALSE;
1002 bfd_boolean is_tlsfunc = FALSE;
1004 r_symndx = ELF32_R_SYM (rel->r_info);
1005 r_type = ELF32_R_TYPE (rel->r_info);
1007 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1009 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1014 if (r_symndx >= symtab_hdr->sh_info)
1016 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1017 while (h->root.type == bfd_link_hash_indirect
1018 || h->root.type == bfd_link_hash_warning)
1019 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1021 eh = elf_xtensa_hash_entry (h);
1025 case R_XTENSA_TLSDESC_FN:
1028 tls_type = GOT_TLS_GD;
1033 tls_type = GOT_TLS_IE;
1036 case R_XTENSA_TLSDESC_ARG:
1039 tls_type = GOT_TLS_GD;
1044 tls_type = GOT_TLS_IE;
1045 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1050 case R_XTENSA_TLS_DTPOFF:
1052 tls_type = GOT_TLS_GD;
1054 tls_type = GOT_TLS_IE;
1057 case R_XTENSA_TLS_TPOFF:
1058 tls_type = GOT_TLS_IE;
1060 info->flags |= DF_STATIC_TLS;
1061 if (info->shared || h)
1066 tls_type = GOT_NORMAL;
1071 tls_type = GOT_NORMAL;
1075 case R_XTENSA_GNU_VTINHERIT:
1076 /* This relocation describes the C++ object vtable hierarchy.
1077 Reconstruct it for later use during GC. */
1078 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1082 case R_XTENSA_GNU_VTENTRY:
1083 /* This relocation describes which C++ vtable entries are actually
1084 used. Record for later use during GC. */
1085 BFD_ASSERT (h != NULL);
1087 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1092 /* Nothing to do for any other relocations. */
1100 if (h->plt.refcount <= 0)
1103 h->plt.refcount = 1;
1106 h->plt.refcount += 1;
1108 /* Keep track of the total PLT relocation count even if we
1109 don't yet know whether the dynamic sections will be
1111 htab->plt_reloc_count += 1;
1113 if (elf_hash_table (info)->dynamic_sections_created)
1115 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1121 if (h->got.refcount <= 0)
1122 h->got.refcount = 1;
1124 h->got.refcount += 1;
1128 eh->tlsfunc_refcount += 1;
1130 old_tls_type = eh->tls_type;
1134 /* Allocate storage the first time. */
1135 if (elf_local_got_refcounts (abfd) == NULL)
1137 bfd_size_type size = symtab_hdr->sh_info;
1140 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1143 elf_local_got_refcounts (abfd) = (bfd_signed_vma *) mem;
1145 mem = bfd_zalloc (abfd, size);
1148 elf_xtensa_local_got_tls_type (abfd) = (char *) mem;
1150 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1153 elf_xtensa_local_tlsfunc_refcounts (abfd)
1154 = (bfd_signed_vma *) mem;
1157 /* This is a global offset table entry for a local symbol. */
1158 if (is_got || is_plt)
1159 elf_local_got_refcounts (abfd) [r_symndx] += 1;
1162 elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx] += 1;
1164 old_tls_type = elf_xtensa_local_got_tls_type (abfd) [r_symndx];
1167 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1168 tls_type |= old_tls_type;
1169 /* If a TLS symbol is accessed using IE at least once,
1170 there is no point to use a dynamic model for it. */
1171 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1172 && ((old_tls_type & GOT_TLS_GD) == 0
1173 || (tls_type & GOT_TLS_IE) == 0))
1175 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_GD))
1176 tls_type = old_tls_type;
1177 else if ((old_tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_GD))
1178 tls_type |= old_tls_type;
1181 (*_bfd_error_handler)
1182 (_("%B: `%s' accessed both as normal and thread local symbol"),
1184 h ? h->root.root.string : "<local>");
1189 if (old_tls_type != tls_type)
1192 eh->tls_type = tls_type;
1194 elf_xtensa_local_got_tls_type (abfd) [r_symndx] = tls_type;
1203 elf_xtensa_make_sym_local (struct bfd_link_info *info,
1204 struct elf_link_hash_entry *h)
1208 if (h->plt.refcount > 0)
1210 /* For shared objects, there's no need for PLT entries for local
1211 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1212 if (h->got.refcount < 0)
1213 h->got.refcount = 0;
1214 h->got.refcount += h->plt.refcount;
1215 h->plt.refcount = 0;
1220 /* Don't need any dynamic relocations at all. */
1221 h->plt.refcount = 0;
1222 h->got.refcount = 0;
1228 elf_xtensa_hide_symbol (struct bfd_link_info *info,
1229 struct elf_link_hash_entry *h,
1230 bfd_boolean force_local)
1232 /* For a shared link, move the plt refcount to the got refcount to leave
1233 space for RELATIVE relocs. */
1234 elf_xtensa_make_sym_local (info, h);
1236 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
1240 /* Return the section that should be marked against GC for a given
1244 elf_xtensa_gc_mark_hook (asection *sec,
1245 struct bfd_link_info *info,
1246 Elf_Internal_Rela *rel,
1247 struct elf_link_hash_entry *h,
1248 Elf_Internal_Sym *sym)
1250 /* Property sections are marked "KEEP" in the linker scripts, but they
1251 should not cause other sections to be marked. (This approach relies
1252 on elf_xtensa_discard_info to remove property table entries that
1253 describe discarded sections. Alternatively, it might be more
1254 efficient to avoid using "KEEP" in the linker scripts and instead use
1255 the gc_mark_extra_sections hook to mark only the property sections
1256 that describe marked sections. That alternative does not work well
1257 with the current property table sections, which do not correspond
1258 one-to-one with the sections they describe, but that should be fixed
1260 if (xtensa_is_property_section (sec))
1264 switch (ELF32_R_TYPE (rel->r_info))
1266 case R_XTENSA_GNU_VTINHERIT:
1267 case R_XTENSA_GNU_VTENTRY:
1271 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1275 /* Update the GOT & PLT entry reference counts
1276 for the section being removed. */
1279 elf_xtensa_gc_sweep_hook (bfd *abfd,
1280 struct bfd_link_info *info,
1282 const Elf_Internal_Rela *relocs)
1284 Elf_Internal_Shdr *symtab_hdr;
1285 struct elf_link_hash_entry **sym_hashes;
1286 const Elf_Internal_Rela *rel, *relend;
1287 struct elf_xtensa_link_hash_table *htab;
1289 htab = elf_xtensa_hash_table (info);
1293 if (info->relocatable)
1296 if ((sec->flags & SEC_ALLOC) == 0)
1299 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1300 sym_hashes = elf_sym_hashes (abfd);
1302 relend = relocs + sec->reloc_count;
1303 for (rel = relocs; rel < relend; rel++)
1305 unsigned long r_symndx;
1306 unsigned int r_type;
1307 struct elf_link_hash_entry *h = NULL;
1308 struct elf_xtensa_link_hash_entry *eh;
1309 bfd_boolean is_got = FALSE;
1310 bfd_boolean is_plt = FALSE;
1311 bfd_boolean is_tlsfunc = FALSE;
1313 r_symndx = ELF32_R_SYM (rel->r_info);
1314 if (r_symndx >= symtab_hdr->sh_info)
1316 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1317 while (h->root.type == bfd_link_hash_indirect
1318 || h->root.type == bfd_link_hash_warning)
1319 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1321 eh = elf_xtensa_hash_entry (h);
1323 r_type = ELF32_R_TYPE (rel->r_info);
1326 case R_XTENSA_TLSDESC_FN:
1334 case R_XTENSA_TLSDESC_ARG:
1339 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1344 case R_XTENSA_TLS_TPOFF:
1345 if (info->shared || h)
1365 if (h->plt.refcount > 0)
1370 if (h->got.refcount > 0)
1375 if (eh->tlsfunc_refcount > 0)
1376 eh->tlsfunc_refcount--;
1381 if (is_got || is_plt)
1383 bfd_signed_vma *got_refcount
1384 = &elf_local_got_refcounts (abfd) [r_symndx];
1385 if (*got_refcount > 0)
1390 bfd_signed_vma *tlsfunc_refcount
1391 = &elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx];
1392 if (*tlsfunc_refcount > 0)
1393 *tlsfunc_refcount -= 1;
1402 /* Create all the dynamic sections. */
1405 elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1407 struct elf_xtensa_link_hash_table *htab;
1408 flagword flags, noalloc_flags;
1410 htab = elf_xtensa_hash_table (info);
1414 /* First do all the standard stuff. */
1415 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
1417 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1418 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1419 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1420 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1421 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1423 /* Create any extra PLT sections in case check_relocs has already
1424 been called on all the non-dynamic input files. */
1425 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1428 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
1429 | SEC_LINKER_CREATED | SEC_READONLY);
1430 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
1432 /* Mark the ".got.plt" section READONLY. */
1433 if (htab->sgotplt == NULL
1434 || ! bfd_set_section_flags (dynobj, htab->sgotplt, flags))
1437 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1438 htab->sgotloc = bfd_make_section_with_flags (dynobj, ".got.loc", flags);
1439 if (htab->sgotloc == NULL
1440 || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
1443 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1444 htab->spltlittbl = bfd_make_section_with_flags (dynobj, ".xt.lit.plt",
1446 if (htab->spltlittbl == NULL
1447 || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
1455 add_extra_plt_sections (struct bfd_link_info *info, int count)
1457 bfd *dynobj = elf_hash_table (info)->dynobj;
1460 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1461 ".got.plt" sections. */
1462 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1468 /* Stop when we find a section has already been created. */
1469 if (elf_xtensa_get_plt_section (info, chunk))
1472 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1473 | SEC_LINKER_CREATED | SEC_READONLY);
1475 sname = (char *) bfd_malloc (10);
1476 sprintf (sname, ".plt.%u", chunk);
1477 s = bfd_make_section_with_flags (dynobj, sname, flags | SEC_CODE);
1479 || ! bfd_set_section_alignment (dynobj, s, 2))
1482 sname = (char *) bfd_malloc (14);
1483 sprintf (sname, ".got.plt.%u", chunk);
1484 s = bfd_make_section_with_flags (dynobj, sname, flags);
1486 || ! bfd_set_section_alignment (dynobj, s, 2))
1494 /* Adjust a symbol defined by a dynamic object and referenced by a
1495 regular object. The current definition is in some section of the
1496 dynamic object, but we're not including those sections. We have to
1497 change the definition to something the rest of the link can
1501 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1502 struct elf_link_hash_entry *h)
1504 /* If this is a weak symbol, and there is a real definition, the
1505 processor independent code will have arranged for us to see the
1506 real definition first, and we can just use the same value. */
1509 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1510 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1511 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1512 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1516 /* This is a reference to a symbol defined by a dynamic object. The
1517 reference must go through the GOT, so there's no need for COPY relocs,
1525 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry *h, void *arg)
1527 struct bfd_link_info *info;
1528 struct elf_xtensa_link_hash_table *htab;
1529 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (h);
1531 if (h->root.type == bfd_link_hash_indirect)
1534 if (h->root.type == bfd_link_hash_warning)
1535 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1537 info = (struct bfd_link_info *) arg;
1538 htab = elf_xtensa_hash_table (info);
1542 /* If we saw any use of an IE model for this symbol, we can then optimize
1543 away GOT entries for any TLSDESC_FN relocs. */
1544 if ((eh->tls_type & GOT_TLS_IE) != 0)
1546 BFD_ASSERT (h->got.refcount >= eh->tlsfunc_refcount);
1547 h->got.refcount -= eh->tlsfunc_refcount;
1550 if (! elf_xtensa_dynamic_symbol_p (h, info))
1551 elf_xtensa_make_sym_local (info, h);
1553 if (h->plt.refcount > 0)
1554 htab->srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1556 if (h->got.refcount > 0)
1557 htab->srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
1564 elf_xtensa_allocate_local_got_size (struct bfd_link_info *info)
1566 struct elf_xtensa_link_hash_table *htab;
1569 htab = elf_xtensa_hash_table (info);
1573 for (i = info->input_bfds; i; i = i->link_next)
1575 bfd_signed_vma *local_got_refcounts;
1576 bfd_size_type j, cnt;
1577 Elf_Internal_Shdr *symtab_hdr;
1579 local_got_refcounts = elf_local_got_refcounts (i);
1580 if (!local_got_refcounts)
1583 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1584 cnt = symtab_hdr->sh_info;
1586 for (j = 0; j < cnt; ++j)
1588 /* If we saw any use of an IE model for this symbol, we can
1589 then optimize away GOT entries for any TLSDESC_FN relocs. */
1590 if ((elf_xtensa_local_got_tls_type (i) [j] & GOT_TLS_IE) != 0)
1592 bfd_signed_vma *tlsfunc_refcount
1593 = &elf_xtensa_local_tlsfunc_refcounts (i) [j];
1594 BFD_ASSERT (local_got_refcounts[j] >= *tlsfunc_refcount);
1595 local_got_refcounts[j] -= *tlsfunc_refcount;
1598 if (local_got_refcounts[j] > 0)
1599 htab->srelgot->size += (local_got_refcounts[j]
1600 * sizeof (Elf32_External_Rela));
1606 /* Set the sizes of the dynamic sections. */
1609 elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1610 struct bfd_link_info *info)
1612 struct elf_xtensa_link_hash_table *htab;
1614 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1615 bfd_boolean relplt, relgot;
1616 int plt_entries, plt_chunks, chunk;
1621 htab = elf_xtensa_hash_table (info);
1625 dynobj = elf_hash_table (info)->dynobj;
1628 srelgot = htab->srelgot;
1629 srelplt = htab->srelplt;
1631 if (elf_hash_table (info)->dynamic_sections_created)
1633 BFD_ASSERT (htab->srelgot != NULL
1634 && htab->srelplt != NULL
1635 && htab->sgot != NULL
1636 && htab->spltlittbl != NULL
1637 && htab->sgotloc != NULL);
1639 /* Set the contents of the .interp section to the interpreter. */
1640 if (info->executable)
1642 s = bfd_get_section_by_name (dynobj, ".interp");
1645 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1646 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1649 /* Allocate room for one word in ".got". */
1650 htab->sgot->size = 4;
1652 /* Allocate space in ".rela.got" for literals that reference global
1653 symbols and space in ".rela.plt" for literals that have PLT
1655 elf_link_hash_traverse (elf_hash_table (info),
1656 elf_xtensa_allocate_dynrelocs,
1659 /* If we are generating a shared object, we also need space in
1660 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1661 reference local symbols. */
1663 elf_xtensa_allocate_local_got_size (info);
1665 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1666 each PLT entry, we need the PLT code plus a 4-byte literal.
1667 For each chunk of ".plt", we also need two more 4-byte
1668 literals, two corresponding entries in ".rela.got", and an
1669 8-byte entry in ".xt.lit.plt". */
1670 spltlittbl = htab->spltlittbl;
1671 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
1673 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1675 /* Iterate over all the PLT chunks, including any extra sections
1676 created earlier because the initial count of PLT relocations
1677 was an overestimate. */
1679 (splt = elf_xtensa_get_plt_section (info, chunk)) != NULL;
1684 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
1685 BFD_ASSERT (sgotplt != NULL);
1687 if (chunk < plt_chunks - 1)
1688 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1689 else if (chunk == plt_chunks - 1)
1690 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1694 if (chunk_entries != 0)
1696 sgotplt->size = 4 * (chunk_entries + 2);
1697 splt->size = PLT_ENTRY_SIZE * chunk_entries;
1698 srelgot->size += 2 * sizeof (Elf32_External_Rela);
1699 spltlittbl->size += 8;
1708 /* Allocate space in ".got.loc" to match the total size of all the
1710 sgotloc = htab->sgotloc;
1711 sgotloc->size = spltlittbl->size;
1712 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1714 if (abfd->flags & DYNAMIC)
1716 for (s = abfd->sections; s != NULL; s = s->next)
1718 if (! elf_discarded_section (s)
1719 && xtensa_is_littable_section (s)
1721 sgotloc->size += s->size;
1726 /* Allocate memory for dynamic sections. */
1729 for (s = dynobj->sections; s != NULL; s = s->next)
1733 if ((s->flags & SEC_LINKER_CREATED) == 0)
1736 /* It's OK to base decisions on the section name, because none
1737 of the dynobj section names depend upon the input files. */
1738 name = bfd_get_section_name (dynobj, s);
1740 if (CONST_STRNEQ (name, ".rela"))
1744 if (strcmp (name, ".rela.plt") == 0)
1746 else if (strcmp (name, ".rela.got") == 0)
1749 /* We use the reloc_count field as a counter if we need
1750 to copy relocs into the output file. */
1754 else if (! CONST_STRNEQ (name, ".plt.")
1755 && ! CONST_STRNEQ (name, ".got.plt.")
1756 && strcmp (name, ".got") != 0
1757 && strcmp (name, ".plt") != 0
1758 && strcmp (name, ".got.plt") != 0
1759 && strcmp (name, ".xt.lit.plt") != 0
1760 && strcmp (name, ".got.loc") != 0)
1762 /* It's not one of our sections, so don't allocate space. */
1768 /* If we don't need this section, strip it from the output
1769 file. We must create the ".plt*" and ".got.plt*"
1770 sections in create_dynamic_sections and/or check_relocs
1771 based on a conservative estimate of the PLT relocation
1772 count, because the sections must be created before the
1773 linker maps input sections to output sections. The
1774 linker does that before size_dynamic_sections, where we
1775 compute the exact size of the PLT, so there may be more
1776 of these sections than are actually needed. */
1777 s->flags |= SEC_EXCLUDE;
1779 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
1781 /* Allocate memory for the section contents. */
1782 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1783 if (s->contents == NULL)
1788 if (elf_hash_table (info)->dynamic_sections_created)
1790 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1791 known until finish_dynamic_sections, but we need to get the relocs
1792 in place before they are sorted. */
1793 for (chunk = 0; chunk < plt_chunks; chunk++)
1795 Elf_Internal_Rela irela;
1799 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1802 loc = (srelgot->contents
1803 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1804 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1805 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1806 loc + sizeof (Elf32_External_Rela));
1807 srelgot->reloc_count += 2;
1810 /* Add some entries to the .dynamic section. We fill in the
1811 values later, in elf_xtensa_finish_dynamic_sections, but we
1812 must add the entries now so that we get the correct size for
1813 the .dynamic section. The DT_DEBUG entry is filled in by the
1814 dynamic linker and used by the debugger. */
1815 #define add_dynamic_entry(TAG, VAL) \
1816 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1818 if (info->executable)
1820 if (!add_dynamic_entry (DT_DEBUG, 0))
1826 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1827 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1828 || !add_dynamic_entry (DT_JMPREL, 0))
1834 if (!add_dynamic_entry (DT_RELA, 0)
1835 || !add_dynamic_entry (DT_RELASZ, 0)
1836 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1840 if (!add_dynamic_entry (DT_PLTGOT, 0)
1841 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1842 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1845 #undef add_dynamic_entry
1851 elf_xtensa_always_size_sections (bfd *output_bfd,
1852 struct bfd_link_info *info)
1854 struct elf_xtensa_link_hash_table *htab;
1857 htab = elf_xtensa_hash_table (info);
1861 tls_sec = htab->elf.tls_sec;
1863 if (tls_sec && (htab->tlsbase->tls_type & GOT_TLS_ANY) != 0)
1865 struct elf_link_hash_entry *tlsbase = &htab->tlsbase->elf;
1866 struct bfd_link_hash_entry *bh = &tlsbase->root;
1867 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
1869 tlsbase->type = STT_TLS;
1870 if (!(_bfd_generic_link_add_one_symbol
1871 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1872 tls_sec, 0, NULL, FALSE,
1873 bed->collect, &bh)))
1875 tlsbase->def_regular = 1;
1876 tlsbase->other = STV_HIDDEN;
1877 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1884 /* Return the base VMA address which should be subtracted from real addresses
1885 when resolving @dtpoff relocation.
1886 This is PT_TLS segment p_vaddr. */
1889 dtpoff_base (struct bfd_link_info *info)
1891 /* If tls_sec is NULL, we should have signalled an error already. */
1892 if (elf_hash_table (info)->tls_sec == NULL)
1894 return elf_hash_table (info)->tls_sec->vma;
1897 /* Return the relocation value for @tpoff relocation
1898 if STT_TLS virtual address is ADDRESS. */
1901 tpoff (struct bfd_link_info *info, bfd_vma address)
1903 struct elf_link_hash_table *htab = elf_hash_table (info);
1906 /* If tls_sec is NULL, we should have signalled an error already. */
1907 if (htab->tls_sec == NULL)
1909 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
1910 return address - htab->tls_sec->vma + base;
1913 /* Perform the specified relocation. The instruction at (contents + address)
1914 is modified to set one operand to represent the value in "relocation". The
1915 operand position is determined by the relocation type recorded in the
1918 #define CALL_SEGMENT_BITS (30)
1919 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1921 static bfd_reloc_status_type
1922 elf_xtensa_do_reloc (reloc_howto_type *howto,
1924 asection *input_section,
1928 bfd_boolean is_weak_undef,
1929 char **error_message)
1932 xtensa_opcode opcode;
1933 xtensa_isa isa = xtensa_default_isa;
1934 static xtensa_insnbuf ibuff = NULL;
1935 static xtensa_insnbuf sbuff = NULL;
1936 bfd_vma self_address;
1937 bfd_size_type input_size;
1943 ibuff = xtensa_insnbuf_alloc (isa);
1944 sbuff = xtensa_insnbuf_alloc (isa);
1947 input_size = bfd_get_section_limit (abfd, input_section);
1949 /* Calculate the PC address for this instruction. */
1950 self_address = (input_section->output_section->vma
1951 + input_section->output_offset
1954 switch (howto->type)
1957 case R_XTENSA_DIFF8:
1958 case R_XTENSA_DIFF16:
1959 case R_XTENSA_DIFF32:
1960 case R_XTENSA_TLS_FUNC:
1961 case R_XTENSA_TLS_ARG:
1962 case R_XTENSA_TLS_CALL:
1963 return bfd_reloc_ok;
1965 case R_XTENSA_ASM_EXPAND:
1968 /* Check for windowed CALL across a 1GB boundary. */
1969 opcode = get_expanded_call_opcode (contents + address,
1970 input_size - address, 0);
1971 if (is_windowed_call_opcode (opcode))
1973 if ((self_address >> CALL_SEGMENT_BITS)
1974 != (relocation >> CALL_SEGMENT_BITS))
1976 *error_message = "windowed longcall crosses 1GB boundary; "
1978 return bfd_reloc_dangerous;
1982 return bfd_reloc_ok;
1984 case R_XTENSA_ASM_SIMPLIFY:
1986 /* Convert the L32R/CALLX to CALL. */
1987 bfd_reloc_status_type retval =
1988 elf_xtensa_do_asm_simplify (contents, address, input_size,
1990 if (retval != bfd_reloc_ok)
1991 return bfd_reloc_dangerous;
1993 /* The CALL needs to be relocated. Continue below for that part. */
1996 howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
2003 x = bfd_get_32 (abfd, contents + address);
2005 bfd_put_32 (abfd, x, contents + address);
2007 return bfd_reloc_ok;
2009 case R_XTENSA_32_PCREL:
2010 bfd_put_32 (abfd, relocation - self_address, contents + address);
2011 return bfd_reloc_ok;
2014 case R_XTENSA_TLSDESC_FN:
2015 case R_XTENSA_TLSDESC_ARG:
2016 case R_XTENSA_TLS_DTPOFF:
2017 case R_XTENSA_TLS_TPOFF:
2018 bfd_put_32 (abfd, relocation, contents + address);
2019 return bfd_reloc_ok;
2022 /* Only instruction slot-specific relocations handled below.... */
2023 slot = get_relocation_slot (howto->type);
2024 if (slot == XTENSA_UNDEFINED)
2026 *error_message = "unexpected relocation";
2027 return bfd_reloc_dangerous;
2030 /* Read the instruction into a buffer and decode the opcode. */
2031 xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
2032 input_size - address);
2033 fmt = xtensa_format_decode (isa, ibuff);
2034 if (fmt == XTENSA_UNDEFINED)
2036 *error_message = "cannot decode instruction format";
2037 return bfd_reloc_dangerous;
2040 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
2042 opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
2043 if (opcode == XTENSA_UNDEFINED)
2045 *error_message = "cannot decode instruction opcode";
2046 return bfd_reloc_dangerous;
2049 /* Check for opcode-specific "alternate" relocations. */
2050 if (is_alt_relocation (howto->type))
2052 if (opcode == get_l32r_opcode ())
2054 /* Handle the special-case of non-PC-relative L32R instructions. */
2055 bfd *output_bfd = input_section->output_section->owner;
2056 asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
2059 *error_message = "relocation references missing .lit4 section";
2060 return bfd_reloc_dangerous;
2062 self_address = ((lit4_sec->vma & ~0xfff)
2063 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2064 newval = relocation;
2067 else if (opcode == get_const16_opcode ())
2069 /* ALT used for high 16 bits. */
2070 newval = relocation >> 16;
2075 /* No other "alternate" relocations currently defined. */
2076 *error_message = "unexpected relocation";
2077 return bfd_reloc_dangerous;
2080 else /* Not an "alternate" relocation.... */
2082 if (opcode == get_const16_opcode ())
2084 newval = relocation & 0xffff;
2089 /* ...normal PC-relative relocation.... */
2091 /* Determine which operand is being relocated. */
2092 opnd = get_relocation_opnd (opcode, howto->type);
2093 if (opnd == XTENSA_UNDEFINED)
2095 *error_message = "unexpected relocation";
2096 return bfd_reloc_dangerous;
2099 if (!howto->pc_relative)
2101 *error_message = "expected PC-relative relocation";
2102 return bfd_reloc_dangerous;
2105 newval = relocation;
2109 /* Apply the relocation. */
2110 if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
2111 || xtensa_operand_encode (isa, opcode, opnd, &newval)
2112 || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
2115 const char *opname = xtensa_opcode_name (isa, opcode);
2118 msg = "cannot encode";
2119 if (is_direct_call_opcode (opcode))
2121 if ((relocation & 0x3) != 0)
2122 msg = "misaligned call target";
2124 msg = "call target out of range";
2126 else if (opcode == get_l32r_opcode ())
2128 if ((relocation & 0x3) != 0)
2129 msg = "misaligned literal target";
2130 else if (is_alt_relocation (howto->type))
2131 msg = "literal target out of range (too many literals)";
2132 else if (self_address > relocation)
2133 msg = "literal target out of range (try using text-section-literals)";
2135 msg = "literal placed after use";
2138 *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
2139 return bfd_reloc_dangerous;
2142 /* Check for calls across 1GB boundaries. */
2143 if (is_direct_call_opcode (opcode)
2144 && is_windowed_call_opcode (opcode))
2146 if ((self_address >> CALL_SEGMENT_BITS)
2147 != (relocation >> CALL_SEGMENT_BITS))
2150 "windowed call crosses 1GB boundary; return may fail";
2151 return bfd_reloc_dangerous;
2155 /* Write the modified instruction back out of the buffer. */
2156 xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
2157 xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
2158 input_size - address);
2159 return bfd_reloc_ok;
2164 vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
2166 /* To reduce the size of the memory leak,
2167 we only use a single message buffer. */
2168 static bfd_size_type alloc_size = 0;
2169 static char *message = NULL;
2170 bfd_size_type orig_len, len = 0;
2171 bfd_boolean is_append;
2173 VA_OPEN (ap, arglen);
2174 VA_FIXEDARG (ap, const char *, origmsg);
2176 is_append = (origmsg == message);
2178 orig_len = strlen (origmsg);
2179 len = orig_len + strlen (fmt) + arglen + 20;
2180 if (len > alloc_size)
2182 message = (char *) bfd_realloc_or_free (message, len);
2185 if (message != NULL)
2188 memcpy (message, origmsg, orig_len);
2189 vsprintf (message + orig_len, fmt, ap);
2196 /* This function is registered as the "special_function" in the
2197 Xtensa howto for handling simplify operations.
2198 bfd_perform_relocation / bfd_install_relocation use it to
2199 perform (install) the specified relocation. Since this replaces the code
2200 in bfd_perform_relocation, it is basically an Xtensa-specific,
2201 stripped-down version of bfd_perform_relocation. */
2203 static bfd_reloc_status_type
2204 bfd_elf_xtensa_reloc (bfd *abfd,
2205 arelent *reloc_entry,
2208 asection *input_section,
2210 char **error_message)
2213 bfd_reloc_status_type flag;
2214 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2215 bfd_vma output_base = 0;
2216 reloc_howto_type *howto = reloc_entry->howto;
2217 asection *reloc_target_output_section;
2218 bfd_boolean is_weak_undef;
2220 if (!xtensa_default_isa)
2221 xtensa_default_isa = xtensa_isa_init (0, 0);
2223 /* ELF relocs are against symbols. If we are producing relocatable
2224 output, and the reloc is against an external symbol, the resulting
2225 reloc will also be against the same symbol. In such a case, we
2226 don't want to change anything about the way the reloc is handled,
2227 since it will all be done at final link time. This test is similar
2228 to what bfd_elf_generic_reloc does except that it lets relocs with
2229 howto->partial_inplace go through even if the addend is non-zero.
2230 (The real problem is that partial_inplace is set for XTENSA_32
2231 relocs to begin with, but that's a long story and there's little we
2232 can do about it now....) */
2234 if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
2236 reloc_entry->address += input_section->output_offset;
2237 return bfd_reloc_ok;
2240 /* Is the address of the relocation really within the section? */
2241 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2242 return bfd_reloc_outofrange;
2244 /* Work out which section the relocation is targeted at and the
2245 initial relocation command value. */
2247 /* Get symbol value. (Common symbols are special.) */
2248 if (bfd_is_com_section (symbol->section))
2251 relocation = symbol->value;
2253 reloc_target_output_section = symbol->section->output_section;
2255 /* Convert input-section-relative symbol value to absolute. */
2256 if ((output_bfd && !howto->partial_inplace)
2257 || reloc_target_output_section == NULL)
2260 output_base = reloc_target_output_section->vma;
2262 relocation += output_base + symbol->section->output_offset;
2264 /* Add in supplied addend. */
2265 relocation += reloc_entry->addend;
2267 /* Here the variable relocation holds the final address of the
2268 symbol we are relocating against, plus any addend. */
2271 if (!howto->partial_inplace)
2273 /* This is a partial relocation, and we want to apply the relocation
2274 to the reloc entry rather than the raw data. Everything except
2275 relocations against section symbols has already been handled
2278 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
2279 reloc_entry->addend = relocation;
2280 reloc_entry->address += input_section->output_offset;
2281 return bfd_reloc_ok;
2285 reloc_entry->address += input_section->output_offset;
2286 reloc_entry->addend = 0;
2290 is_weak_undef = (bfd_is_und_section (symbol->section)
2291 && (symbol->flags & BSF_WEAK) != 0);
2292 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
2293 (bfd_byte *) data, (bfd_vma) octets,
2294 is_weak_undef, error_message);
2296 if (flag == bfd_reloc_dangerous)
2298 /* Add the symbol name to the error message. */
2299 if (! *error_message)
2300 *error_message = "";
2301 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
2302 strlen (symbol->name) + 17,
2304 (unsigned long) reloc_entry->addend);
2311 /* Set up an entry in the procedure linkage table. */
2314 elf_xtensa_create_plt_entry (struct bfd_link_info *info,
2316 unsigned reloc_index)
2318 asection *splt, *sgotplt;
2319 bfd_vma plt_base, got_base;
2320 bfd_vma code_offset, lit_offset;
2323 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
2324 splt = elf_xtensa_get_plt_section (info, chunk);
2325 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
2326 BFD_ASSERT (splt != NULL && sgotplt != NULL);
2328 plt_base = splt->output_section->vma + splt->output_offset;
2329 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
2331 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
2332 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
2334 /* Fill in the literal entry. This is the offset of the dynamic
2335 relocation entry. */
2336 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
2337 sgotplt->contents + lit_offset);
2339 /* Fill in the entry in the procedure linkage table. */
2340 memcpy (splt->contents + code_offset,
2341 (bfd_big_endian (output_bfd)
2342 ? elf_xtensa_be_plt_entry
2343 : elf_xtensa_le_plt_entry),
2345 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
2346 plt_base + code_offset + 3),
2347 splt->contents + code_offset + 4);
2348 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
2349 plt_base + code_offset + 6),
2350 splt->contents + code_offset + 7);
2351 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
2352 plt_base + code_offset + 9),
2353 splt->contents + code_offset + 10);
2355 return plt_base + code_offset;
2359 static bfd_boolean get_indirect_call_dest_reg (xtensa_opcode, unsigned *);
2362 replace_tls_insn (Elf_Internal_Rela *rel,
2364 asection *input_section,
2366 bfd_boolean is_ld_model,
2367 char **error_message)
2369 static xtensa_insnbuf ibuff = NULL;
2370 static xtensa_insnbuf sbuff = NULL;
2371 xtensa_isa isa = xtensa_default_isa;
2373 xtensa_opcode old_op, new_op;
2374 bfd_size_type input_size;
2376 unsigned dest_reg, src_reg;
2380 ibuff = xtensa_insnbuf_alloc (isa);
2381 sbuff = xtensa_insnbuf_alloc (isa);
2384 input_size = bfd_get_section_limit (abfd, input_section);
2386 /* Read the instruction into a buffer and decode the opcode. */
2387 xtensa_insnbuf_from_chars (isa, ibuff, contents + rel->r_offset,
2388 input_size - rel->r_offset);
2389 fmt = xtensa_format_decode (isa, ibuff);
2390 if (fmt == XTENSA_UNDEFINED)
2392 *error_message = "cannot decode instruction format";
2396 BFD_ASSERT (xtensa_format_num_slots (isa, fmt) == 1);
2397 xtensa_format_get_slot (isa, fmt, 0, ibuff, sbuff);
2399 old_op = xtensa_opcode_decode (isa, fmt, 0, sbuff);
2400 if (old_op == XTENSA_UNDEFINED)
2402 *error_message = "cannot decode instruction opcode";
2406 r_type = ELF32_R_TYPE (rel->r_info);
2409 case R_XTENSA_TLS_FUNC:
2410 case R_XTENSA_TLS_ARG:
2411 if (old_op != get_l32r_opcode ()
2412 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2413 sbuff, &dest_reg) != 0)
2415 *error_message = "cannot extract L32R destination for TLS access";
2420 case R_XTENSA_TLS_CALL:
2421 if (! get_indirect_call_dest_reg (old_op, &dest_reg)
2422 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2423 sbuff, &src_reg) != 0)
2425 *error_message = "cannot extract CALLXn operands for TLS access";
2438 case R_XTENSA_TLS_FUNC:
2439 case R_XTENSA_TLS_ARG:
2440 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2441 versions of Xtensa). */
2442 new_op = xtensa_opcode_lookup (isa, "nop");
2443 if (new_op == XTENSA_UNDEFINED)
2445 new_op = xtensa_opcode_lookup (isa, "or");
2446 if (new_op == XTENSA_UNDEFINED
2447 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2448 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2450 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2452 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2455 *error_message = "cannot encode OR for TLS access";
2461 if (xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0)
2463 *error_message = "cannot encode NOP for TLS access";
2469 case R_XTENSA_TLS_CALL:
2470 /* Read THREADPTR into the CALLX's return value register. */
2471 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2472 if (new_op == XTENSA_UNDEFINED
2473 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2474 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2475 sbuff, dest_reg + 2) != 0)
2477 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2487 case R_XTENSA_TLS_FUNC:
2488 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2489 if (new_op == XTENSA_UNDEFINED
2490 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2491 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2492 sbuff, dest_reg) != 0)
2494 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2499 case R_XTENSA_TLS_ARG:
2500 /* Nothing to do. Keep the original L32R instruction. */
2503 case R_XTENSA_TLS_CALL:
2504 /* Add the CALLX's src register (holding the THREADPTR value)
2505 to the first argument register (holding the offset) and put
2506 the result in the CALLX's return value register. */
2507 new_op = xtensa_opcode_lookup (isa, "add");
2508 if (new_op == XTENSA_UNDEFINED
2509 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2510 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2511 sbuff, dest_reg + 2) != 0
2512 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2513 sbuff, dest_reg + 2) != 0
2514 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2515 sbuff, src_reg) != 0)
2517 *error_message = "cannot encode ADD for TLS access";
2524 xtensa_format_set_slot (isa, fmt, 0, ibuff, sbuff);
2525 xtensa_insnbuf_to_chars (isa, ibuff, contents + rel->r_offset,
2526 input_size - rel->r_offset);
2532 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2533 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2534 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2535 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2536 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2537 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2538 || (R_TYPE) == R_XTENSA_TLS_ARG \
2539 || (R_TYPE) == R_XTENSA_TLS_CALL)
2541 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2542 both relocatable and final links. */
2545 elf_xtensa_relocate_section (bfd *output_bfd,
2546 struct bfd_link_info *info,
2548 asection *input_section,
2550 Elf_Internal_Rela *relocs,
2551 Elf_Internal_Sym *local_syms,
2552 asection **local_sections)
2554 struct elf_xtensa_link_hash_table *htab;
2555 Elf_Internal_Shdr *symtab_hdr;
2556 Elf_Internal_Rela *rel;
2557 Elf_Internal_Rela *relend;
2558 struct elf_link_hash_entry **sym_hashes;
2559 property_table_entry *lit_table = 0;
2561 char *local_got_tls_types;
2562 char *error_message = NULL;
2563 bfd_size_type input_size;
2566 if (!xtensa_default_isa)
2567 xtensa_default_isa = xtensa_isa_init (0, 0);
2569 BFD_ASSERT (is_xtensa_elf (input_bfd));
2571 htab = elf_xtensa_hash_table (info);
2575 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2576 sym_hashes = elf_sym_hashes (input_bfd);
2577 local_got_tls_types = elf_xtensa_local_got_tls_type (input_bfd);
2579 if (elf_hash_table (info)->dynamic_sections_created)
2581 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
2582 &lit_table, XTENSA_LIT_SEC_NAME,
2588 input_size = bfd_get_section_limit (input_bfd, input_section);
2591 relend = relocs + input_section->reloc_count;
2592 for (; rel < relend; rel++)
2595 reloc_howto_type *howto;
2596 unsigned long r_symndx;
2597 struct elf_link_hash_entry *h;
2598 Elf_Internal_Sym *sym;
2603 bfd_reloc_status_type r;
2604 bfd_boolean is_weak_undef;
2605 bfd_boolean unresolved_reloc;
2607 bfd_boolean dynamic_symbol;
2609 r_type = ELF32_R_TYPE (rel->r_info);
2610 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2611 || r_type == (int) R_XTENSA_GNU_VTENTRY)
2614 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2616 bfd_set_error (bfd_error_bad_value);
2619 howto = &elf_howto_table[r_type];
2621 r_symndx = ELF32_R_SYM (rel->r_info);
2626 is_weak_undef = FALSE;
2627 unresolved_reloc = FALSE;
2630 if (howto->partial_inplace && !info->relocatable)
2632 /* Because R_XTENSA_32 was made partial_inplace to fix some
2633 problems with DWARF info in partial links, there may be
2634 an addend stored in the contents. Take it out of there
2635 and move it back into the addend field of the reloc. */
2636 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2637 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2640 if (r_symndx < symtab_hdr->sh_info)
2642 sym = local_syms + r_symndx;
2643 sym_type = ELF32_ST_TYPE (sym->st_info);
2644 sec = local_sections[r_symndx];
2645 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2649 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2650 r_symndx, symtab_hdr, sym_hashes,
2652 unresolved_reloc, warned);
2655 && !unresolved_reloc
2656 && h->root.type == bfd_link_hash_undefweak)
2657 is_weak_undef = TRUE;
2662 if (sec != NULL && elf_discarded_section (sec))
2664 /* For relocs against symbols from removed linkonce sections,
2665 or sections discarded by a linker script, we just want the
2666 section contents zeroed. Avoid any special processing. */
2667 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2673 if (info->relocatable)
2676 asection * sym_sec = get_elf_r_symndx_section (input_bfd, r_symndx);
2678 /* This is a relocatable link.
2679 1) If the reloc is against a section symbol, adjust
2680 according to the output section.
2681 2) If there is a new target for this relocation,
2682 the new target will be in the same output section.
2683 We adjust the relocation by the output section
2686 if (relaxing_section)
2688 /* Check if this references a section in another input file. */
2689 if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2694 dest_addr = sym_sec->output_section->vma + sym_sec->output_offset
2695 + get_elf_r_symndx_offset (input_bfd, r_symndx) + rel->r_addend;
2697 if (r_type == R_XTENSA_ASM_SIMPLIFY)
2699 error_message = NULL;
2700 /* Convert ASM_SIMPLIFY into the simpler relocation
2701 so that they never escape a relaxing link. */
2702 r = contract_asm_expansion (contents, input_size, rel,
2704 if (r != bfd_reloc_ok)
2706 if (!((*info->callbacks->reloc_dangerous)
2707 (info, error_message, input_bfd, input_section,
2711 r_type = ELF32_R_TYPE (rel->r_info);
2714 /* This is a relocatable link, so we don't have to change
2715 anything unless the reloc is against a section symbol,
2716 in which case we have to adjust according to where the
2717 section symbol winds up in the output section. */
2718 if (r_symndx < symtab_hdr->sh_info)
2720 sym = local_syms + r_symndx;
2721 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2723 sec = local_sections[r_symndx];
2724 rel->r_addend += sec->output_offset + sym->st_value;
2728 /* If there is an addend with a partial_inplace howto,
2729 then move the addend to the contents. This is a hack
2730 to work around problems with DWARF in relocatable links
2731 with some previous version of BFD. Now we can't easily get
2732 rid of the hack without breaking backward compatibility.... */
2734 howto = &elf_howto_table[r_type];
2735 if (howto->partial_inplace && rel->r_addend)
2737 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2738 rel->r_addend, contents,
2739 rel->r_offset, FALSE,
2745 /* Put the correct bits in the target instruction, even
2746 though the relocation will still be present in the output
2747 file. This makes disassembly clearer, as well as
2748 allowing loadable kernel modules to work without needing
2749 relocations on anything other than calls and l32r's. */
2751 /* If it is not in the same section, there is nothing we can do. */
2752 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP &&
2753 sym_sec->output_section == input_section->output_section)
2755 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2756 dest_addr, contents,
2757 rel->r_offset, FALSE,
2761 if (r != bfd_reloc_ok)
2763 if (!((*info->callbacks->reloc_dangerous)
2764 (info, error_message, input_bfd, input_section,
2769 /* Done with work for relocatable link; continue with next reloc. */
2773 /* This is a final link. */
2775 if (relaxing_section)
2777 /* Check if this references a section in another input file. */
2778 do_fix_for_final_link (rel, input_bfd, input_section, contents,
2782 /* Sanity check the address. */
2783 if (rel->r_offset >= input_size
2784 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2786 (*_bfd_error_handler)
2787 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2788 input_bfd, input_section, rel->r_offset, input_size);
2789 bfd_set_error (bfd_error_bad_value);
2794 name = h->root.root.string;
2797 name = (bfd_elf_string_from_elf_section
2798 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2799 if (name == NULL || *name == '\0')
2800 name = bfd_section_name (input_bfd, sec);
2804 && r_type != R_XTENSA_NONE
2806 || h->root.type == bfd_link_hash_defined
2807 || h->root.type == bfd_link_hash_defweak)
2808 && IS_XTENSA_TLS_RELOC (r_type) != (sym_type == STT_TLS))
2810 (*_bfd_error_handler)
2811 ((sym_type == STT_TLS
2812 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
2813 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
2816 (long) rel->r_offset,
2821 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
2823 tls_type = GOT_UNKNOWN;
2825 tls_type = elf_xtensa_hash_entry (h)->tls_type;
2826 else if (local_got_tls_types)
2827 tls_type = local_got_tls_types [r_symndx];
2833 if (elf_hash_table (info)->dynamic_sections_created
2834 && (input_section->flags & SEC_ALLOC) != 0
2835 && (dynamic_symbol || info->shared))
2837 Elf_Internal_Rela outrel;
2841 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2842 srel = htab->srelplt;
2844 srel = htab->srelgot;
2846 BFD_ASSERT (srel != NULL);
2849 _bfd_elf_section_offset (output_bfd, info,
2850 input_section, rel->r_offset);
2852 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2853 memset (&outrel, 0, sizeof outrel);
2856 outrel.r_offset += (input_section->output_section->vma
2857 + input_section->output_offset);
2859 /* Complain if the relocation is in a read-only section
2860 and not in a literal pool. */
2861 if ((input_section->flags & SEC_READONLY) != 0
2862 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
2866 _("dynamic relocation in read-only section");
2867 if (!((*info->callbacks->reloc_dangerous)
2868 (info, error_message, input_bfd, input_section,
2875 outrel.r_addend = rel->r_addend;
2878 if (r_type == R_XTENSA_32)
2881 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2884 else /* r_type == R_XTENSA_PLT */
2887 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2889 /* Create the PLT entry and set the initial
2890 contents of the literal entry to the address of
2893 elf_xtensa_create_plt_entry (info, output_bfd,
2896 unresolved_reloc = FALSE;
2900 /* Generate a RELATIVE relocation. */
2901 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2902 outrel.r_addend = 0;
2906 loc = (srel->contents
2907 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2908 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2909 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2912 else if (r_type == R_XTENSA_ASM_EXPAND && dynamic_symbol)
2914 /* This should only happen for non-PIC code, which is not
2915 supposed to be used on systems with dynamic linking.
2916 Just ignore these relocations. */
2921 case R_XTENSA_TLS_TPOFF:
2922 /* Switch to LE model for local symbols in an executable. */
2923 if (! info->shared && ! dynamic_symbol)
2925 relocation = tpoff (info, relocation);
2930 case R_XTENSA_TLSDESC_FN:
2931 case R_XTENSA_TLSDESC_ARG:
2933 if (r_type == R_XTENSA_TLSDESC_FN)
2935 if (! info->shared || (tls_type & GOT_TLS_IE) != 0)
2936 r_type = R_XTENSA_NONE;
2938 else if (r_type == R_XTENSA_TLSDESC_ARG)
2942 if ((tls_type & GOT_TLS_IE) != 0)
2943 r_type = R_XTENSA_TLS_TPOFF;
2947 r_type = R_XTENSA_TLS_TPOFF;
2948 if (! dynamic_symbol)
2950 relocation = tpoff (info, relocation);
2956 if (r_type == R_XTENSA_NONE)
2957 /* Nothing to do here; skip to the next reloc. */
2960 if (! elf_hash_table (info)->dynamic_sections_created)
2963 _("TLS relocation invalid without dynamic sections");
2964 if (!((*info->callbacks->reloc_dangerous)
2965 (info, error_message, input_bfd, input_section,
2971 Elf_Internal_Rela outrel;
2973 asection *srel = htab->srelgot;
2976 outrel.r_offset = (input_section->output_section->vma
2977 + input_section->output_offset
2980 /* Complain if the relocation is in a read-only section
2981 and not in a literal pool. */
2982 if ((input_section->flags & SEC_READONLY) != 0
2983 && ! elf_xtensa_in_literal_pool (lit_table, ltblsize,
2987 _("dynamic relocation in read-only section");
2988 if (!((*info->callbacks->reloc_dangerous)
2989 (info, error_message, input_bfd, input_section,
2994 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2996 outrel.r_addend = relocation - dtpoff_base (info);
2998 outrel.r_addend = 0;
3001 outrel.r_info = ELF32_R_INFO (indx, r_type);
3003 unresolved_reloc = FALSE;
3006 loc = (srel->contents
3007 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
3008 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3009 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
3015 case R_XTENSA_TLS_DTPOFF:
3017 /* Switch from LD model to LE model. */
3018 relocation = tpoff (info, relocation);
3020 relocation -= dtpoff_base (info);
3023 case R_XTENSA_TLS_FUNC:
3024 case R_XTENSA_TLS_ARG:
3025 case R_XTENSA_TLS_CALL:
3026 /* Check if optimizing to IE or LE model. */
3027 if ((tls_type & GOT_TLS_IE) != 0)
3029 bfd_boolean is_ld_model =
3030 (h && elf_xtensa_hash_entry (h) == htab->tlsbase);
3031 if (! replace_tls_insn (rel, input_bfd, input_section, contents,
3032 is_ld_model, &error_message))
3034 if (!((*info->callbacks->reloc_dangerous)
3035 (info, error_message, input_bfd, input_section,
3040 if (r_type != R_XTENSA_TLS_ARG || is_ld_model)
3042 /* Skip subsequent relocations on the same instruction. */
3043 while (rel + 1 < relend && rel[1].r_offset == rel->r_offset)
3050 if (elf_hash_table (info)->dynamic_sections_created
3051 && dynamic_symbol && (is_operand_relocation (r_type)
3052 || r_type == R_XTENSA_32_PCREL))
3055 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3056 strlen (name) + 2, name);
3057 if (!((*info->callbacks->reloc_dangerous)
3058 (info, error_message, input_bfd, input_section,
3066 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3067 because such sections are not SEC_ALLOC and thus ld.so will
3068 not process them. */
3069 if (unresolved_reloc
3070 && !((input_section->flags & SEC_DEBUGGING) != 0
3073 (*_bfd_error_handler)
3074 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3077 (long) rel->r_offset,
3083 /* TLS optimizations may have changed r_type; update "howto". */
3084 howto = &elf_howto_table[r_type];
3086 /* There's no point in calling bfd_perform_relocation here.
3087 Just go directly to our "special function". */
3088 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
3089 relocation + rel->r_addend,
3090 contents, rel->r_offset, is_weak_undef,
3093 if (r != bfd_reloc_ok && !warned)
3095 BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
3096 BFD_ASSERT (error_message != NULL);
3098 if (rel->r_addend == 0)
3099 error_message = vsprint_msg (error_message, ": %s",
3100 strlen (name) + 2, name);
3102 error_message = vsprint_msg (error_message, ": (%s+0x%x)",
3104 name, (int) rel->r_addend);
3106 if (!((*info->callbacks->reloc_dangerous)
3107 (info, error_message, input_bfd, input_section,
3116 input_section->reloc_done = TRUE;
3122 /* Finish up dynamic symbol handling. There's not much to do here since
3123 the PLT and GOT entries are all set up by relocate_section. */
3126 elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
3127 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3128 struct elf_link_hash_entry *h,
3129 Elf_Internal_Sym *sym)
3131 if (h->needs_plt && !h->def_regular)
3133 /* Mark the symbol as undefined, rather than as defined in
3134 the .plt section. Leave the value alone. */
3135 sym->st_shndx = SHN_UNDEF;
3136 /* If the symbol is weak, we do need to clear the value.
3137 Otherwise, the PLT entry would provide a definition for
3138 the symbol even if the symbol wasn't defined anywhere,
3139 and so the symbol would never be NULL. */
3140 if (!h->ref_regular_nonweak)
3144 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3145 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3146 || h == elf_hash_table (info)->hgot)
3147 sym->st_shndx = SHN_ABS;
3153 /* Combine adjacent literal table entries in the output. Adjacent
3154 entries within each input section may have been removed during
3155 relaxation, but we repeat the process here, even though it's too late
3156 to shrink the output section, because it's important to minimize the
3157 number of literal table entries to reduce the start-up work for the
3158 runtime linker. Returns the number of remaining table entries or -1
3162 elf_xtensa_combine_prop_entries (bfd *output_bfd,
3167 property_table_entry *table;
3168 bfd_size_type section_size, sgotloc_size;
3172 section_size = sxtlit->size;
3173 BFD_ASSERT (section_size % 8 == 0);
3174 num = section_size / 8;
3176 sgotloc_size = sgotloc->size;
3177 if (sgotloc_size != section_size)
3179 (*_bfd_error_handler)
3180 (_("internal inconsistency in size of .got.loc section"));
3184 table = bfd_malloc (num * sizeof (property_table_entry));
3188 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3189 propagates to the output section, where it doesn't really apply and
3190 where it breaks the following call to bfd_malloc_and_get_section. */
3191 sxtlit->flags &= ~SEC_IN_MEMORY;
3193 if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
3201 /* There should never be any relocations left at this point, so this
3202 is quite a bit easier than what is done during relaxation. */
3204 /* Copy the raw contents into a property table array and sort it. */
3206 for (n = 0; n < num; n++)
3208 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
3209 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
3212 qsort (table, num, sizeof (property_table_entry), property_table_compare);
3214 for (n = 0; n < num; n++)
3216 bfd_boolean remove_entry = FALSE;
3218 if (table[n].size == 0)
3219 remove_entry = TRUE;
3221 && (table[n-1].address + table[n-1].size == table[n].address))
3223 table[n-1].size += table[n].size;
3224 remove_entry = TRUE;
3229 for (m = n; m < num - 1; m++)
3231 table[m].address = table[m+1].address;
3232 table[m].size = table[m+1].size;
3240 /* Copy the data back to the raw contents. */
3242 for (n = 0; n < num; n++)
3244 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
3245 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
3249 /* Clear the removed bytes. */
3250 if ((bfd_size_type) (num * 8) < section_size)
3251 memset (&contents[num * 8], 0, section_size - num * 8);
3253 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
3257 /* Copy the contents to ".got.loc". */
3258 memcpy (sgotloc->contents, contents, section_size);
3266 /* Finish up the dynamic sections. */
3269 elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
3270 struct bfd_link_info *info)
3272 struct elf_xtensa_link_hash_table *htab;
3274 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
3275 Elf32_External_Dyn *dyncon, *dynconend;
3276 int num_xtlit_entries = 0;
3278 if (! elf_hash_table (info)->dynamic_sections_created)
3281 htab = elf_xtensa_hash_table (info);
3285 dynobj = elf_hash_table (info)->dynobj;
3286 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3287 BFD_ASSERT (sdyn != NULL);
3289 /* Set the first entry in the global offset table to the address of
3290 the dynamic section. */
3294 BFD_ASSERT (sgot->size == 4);
3296 bfd_put_32 (output_bfd, 0, sgot->contents);
3298 bfd_put_32 (output_bfd,
3299 sdyn->output_section->vma + sdyn->output_offset,
3303 srelplt = htab->srelplt;
3304 if (srelplt && srelplt->size != 0)
3306 asection *sgotplt, *srelgot, *spltlittbl;
3307 int chunk, plt_chunks, plt_entries;
3308 Elf_Internal_Rela irela;
3310 unsigned rtld_reloc;
3312 srelgot = htab->srelgot;
3313 spltlittbl = htab->spltlittbl;
3314 BFD_ASSERT (srelgot != NULL && spltlittbl != NULL);
3316 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3317 of them follow immediately after.... */
3318 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
3320 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3321 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3322 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
3325 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
3327 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
3329 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
3331 for (chunk = 0; chunk < plt_chunks; chunk++)
3333 int chunk_entries = 0;
3335 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
3336 BFD_ASSERT (sgotplt != NULL);
3338 /* Emit special RTLD relocations for the first two entries in
3339 each chunk of the .got.plt section. */
3341 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3342 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3343 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3344 irela.r_offset = (sgotplt->output_section->vma
3345 + sgotplt->output_offset);
3346 irela.r_addend = 1; /* tell rtld to set value to resolver function */
3347 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3349 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3351 /* Next literal immediately follows the first. */
3352 loc += sizeof (Elf32_External_Rela);
3353 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3354 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3355 irela.r_offset = (sgotplt->output_section->vma
3356 + sgotplt->output_offset + 4);
3357 /* Tell rtld to set value to object's link map. */
3359 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3361 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3363 /* Fill in the literal table. */
3364 if (chunk < plt_chunks - 1)
3365 chunk_entries = PLT_ENTRIES_PER_CHUNK;
3367 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
3369 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
3370 bfd_put_32 (output_bfd,
3371 sgotplt->output_section->vma + sgotplt->output_offset,
3372 spltlittbl->contents + (chunk * 8) + 0);
3373 bfd_put_32 (output_bfd,
3374 8 + (chunk_entries * 4),
3375 spltlittbl->contents + (chunk * 8) + 4);
3378 /* All the dynamic relocations have been emitted at this point.
3379 Make sure the relocation sections are the correct size. */
3380 if (srelgot->size != (sizeof (Elf32_External_Rela)
3381 * srelgot->reloc_count)
3382 || srelplt->size != (sizeof (Elf32_External_Rela)
3383 * srelplt->reloc_count))
3386 /* The .xt.lit.plt section has just been modified. This must
3387 happen before the code below which combines adjacent literal
3388 table entries, and the .xt.lit.plt contents have to be forced to
3390 if (! bfd_set_section_contents (output_bfd,
3391 spltlittbl->output_section,
3392 spltlittbl->contents,
3393 spltlittbl->output_offset,
3396 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3397 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
3400 /* Combine adjacent literal table entries. */
3401 BFD_ASSERT (! info->relocatable);
3402 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
3403 sgotloc = htab->sgotloc;
3404 BFD_ASSERT (sgotloc);
3408 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
3409 if (num_xtlit_entries < 0)
3413 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3414 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3415 for (; dyncon < dynconend; dyncon++)
3417 Elf_Internal_Dyn dyn;
3419 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3426 case DT_XTENSA_GOT_LOC_SZ:
3427 dyn.d_un.d_val = num_xtlit_entries;
3430 case DT_XTENSA_GOT_LOC_OFF:
3431 dyn.d_un.d_ptr = htab->sgotloc->output_section->vma;
3435 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3439 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3443 dyn.d_un.d_val = htab->srelplt->output_section->size;
3447 /* Adjust RELASZ to not include JMPREL. This matches what
3448 glibc expects and what is done for several other ELF
3449 targets (e.g., i386, alpha), but the "correct" behavior
3450 seems to be unresolved. Since the linker script arranges
3451 for .rela.plt to follow all other relocation sections, we
3452 don't have to worry about changing the DT_RELA entry. */
3454 dyn.d_un.d_val -= htab->srelplt->output_section->size;
3458 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3465 /* Functions for dealing with the e_flags field. */
3467 /* Merge backend specific data from an object file to the output
3468 object file when linking. */
3471 elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3473 unsigned out_mach, in_mach;
3474 flagword out_flag, in_flag;
3476 /* Check if we have the same endianess. */
3477 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
3480 /* Don't even pretend to support mixed-format linking. */
3481 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3482 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3485 out_flag = elf_elfheader (obfd)->e_flags;
3486 in_flag = elf_elfheader (ibfd)->e_flags;
3488 out_mach = out_flag & EF_XTENSA_MACH;
3489 in_mach = in_flag & EF_XTENSA_MACH;
3490 if (out_mach != in_mach)
3492 (*_bfd_error_handler)
3493 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
3494 ibfd, out_mach, in_mach);
3495 bfd_set_error (bfd_error_wrong_format);
3499 if (! elf_flags_init (obfd))
3501 elf_flags_init (obfd) = TRUE;
3502 elf_elfheader (obfd)->e_flags = in_flag;
3504 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3505 && bfd_get_arch_info (obfd)->the_default)
3506 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3507 bfd_get_mach (ibfd));
3512 if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
3513 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
3515 if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
3516 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
3523 elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
3525 BFD_ASSERT (!elf_flags_init (abfd)
3526 || elf_elfheader (abfd)->e_flags == flags);
3528 elf_elfheader (abfd)->e_flags |= flags;
3529 elf_flags_init (abfd) = TRUE;
3536 elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
3538 FILE *f = (FILE *) farg;
3539 flagword e_flags = elf_elfheader (abfd)->e_flags;
3541 fprintf (f, "\nXtensa header:\n");
3542 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
3543 fprintf (f, "\nMachine = Base\n");
3545 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
3547 fprintf (f, "Insn tables = %s\n",
3548 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
3550 fprintf (f, "Literal tables = %s\n",
3551 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
3553 return _bfd_elf_print_private_bfd_data (abfd, farg);
3557 /* Set the right machine number for an Xtensa ELF file. */
3560 elf_xtensa_object_p (bfd *abfd)
3563 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
3568 mach = bfd_mach_xtensa;
3574 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
3579 /* The final processing done just before writing out an Xtensa ELF object
3580 file. This gets the Xtensa architecture right based on the machine
3584 elf_xtensa_final_write_processing (bfd *abfd,
3585 bfd_boolean linker ATTRIBUTE_UNUSED)
3590 switch (mach = bfd_get_mach (abfd))
3592 case bfd_mach_xtensa:
3593 val = E_XTENSA_MACH;
3599 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
3600 elf_elfheader (abfd)->e_flags |= val;
3604 static enum elf_reloc_type_class
3605 elf_xtensa_reloc_type_class (const Elf_Internal_Rela *rela)
3607 switch ((int) ELF32_R_TYPE (rela->r_info))
3609 case R_XTENSA_RELATIVE:
3610 return reloc_class_relative;
3611 case R_XTENSA_JMP_SLOT:
3612 return reloc_class_plt;
3614 return reloc_class_normal;
3620 elf_xtensa_discard_info_for_section (bfd *abfd,
3621 struct elf_reloc_cookie *cookie,
3622 struct bfd_link_info *info,
3626 bfd_vma offset, actual_offset;
3627 bfd_size_type removed_bytes = 0;
3628 bfd_size_type entry_size;
3630 if (sec->output_section
3631 && bfd_is_abs_section (sec->output_section))
3634 if (xtensa_is_proptable_section (sec))
3639 if (sec->size == 0 || sec->size % entry_size != 0)
3642 contents = retrieve_contents (abfd, sec, info->keep_memory);
3646 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
3649 release_contents (sec, contents);
3653 /* Sort the relocations. They should already be in order when
3654 relaxation is enabled, but it might not be. */
3655 qsort (cookie->rels, sec->reloc_count, sizeof (Elf_Internal_Rela),
3656 internal_reloc_compare);
3658 cookie->rel = cookie->rels;
3659 cookie->relend = cookie->rels + sec->reloc_count;
3661 for (offset = 0; offset < sec->size; offset += entry_size)
3663 actual_offset = offset - removed_bytes;
3665 /* The ...symbol_deleted_p function will skip over relocs but it
3666 won't adjust their offsets, so do that here. */
3667 while (cookie->rel < cookie->relend
3668 && cookie->rel->r_offset < offset)
3670 cookie->rel->r_offset -= removed_bytes;
3674 while (cookie->rel < cookie->relend
3675 && cookie->rel->r_offset == offset)
3677 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
3679 /* Remove the table entry. (If the reloc type is NONE, then
3680 the entry has already been merged with another and deleted
3681 during relaxation.) */
3682 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
3684 /* Shift the contents up. */
3685 if (offset + entry_size < sec->size)
3686 memmove (&contents[actual_offset],
3687 &contents[actual_offset + entry_size],
3688 sec->size - offset - entry_size);
3689 removed_bytes += entry_size;
3692 /* Remove this relocation. */
3693 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3696 /* Adjust the relocation offset for previous removals. This
3697 should not be done before calling ...symbol_deleted_p
3698 because it might mess up the offset comparisons there.
3699 Make sure the offset doesn't underflow in the case where
3700 the first entry is removed. */
3701 if (cookie->rel->r_offset >= removed_bytes)
3702 cookie->rel->r_offset -= removed_bytes;
3704 cookie->rel->r_offset = 0;
3710 if (removed_bytes != 0)
3712 /* Adjust any remaining relocs (shouldn't be any). */
3713 for (; cookie->rel < cookie->relend; cookie->rel++)
3715 if (cookie->rel->r_offset >= removed_bytes)
3716 cookie->rel->r_offset -= removed_bytes;
3718 cookie->rel->r_offset = 0;
3721 /* Clear the removed bytes. */
3722 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
3724 pin_contents (sec, contents);
3725 pin_internal_relocs (sec, cookie->rels);
3728 if (sec->rawsize == 0)
3729 sec->rawsize = sec->size;
3730 sec->size -= removed_bytes;
3732 if (xtensa_is_littable_section (sec))
3734 asection *sgotloc = elf_xtensa_hash_table (info)->sgotloc;
3736 sgotloc->size -= removed_bytes;
3741 release_contents (sec, contents);
3742 release_internal_relocs (sec, cookie->rels);
3745 return (removed_bytes != 0);
3750 elf_xtensa_discard_info (bfd *abfd,
3751 struct elf_reloc_cookie *cookie,
3752 struct bfd_link_info *info)
3755 bfd_boolean changed = FALSE;
3757 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3759 if (xtensa_is_property_section (sec))
3761 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
3771 elf_xtensa_ignore_discarded_relocs (asection *sec)
3773 return xtensa_is_property_section (sec);
3778 elf_xtensa_action_discarded (asection *sec)
3780 if (strcmp (".xt_except_table", sec->name) == 0)
3783 if (strcmp (".xt_except_desc", sec->name) == 0)
3786 return _bfd_elf_default_action_discarded (sec);
3790 /* Support for core dump NOTE sections. */
3793 elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3798 /* The size for Xtensa is variable, so don't try to recognize the format
3799 based on the size. Just assume this is GNU/Linux. */
3802 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3805 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
3809 size = note->descsz - offset - 4;
3811 /* Make a ".reg/999" section. */
3812 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3813 size, note->descpos + offset);
3818 elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3820 switch (note->descsz)
3825 case 128: /* GNU/Linux elf_prpsinfo */
3826 elf_tdata (abfd)->core_program
3827 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3828 elf_tdata (abfd)->core_command
3829 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3832 /* Note that for some reason, a spurious space is tacked
3833 onto the end of the args in some (at least one anyway)
3834 implementations, so strip it off if it exists. */
3837 char *command = elf_tdata (abfd)->core_command;
3838 int n = strlen (command);
3840 if (0 < n && command[n - 1] == ' ')
3841 command[n - 1] = '\0';
3848 /* Generic Xtensa configurability stuff. */
3850 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3851 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3852 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3853 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3854 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3855 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3856 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3857 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3860 init_call_opcodes (void)
3862 if (callx0_op == XTENSA_UNDEFINED)
3864 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3865 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3866 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3867 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3868 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3869 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3870 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3871 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3877 is_indirect_call_opcode (xtensa_opcode opcode)
3879 init_call_opcodes ();
3880 return (opcode == callx0_op
3881 || opcode == callx4_op
3882 || opcode == callx8_op
3883 || opcode == callx12_op);
3888 is_direct_call_opcode (xtensa_opcode opcode)
3890 init_call_opcodes ();
3891 return (opcode == call0_op
3892 || opcode == call4_op
3893 || opcode == call8_op
3894 || opcode == call12_op);
3899 is_windowed_call_opcode (xtensa_opcode opcode)
3901 init_call_opcodes ();
3902 return (opcode == call4_op
3903 || opcode == call8_op
3904 || opcode == call12_op
3905 || opcode == callx4_op
3906 || opcode == callx8_op
3907 || opcode == callx12_op);
3912 get_indirect_call_dest_reg (xtensa_opcode opcode, unsigned *pdst)
3914 unsigned dst = (unsigned) -1;
3916 init_call_opcodes ();
3917 if (opcode == callx0_op)
3919 else if (opcode == callx4_op)
3921 else if (opcode == callx8_op)
3923 else if (opcode == callx12_op)
3926 if (dst == (unsigned) -1)
3934 static xtensa_opcode
3935 get_const16_opcode (void)
3937 static bfd_boolean done_lookup = FALSE;
3938 static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3941 const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3944 return const16_opcode;
3948 static xtensa_opcode
3949 get_l32r_opcode (void)
3951 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
3952 static bfd_boolean done_lookup = FALSE;
3956 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
3964 l32r_offset (bfd_vma addr, bfd_vma pc)
3968 offset = addr - ((pc+3) & -4);
3969 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3970 offset = (signed int) offset >> 2;
3971 BFD_ASSERT ((signed int) offset >> 16 == -1);
3977 get_relocation_opnd (xtensa_opcode opcode, int r_type)
3979 xtensa_isa isa = xtensa_default_isa;
3980 int last_immed, last_opnd, opi;
3982 if (opcode == XTENSA_UNDEFINED)
3983 return XTENSA_UNDEFINED;
3985 /* Find the last visible PC-relative immediate operand for the opcode.
3986 If there are no PC-relative immediates, then choose the last visible
3987 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3988 last_immed = XTENSA_UNDEFINED;
3989 last_opnd = xtensa_opcode_num_operands (isa, opcode);
3990 for (opi = last_opnd - 1; opi >= 0; opi--)
3992 if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
3994 if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
3999 if (last_immed == XTENSA_UNDEFINED
4000 && xtensa_operand_is_register (isa, opcode, opi) == 0)
4004 return XTENSA_UNDEFINED;
4006 /* If the operand number was specified in an old-style relocation,
4007 check for consistency with the operand computed above. */
4008 if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
4010 int reloc_opnd = r_type - R_XTENSA_OP0;
4011 if (reloc_opnd != last_immed)
4012 return XTENSA_UNDEFINED;
4020 get_relocation_slot (int r_type)
4030 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4031 return r_type - R_XTENSA_SLOT0_OP;
4032 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4033 return r_type - R_XTENSA_SLOT0_ALT;
4037 return XTENSA_UNDEFINED;
4041 /* Get the opcode for a relocation. */
4043 static xtensa_opcode
4044 get_relocation_opcode (bfd *abfd,
4047 Elf_Internal_Rela *irel)
4049 static xtensa_insnbuf ibuff = NULL;
4050 static xtensa_insnbuf sbuff = NULL;
4051 xtensa_isa isa = xtensa_default_isa;
4055 if (contents == NULL)
4056 return XTENSA_UNDEFINED;
4058 if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
4059 return XTENSA_UNDEFINED;
4063 ibuff = xtensa_insnbuf_alloc (isa);
4064 sbuff = xtensa_insnbuf_alloc (isa);
4067 /* Decode the instruction. */
4068 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
4069 sec->size - irel->r_offset);
4070 fmt = xtensa_format_decode (isa, ibuff);
4071 slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
4072 if (slot == XTENSA_UNDEFINED)
4073 return XTENSA_UNDEFINED;
4074 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
4075 return xtensa_opcode_decode (isa, fmt, slot, sbuff);
4080 is_l32r_relocation (bfd *abfd,
4083 Elf_Internal_Rela *irel)
4085 xtensa_opcode opcode;
4086 if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
4088 opcode = get_relocation_opcode (abfd, sec, contents, irel);
4089 return (opcode == get_l32r_opcode ());
4093 static bfd_size_type
4094 get_asm_simplify_size (bfd_byte *contents,
4095 bfd_size_type content_len,
4096 bfd_size_type offset)
4098 bfd_size_type insnlen, size = 0;
4100 /* Decode the size of the next two instructions. */
4101 insnlen = insn_decode_len (contents, content_len, offset);
4107 insnlen = insn_decode_len (contents, content_len, offset + size);
4117 is_alt_relocation (int r_type)
4119 return (r_type >= R_XTENSA_SLOT0_ALT
4120 && r_type <= R_XTENSA_SLOT14_ALT);
4125 is_operand_relocation (int r_type)
4135 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4137 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4146 #define MIN_INSN_LENGTH 2
4148 /* Return 0 if it fails to decode. */
4151 insn_decode_len (bfd_byte *contents,
4152 bfd_size_type content_len,
4153 bfd_size_type offset)
4156 xtensa_isa isa = xtensa_default_isa;
4158 static xtensa_insnbuf ibuff = NULL;
4160 if (offset + MIN_INSN_LENGTH > content_len)
4164 ibuff = xtensa_insnbuf_alloc (isa);
4165 xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
4166 content_len - offset);
4167 fmt = xtensa_format_decode (isa, ibuff);
4168 if (fmt == XTENSA_UNDEFINED)
4170 insn_len = xtensa_format_length (isa, fmt);
4171 if (insn_len == XTENSA_UNDEFINED)
4177 /* Decode the opcode for a single slot instruction.
4178 Return 0 if it fails to decode or the instruction is multi-slot. */
4181 insn_decode_opcode (bfd_byte *contents,
4182 bfd_size_type content_len,
4183 bfd_size_type offset,
4186 xtensa_isa isa = xtensa_default_isa;
4188 static xtensa_insnbuf insnbuf = NULL;
4189 static xtensa_insnbuf slotbuf = NULL;
4191 if (offset + MIN_INSN_LENGTH > content_len)
4192 return XTENSA_UNDEFINED;
4194 if (insnbuf == NULL)
4196 insnbuf = xtensa_insnbuf_alloc (isa);
4197 slotbuf = xtensa_insnbuf_alloc (isa);
4200 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4201 content_len - offset);
4202 fmt = xtensa_format_decode (isa, insnbuf);
4203 if (fmt == XTENSA_UNDEFINED)
4204 return XTENSA_UNDEFINED;
4206 if (slot >= xtensa_format_num_slots (isa, fmt))
4207 return XTENSA_UNDEFINED;
4209 xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4210 return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4214 /* The offset is the offset in the contents.
4215 The address is the address of that offset. */
4218 check_branch_target_aligned (bfd_byte *contents,
4219 bfd_size_type content_length,
4223 bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
4226 return check_branch_target_aligned_address (address, insn_len);
4231 check_loop_aligned (bfd_byte *contents,
4232 bfd_size_type content_length,
4236 bfd_size_type loop_len, insn_len;
4237 xtensa_opcode opcode;
4239 opcode = insn_decode_opcode (contents, content_length, offset, 0);
4240 if (opcode == XTENSA_UNDEFINED
4241 || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
4247 loop_len = insn_decode_len (contents, content_length, offset);
4248 insn_len = insn_decode_len (contents, content_length, offset + loop_len);
4249 if (loop_len == 0 || insn_len == 0)
4255 return check_branch_target_aligned_address (address + loop_len, insn_len);
4260 check_branch_target_aligned_address (bfd_vma addr, int len)
4263 return (addr % 8 == 0);
4264 return ((addr >> 2) == ((addr + len - 1) >> 2));
4268 /* Instruction widening and narrowing. */
4270 /* When FLIX is available we need to access certain instructions only
4271 when they are 16-bit or 24-bit instructions. This table caches
4272 information about such instructions by walking through all the
4273 opcodes and finding the smallest single-slot format into which each
4276 static xtensa_format *op_single_fmt_table = NULL;
4280 init_op_single_format_table (void)
4282 xtensa_isa isa = xtensa_default_isa;
4283 xtensa_insnbuf ibuf;
4284 xtensa_opcode opcode;
4288 if (op_single_fmt_table)
4291 ibuf = xtensa_insnbuf_alloc (isa);
4292 num_opcodes = xtensa_isa_num_opcodes (isa);
4294 op_single_fmt_table = (xtensa_format *)
4295 bfd_malloc (sizeof (xtensa_format) * num_opcodes);
4296 for (opcode = 0; opcode < num_opcodes; opcode++)
4298 op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
4299 for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
4301 if (xtensa_format_num_slots (isa, fmt) == 1
4302 && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
4304 xtensa_opcode old_fmt = op_single_fmt_table[opcode];
4305 int fmt_length = xtensa_format_length (isa, fmt);
4306 if (old_fmt == XTENSA_UNDEFINED
4307 || fmt_length < xtensa_format_length (isa, old_fmt))
4308 op_single_fmt_table[opcode] = fmt;
4312 xtensa_insnbuf_free (isa, ibuf);
4316 static xtensa_format
4317 get_single_format (xtensa_opcode opcode)
4319 init_op_single_format_table ();
4320 return op_single_fmt_table[opcode];
4324 /* For the set of narrowable instructions we do NOT include the
4325 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4326 involved during linker relaxation that may require these to
4327 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4328 requires special case code to ensure it only works when op1 == op2. */
4336 struct string_pair narrowable[] =
4339 { "addi", "addi.n" },
4340 { "addmi", "addi.n" },
4341 { "l32i", "l32i.n" },
4342 { "movi", "movi.n" },
4344 { "retw", "retw.n" },
4345 { "s32i", "s32i.n" },
4346 { "or", "mov.n" } /* special case only when op1 == op2 */
4349 struct string_pair widenable[] =
4352 { "addi", "addi.n" },
4353 { "addmi", "addi.n" },
4354 { "beqz", "beqz.n" },
4355 { "bnez", "bnez.n" },
4356 { "l32i", "l32i.n" },
4357 { "movi", "movi.n" },
4359 { "retw", "retw.n" },
4360 { "s32i", "s32i.n" },
4361 { "or", "mov.n" } /* special case only when op1 == op2 */
4365 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4366 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4367 return the instruction buffer holding the narrow instruction. Otherwise,
4368 return 0. The set of valid narrowing are specified by a string table
4369 but require some special case operand checks in some cases. */
4371 static xtensa_insnbuf
4372 can_narrow_instruction (xtensa_insnbuf slotbuf,
4374 xtensa_opcode opcode)
4376 xtensa_isa isa = xtensa_default_isa;
4377 xtensa_format o_fmt;
4380 static xtensa_insnbuf o_insnbuf = NULL;
4381 static xtensa_insnbuf o_slotbuf = NULL;
4383 if (o_insnbuf == NULL)
4385 o_insnbuf = xtensa_insnbuf_alloc (isa);
4386 o_slotbuf = xtensa_insnbuf_alloc (isa);
4389 for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
4391 bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
4393 if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
4395 uint32 value, newval;
4396 int i, operand_count, o_operand_count;
4397 xtensa_opcode o_opcode;
4399 /* Address does not matter in this case. We might need to
4400 fix it to handle branches/jumps. */
4401 bfd_vma self_address = 0;
4403 o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
4404 if (o_opcode == XTENSA_UNDEFINED)
4406 o_fmt = get_single_format (o_opcode);
4407 if (o_fmt == XTENSA_UNDEFINED)
4410 if (xtensa_format_length (isa, fmt) != 3
4411 || xtensa_format_length (isa, o_fmt) != 2)
4414 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4415 operand_count = xtensa_opcode_num_operands (isa, opcode);
4416 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4418 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4423 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4428 uint32 rawval0, rawval1, rawval2;
4430 if (o_operand_count + 1 != operand_count
4431 || xtensa_operand_get_field (isa, opcode, 0,
4432 fmt, 0, slotbuf, &rawval0) != 0
4433 || xtensa_operand_get_field (isa, opcode, 1,
4434 fmt, 0, slotbuf, &rawval1) != 0
4435 || xtensa_operand_get_field (isa, opcode, 2,
4436 fmt, 0, slotbuf, &rawval2) != 0
4437 || rawval1 != rawval2
4438 || rawval0 == rawval1 /* it is a nop */)
4442 for (i = 0; i < o_operand_count; ++i)
4444 if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
4446 || xtensa_operand_decode (isa, opcode, i, &value))
4449 /* PC-relative branches need adjustment, but
4450 the PC-rel operand will always have a relocation. */
4452 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4454 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4455 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4460 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4470 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4471 the action in-place directly into the contents and return TRUE. Otherwise,
4472 the return value is FALSE and the contents are not modified. */
4475 narrow_instruction (bfd_byte *contents,
4476 bfd_size_type content_length,
4477 bfd_size_type offset)
4479 xtensa_opcode opcode;
4480 bfd_size_type insn_len;
4481 xtensa_isa isa = xtensa_default_isa;
4483 xtensa_insnbuf o_insnbuf;
4485 static xtensa_insnbuf insnbuf = NULL;
4486 static xtensa_insnbuf slotbuf = NULL;
4488 if (insnbuf == NULL)
4490 insnbuf = xtensa_insnbuf_alloc (isa);
4491 slotbuf = xtensa_insnbuf_alloc (isa);
4494 BFD_ASSERT (offset < content_length);
4496 if (content_length < 2)
4499 /* We will hand-code a few of these for a little while.
4500 These have all been specified in the assembler aleady. */
4501 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4502 content_length - offset);
4503 fmt = xtensa_format_decode (isa, insnbuf);
4504 if (xtensa_format_num_slots (isa, fmt) != 1)
4507 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4510 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4511 if (opcode == XTENSA_UNDEFINED)
4513 insn_len = xtensa_format_length (isa, fmt);
4514 if (insn_len > content_length)
4517 o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
4520 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4521 content_length - offset);
4529 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4530 "density" instruction to a standard 3-byte instruction. If it is valid,
4531 return the instruction buffer holding the wide instruction. Otherwise,
4532 return 0. The set of valid widenings are specified by a string table
4533 but require some special case operand checks in some cases. */
4535 static xtensa_insnbuf
4536 can_widen_instruction (xtensa_insnbuf slotbuf,
4538 xtensa_opcode opcode)
4540 xtensa_isa isa = xtensa_default_isa;
4541 xtensa_format o_fmt;
4544 static xtensa_insnbuf o_insnbuf = NULL;
4545 static xtensa_insnbuf o_slotbuf = NULL;
4547 if (o_insnbuf == NULL)
4549 o_insnbuf = xtensa_insnbuf_alloc (isa);
4550 o_slotbuf = xtensa_insnbuf_alloc (isa);
4553 for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
4555 bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
4556 bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
4557 || strcmp ("bnez", widenable[opi].wide) == 0);
4559 if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
4561 uint32 value, newval;
4562 int i, operand_count, o_operand_count, check_operand_count;
4563 xtensa_opcode o_opcode;
4565 /* Address does not matter in this case. We might need to fix it
4566 to handle branches/jumps. */
4567 bfd_vma self_address = 0;
4569 o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
4570 if (o_opcode == XTENSA_UNDEFINED)
4572 o_fmt = get_single_format (o_opcode);
4573 if (o_fmt == XTENSA_UNDEFINED)
4576 if (xtensa_format_length (isa, fmt) != 2
4577 || xtensa_format_length (isa, o_fmt) != 3)
4580 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4581 operand_count = xtensa_opcode_num_operands (isa, opcode);
4582 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4583 check_operand_count = o_operand_count;
4585 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4590 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4595 uint32 rawval0, rawval1;
4597 if (o_operand_count != operand_count + 1
4598 || xtensa_operand_get_field (isa, opcode, 0,
4599 fmt, 0, slotbuf, &rawval0) != 0
4600 || xtensa_operand_get_field (isa, opcode, 1,
4601 fmt, 0, slotbuf, &rawval1) != 0
4602 || rawval0 == rawval1 /* it is a nop */)
4606 check_operand_count--;
4608 for (i = 0; i < check_operand_count; i++)
4611 if (is_or && i == o_operand_count - 1)
4613 if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
4615 || xtensa_operand_decode (isa, opcode, new_i, &value))
4618 /* PC-relative branches need adjustment, but
4619 the PC-rel operand will always have a relocation. */
4621 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4623 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4624 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4629 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4639 /* Attempt to widen an instruction. If the widening is valid, perform
4640 the action in-place directly into the contents and return TRUE. Otherwise,
4641 the return value is FALSE and the contents are not modified. */
4644 widen_instruction (bfd_byte *contents,
4645 bfd_size_type content_length,
4646 bfd_size_type offset)
4648 xtensa_opcode opcode;
4649 bfd_size_type insn_len;
4650 xtensa_isa isa = xtensa_default_isa;
4652 xtensa_insnbuf o_insnbuf;
4654 static xtensa_insnbuf insnbuf = NULL;
4655 static xtensa_insnbuf slotbuf = NULL;
4657 if (insnbuf == NULL)
4659 insnbuf = xtensa_insnbuf_alloc (isa);
4660 slotbuf = xtensa_insnbuf_alloc (isa);
4663 BFD_ASSERT (offset < content_length);
4665 if (content_length < 2)
4668 /* We will hand-code a few of these for a little while.
4669 These have all been specified in the assembler aleady. */
4670 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4671 content_length - offset);
4672 fmt = xtensa_format_decode (isa, insnbuf);
4673 if (xtensa_format_num_slots (isa, fmt) != 1)
4676 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4679 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4680 if (opcode == XTENSA_UNDEFINED)
4682 insn_len = xtensa_format_length (isa, fmt);
4683 if (insn_len > content_length)
4686 o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
4689 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4690 content_length - offset);
4697 /* Code for transforming CALLs at link-time. */
4699 static bfd_reloc_status_type
4700 elf_xtensa_do_asm_simplify (bfd_byte *contents,
4702 bfd_vma content_length,
4703 char **error_message)
4705 static xtensa_insnbuf insnbuf = NULL;
4706 static xtensa_insnbuf slotbuf = NULL;
4707 xtensa_format core_format = XTENSA_UNDEFINED;
4708 xtensa_opcode opcode;
4709 xtensa_opcode direct_call_opcode;
4710 xtensa_isa isa = xtensa_default_isa;
4711 bfd_byte *chbuf = contents + address;
4714 if (insnbuf == NULL)
4716 insnbuf = xtensa_insnbuf_alloc (isa);
4717 slotbuf = xtensa_insnbuf_alloc (isa);
4720 if (content_length < address)
4722 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4723 return bfd_reloc_other;
4726 opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
4727 direct_call_opcode = swap_callx_for_call_opcode (opcode);
4728 if (direct_call_opcode == XTENSA_UNDEFINED)
4730 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4731 return bfd_reloc_other;
4734 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4735 core_format = xtensa_format_lookup (isa, "x24");
4736 opcode = xtensa_opcode_lookup (isa, "or");
4737 xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
4738 for (opn = 0; opn < 3; opn++)
4741 xtensa_operand_encode (isa, opcode, opn, ®no);
4742 xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
4745 xtensa_format_encode (isa, core_format, insnbuf);
4746 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4747 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
4749 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4750 xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
4751 xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
4753 xtensa_format_encode (isa, core_format, insnbuf);
4754 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4755 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
4756 content_length - address - 3);
4758 return bfd_reloc_ok;
4762 static bfd_reloc_status_type
4763 contract_asm_expansion (bfd_byte *contents,
4764 bfd_vma content_length,
4765 Elf_Internal_Rela *irel,
4766 char **error_message)
4768 bfd_reloc_status_type retval =
4769 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
4772 if (retval != bfd_reloc_ok)
4773 return bfd_reloc_dangerous;
4775 /* Update the irel->r_offset field so that the right immediate and
4776 the right instruction are modified during the relocation. */
4777 irel->r_offset += 3;
4778 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
4779 return bfd_reloc_ok;
4783 static xtensa_opcode
4784 swap_callx_for_call_opcode (xtensa_opcode opcode)
4786 init_call_opcodes ();
4788 if (opcode == callx0_op) return call0_op;
4789 if (opcode == callx4_op) return call4_op;
4790 if (opcode == callx8_op) return call8_op;
4791 if (opcode == callx12_op) return call12_op;
4793 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4794 return XTENSA_UNDEFINED;
4798 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4799 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4800 If not, return XTENSA_UNDEFINED. */
4802 #define L32R_TARGET_REG_OPERAND 0
4803 #define CONST16_TARGET_REG_OPERAND 0
4804 #define CALLN_SOURCE_OPERAND 0
4806 static xtensa_opcode
4807 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
4809 static xtensa_insnbuf insnbuf = NULL;
4810 static xtensa_insnbuf slotbuf = NULL;
4812 xtensa_opcode opcode;
4813 xtensa_isa isa = xtensa_default_isa;
4814 uint32 regno, const16_regno, call_regno;
4817 if (insnbuf == NULL)
4819 insnbuf = xtensa_insnbuf_alloc (isa);
4820 slotbuf = xtensa_insnbuf_alloc (isa);
4823 xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4824 fmt = xtensa_format_decode (isa, insnbuf);
4825 if (fmt == XTENSA_UNDEFINED
4826 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4827 return XTENSA_UNDEFINED;
4829 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4830 if (opcode == XTENSA_UNDEFINED)
4831 return XTENSA_UNDEFINED;
4833 if (opcode == get_l32r_opcode ())
4836 *p_uses_l32r = TRUE;
4837 if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4838 fmt, 0, slotbuf, ®no)
4839 || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4841 return XTENSA_UNDEFINED;
4843 else if (opcode == get_const16_opcode ())
4846 *p_uses_l32r = FALSE;
4847 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4848 fmt, 0, slotbuf, ®no)
4849 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4851 return XTENSA_UNDEFINED;
4853 /* Check that the next instruction is also CONST16. */
4854 offset += xtensa_format_length (isa, fmt);
4855 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4856 fmt = xtensa_format_decode (isa, insnbuf);
4857 if (fmt == XTENSA_UNDEFINED
4858 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4859 return XTENSA_UNDEFINED;
4860 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4861 if (opcode != get_const16_opcode ())
4862 return XTENSA_UNDEFINED;
4864 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4865 fmt, 0, slotbuf, &const16_regno)
4866 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4868 || const16_regno != regno)
4869 return XTENSA_UNDEFINED;
4872 return XTENSA_UNDEFINED;
4874 /* Next instruction should be an CALLXn with operand 0 == regno. */
4875 offset += xtensa_format_length (isa, fmt);
4876 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4877 fmt = xtensa_format_decode (isa, insnbuf);
4878 if (fmt == XTENSA_UNDEFINED
4879 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4880 return XTENSA_UNDEFINED;
4881 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4882 if (opcode == XTENSA_UNDEFINED
4883 || !is_indirect_call_opcode (opcode))
4884 return XTENSA_UNDEFINED;
4886 if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4887 fmt, 0, slotbuf, &call_regno)
4888 || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4890 return XTENSA_UNDEFINED;
4892 if (call_regno != regno)
4893 return XTENSA_UNDEFINED;
4899 /* Data structures used during relaxation. */
4901 /* r_reloc: relocation values. */
4903 /* Through the relaxation process, we need to keep track of the values
4904 that will result from evaluating relocations. The standard ELF
4905 relocation structure is not sufficient for this purpose because we're
4906 operating on multiple input files at once, so we need to know which
4907 input file a relocation refers to. The r_reloc structure thus
4908 records both the input file (bfd) and ELF relocation.
4910 For efficiency, an r_reloc also contains a "target_offset" field to
4911 cache the target-section-relative offset value that is represented by
4914 The r_reloc also contains a virtual offset that allows multiple
4915 inserted literals to be placed at the same "address" with
4916 different offsets. */
4918 typedef struct r_reloc_struct r_reloc;
4920 struct r_reloc_struct
4923 Elf_Internal_Rela rela;
4924 bfd_vma target_offset;
4925 bfd_vma virtual_offset;
4929 /* The r_reloc structure is included by value in literal_value, but not
4930 every literal_value has an associated relocation -- some are simple
4931 constants. In such cases, we set all the fields in the r_reloc
4932 struct to zero. The r_reloc_is_const function should be used to
4933 detect this case. */
4936 r_reloc_is_const (const r_reloc *r_rel)
4938 return (r_rel->abfd == NULL);
4943 r_reloc_get_target_offset (const r_reloc *r_rel)
4945 bfd_vma target_offset;
4946 unsigned long r_symndx;
4948 BFD_ASSERT (!r_reloc_is_const (r_rel));
4949 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4950 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4951 return (target_offset + r_rel->rela.r_addend);
4955 static struct elf_link_hash_entry *
4956 r_reloc_get_hash_entry (const r_reloc *r_rel)
4958 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4959 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4964 r_reloc_get_section (const r_reloc *r_rel)
4966 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4967 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4972 r_reloc_is_defined (const r_reloc *r_rel)
4978 sec = r_reloc_get_section (r_rel);
4979 if (sec == bfd_abs_section_ptr
4980 || sec == bfd_com_section_ptr
4981 || sec == bfd_und_section_ptr)
4988 r_reloc_init (r_reloc *r_rel,
4990 Elf_Internal_Rela *irel,
4992 bfd_size_type content_length)
4995 reloc_howto_type *howto;
4999 r_rel->rela = *irel;
5001 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
5002 r_rel->virtual_offset = 0;
5003 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
5004 howto = &elf_howto_table[r_type];
5005 if (howto->partial_inplace)
5007 bfd_vma inplace_val;
5008 BFD_ASSERT (r_rel->rela.r_offset < content_length);
5010 inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
5011 r_rel->target_offset += inplace_val;
5015 memset (r_rel, 0, sizeof (r_reloc));
5022 print_r_reloc (FILE *fp, const r_reloc *r_rel)
5024 if (r_reloc_is_defined (r_rel))
5026 asection *sec = r_reloc_get_section (r_rel);
5027 fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
5029 else if (r_reloc_get_hash_entry (r_rel))
5030 fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
5032 fprintf (fp, " ?? + ");
5034 fprintf_vma (fp, r_rel->target_offset);
5035 if (r_rel->virtual_offset)
5037 fprintf (fp, " + ");
5038 fprintf_vma (fp, r_rel->virtual_offset);
5047 /* source_reloc: relocations that reference literals. */
5049 /* To determine whether literals can be coalesced, we need to first
5050 record all the relocations that reference the literals. The
5051 source_reloc structure below is used for this purpose. The
5052 source_reloc entries are kept in a per-literal-section array, sorted
5053 by offset within the literal section (i.e., target offset).
5055 The source_sec and r_rel.rela.r_offset fields identify the source of
5056 the relocation. The r_rel field records the relocation value, i.e.,
5057 the offset of the literal being referenced. The opnd field is needed
5058 to determine the range of the immediate field to which the relocation
5059 applies, so we can determine whether another literal with the same
5060 value is within range. The is_null field is true when the relocation
5061 is being removed (e.g., when an L32R is being removed due to a CALLX
5062 that is converted to a direct CALL). */
5064 typedef struct source_reloc_struct source_reloc;
5066 struct source_reloc_struct
5068 asection *source_sec;
5070 xtensa_opcode opcode;
5072 bfd_boolean is_null;
5073 bfd_boolean is_abs_literal;
5078 init_source_reloc (source_reloc *reloc,
5079 asection *source_sec,
5080 const r_reloc *r_rel,
5081 xtensa_opcode opcode,
5083 bfd_boolean is_abs_literal)
5085 reloc->source_sec = source_sec;
5086 reloc->r_rel = *r_rel;
5087 reloc->opcode = opcode;
5089 reloc->is_null = FALSE;
5090 reloc->is_abs_literal = is_abs_literal;
5094 /* Find the source_reloc for a particular source offset and relocation
5095 type. Note that the array is sorted by _target_ offset, so this is
5096 just a linear search. */
5098 static source_reloc *
5099 find_source_reloc (source_reloc *src_relocs,
5102 Elf_Internal_Rela *irel)
5106 for (i = 0; i < src_count; i++)
5108 if (src_relocs[i].source_sec == sec
5109 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
5110 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
5111 == ELF32_R_TYPE (irel->r_info)))
5112 return &src_relocs[i];
5120 source_reloc_compare (const void *ap, const void *bp)
5122 const source_reloc *a = (const source_reloc *) ap;
5123 const source_reloc *b = (const source_reloc *) bp;
5125 if (a->r_rel.target_offset != b->r_rel.target_offset)
5126 return (a->r_rel.target_offset - b->r_rel.target_offset);
5128 /* We don't need to sort on these criteria for correctness,
5129 but enforcing a more strict ordering prevents unstable qsort
5130 from behaving differently with different implementations.
5131 Without the code below we get correct but different results
5132 on Solaris 2.7 and 2.8. We would like to always produce the
5133 same results no matter the host. */
5135 if ((!a->is_null) - (!b->is_null))
5136 return ((!a->is_null) - (!b->is_null));
5137 return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
5141 /* Literal values and value hash tables. */
5143 /* Literals with the same value can be coalesced. The literal_value
5144 structure records the value of a literal: the "r_rel" field holds the
5145 information from the relocation on the literal (if there is one) and
5146 the "value" field holds the contents of the literal word itself.
5148 The value_map structure records a literal value along with the
5149 location of a literal holding that value. The value_map hash table
5150 is indexed by the literal value, so that we can quickly check if a
5151 particular literal value has been seen before and is thus a candidate
5154 typedef struct literal_value_struct literal_value;
5155 typedef struct value_map_struct value_map;
5156 typedef struct value_map_hash_table_struct value_map_hash_table;
5158 struct literal_value_struct
5161 unsigned long value;
5162 bfd_boolean is_abs_literal;
5165 struct value_map_struct
5167 literal_value val; /* The literal value. */
5168 r_reloc loc; /* Location of the literal. */
5172 struct value_map_hash_table_struct
5174 unsigned bucket_count;
5175 value_map **buckets;
5177 bfd_boolean has_last_loc;
5183 init_literal_value (literal_value *lit,
5184 const r_reloc *r_rel,
5185 unsigned long value,
5186 bfd_boolean is_abs_literal)
5188 lit->r_rel = *r_rel;
5190 lit->is_abs_literal = is_abs_literal;
5195 literal_value_equal (const literal_value *src1,
5196 const literal_value *src2,
5197 bfd_boolean final_static_link)
5199 struct elf_link_hash_entry *h1, *h2;
5201 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
5204 if (r_reloc_is_const (&src1->r_rel))
5205 return (src1->value == src2->value);
5207 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
5208 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
5211 if (src1->r_rel.target_offset != src2->r_rel.target_offset)
5214 if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
5217 if (src1->value != src2->value)
5220 /* Now check for the same section (if defined) or the same elf_hash
5221 (if undefined or weak). */
5222 h1 = r_reloc_get_hash_entry (&src1->r_rel);
5223 h2 = r_reloc_get_hash_entry (&src2->r_rel);
5224 if (r_reloc_is_defined (&src1->r_rel)
5225 && (final_static_link
5226 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
5227 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
5229 if (r_reloc_get_section (&src1->r_rel)
5230 != r_reloc_get_section (&src2->r_rel))
5235 /* Require that the hash entries (i.e., symbols) be identical. */
5236 if (h1 != h2 || h1 == 0)
5240 if (src1->is_abs_literal != src2->is_abs_literal)
5247 /* Must be power of 2. */
5248 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5250 static value_map_hash_table *
5251 value_map_hash_table_init (void)
5253 value_map_hash_table *values;
5255 values = (value_map_hash_table *)
5256 bfd_zmalloc (sizeof (value_map_hash_table));
5257 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
5259 values->buckets = (value_map **)
5260 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
5261 if (values->buckets == NULL)
5266 values->has_last_loc = FALSE;
5273 value_map_hash_table_delete (value_map_hash_table *table)
5275 free (table->buckets);
5281 hash_bfd_vma (bfd_vma val)
5283 return (val >> 2) + (val >> 10);
5288 literal_value_hash (const literal_value *src)
5292 hash_val = hash_bfd_vma (src->value);
5293 if (!r_reloc_is_const (&src->r_rel))
5297 hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
5298 hash_val += hash_bfd_vma (src->r_rel.target_offset);
5299 hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
5301 /* Now check for the same section and the same elf_hash. */
5302 if (r_reloc_is_defined (&src->r_rel))
5303 sec_or_hash = r_reloc_get_section (&src->r_rel);
5305 sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
5306 hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
5312 /* Check if the specified literal_value has been seen before. */
5315 value_map_get_cached_value (value_map_hash_table *map,
5316 const literal_value *val,
5317 bfd_boolean final_static_link)
5323 idx = literal_value_hash (val);
5324 idx = idx & (map->bucket_count - 1);
5325 bucket = map->buckets[idx];
5326 for (map_e = bucket; map_e; map_e = map_e->next)
5328 if (literal_value_equal (&map_e->val, val, final_static_link))
5335 /* Record a new literal value. It is illegal to call this if VALUE
5336 already has an entry here. */
5339 add_value_map (value_map_hash_table *map,
5340 const literal_value *val,
5342 bfd_boolean final_static_link)
5344 value_map **bucket_p;
5347 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
5350 bfd_set_error (bfd_error_no_memory);
5354 BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
5358 idx = literal_value_hash (val);
5359 idx = idx & (map->bucket_count - 1);
5360 bucket_p = &map->buckets[idx];
5362 val_e->next = *bucket_p;
5365 /* FIXME: Consider resizing the hash table if we get too many entries. */
5371 /* Lists of text actions (ta_) for narrowing, widening, longcall
5372 conversion, space fill, code & literal removal, etc. */
5374 /* The following text actions are generated:
5376 "ta_remove_insn" remove an instruction or instructions
5377 "ta_remove_longcall" convert longcall to call
5378 "ta_convert_longcall" convert longcall to nop/call
5379 "ta_narrow_insn" narrow a wide instruction
5380 "ta_widen" widen a narrow instruction
5381 "ta_fill" add fill or remove fill
5382 removed < 0 is a fill; branches to the fill address will be
5383 changed to address + fill size (e.g., address - removed)
5384 removed >= 0 branches to the fill address will stay unchanged
5385 "ta_remove_literal" remove a literal; this action is
5386 indicated when a literal is removed
5388 "ta_add_literal" insert a new literal; this action is
5389 indicated when a literal has been moved.
5390 It may use a virtual_offset because
5391 multiple literals can be placed at the
5394 For each of these text actions, we also record the number of bytes
5395 removed by performing the text action. In the case of a "ta_widen"
5396 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5398 typedef struct text_action_struct text_action;
5399 typedef struct text_action_list_struct text_action_list;
5400 typedef enum text_action_enum_t text_action_t;
5402 enum text_action_enum_t
5405 ta_remove_insn, /* removed = -size */
5406 ta_remove_longcall, /* removed = -size */
5407 ta_convert_longcall, /* removed = 0 */
5408 ta_narrow_insn, /* removed = -1 */
5409 ta_widen_insn, /* removed = +1 */
5410 ta_fill, /* removed = +size */
5416 /* Structure for a text action record. */
5417 struct text_action_struct
5419 text_action_t action;
5420 asection *sec; /* Optional */
5422 bfd_vma virtual_offset; /* Zero except for adding literals. */
5424 literal_value value; /* Only valid when adding literals. */
5430 /* List of all of the actions taken on a text section. */
5431 struct text_action_list_struct
5437 static text_action *
5438 find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
5442 /* It is not necessary to fill at the end of a section. */
5443 if (sec->size == offset)
5446 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
5448 text_action *t = *m_p;
5449 /* When the action is another fill at the same address,
5450 just increase the size. */
5451 if (t->offset == offset && t->action == ta_fill)
5459 compute_removed_action_diff (const text_action *ta,
5463 int removable_space)
5466 int current_removed = 0;
5469 current_removed = ta->removed_bytes;
5471 BFD_ASSERT (ta == NULL || ta->offset == offset);
5472 BFD_ASSERT (ta == NULL || ta->action == ta_fill);
5474 /* It is not necessary to fill at the end of a section. Clean this up. */
5475 if (sec->size == offset)
5476 new_removed = removable_space - 0;
5480 int added = -removed - current_removed;
5481 /* Ignore multiples of the section alignment. */
5482 added = ((1 << sec->alignment_power) - 1) & added;
5483 new_removed = (-added);
5485 /* Modify for removable. */
5486 space = removable_space - new_removed;
5487 new_removed = (removable_space
5488 - (((1 << sec->alignment_power) - 1) & space));
5490 return (new_removed - current_removed);
5495 adjust_fill_action (text_action *ta, int fill_diff)
5497 ta->removed_bytes += fill_diff;
5501 /* Add a modification action to the text. For the case of adding or
5502 removing space, modify any current fill and assume that
5503 "unreachable_space" bytes can be freely contracted. Note that a
5504 negative removed value is a fill. */
5507 text_action_add (text_action_list *l,
5508 text_action_t action,
5516 /* It is not necessary to fill at the end of a section. */
5517 if (action == ta_fill && sec->size == offset)
5520 /* It is not necessary to fill 0 bytes. */
5521 if (action == ta_fill && removed == 0)
5524 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
5526 text_action *t = *m_p;
5528 if (action == ta_fill)
5530 /* When the action is another fill at the same address,
5531 just increase the size. */
5532 if (t->offset == offset && t->action == ta_fill)
5534 t->removed_bytes += removed;
5537 /* Fills need to happen before widens so that we don't
5538 insert fill bytes into the instruction stream. */
5539 if (t->offset == offset && t->action == ta_widen_insn)
5544 /* Create a new record and fill it up. */
5545 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5546 ta->action = action;
5548 ta->offset = offset;
5549 ta->removed_bytes = removed;
5556 text_action_add_literal (text_action_list *l,
5557 text_action_t action,
5559 const literal_value *value,
5564 asection *sec = r_reloc_get_section (loc);
5565 bfd_vma offset = loc->target_offset;
5566 bfd_vma virtual_offset = loc->virtual_offset;
5568 BFD_ASSERT (action == ta_add_literal);
5570 for (m_p = &l->head; *m_p != NULL; m_p = &(*m_p)->next)
5572 if ((*m_p)->offset > offset
5573 && ((*m_p)->offset != offset
5574 || (*m_p)->virtual_offset > virtual_offset))
5578 /* Create a new record and fill it up. */
5579 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5580 ta->action = action;
5582 ta->offset = offset;
5583 ta->virtual_offset = virtual_offset;
5585 ta->removed_bytes = removed;
5591 /* Find the total offset adjustment for the relaxations specified by
5592 text_actions, beginning from a particular starting action. This is
5593 typically used from offset_with_removed_text to search an entire list of
5594 actions, but it may also be called directly when adjusting adjacent offsets
5595 so that each search may begin where the previous one left off. */
5598 removed_by_actions (text_action **p_start_action,
5600 bfd_boolean before_fill)
5605 r = *p_start_action;
5608 if (r->offset > offset)
5611 if (r->offset == offset
5612 && (before_fill || r->action != ta_fill || r->removed_bytes >= 0))
5615 removed += r->removed_bytes;
5620 *p_start_action = r;
5626 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
5628 text_action *r = action_list->head;
5629 return offset - removed_by_actions (&r, offset, FALSE);
5634 action_list_count (text_action_list *action_list)
5636 text_action *r = action_list->head;
5638 for (r = action_list->head; r != NULL; r = r->next)
5646 /* The find_insn_action routine will only find non-fill actions. */
5648 static text_action *
5649 find_insn_action (text_action_list *action_list, bfd_vma offset)
5652 for (t = action_list->head; t; t = t->next)
5654 if (t->offset == offset)
5661 case ta_remove_insn:
5662 case ta_remove_longcall:
5663 case ta_convert_longcall:
5664 case ta_narrow_insn:
5667 case ta_remove_literal:
5668 case ta_add_literal:
5681 print_action_list (FILE *fp, text_action_list *action_list)
5685 fprintf (fp, "Text Action\n");
5686 for (r = action_list->head; r != NULL; r = r->next)
5688 const char *t = "unknown";
5691 case ta_remove_insn:
5692 t = "remove_insn"; break;
5693 case ta_remove_longcall:
5694 t = "remove_longcall"; break;
5695 case ta_convert_longcall:
5696 t = "convert_longcall"; break;
5697 case ta_narrow_insn:
5698 t = "narrow_insn"; break;
5700 t = "widen_insn"; break;
5705 case ta_remove_literal:
5706 t = "remove_literal"; break;
5707 case ta_add_literal:
5708 t = "add_literal"; break;
5711 fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
5712 r->sec->owner->filename,
5713 r->sec->name, r->offset, t, r->removed_bytes);
5720 /* Lists of literals being coalesced or removed. */
5722 /* In the usual case, the literal identified by "from" is being
5723 coalesced with another literal identified by "to". If the literal is
5724 unused and is being removed altogether, "to.abfd" will be NULL.
5725 The removed_literal entries are kept on a per-section list, sorted
5726 by the "from" offset field. */
5728 typedef struct removed_literal_struct removed_literal;
5729 typedef struct removed_literal_list_struct removed_literal_list;
5731 struct removed_literal_struct
5735 removed_literal *next;
5738 struct removed_literal_list_struct
5740 removed_literal *head;
5741 removed_literal *tail;
5745 /* Record that the literal at "from" is being removed. If "to" is not
5746 NULL, the "from" literal is being coalesced with the "to" literal. */
5749 add_removed_literal (removed_literal_list *removed_list,
5750 const r_reloc *from,
5753 removed_literal *r, *new_r, *next_r;
5755 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
5757 new_r->from = *from;
5761 new_r->to.abfd = NULL;
5764 r = removed_list->head;
5767 removed_list->head = new_r;
5768 removed_list->tail = new_r;
5770 /* Special check for common case of append. */
5771 else if (removed_list->tail->from.target_offset < from->target_offset)
5773 removed_list->tail->next = new_r;
5774 removed_list->tail = new_r;
5778 while (r->from.target_offset < from->target_offset && r->next)
5784 new_r->next = next_r;
5786 removed_list->tail = new_r;
5791 /* Check if the list of removed literals contains an entry for the
5792 given address. Return the entry if found. */
5794 static removed_literal *
5795 find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
5797 removed_literal *r = removed_list->head;
5798 while (r && r->from.target_offset < addr)
5800 if (r && r->from.target_offset == addr)
5809 print_removed_literals (FILE *fp, removed_literal_list *removed_list)
5812 r = removed_list->head;
5814 fprintf (fp, "Removed Literals\n");
5815 for (; r != NULL; r = r->next)
5817 print_r_reloc (fp, &r->from);
5818 fprintf (fp, " => ");
5819 if (r->to.abfd == NULL)
5820 fprintf (fp, "REMOVED");
5822 print_r_reloc (fp, &r->to);
5830 /* Per-section data for relaxation. */
5832 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
5834 struct xtensa_relax_info_struct
5836 bfd_boolean is_relaxable_literal_section;
5837 bfd_boolean is_relaxable_asm_section;
5838 int visited; /* Number of times visited. */
5840 source_reloc *src_relocs; /* Array[src_count]. */
5842 int src_next; /* Next src_relocs entry to assign. */
5844 removed_literal_list removed_list;
5845 text_action_list action_list;
5847 reloc_bfd_fix *fix_list;
5848 reloc_bfd_fix *fix_array;
5849 unsigned fix_array_count;
5851 /* Support for expanding the reloc array that is stored
5852 in the section structure. If the relocations have been
5853 reallocated, the newly allocated relocations will be referenced
5854 here along with the actual size allocated. The relocation
5855 count will always be found in the section structure. */
5856 Elf_Internal_Rela *allocated_relocs;
5857 unsigned relocs_count;
5858 unsigned allocated_relocs_count;
5861 struct elf_xtensa_section_data
5863 struct bfd_elf_section_data elf;
5864 xtensa_relax_info relax_info;
5869 elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
5871 if (!sec->used_by_bfd)
5873 struct elf_xtensa_section_data *sdata;
5874 bfd_size_type amt = sizeof (*sdata);
5876 sdata = bfd_zalloc (abfd, amt);
5879 sec->used_by_bfd = sdata;
5882 return _bfd_elf_new_section_hook (abfd, sec);
5886 static xtensa_relax_info *
5887 get_xtensa_relax_info (asection *sec)
5889 struct elf_xtensa_section_data *section_data;
5891 /* No info available if no section or if it is an output section. */
5892 if (!sec || sec == sec->output_section)
5895 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
5896 return §ion_data->relax_info;
5901 init_xtensa_relax_info (asection *sec)
5903 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5905 relax_info->is_relaxable_literal_section = FALSE;
5906 relax_info->is_relaxable_asm_section = FALSE;
5907 relax_info->visited = 0;
5909 relax_info->src_relocs = NULL;
5910 relax_info->src_count = 0;
5911 relax_info->src_next = 0;
5913 relax_info->removed_list.head = NULL;
5914 relax_info->removed_list.tail = NULL;
5916 relax_info->action_list.head = NULL;
5918 relax_info->fix_list = NULL;
5919 relax_info->fix_array = NULL;
5920 relax_info->fix_array_count = 0;
5922 relax_info->allocated_relocs = NULL;
5923 relax_info->relocs_count = 0;
5924 relax_info->allocated_relocs_count = 0;
5928 /* Coalescing literals may require a relocation to refer to a section in
5929 a different input file, but the standard relocation information
5930 cannot express that. Instead, the reloc_bfd_fix structures are used
5931 to "fix" the relocations that refer to sections in other input files.
5932 These structures are kept on per-section lists. The "src_type" field
5933 records the relocation type in case there are multiple relocations on
5934 the same location. FIXME: This is ugly; an alternative might be to
5935 add new symbols with the "owner" field to some other input file. */
5937 struct reloc_bfd_fix_struct
5941 unsigned src_type; /* Relocation type. */
5943 asection *target_sec;
5944 bfd_vma target_offset;
5945 bfd_boolean translated;
5947 reloc_bfd_fix *next;
5951 static reloc_bfd_fix *
5952 reloc_bfd_fix_init (asection *src_sec,
5955 asection *target_sec,
5956 bfd_vma target_offset,
5957 bfd_boolean translated)
5961 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
5962 fix->src_sec = src_sec;
5963 fix->src_offset = src_offset;
5964 fix->src_type = src_type;
5965 fix->target_sec = target_sec;
5966 fix->target_offset = target_offset;
5967 fix->translated = translated;
5974 add_fix (asection *src_sec, reloc_bfd_fix *fix)
5976 xtensa_relax_info *relax_info;
5978 relax_info = get_xtensa_relax_info (src_sec);
5979 fix->next = relax_info->fix_list;
5980 relax_info->fix_list = fix;
5985 fix_compare (const void *ap, const void *bp)
5987 const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
5988 const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
5990 if (a->src_offset != b->src_offset)
5991 return (a->src_offset - b->src_offset);
5992 return (a->src_type - b->src_type);
5997 cache_fix_array (asection *sec)
5999 unsigned i, count = 0;
6001 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6003 if (relax_info == NULL)
6005 if (relax_info->fix_list == NULL)
6008 for (r = relax_info->fix_list; r != NULL; r = r->next)
6011 relax_info->fix_array =
6012 (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
6013 relax_info->fix_array_count = count;
6015 r = relax_info->fix_list;
6016 for (i = 0; i < count; i++, r = r->next)
6018 relax_info->fix_array[count - 1 - i] = *r;
6019 relax_info->fix_array[count - 1 - i].next = NULL;
6022 qsort (relax_info->fix_array, relax_info->fix_array_count,
6023 sizeof (reloc_bfd_fix), fix_compare);
6027 static reloc_bfd_fix *
6028 get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
6030 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
6034 if (relax_info == NULL)
6036 if (relax_info->fix_list == NULL)
6039 if (relax_info->fix_array == NULL)
6040 cache_fix_array (sec);
6042 key.src_offset = offset;
6043 key.src_type = type;
6044 rv = bsearch (&key, relax_info->fix_array, relax_info->fix_array_count,
6045 sizeof (reloc_bfd_fix), fix_compare);
6050 /* Section caching. */
6052 typedef struct section_cache_struct section_cache_t;
6054 struct section_cache_struct
6058 bfd_byte *contents; /* Cache of the section contents. */
6059 bfd_size_type content_length;
6061 property_table_entry *ptbl; /* Cache of the section property table. */
6064 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6065 unsigned reloc_count;
6070 init_section_cache (section_cache_t *sec_cache)
6072 memset (sec_cache, 0, sizeof (*sec_cache));
6077 clear_section_cache (section_cache_t *sec_cache)
6081 release_contents (sec_cache->sec, sec_cache->contents);
6082 release_internal_relocs (sec_cache->sec, sec_cache->relocs);
6083 if (sec_cache->ptbl)
6084 free (sec_cache->ptbl);
6085 memset (sec_cache, 0, sizeof (sec_cache));
6091 section_cache_section (section_cache_t *sec_cache,
6093 struct bfd_link_info *link_info)
6096 property_table_entry *prop_table = NULL;
6098 bfd_byte *contents = NULL;
6099 Elf_Internal_Rela *internal_relocs = NULL;
6100 bfd_size_type sec_size;
6104 if (sec == sec_cache->sec)
6108 sec_size = bfd_get_section_limit (abfd, sec);
6110 /* Get the contents. */
6111 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6112 if (contents == NULL && sec_size != 0)
6115 /* Get the relocations. */
6116 internal_relocs = retrieve_internal_relocs (abfd, sec,
6117 link_info->keep_memory);
6119 /* Get the entry table. */
6120 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6121 XTENSA_PROP_SEC_NAME, FALSE);
6125 /* Fill in the new section cache. */
6126 clear_section_cache (sec_cache);
6127 memset (sec_cache, 0, sizeof (sec_cache));
6129 sec_cache->sec = sec;
6130 sec_cache->contents = contents;
6131 sec_cache->content_length = sec_size;
6132 sec_cache->relocs = internal_relocs;
6133 sec_cache->reloc_count = sec->reloc_count;
6134 sec_cache->pte_count = ptblsize;
6135 sec_cache->ptbl = prop_table;
6140 release_contents (sec, contents);
6141 release_internal_relocs (sec, internal_relocs);
6148 /* Extended basic blocks. */
6150 /* An ebb_struct represents an Extended Basic Block. Within this
6151 range, we guarantee that all instructions are decodable, the
6152 property table entries are contiguous, and no property table
6153 specifies a segment that cannot have instructions moved. This
6154 structure contains caches of the contents, property table and
6155 relocations for the specified section for easy use. The range is
6156 specified by ranges of indices for the byte offset, property table
6157 offsets and relocation offsets. These must be consistent. */
6159 typedef struct ebb_struct ebb_t;
6165 bfd_byte *contents; /* Cache of the section contents. */
6166 bfd_size_type content_length;
6168 property_table_entry *ptbl; /* Cache of the section property table. */
6171 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6172 unsigned reloc_count;
6174 bfd_vma start_offset; /* Offset in section. */
6175 unsigned start_ptbl_idx; /* Offset in the property table. */
6176 unsigned start_reloc_idx; /* Offset in the relocations. */
6179 unsigned end_ptbl_idx;
6180 unsigned end_reloc_idx;
6182 bfd_boolean ends_section; /* Is this the last ebb in a section? */
6184 /* The unreachable property table at the end of this set of blocks;
6185 NULL if the end is not an unreachable block. */
6186 property_table_entry *ends_unreachable;
6190 enum ebb_target_enum
6193 EBB_DESIRE_TGT_ALIGN,
6194 EBB_REQUIRE_TGT_ALIGN,
6195 EBB_REQUIRE_LOOP_ALIGN,
6200 /* proposed_action_struct is similar to the text_action_struct except
6201 that is represents a potential transformation, not one that will
6202 occur. We build a list of these for an extended basic block
6203 and use them to compute the actual actions desired. We must be
6204 careful that the entire set of actual actions we perform do not
6205 break any relocations that would fit if the actions were not
6208 typedef struct proposed_action_struct proposed_action;
6210 struct proposed_action_struct
6212 enum ebb_target_enum align_type; /* for the target alignment */
6213 bfd_vma alignment_pow;
6214 text_action_t action;
6217 bfd_boolean do_action; /* If false, then we will not perform the action. */
6221 /* The ebb_constraint_struct keeps a set of proposed actions for an
6222 extended basic block. */
6224 typedef struct ebb_constraint_struct ebb_constraint;
6226 struct ebb_constraint_struct
6229 bfd_boolean start_movable;
6231 /* Bytes of extra space at the beginning if movable. */
6232 int start_extra_space;
6234 enum ebb_target_enum start_align;
6236 bfd_boolean end_movable;
6238 /* Bytes of extra space at the end if movable. */
6239 int end_extra_space;
6241 unsigned action_count;
6242 unsigned action_allocated;
6244 /* Array of proposed actions. */
6245 proposed_action *actions;
6247 /* Action alignments -- one for each proposed action. */
6248 enum ebb_target_enum *action_aligns;
6253 init_ebb_constraint (ebb_constraint *c)
6255 memset (c, 0, sizeof (ebb_constraint));
6260 free_ebb_constraint (ebb_constraint *c)
6268 init_ebb (ebb_t *ebb,
6271 bfd_size_type content_length,
6272 property_table_entry *prop_table,
6274 Elf_Internal_Rela *internal_relocs,
6275 unsigned reloc_count)
6277 memset (ebb, 0, sizeof (ebb_t));
6279 ebb->contents = contents;
6280 ebb->content_length = content_length;
6281 ebb->ptbl = prop_table;
6282 ebb->pte_count = ptblsize;
6283 ebb->relocs = internal_relocs;
6284 ebb->reloc_count = reloc_count;
6285 ebb->start_offset = 0;
6286 ebb->end_offset = ebb->content_length - 1;
6287 ebb->start_ptbl_idx = 0;
6288 ebb->end_ptbl_idx = ptblsize;
6289 ebb->start_reloc_idx = 0;
6290 ebb->end_reloc_idx = reloc_count;
6294 /* Extend the ebb to all decodable contiguous sections. The algorithm
6295 for building a basic block around an instruction is to push it
6296 forward until we hit the end of a section, an unreachable block or
6297 a block that cannot be transformed. Then we push it backwards
6298 searching for similar conditions. */
6300 static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
6301 static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
6302 static bfd_size_type insn_block_decodable_len
6303 (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
6306 extend_ebb_bounds (ebb_t *ebb)
6308 if (!extend_ebb_bounds_forward (ebb))
6310 if (!extend_ebb_bounds_backward (ebb))
6317 extend_ebb_bounds_forward (ebb_t *ebb)
6319 property_table_entry *the_entry, *new_entry;
6321 the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6323 /* Stop when (1) we cannot decode an instruction, (2) we are at
6324 the end of the property tables, (3) we hit a non-contiguous property
6325 table entry, (4) we hit a NO_TRANSFORM region. */
6330 bfd_size_type insn_block_len;
6332 entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
6334 insn_block_decodable_len (ebb->contents, ebb->content_length,
6336 entry_end - ebb->end_offset);
6337 if (insn_block_len != (entry_end - ebb->end_offset))
6339 (*_bfd_error_handler)
6340 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6341 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6344 ebb->end_offset += insn_block_len;
6346 if (ebb->end_offset == ebb->sec->size)
6347 ebb->ends_section = TRUE;
6349 /* Update the reloc counter. */
6350 while (ebb->end_reloc_idx + 1 < ebb->reloc_count
6351 && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
6354 ebb->end_reloc_idx++;
6357 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6360 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6361 if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
6362 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6363 || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
6366 if (the_entry->address + the_entry->size != new_entry->address)
6369 the_entry = new_entry;
6370 ebb->end_ptbl_idx++;
6373 /* Quick check for an unreachable or end of file just at the end. */
6374 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6376 if (ebb->end_offset == ebb->content_length)
6377 ebb->ends_section = TRUE;
6381 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6382 if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
6383 && the_entry->address + the_entry->size == new_entry->address)
6384 ebb->ends_unreachable = new_entry;
6387 /* Any other ending requires exact alignment. */
6393 extend_ebb_bounds_backward (ebb_t *ebb)
6395 property_table_entry *the_entry, *new_entry;
6397 the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6399 /* Stop when (1) we cannot decode the instructions in the current entry.
6400 (2) we are at the beginning of the property tables, (3) we hit a
6401 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6405 bfd_vma block_begin;
6406 bfd_size_type insn_block_len;
6408 block_begin = the_entry->address - ebb->sec->vma;
6410 insn_block_decodable_len (ebb->contents, ebb->content_length,
6412 ebb->start_offset - block_begin);
6413 if (insn_block_len != ebb->start_offset - block_begin)
6415 (*_bfd_error_handler)
6416 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6417 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6420 ebb->start_offset -= insn_block_len;
6422 /* Update the reloc counter. */
6423 while (ebb->start_reloc_idx > 0
6424 && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
6425 >= ebb->start_offset))
6427 ebb->start_reloc_idx--;
6430 if (ebb->start_ptbl_idx == 0)
6433 new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
6434 if ((new_entry->flags & XTENSA_PROP_INSN) == 0
6435 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6436 || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
6438 if (new_entry->address + new_entry->size != the_entry->address)
6441 the_entry = new_entry;
6442 ebb->start_ptbl_idx--;
6448 static bfd_size_type
6449 insn_block_decodable_len (bfd_byte *contents,
6450 bfd_size_type content_len,
6451 bfd_vma block_offset,
6452 bfd_size_type block_len)
6454 bfd_vma offset = block_offset;
6456 while (offset < block_offset + block_len)
6458 bfd_size_type insn_len = 0;
6460 insn_len = insn_decode_len (contents, content_len, offset);
6462 return (offset - block_offset);
6465 return (offset - block_offset);
6470 ebb_propose_action (ebb_constraint *c,
6471 enum ebb_target_enum align_type,
6472 bfd_vma alignment_pow,
6473 text_action_t action,
6476 bfd_boolean do_action)
6478 proposed_action *act;
6480 if (c->action_allocated <= c->action_count)
6482 unsigned new_allocated, i;
6483 proposed_action *new_actions;
6485 new_allocated = (c->action_count + 2) * 2;
6486 new_actions = (proposed_action *)
6487 bfd_zmalloc (sizeof (proposed_action) * new_allocated);
6489 for (i = 0; i < c->action_count; i++)
6490 new_actions[i] = c->actions[i];
6493 c->actions = new_actions;
6494 c->action_allocated = new_allocated;
6497 act = &c->actions[c->action_count];
6498 act->align_type = align_type;
6499 act->alignment_pow = alignment_pow;
6500 act->action = action;
6501 act->offset = offset;
6502 act->removed_bytes = removed_bytes;
6503 act->do_action = do_action;
6509 /* Access to internal relocations, section contents and symbols. */
6511 /* During relaxation, we need to modify relocations, section contents,
6512 and symbol definitions, and we need to keep the original values from
6513 being reloaded from the input files, i.e., we need to "pin" the
6514 modified values in memory. We also want to continue to observe the
6515 setting of the "keep-memory" flag. The following functions wrap the
6516 standard BFD functions to take care of this for us. */
6518 static Elf_Internal_Rela *
6519 retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6521 Elf_Internal_Rela *internal_relocs;
6523 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6526 internal_relocs = elf_section_data (sec)->relocs;
6527 if (internal_relocs == NULL)
6528 internal_relocs = (_bfd_elf_link_read_relocs
6529 (abfd, sec, NULL, NULL, keep_memory));
6530 return internal_relocs;
6535 pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6537 elf_section_data (sec)->relocs = internal_relocs;
6542 release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6545 && elf_section_data (sec)->relocs != internal_relocs)
6546 free (internal_relocs);
6551 retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6554 bfd_size_type sec_size;
6556 sec_size = bfd_get_section_limit (abfd, sec);
6557 contents = elf_section_data (sec)->this_hdr.contents;
6559 if (contents == NULL && sec_size != 0)
6561 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
6568 elf_section_data (sec)->this_hdr.contents = contents;
6575 pin_contents (asection *sec, bfd_byte *contents)
6577 elf_section_data (sec)->this_hdr.contents = contents;
6582 release_contents (asection *sec, bfd_byte *contents)
6584 if (contents && elf_section_data (sec)->this_hdr.contents != contents)
6589 static Elf_Internal_Sym *
6590 retrieve_local_syms (bfd *input_bfd)
6592 Elf_Internal_Shdr *symtab_hdr;
6593 Elf_Internal_Sym *isymbuf;
6596 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6597 locsymcount = symtab_hdr->sh_info;
6599 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6600 if (isymbuf == NULL && locsymcount != 0)
6601 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
6604 /* Save the symbols for this input file so they won't be read again. */
6605 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
6606 symtab_hdr->contents = (unsigned char *) isymbuf;
6612 /* Code for link-time relaxation. */
6614 /* Initialization for relaxation: */
6615 static bfd_boolean analyze_relocations (struct bfd_link_info *);
6616 static bfd_boolean find_relaxable_sections
6617 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
6618 static bfd_boolean collect_source_relocs
6619 (bfd *, asection *, struct bfd_link_info *);
6620 static bfd_boolean is_resolvable_asm_expansion
6621 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
6623 static Elf_Internal_Rela *find_associated_l32r_irel
6624 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
6625 static bfd_boolean compute_text_actions
6626 (bfd *, asection *, struct bfd_link_info *);
6627 static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
6628 static bfd_boolean compute_ebb_actions (ebb_constraint *);
6629 static bfd_boolean check_section_ebb_pcrels_fit
6630 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, const ebb_constraint *,
6631 const xtensa_opcode *);
6632 static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
6633 static void text_action_add_proposed
6634 (text_action_list *, const ebb_constraint *, asection *);
6635 static int compute_fill_extra_space (property_table_entry *);
6638 static bfd_boolean compute_removed_literals
6639 (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
6640 static Elf_Internal_Rela *get_irel_at_offset
6641 (asection *, Elf_Internal_Rela *, bfd_vma);
6642 static bfd_boolean is_removable_literal
6643 (const source_reloc *, int, const source_reloc *, int, asection *,
6644 property_table_entry *, int);
6645 static bfd_boolean remove_dead_literal
6646 (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
6647 Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
6648 static bfd_boolean identify_literal_placement
6649 (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
6650 value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
6651 source_reloc *, property_table_entry *, int, section_cache_t *,
6653 static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
6654 static bfd_boolean coalesce_shared_literal
6655 (asection *, source_reloc *, property_table_entry *, int, value_map *);
6656 static bfd_boolean move_shared_literal
6657 (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
6658 int, const r_reloc *, const literal_value *, section_cache_t *);
6661 static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
6662 static bfd_boolean translate_section_fixes (asection *);
6663 static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
6664 static asection *translate_reloc (const r_reloc *, r_reloc *, asection *);
6665 static void shrink_dynamic_reloc_sections
6666 (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
6667 static bfd_boolean move_literal
6668 (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
6669 xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
6670 static bfd_boolean relax_property_section
6671 (bfd *, asection *, struct bfd_link_info *);
6674 static bfd_boolean relax_section_symbols (bfd *, asection *);
6678 elf_xtensa_relax_section (bfd *abfd,
6680 struct bfd_link_info *link_info,
6683 static value_map_hash_table *values = NULL;
6684 static bfd_boolean relocations_analyzed = FALSE;
6685 xtensa_relax_info *relax_info;
6687 if (!relocations_analyzed)
6689 /* Do some overall initialization for relaxation. */
6690 values = value_map_hash_table_init ();
6693 relaxing_section = TRUE;
6694 if (!analyze_relocations (link_info))
6696 relocations_analyzed = TRUE;
6700 /* Don't mess with linker-created sections. */
6701 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6704 relax_info = get_xtensa_relax_info (sec);
6705 BFD_ASSERT (relax_info != NULL);
6707 switch (relax_info->visited)
6710 /* Note: It would be nice to fold this pass into
6711 analyze_relocations, but it is important for this step that the
6712 sections be examined in link order. */
6713 if (!compute_removed_literals (abfd, sec, link_info, values))
6720 value_map_hash_table_delete (values);
6722 if (!relax_section (abfd, sec, link_info))
6728 if (!relax_section_symbols (abfd, sec))
6733 relax_info->visited++;
6738 /* Initialization for relaxation. */
6740 /* This function is called once at the start of relaxation. It scans
6741 all the input sections and marks the ones that are relaxable (i.e.,
6742 literal sections with L32R relocations against them), and then
6743 collects source_reloc information for all the relocations against
6744 those relaxable sections. During this process, it also detects
6745 longcalls, i.e., calls relaxed by the assembler into indirect
6746 calls, that can be optimized back into direct calls. Within each
6747 extended basic block (ebb) containing an optimized longcall, it
6748 computes a set of "text actions" that can be performed to remove
6749 the L32R associated with the longcall while optionally preserving
6750 branch target alignments. */
6753 analyze_relocations (struct bfd_link_info *link_info)
6757 bfd_boolean is_relaxable = FALSE;
6759 /* Initialize the per-section relaxation info. */
6760 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6761 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6763 init_xtensa_relax_info (sec);
6766 /* Mark relaxable sections (and count relocations against each one). */
6767 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6768 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6770 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
6774 /* Bail out if there are no relaxable sections. */
6778 /* Allocate space for source_relocs. */
6779 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6780 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6782 xtensa_relax_info *relax_info;
6784 relax_info = get_xtensa_relax_info (sec);
6785 if (relax_info->is_relaxable_literal_section
6786 || relax_info->is_relaxable_asm_section)
6788 relax_info->src_relocs = (source_reloc *)
6789 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
6792 relax_info->src_count = 0;
6795 /* Collect info on relocations against each relaxable section. */
6796 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6797 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6799 if (!collect_source_relocs (abfd, sec, link_info))
6803 /* Compute the text actions. */
6804 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6805 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6807 if (!compute_text_actions (abfd, sec, link_info))
6815 /* Find all the sections that might be relaxed. The motivation for
6816 this pass is that collect_source_relocs() needs to record _all_ the
6817 relocations that target each relaxable section. That is expensive
6818 and unnecessary unless the target section is actually going to be
6819 relaxed. This pass identifies all such sections by checking if
6820 they have L32Rs pointing to them. In the process, the total number
6821 of relocations targeting each section is also counted so that we
6822 know how much space to allocate for source_relocs against each
6823 relaxable literal section. */
6826 find_relaxable_sections (bfd *abfd,
6828 struct bfd_link_info *link_info,
6829 bfd_boolean *is_relaxable_p)
6831 Elf_Internal_Rela *internal_relocs;
6833 bfd_boolean ok = TRUE;
6835 xtensa_relax_info *source_relax_info;
6836 bfd_boolean is_l32r_reloc;
6838 internal_relocs = retrieve_internal_relocs (abfd, sec,
6839 link_info->keep_memory);
6840 if (internal_relocs == NULL)
6843 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6844 if (contents == NULL && sec->size != 0)
6850 source_relax_info = get_xtensa_relax_info (sec);
6851 for (i = 0; i < sec->reloc_count; i++)
6853 Elf_Internal_Rela *irel = &internal_relocs[i];
6855 asection *target_sec;
6856 xtensa_relax_info *target_relax_info;
6858 /* If this section has not already been marked as "relaxable", and
6859 if it contains any ASM_EXPAND relocations (marking expanded
6860 longcalls) that can be optimized into direct calls, then mark
6861 the section as "relaxable". */
6862 if (source_relax_info
6863 && !source_relax_info->is_relaxable_asm_section
6864 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
6866 bfd_boolean is_reachable = FALSE;
6867 if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
6868 link_info, &is_reachable)
6871 source_relax_info->is_relaxable_asm_section = TRUE;
6872 *is_relaxable_p = TRUE;
6876 r_reloc_init (&r_rel, abfd, irel, contents,
6877 bfd_get_section_limit (abfd, sec));
6879 target_sec = r_reloc_get_section (&r_rel);
6880 target_relax_info = get_xtensa_relax_info (target_sec);
6881 if (!target_relax_info)
6884 /* Count PC-relative operand relocations against the target section.
6885 Note: The conditions tested here must match the conditions under
6886 which init_source_reloc is called in collect_source_relocs(). */
6887 is_l32r_reloc = FALSE;
6888 if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6890 xtensa_opcode opcode =
6891 get_relocation_opcode (abfd, sec, contents, irel);
6892 if (opcode != XTENSA_UNDEFINED)
6894 is_l32r_reloc = (opcode == get_l32r_opcode ());
6895 if (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
6897 target_relax_info->src_count++;
6901 if (is_l32r_reloc && r_reloc_is_defined (&r_rel))
6903 /* Mark the target section as relaxable. */
6904 target_relax_info->is_relaxable_literal_section = TRUE;
6905 *is_relaxable_p = TRUE;
6910 release_contents (sec, contents);
6911 release_internal_relocs (sec, internal_relocs);
6916 /* Record _all_ the relocations that point to relaxable sections, and
6917 get rid of ASM_EXPAND relocs by either converting them to
6918 ASM_SIMPLIFY or by removing them. */
6921 collect_source_relocs (bfd *abfd,
6923 struct bfd_link_info *link_info)
6925 Elf_Internal_Rela *internal_relocs;
6927 bfd_boolean ok = TRUE;
6929 bfd_size_type sec_size;
6931 internal_relocs = retrieve_internal_relocs (abfd, sec,
6932 link_info->keep_memory);
6933 if (internal_relocs == NULL)
6936 sec_size = bfd_get_section_limit (abfd, sec);
6937 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6938 if (contents == NULL && sec_size != 0)
6944 /* Record relocations against relaxable literal sections. */
6945 for (i = 0; i < sec->reloc_count; i++)
6947 Elf_Internal_Rela *irel = &internal_relocs[i];
6949 asection *target_sec;
6950 xtensa_relax_info *target_relax_info;
6952 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6954 target_sec = r_reloc_get_section (&r_rel);
6955 target_relax_info = get_xtensa_relax_info (target_sec);
6957 if (target_relax_info
6958 && (target_relax_info->is_relaxable_literal_section
6959 || target_relax_info->is_relaxable_asm_section))
6961 xtensa_opcode opcode = XTENSA_UNDEFINED;
6963 bfd_boolean is_abs_literal = FALSE;
6965 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
6967 /* None of the current alternate relocs are PC-relative,
6968 and only PC-relative relocs matter here. However, we
6969 still need to record the opcode for literal
6971 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6972 if (opcode == get_l32r_opcode ())
6974 is_abs_literal = TRUE;
6978 opcode = XTENSA_UNDEFINED;
6980 else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6982 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6983 opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
6986 if (opcode != XTENSA_UNDEFINED)
6988 int src_next = target_relax_info->src_next++;
6989 source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
6991 init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
6997 /* Now get rid of ASM_EXPAND relocations. At this point, the
6998 src_relocs array for the target literal section may still be
6999 incomplete, but it must at least contain the entries for the L32R
7000 relocations associated with ASM_EXPANDs because they were just
7001 added in the preceding loop over the relocations. */
7003 for (i = 0; i < sec->reloc_count; i++)
7005 Elf_Internal_Rela *irel = &internal_relocs[i];
7006 bfd_boolean is_reachable;
7008 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
7014 Elf_Internal_Rela *l32r_irel;
7016 asection *target_sec;
7017 xtensa_relax_info *target_relax_info;
7019 /* Mark the source_reloc for the L32R so that it will be
7020 removed in compute_removed_literals(), along with the
7021 associated literal. */
7022 l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
7023 irel, internal_relocs);
7024 if (l32r_irel == NULL)
7027 r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
7029 target_sec = r_reloc_get_section (&r_rel);
7030 target_relax_info = get_xtensa_relax_info (target_sec);
7032 if (target_relax_info
7033 && (target_relax_info->is_relaxable_literal_section
7034 || target_relax_info->is_relaxable_asm_section))
7036 source_reloc *s_reloc;
7038 /* Search the source_relocs for the entry corresponding to
7039 the l32r_irel. Note: The src_relocs array is not yet
7040 sorted, but it wouldn't matter anyway because we're
7041 searching by source offset instead of target offset. */
7042 s_reloc = find_source_reloc (target_relax_info->src_relocs,
7043 target_relax_info->src_next,
7045 BFD_ASSERT (s_reloc);
7046 s_reloc->is_null = TRUE;
7049 /* Convert this reloc to ASM_SIMPLIFY. */
7050 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7051 R_XTENSA_ASM_SIMPLIFY);
7052 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7054 pin_internal_relocs (sec, internal_relocs);
7058 /* It is resolvable but doesn't reach. We resolve now
7059 by eliminating the relocation -- the call will remain
7060 expanded into L32R/CALLX. */
7061 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7062 pin_internal_relocs (sec, internal_relocs);
7067 release_contents (sec, contents);
7068 release_internal_relocs (sec, internal_relocs);
7073 /* Return TRUE if the asm expansion can be resolved. Generally it can
7074 be resolved on a final link or when a partial link locates it in the
7075 same section as the target. Set "is_reachable" flag if the target of
7076 the call is within the range of a direct call, given the current VMA
7077 for this section and the target section. */
7080 is_resolvable_asm_expansion (bfd *abfd,
7083 Elf_Internal_Rela *irel,
7084 struct bfd_link_info *link_info,
7085 bfd_boolean *is_reachable_p)
7087 asection *target_sec;
7088 bfd_vma target_offset;
7090 xtensa_opcode opcode, direct_call_opcode;
7091 bfd_vma self_address;
7092 bfd_vma dest_address;
7093 bfd_boolean uses_l32r;
7094 bfd_size_type sec_size;
7096 *is_reachable_p = FALSE;
7098 if (contents == NULL)
7101 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
7104 sec_size = bfd_get_section_limit (abfd, sec);
7105 opcode = get_expanded_call_opcode (contents + irel->r_offset,
7106 sec_size - irel->r_offset, &uses_l32r);
7107 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7111 direct_call_opcode = swap_callx_for_call_opcode (opcode);
7112 if (direct_call_opcode == XTENSA_UNDEFINED)
7115 /* Check and see that the target resolves. */
7116 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7117 if (!r_reloc_is_defined (&r_rel))
7120 target_sec = r_reloc_get_section (&r_rel);
7121 target_offset = r_rel.target_offset;
7123 /* If the target is in a shared library, then it doesn't reach. This
7124 isn't supposed to come up because the compiler should never generate
7125 non-PIC calls on systems that use shared libraries, but the linker
7126 shouldn't crash regardless. */
7127 if (!target_sec->output_section)
7130 /* For relocatable sections, we can only simplify when the output
7131 section of the target is the same as the output section of the
7133 if (link_info->relocatable
7134 && (target_sec->output_section != sec->output_section
7135 || is_reloc_sym_weak (abfd, irel)))
7138 self_address = (sec->output_section->vma
7139 + sec->output_offset + irel->r_offset + 3);
7140 dest_address = (target_sec->output_section->vma
7141 + target_sec->output_offset + target_offset);
7143 *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
7144 self_address, dest_address);
7146 if ((self_address >> CALL_SEGMENT_BITS) !=
7147 (dest_address >> CALL_SEGMENT_BITS))
7154 static Elf_Internal_Rela *
7155 find_associated_l32r_irel (bfd *abfd,
7158 Elf_Internal_Rela *other_irel,
7159 Elf_Internal_Rela *internal_relocs)
7163 for (i = 0; i < sec->reloc_count; i++)
7165 Elf_Internal_Rela *irel = &internal_relocs[i];
7167 if (irel == other_irel)
7169 if (irel->r_offset != other_irel->r_offset)
7171 if (is_l32r_relocation (abfd, sec, contents, irel))
7179 static xtensa_opcode *
7180 build_reloc_opcodes (bfd *abfd,
7183 Elf_Internal_Rela *internal_relocs)
7186 xtensa_opcode *reloc_opcodes =
7187 (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
7188 for (i = 0; i < sec->reloc_count; i++)
7190 Elf_Internal_Rela *irel = &internal_relocs[i];
7191 reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
7193 return reloc_opcodes;
7197 /* The compute_text_actions function will build a list of potential
7198 transformation actions for code in the extended basic block of each
7199 longcall that is optimized to a direct call. From this list we
7200 generate a set of actions to actually perform that optimizes for
7201 space and, if not using size_opt, maintains branch target
7204 These actions to be performed are placed on a per-section list.
7205 The actual changes are performed by relax_section() in the second
7209 compute_text_actions (bfd *abfd,
7211 struct bfd_link_info *link_info)
7213 xtensa_opcode *reloc_opcodes = NULL;
7214 xtensa_relax_info *relax_info;
7216 Elf_Internal_Rela *internal_relocs;
7217 bfd_boolean ok = TRUE;
7219 property_table_entry *prop_table = 0;
7221 bfd_size_type sec_size;
7223 relax_info = get_xtensa_relax_info (sec);
7224 BFD_ASSERT (relax_info);
7225 BFD_ASSERT (relax_info->src_next == relax_info->src_count);
7227 /* Do nothing if the section contains no optimized longcalls. */
7228 if (!relax_info->is_relaxable_asm_section)
7231 internal_relocs = retrieve_internal_relocs (abfd, sec,
7232 link_info->keep_memory);
7234 if (internal_relocs)
7235 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7236 internal_reloc_compare);
7238 sec_size = bfd_get_section_limit (abfd, sec);
7239 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7240 if (contents == NULL && sec_size != 0)
7246 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7247 XTENSA_PROP_SEC_NAME, FALSE);
7254 for (i = 0; i < sec->reloc_count; i++)
7256 Elf_Internal_Rela *irel = &internal_relocs[i];
7258 property_table_entry *the_entry;
7261 ebb_constraint ebb_table;
7262 bfd_size_type simplify_size;
7264 if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
7266 r_offset = irel->r_offset;
7268 simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
7269 if (simplify_size == 0)
7271 (*_bfd_error_handler)
7272 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
7273 sec->owner, sec, r_offset);
7277 /* If the instruction table is not around, then don't do this
7279 the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7280 sec->vma + irel->r_offset);
7281 if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
7283 text_action_add (&relax_info->action_list,
7284 ta_convert_longcall, sec, r_offset,
7289 /* If the next longcall happens to be at the same address as an
7290 unreachable section of size 0, then skip forward. */
7291 ptbl_idx = the_entry - prop_table;
7292 while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
7293 && the_entry->size == 0
7294 && ptbl_idx + 1 < ptblsize
7295 && (prop_table[ptbl_idx + 1].address
7296 == prop_table[ptbl_idx].address))
7302 if (the_entry->flags & XTENSA_PROP_NO_TRANSFORM)
7303 /* NO_REORDER is OK */
7306 init_ebb_constraint (&ebb_table);
7307 ebb = &ebb_table.ebb;
7308 init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
7309 internal_relocs, sec->reloc_count);
7310 ebb->start_offset = r_offset + simplify_size;
7311 ebb->end_offset = r_offset + simplify_size;
7312 ebb->start_ptbl_idx = ptbl_idx;
7313 ebb->end_ptbl_idx = ptbl_idx;
7314 ebb->start_reloc_idx = i;
7315 ebb->end_reloc_idx = i;
7317 /* Precompute the opcode for each relocation. */
7318 if (reloc_opcodes == NULL)
7319 reloc_opcodes = build_reloc_opcodes (abfd, sec, contents,
7322 if (!extend_ebb_bounds (ebb)
7323 || !compute_ebb_proposed_actions (&ebb_table)
7324 || !compute_ebb_actions (&ebb_table)
7325 || !check_section_ebb_pcrels_fit (abfd, sec, contents,
7326 internal_relocs, &ebb_table,
7328 || !check_section_ebb_reduces (&ebb_table))
7330 /* If anything goes wrong or we get unlucky and something does
7331 not fit, with our plan because of expansion between
7332 critical branches, just convert to a NOP. */
7334 text_action_add (&relax_info->action_list,
7335 ta_convert_longcall, sec, r_offset, 0);
7336 i = ebb_table.ebb.end_reloc_idx;
7337 free_ebb_constraint (&ebb_table);
7341 text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
7343 /* Update the index so we do not go looking at the relocations
7344 we have already processed. */
7345 i = ebb_table.ebb.end_reloc_idx;
7346 free_ebb_constraint (&ebb_table);
7350 if (relax_info->action_list.head)
7351 print_action_list (stderr, &relax_info->action_list);
7355 release_contents (sec, contents);
7356 release_internal_relocs (sec, internal_relocs);
7360 free (reloc_opcodes);
7366 /* Do not widen an instruction if it is preceeded by a
7367 loop opcode. It might cause misalignment. */
7370 prev_instr_is_a_loop (bfd_byte *contents,
7371 bfd_size_type content_length,
7372 bfd_size_type offset)
7374 xtensa_opcode prev_opcode;
7378 prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
7379 return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
7383 /* Find all of the possible actions for an extended basic block. */
7386 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
7388 const ebb_t *ebb = &ebb_table->ebb;
7389 unsigned rel_idx = ebb->start_reloc_idx;
7390 property_table_entry *entry, *start_entry, *end_entry;
7392 xtensa_isa isa = xtensa_default_isa;
7394 static xtensa_insnbuf insnbuf = NULL;
7395 static xtensa_insnbuf slotbuf = NULL;
7397 if (insnbuf == NULL)
7399 insnbuf = xtensa_insnbuf_alloc (isa);
7400 slotbuf = xtensa_insnbuf_alloc (isa);
7403 start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
7404 end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
7406 for (entry = start_entry; entry <= end_entry; entry++)
7408 bfd_vma start_offset, end_offset;
7409 bfd_size_type insn_len;
7411 start_offset = entry->address - ebb->sec->vma;
7412 end_offset = entry->address + entry->size - ebb->sec->vma;
7414 if (entry == start_entry)
7415 start_offset = ebb->start_offset;
7416 if (entry == end_entry)
7417 end_offset = ebb->end_offset;
7418 offset = start_offset;
7420 if (offset == entry->address - ebb->sec->vma
7421 && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
7423 enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
7424 BFD_ASSERT (offset != end_offset);
7425 if (offset == end_offset)
7428 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
7433 if (check_branch_target_aligned_address (offset, insn_len))
7434 align_type = EBB_REQUIRE_TGT_ALIGN;
7436 ebb_propose_action (ebb_table, align_type, 0,
7437 ta_none, offset, 0, TRUE);
7440 while (offset != end_offset)
7442 Elf_Internal_Rela *irel;
7443 xtensa_opcode opcode;
7445 while (rel_idx < ebb->end_reloc_idx
7446 && (ebb->relocs[rel_idx].r_offset < offset
7447 || (ebb->relocs[rel_idx].r_offset == offset
7448 && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
7449 != R_XTENSA_ASM_SIMPLIFY))))
7452 /* Check for longcall. */
7453 irel = &ebb->relocs[rel_idx];
7454 if (irel->r_offset == offset
7455 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
7457 bfd_size_type simplify_size;
7459 simplify_size = get_asm_simplify_size (ebb->contents,
7460 ebb->content_length,
7462 if (simplify_size == 0)
7465 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7466 ta_convert_longcall, offset, 0, TRUE);
7468 offset += simplify_size;
7472 if (offset + MIN_INSN_LENGTH > ebb->content_length)
7474 xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
7475 ebb->content_length - offset);
7476 fmt = xtensa_format_decode (isa, insnbuf);
7477 if (fmt == XTENSA_UNDEFINED)
7479 insn_len = xtensa_format_length (isa, fmt);
7480 if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
7483 if (xtensa_format_num_slots (isa, fmt) != 1)
7489 xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7490 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7491 if (opcode == XTENSA_UNDEFINED)
7494 if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
7495 && (entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7496 && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
7498 /* Add an instruction narrow action. */
7499 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7500 ta_narrow_insn, offset, 0, FALSE);
7502 else if ((entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7503 && can_widen_instruction (slotbuf, fmt, opcode) != 0
7504 && ! prev_instr_is_a_loop (ebb->contents,
7505 ebb->content_length, offset))
7507 /* Add an instruction widen action. */
7508 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7509 ta_widen_insn, offset, 0, FALSE);
7511 else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
7513 /* Check for branch targets. */
7514 ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
7515 ta_none, offset, 0, TRUE);
7522 if (ebb->ends_unreachable)
7524 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7525 ta_fill, ebb->end_offset, 0, TRUE);
7531 (*_bfd_error_handler)
7532 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
7533 ebb->sec->owner, ebb->sec, offset);
7538 /* After all of the information has collected about the
7539 transformations possible in an EBB, compute the appropriate actions
7540 here in compute_ebb_actions. We still must check later to make
7541 sure that the actions do not break any relocations. The algorithm
7542 used here is pretty greedy. Basically, it removes as many no-ops
7543 as possible so that the end of the EBB has the same alignment
7544 characteristics as the original. First, it uses narrowing, then
7545 fill space at the end of the EBB, and finally widenings. If that
7546 does not work, it tries again with one fewer no-op removed. The
7547 optimization will only be performed if all of the branch targets
7548 that were aligned before transformation are also aligned after the
7551 When the size_opt flag is set, ignore the branch target alignments,
7552 narrow all wide instructions, and remove all no-ops unless the end
7553 of the EBB prevents it. */
7556 compute_ebb_actions (ebb_constraint *ebb_table)
7560 int removed_bytes = 0;
7561 ebb_t *ebb = &ebb_table->ebb;
7562 unsigned seg_idx_start = 0;
7563 unsigned seg_idx_end = 0;
7565 /* We perform this like the assembler relaxation algorithm: Start by
7566 assuming all instructions are narrow and all no-ops removed; then
7569 /* For each segment of this that has a solid constraint, check to
7570 see if there are any combinations that will keep the constraint.
7572 for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
7574 bfd_boolean requires_text_end_align = FALSE;
7575 unsigned longcall_count = 0;
7576 unsigned longcall_convert_count = 0;
7577 unsigned narrowable_count = 0;
7578 unsigned narrowable_convert_count = 0;
7579 unsigned widenable_count = 0;
7580 unsigned widenable_convert_count = 0;
7582 proposed_action *action = NULL;
7583 int align = (1 << ebb_table->ebb.sec->alignment_power);
7585 seg_idx_start = seg_idx_end;
7587 for (i = seg_idx_start; i < ebb_table->action_count; i++)
7589 action = &ebb_table->actions[i];
7590 if (action->action == ta_convert_longcall)
7592 if (action->action == ta_narrow_insn)
7594 if (action->action == ta_widen_insn)
7596 if (action->action == ta_fill)
7598 if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
7600 if (action->align_type == EBB_REQUIRE_TGT_ALIGN
7601 && !elf32xtensa_size_opt)
7606 if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
7607 requires_text_end_align = TRUE;
7609 if (elf32xtensa_size_opt && !requires_text_end_align
7610 && action->align_type != EBB_REQUIRE_LOOP_ALIGN
7611 && action->align_type != EBB_REQUIRE_TGT_ALIGN)
7613 longcall_convert_count = longcall_count;
7614 narrowable_convert_count = narrowable_count;
7615 widenable_convert_count = 0;
7619 /* There is a constraint. Convert the max number of longcalls. */
7620 narrowable_convert_count = 0;
7621 longcall_convert_count = 0;
7622 widenable_convert_count = 0;
7624 for (j = 0; j < longcall_count; j++)
7626 int removed = (longcall_count - j) * 3 & (align - 1);
7627 unsigned desire_narrow = (align - removed) & (align - 1);
7628 unsigned desire_widen = removed;
7629 if (desire_narrow <= narrowable_count)
7631 narrowable_convert_count = desire_narrow;
7632 narrowable_convert_count +=
7633 (align * ((narrowable_count - narrowable_convert_count)
7635 longcall_convert_count = (longcall_count - j);
7636 widenable_convert_count = 0;
7639 if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
7641 narrowable_convert_count = 0;
7642 longcall_convert_count = longcall_count - j;
7643 widenable_convert_count = desire_widen;
7649 /* Now the number of conversions are saved. Do them. */
7650 for (i = seg_idx_start; i < seg_idx_end; i++)
7652 action = &ebb_table->actions[i];
7653 switch (action->action)
7655 case ta_convert_longcall:
7656 if (longcall_convert_count != 0)
7658 action->action = ta_remove_longcall;
7659 action->do_action = TRUE;
7660 action->removed_bytes += 3;
7661 longcall_convert_count--;
7664 case ta_narrow_insn:
7665 if (narrowable_convert_count != 0)
7667 action->do_action = TRUE;
7668 action->removed_bytes += 1;
7669 narrowable_convert_count--;
7673 if (widenable_convert_count != 0)
7675 action->do_action = TRUE;
7676 action->removed_bytes -= 1;
7677 widenable_convert_count--;
7686 /* Now we move on to some local opts. Try to remove each of the
7687 remaining longcalls. */
7689 if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
7692 for (i = 0; i < ebb_table->action_count; i++)
7694 int old_removed_bytes = removed_bytes;
7695 proposed_action *action = &ebb_table->actions[i];
7697 if (action->do_action && action->action == ta_convert_longcall)
7699 bfd_boolean bad_alignment = FALSE;
7701 for (j = i + 1; j < ebb_table->action_count; j++)
7703 proposed_action *new_action = &ebb_table->actions[j];
7704 bfd_vma offset = new_action->offset;
7705 if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
7707 if (!check_branch_target_aligned
7708 (ebb_table->ebb.contents,
7709 ebb_table->ebb.content_length,
7710 offset, offset - removed_bytes))
7712 bad_alignment = TRUE;
7716 if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
7718 if (!check_loop_aligned (ebb_table->ebb.contents,
7719 ebb_table->ebb.content_length,
7721 offset - removed_bytes))
7723 bad_alignment = TRUE;
7727 if (new_action->action == ta_narrow_insn
7728 && !new_action->do_action
7729 && ebb_table->ebb.sec->alignment_power == 2)
7731 /* Narrow an instruction and we are done. */
7732 new_action->do_action = TRUE;
7733 new_action->removed_bytes += 1;
7734 bad_alignment = FALSE;
7737 if (new_action->action == ta_widen_insn
7738 && new_action->do_action
7739 && ebb_table->ebb.sec->alignment_power == 2)
7741 /* Narrow an instruction and we are done. */
7742 new_action->do_action = FALSE;
7743 new_action->removed_bytes += 1;
7744 bad_alignment = FALSE;
7747 if (new_action->do_action)
7748 removed_bytes += new_action->removed_bytes;
7752 action->removed_bytes += 3;
7753 action->action = ta_remove_longcall;
7754 action->do_action = TRUE;
7757 removed_bytes = old_removed_bytes;
7758 if (action->do_action)
7759 removed_bytes += action->removed_bytes;
7764 for (i = 0; i < ebb_table->action_count; ++i)
7766 proposed_action *action = &ebb_table->actions[i];
7767 if (action->do_action)
7768 removed_bytes += action->removed_bytes;
7771 if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
7772 && ebb->ends_unreachable)
7774 proposed_action *action;
7778 BFD_ASSERT (ebb_table->action_count != 0);
7779 action = &ebb_table->actions[ebb_table->action_count - 1];
7780 BFD_ASSERT (action->action == ta_fill);
7781 BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
7783 extra_space = compute_fill_extra_space (ebb->ends_unreachable);
7784 br = action->removed_bytes + removed_bytes + extra_space;
7785 br = br & ((1 << ebb->sec->alignment_power ) - 1);
7787 action->removed_bytes = extra_space - br;
7793 /* The xlate_map is a sorted array of address mappings designed to
7794 answer the offset_with_removed_text() query with a binary search instead
7795 of a linear search through the section's action_list. */
7797 typedef struct xlate_map_entry xlate_map_entry_t;
7798 typedef struct xlate_map xlate_map_t;
7800 struct xlate_map_entry
7802 unsigned orig_address;
7803 unsigned new_address;
7809 unsigned entry_count;
7810 xlate_map_entry_t *entry;
7815 xlate_compare (const void *a_v, const void *b_v)
7817 const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
7818 const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
7819 if (a->orig_address < b->orig_address)
7821 if (a->orig_address > (b->orig_address + b->size - 1))
7828 xlate_offset_with_removed_text (const xlate_map_t *map,
7829 text_action_list *action_list,
7832 xlate_map_entry_t tmp;
7834 xlate_map_entry_t *e;
7837 return offset_with_removed_text (action_list, offset);
7839 if (map->entry_count == 0)
7842 tmp.orig_address = offset;
7843 tmp.new_address = offset;
7846 r = bsearch (&offset, map->entry, map->entry_count,
7847 sizeof (xlate_map_entry_t), &xlate_compare);
7848 e = (xlate_map_entry_t *) r;
7850 BFD_ASSERT (e != NULL);
7853 return e->new_address - e->orig_address + offset;
7857 /* Build a binary searchable offset translation map from a section's
7860 static xlate_map_t *
7861 build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
7863 xlate_map_t *map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
7864 text_action_list *action_list = &relax_info->action_list;
7865 unsigned num_actions = 0;
7868 xlate_map_entry_t *current_entry;
7873 num_actions = action_list_count (action_list);
7874 map->entry = (xlate_map_entry_t *)
7875 bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
7876 if (map->entry == NULL)
7881 map->entry_count = 0;
7884 current_entry = &map->entry[0];
7886 current_entry->orig_address = 0;
7887 current_entry->new_address = 0;
7888 current_entry->size = 0;
7890 for (r = action_list->head; r != NULL; r = r->next)
7892 unsigned orig_size = 0;
7896 case ta_remove_insn:
7897 case ta_convert_longcall:
7898 case ta_remove_literal:
7899 case ta_add_literal:
7901 case ta_remove_longcall:
7904 case ta_narrow_insn:
7913 current_entry->size =
7914 r->offset + orig_size - current_entry->orig_address;
7915 if (current_entry->size != 0)
7920 current_entry->orig_address = r->offset + orig_size;
7921 removed += r->removed_bytes;
7922 current_entry->new_address = r->offset + orig_size - removed;
7923 current_entry->size = 0;
7926 current_entry->size = (bfd_get_section_limit (sec->owner, sec)
7927 - current_entry->orig_address);
7928 if (current_entry->size != 0)
7935 /* Free an offset translation map. */
7938 free_xlate_map (xlate_map_t *map)
7940 if (map && map->entry)
7947 /* Use check_section_ebb_pcrels_fit to make sure that all of the
7948 relocations in a section will fit if a proposed set of actions
7952 check_section_ebb_pcrels_fit (bfd *abfd,
7955 Elf_Internal_Rela *internal_relocs,
7956 const ebb_constraint *constraint,
7957 const xtensa_opcode *reloc_opcodes)
7960 Elf_Internal_Rela *irel;
7961 xlate_map_t *xmap = NULL;
7962 bfd_boolean ok = TRUE;
7963 xtensa_relax_info *relax_info;
7965 relax_info = get_xtensa_relax_info (sec);
7967 if (relax_info && sec->reloc_count > 100)
7969 xmap = build_xlate_map (sec, relax_info);
7970 /* NULL indicates out of memory, but the slow version
7971 can still be used. */
7974 for (i = 0; i < sec->reloc_count; i++)
7977 bfd_vma orig_self_offset, orig_target_offset;
7978 bfd_vma self_offset, target_offset;
7980 reloc_howto_type *howto;
7981 int self_removed_bytes, target_removed_bytes;
7983 irel = &internal_relocs[i];
7984 r_type = ELF32_R_TYPE (irel->r_info);
7986 howto = &elf_howto_table[r_type];
7987 /* We maintain the required invariant: PC-relative relocations
7988 that fit before linking must fit after linking. Thus we only
7989 need to deal with relocations to the same section that are
7991 if (r_type == R_XTENSA_ASM_SIMPLIFY
7992 || r_type == R_XTENSA_32_PCREL
7993 || !howto->pc_relative)
7996 r_reloc_init (&r_rel, abfd, irel, contents,
7997 bfd_get_section_limit (abfd, sec));
7999 if (r_reloc_get_section (&r_rel) != sec)
8002 orig_self_offset = irel->r_offset;
8003 orig_target_offset = r_rel.target_offset;
8005 self_offset = orig_self_offset;
8006 target_offset = orig_target_offset;
8011 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8014 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
8015 orig_target_offset);
8018 self_removed_bytes = 0;
8019 target_removed_bytes = 0;
8021 for (j = 0; j < constraint->action_count; ++j)
8023 proposed_action *action = &constraint->actions[j];
8024 bfd_vma offset = action->offset;
8025 int removed_bytes = action->removed_bytes;
8026 if (offset < orig_self_offset
8027 || (offset == orig_self_offset && action->action == ta_fill
8028 && action->removed_bytes < 0))
8029 self_removed_bytes += removed_bytes;
8030 if (offset < orig_target_offset
8031 || (offset == orig_target_offset && action->action == ta_fill
8032 && action->removed_bytes < 0))
8033 target_removed_bytes += removed_bytes;
8035 self_offset -= self_removed_bytes;
8036 target_offset -= target_removed_bytes;
8038 /* Try to encode it. Get the operand and check. */
8039 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
8041 /* None of the current alternate relocs are PC-relative,
8042 and only PC-relative relocs matter here. */
8046 xtensa_opcode opcode;
8050 opcode = reloc_opcodes[i];
8052 opcode = get_relocation_opcode (abfd, sec, contents, irel);
8053 if (opcode == XTENSA_UNDEFINED)
8059 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
8060 if (opnum == XTENSA_UNDEFINED)
8066 if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
8075 free_xlate_map (xmap);
8082 check_section_ebb_reduces (const ebb_constraint *constraint)
8087 for (i = 0; i < constraint->action_count; i++)
8089 const proposed_action *action = &constraint->actions[i];
8090 if (action->do_action)
8091 removed += action->removed_bytes;
8101 text_action_add_proposed (text_action_list *l,
8102 const ebb_constraint *ebb_table,
8107 for (i = 0; i < ebb_table->action_count; i++)
8109 proposed_action *action = &ebb_table->actions[i];
8111 if (!action->do_action)
8113 switch (action->action)
8115 case ta_remove_insn:
8116 case ta_remove_longcall:
8117 case ta_convert_longcall:
8118 case ta_narrow_insn:
8121 case ta_remove_literal:
8122 text_action_add (l, action->action, sec, action->offset,
8123 action->removed_bytes);
8136 compute_fill_extra_space (property_table_entry *entry)
8138 int fill_extra_space;
8143 if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
8146 fill_extra_space = entry->size;
8147 if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
8149 /* Fill bytes for alignment:
8150 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8151 int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
8152 int nsm = (1 << pow) - 1;
8153 bfd_vma addr = entry->address + entry->size;
8154 bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
8155 fill_extra_space += align_fill;
8157 return fill_extra_space;
8161 /* First relaxation pass. */
8163 /* If the section contains relaxable literals, check each literal to
8164 see if it has the same value as another literal that has already
8165 been seen, either in the current section or a previous one. If so,
8166 add an entry to the per-section list of removed literals. The
8167 actual changes are deferred until the next pass. */
8170 compute_removed_literals (bfd *abfd,
8172 struct bfd_link_info *link_info,
8173 value_map_hash_table *values)
8175 xtensa_relax_info *relax_info;
8177 Elf_Internal_Rela *internal_relocs;
8178 source_reloc *src_relocs, *rel;
8179 bfd_boolean ok = TRUE;
8180 property_table_entry *prop_table = NULL;
8183 bfd_boolean last_loc_is_prev = FALSE;
8184 bfd_vma last_target_offset = 0;
8185 section_cache_t target_sec_cache;
8186 bfd_size_type sec_size;
8188 init_section_cache (&target_sec_cache);
8190 /* Do nothing if it is not a relaxable literal section. */
8191 relax_info = get_xtensa_relax_info (sec);
8192 BFD_ASSERT (relax_info);
8193 if (!relax_info->is_relaxable_literal_section)
8196 internal_relocs = retrieve_internal_relocs (abfd, sec,
8197 link_info->keep_memory);
8199 sec_size = bfd_get_section_limit (abfd, sec);
8200 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8201 if (contents == NULL && sec_size != 0)
8207 /* Sort the source_relocs by target offset. */
8208 src_relocs = relax_info->src_relocs;
8209 qsort (src_relocs, relax_info->src_count,
8210 sizeof (source_reloc), source_reloc_compare);
8211 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8212 internal_reloc_compare);
8214 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
8215 XTENSA_PROP_SEC_NAME, FALSE);
8223 for (i = 0; i < relax_info->src_count; i++)
8225 Elf_Internal_Rela *irel = NULL;
8227 rel = &src_relocs[i];
8228 if (get_l32r_opcode () != rel->opcode)
8230 irel = get_irel_at_offset (sec, internal_relocs,
8231 rel->r_rel.target_offset);
8233 /* If the relocation on this is not a simple R_XTENSA_32 or
8234 R_XTENSA_PLT then do not consider it. This may happen when
8235 the difference of two symbols is used in a literal. */
8236 if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
8237 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
8240 /* If the target_offset for this relocation is the same as the
8241 previous relocation, then we've already considered whether the
8242 literal can be coalesced. Skip to the next one.... */
8243 if (i != 0 && prev_i != -1
8244 && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
8248 if (last_loc_is_prev &&
8249 last_target_offset + 4 != rel->r_rel.target_offset)
8250 last_loc_is_prev = FALSE;
8252 /* Check if the relocation was from an L32R that is being removed
8253 because a CALLX was converted to a direct CALL, and check if
8254 there are no other relocations to the literal. */
8255 if (is_removable_literal (rel, i, src_relocs, relax_info->src_count,
8256 sec, prop_table, ptblsize))
8258 if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
8259 irel, rel, prop_table, ptblsize))
8264 last_target_offset = rel->r_rel.target_offset;
8268 if (!identify_literal_placement (abfd, sec, contents, link_info,
8270 &last_loc_is_prev, irel,
8271 relax_info->src_count - i, rel,
8272 prop_table, ptblsize,
8273 &target_sec_cache, rel->is_abs_literal))
8278 last_target_offset = rel->r_rel.target_offset;
8282 print_removed_literals (stderr, &relax_info->removed_list);
8283 print_action_list (stderr, &relax_info->action_list);
8287 if (prop_table) free (prop_table);
8288 clear_section_cache (&target_sec_cache);
8290 release_contents (sec, contents);
8291 release_internal_relocs (sec, internal_relocs);
8296 static Elf_Internal_Rela *
8297 get_irel_at_offset (asection *sec,
8298 Elf_Internal_Rela *internal_relocs,
8302 Elf_Internal_Rela *irel;
8304 Elf_Internal_Rela key;
8306 if (!internal_relocs)
8309 key.r_offset = offset;
8310 irel = bsearch (&key, internal_relocs, sec->reloc_count,
8311 sizeof (Elf_Internal_Rela), internal_reloc_matches);
8315 /* bsearch does not guarantee which will be returned if there are
8316 multiple matches. We need the first that is not an alignment. */
8317 i = irel - internal_relocs;
8320 if (internal_relocs[i-1].r_offset != offset)
8324 for ( ; i < sec->reloc_count; i++)
8326 irel = &internal_relocs[i];
8327 r_type = ELF32_R_TYPE (irel->r_info);
8328 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
8337 is_removable_literal (const source_reloc *rel,
8339 const source_reloc *src_relocs,
8342 property_table_entry *prop_table,
8345 const source_reloc *curr_rel;
8346 property_table_entry *entry;
8351 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8352 sec->vma + rel->r_rel.target_offset);
8353 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8356 for (++i; i < src_count; ++i)
8358 curr_rel = &src_relocs[i];
8359 /* If all others have the same target offset.... */
8360 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
8363 if (!curr_rel->is_null
8364 && !xtensa_is_property_section (curr_rel->source_sec)
8365 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
8373 remove_dead_literal (bfd *abfd,
8375 struct bfd_link_info *link_info,
8376 Elf_Internal_Rela *internal_relocs,
8377 Elf_Internal_Rela *irel,
8379 property_table_entry *prop_table,
8382 property_table_entry *entry;
8383 xtensa_relax_info *relax_info;
8385 relax_info = get_xtensa_relax_info (sec);
8389 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8390 sec->vma + rel->r_rel.target_offset);
8392 /* Mark the unused literal so that it will be removed. */
8393 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
8395 text_action_add (&relax_info->action_list,
8396 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8398 /* If the section is 4-byte aligned, do not add fill. */
8399 if (sec->alignment_power > 2)
8401 int fill_extra_space;
8402 bfd_vma entry_sec_offset;
8404 property_table_entry *the_add_entry;
8408 entry_sec_offset = entry->address - sec->vma + entry->size;
8410 entry_sec_offset = rel->r_rel.target_offset + 4;
8412 /* If the literal range is at the end of the section,
8414 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8416 fill_extra_space = compute_fill_extra_space (the_add_entry);
8418 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8419 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8420 -4, fill_extra_space);
8422 adjust_fill_action (fa, removed_diff);
8424 text_action_add (&relax_info->action_list,
8425 ta_fill, sec, entry_sec_offset, removed_diff);
8428 /* Zero out the relocation on this literal location. */
8431 if (elf_hash_table (link_info)->dynamic_sections_created)
8432 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8434 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8435 pin_internal_relocs (sec, internal_relocs);
8438 /* Do not modify "last_loc_is_prev". */
8444 identify_literal_placement (bfd *abfd,
8447 struct bfd_link_info *link_info,
8448 value_map_hash_table *values,
8449 bfd_boolean *last_loc_is_prev_p,
8450 Elf_Internal_Rela *irel,
8451 int remaining_src_rels,
8453 property_table_entry *prop_table,
8455 section_cache_t *target_sec_cache,
8456 bfd_boolean is_abs_literal)
8460 xtensa_relax_info *relax_info;
8461 bfd_boolean literal_placed = FALSE;
8463 unsigned long value;
8464 bfd_boolean final_static_link;
8465 bfd_size_type sec_size;
8467 relax_info = get_xtensa_relax_info (sec);
8471 sec_size = bfd_get_section_limit (abfd, sec);
8474 (!link_info->relocatable
8475 && !elf_hash_table (link_info)->dynamic_sections_created);
8477 /* The placement algorithm first checks to see if the literal is
8478 already in the value map. If so and the value map is reachable
8479 from all uses, then the literal is moved to that location. If
8480 not, then we identify the last location where a fresh literal was
8481 placed. If the literal can be safely moved there, then we do so.
8482 If not, then we assume that the literal is not to move and leave
8483 the literal where it is, marking it as the last literal
8486 /* Find the literal value. */
8488 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8491 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
8492 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
8494 init_literal_value (&val, &r_rel, value, is_abs_literal);
8496 /* Check if we've seen another literal with the same value that
8497 is in the same output section. */
8498 val_map = value_map_get_cached_value (values, &val, final_static_link);
8501 && (r_reloc_get_section (&val_map->loc)->output_section
8502 == sec->output_section)
8503 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
8504 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
8506 /* No change to last_loc_is_prev. */
8507 literal_placed = TRUE;
8510 /* For relocatable links, do not try to move literals. To do it
8511 correctly might increase the number of relocations in an input
8512 section making the default relocatable linking fail. */
8513 if (!link_info->relocatable && !literal_placed
8514 && values->has_last_loc && !(*last_loc_is_prev_p))
8516 asection *target_sec = r_reloc_get_section (&values->last_loc);
8517 if (target_sec && target_sec->output_section == sec->output_section)
8519 /* Increment the virtual offset. */
8520 r_reloc try_loc = values->last_loc;
8521 try_loc.virtual_offset += 4;
8523 /* There is a last loc that was in the same output section. */
8524 if (relocations_reach (rel, remaining_src_rels, &try_loc)
8525 && move_shared_literal (sec, link_info, rel,
8526 prop_table, ptblsize,
8527 &try_loc, &val, target_sec_cache))
8529 values->last_loc.virtual_offset += 4;
8530 literal_placed = TRUE;
8532 val_map = add_value_map (values, &val, &try_loc,
8535 val_map->loc = try_loc;
8540 if (!literal_placed)
8542 /* Nothing worked, leave the literal alone but update the last loc. */
8543 values->has_last_loc = TRUE;
8544 values->last_loc = rel->r_rel;
8546 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
8548 val_map->loc = rel->r_rel;
8549 *last_loc_is_prev_p = TRUE;
8556 /* Check if the original relocations (presumably on L32R instructions)
8557 identified by reloc[0..N] can be changed to reference the literal
8558 identified by r_rel. If r_rel is out of range for any of the
8559 original relocations, then we don't want to coalesce the original
8560 literal with the one at r_rel. We only check reloc[0..N], where the
8561 offsets are all the same as for reloc[0] (i.e., they're all
8562 referencing the same literal) and where N is also bounded by the
8563 number of remaining entries in the "reloc" array. The "reloc" array
8564 is sorted by target offset so we know all the entries for the same
8565 literal will be contiguous. */
8568 relocations_reach (source_reloc *reloc,
8569 int remaining_relocs,
8570 const r_reloc *r_rel)
8572 bfd_vma from_offset, source_address, dest_address;
8576 if (!r_reloc_is_defined (r_rel))
8579 sec = r_reloc_get_section (r_rel);
8580 from_offset = reloc[0].r_rel.target_offset;
8582 for (i = 0; i < remaining_relocs; i++)
8584 if (reloc[i].r_rel.target_offset != from_offset)
8587 /* Ignore relocations that have been removed. */
8588 if (reloc[i].is_null)
8591 /* The original and new output section for these must be the same
8592 in order to coalesce. */
8593 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
8594 != sec->output_section)
8597 /* Absolute literals in the same output section can always be
8599 if (reloc[i].is_abs_literal)
8602 /* A literal with no PC-relative relocations can be moved anywhere. */
8603 if (reloc[i].opnd != -1)
8605 /* Otherwise, check to see that it fits. */
8606 source_address = (reloc[i].source_sec->output_section->vma
8607 + reloc[i].source_sec->output_offset
8608 + reloc[i].r_rel.rela.r_offset);
8609 dest_address = (sec->output_section->vma
8610 + sec->output_offset
8611 + r_rel->target_offset);
8613 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
8614 source_address, dest_address))
8623 /* Move a literal to another literal location because it is
8624 the same as the other literal value. */
8627 coalesce_shared_literal (asection *sec,
8629 property_table_entry *prop_table,
8633 property_table_entry *entry;
8635 property_table_entry *the_add_entry;
8637 xtensa_relax_info *relax_info;
8639 relax_info = get_xtensa_relax_info (sec);
8643 entry = elf_xtensa_find_property_entry
8644 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
8645 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8648 /* Mark that the literal will be coalesced. */
8649 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
8651 text_action_add (&relax_info->action_list,
8652 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8654 /* If the section is 4-byte aligned, do not add fill. */
8655 if (sec->alignment_power > 2)
8657 int fill_extra_space;
8658 bfd_vma entry_sec_offset;
8661 entry_sec_offset = entry->address - sec->vma + entry->size;
8663 entry_sec_offset = rel->r_rel.target_offset + 4;
8665 /* If the literal range is at the end of the section,
8667 fill_extra_space = 0;
8668 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8670 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8671 fill_extra_space = the_add_entry->size;
8673 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8674 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8675 -4, fill_extra_space);
8677 adjust_fill_action (fa, removed_diff);
8679 text_action_add (&relax_info->action_list,
8680 ta_fill, sec, entry_sec_offset, removed_diff);
8687 /* Move a literal to another location. This may actually increase the
8688 total amount of space used because of alignments so we need to do
8689 this carefully. Also, it may make a branch go out of range. */
8692 move_shared_literal (asection *sec,
8693 struct bfd_link_info *link_info,
8695 property_table_entry *prop_table,
8697 const r_reloc *target_loc,
8698 const literal_value *lit_value,
8699 section_cache_t *target_sec_cache)
8701 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
8702 text_action *fa, *target_fa;
8704 xtensa_relax_info *relax_info, *target_relax_info;
8705 asection *target_sec;
8707 ebb_constraint ebb_table;
8708 bfd_boolean relocs_fit;
8710 /* If this routine always returns FALSE, the literals that cannot be
8711 coalesced will not be moved. */
8712 if (elf32xtensa_no_literal_movement)
8715 relax_info = get_xtensa_relax_info (sec);
8719 target_sec = r_reloc_get_section (target_loc);
8720 target_relax_info = get_xtensa_relax_info (target_sec);
8722 /* Literals to undefined sections may not be moved because they
8723 must report an error. */
8724 if (bfd_is_und_section (target_sec))
8727 src_entry = elf_xtensa_find_property_entry
8728 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
8730 if (!section_cache_section (target_sec_cache, target_sec, link_info))
8733 target_entry = elf_xtensa_find_property_entry
8734 (target_sec_cache->ptbl, target_sec_cache->pte_count,
8735 target_sec->vma + target_loc->target_offset);
8740 /* Make sure that we have not broken any branches. */
8743 init_ebb_constraint (&ebb_table);
8744 ebb = &ebb_table.ebb;
8745 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
8746 target_sec_cache->content_length,
8747 target_sec_cache->ptbl, target_sec_cache->pte_count,
8748 target_sec_cache->relocs, target_sec_cache->reloc_count);
8750 /* Propose to add 4 bytes + worst-case alignment size increase to
8752 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
8753 ta_fill, target_loc->target_offset,
8754 -4 - (1 << target_sec->alignment_power), TRUE);
8756 /* Check all of the PC-relative relocations to make sure they still fit. */
8757 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
8758 target_sec_cache->contents,
8759 target_sec_cache->relocs,
8765 text_action_add_literal (&target_relax_info->action_list,
8766 ta_add_literal, target_loc, lit_value, -4);
8768 if (target_sec->alignment_power > 2 && target_entry != src_entry)
8770 /* May need to add or remove some fill to maintain alignment. */
8771 int fill_extra_space;
8772 bfd_vma entry_sec_offset;
8775 target_entry->address - target_sec->vma + target_entry->size;
8777 /* If the literal range is at the end of the section,
8779 fill_extra_space = 0;
8781 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
8782 target_sec_cache->pte_count,
8784 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8785 fill_extra_space = the_add_entry->size;
8787 target_fa = find_fill_action (&target_relax_info->action_list,
8788 target_sec, entry_sec_offset);
8789 removed_diff = compute_removed_action_diff (target_fa, target_sec,
8790 entry_sec_offset, 4,
8793 adjust_fill_action (target_fa, removed_diff);
8795 text_action_add (&target_relax_info->action_list,
8796 ta_fill, target_sec, entry_sec_offset, removed_diff);
8799 /* Mark that the literal will be moved to the new location. */
8800 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
8802 /* Remove the literal. */
8803 text_action_add (&relax_info->action_list,
8804 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8806 /* If the section is 4-byte aligned, do not add fill. */
8807 if (sec->alignment_power > 2 && target_entry != src_entry)
8809 int fill_extra_space;
8810 bfd_vma entry_sec_offset;
8813 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
8815 entry_sec_offset = rel->r_rel.target_offset+4;
8817 /* If the literal range is at the end of the section,
8819 fill_extra_space = 0;
8820 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8822 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8823 fill_extra_space = the_add_entry->size;
8825 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8826 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8827 -4, fill_extra_space);
8829 adjust_fill_action (fa, removed_diff);
8831 text_action_add (&relax_info->action_list,
8832 ta_fill, sec, entry_sec_offset, removed_diff);
8839 /* Second relaxation pass. */
8841 /* Modify all of the relocations to point to the right spot, and if this
8842 is a relaxable section, delete the unwanted literals and fix the
8846 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
8848 Elf_Internal_Rela *internal_relocs;
8849 xtensa_relax_info *relax_info;
8851 bfd_boolean ok = TRUE;
8853 bfd_boolean rv = FALSE;
8854 bfd_boolean virtual_action;
8855 bfd_size_type sec_size;
8857 sec_size = bfd_get_section_limit (abfd, sec);
8858 relax_info = get_xtensa_relax_info (sec);
8859 BFD_ASSERT (relax_info);
8861 /* First translate any of the fixes that have been added already. */
8862 translate_section_fixes (sec);
8864 /* Handle property sections (e.g., literal tables) specially. */
8865 if (xtensa_is_property_section (sec))
8867 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
8868 return relax_property_section (abfd, sec, link_info);
8871 internal_relocs = retrieve_internal_relocs (abfd, sec,
8872 link_info->keep_memory);
8873 if (!internal_relocs && !relax_info->action_list.head)
8876 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8877 if (contents == NULL && sec_size != 0)
8883 if (internal_relocs)
8885 for (i = 0; i < sec->reloc_count; i++)
8887 Elf_Internal_Rela *irel;
8888 xtensa_relax_info *target_relax_info;
8889 bfd_vma source_offset, old_source_offset;
8892 asection *target_sec;
8894 /* Locally change the source address.
8895 Translate the target to the new target address.
8896 If it points to this section and has been removed,
8900 irel = &internal_relocs[i];
8901 source_offset = irel->r_offset;
8902 old_source_offset = source_offset;
8904 r_type = ELF32_R_TYPE (irel->r_info);
8905 r_reloc_init (&r_rel, abfd, irel, contents,
8906 bfd_get_section_limit (abfd, sec));
8908 /* If this section could have changed then we may need to
8909 change the relocation's offset. */
8911 if (relax_info->is_relaxable_literal_section
8912 || relax_info->is_relaxable_asm_section)
8914 pin_internal_relocs (sec, internal_relocs);
8916 if (r_type != R_XTENSA_NONE
8917 && find_removed_literal (&relax_info->removed_list,
8920 /* Remove this relocation. */
8921 if (elf_hash_table (link_info)->dynamic_sections_created)
8922 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8923 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8924 irel->r_offset = offset_with_removed_text
8925 (&relax_info->action_list, irel->r_offset);
8929 if (r_type == R_XTENSA_ASM_SIMPLIFY)
8931 text_action *action =
8932 find_insn_action (&relax_info->action_list,
8934 if (action && (action->action == ta_convert_longcall
8935 || action->action == ta_remove_longcall))
8937 bfd_reloc_status_type retval;
8938 char *error_message = NULL;
8940 retval = contract_asm_expansion (contents, sec_size,
8941 irel, &error_message);
8942 if (retval != bfd_reloc_ok)
8944 (*link_info->callbacks->reloc_dangerous)
8945 (link_info, error_message, abfd, sec,
8949 /* Update the action so that the code that moves
8950 the contents will do the right thing. */
8951 if (action->action == ta_remove_longcall)
8952 action->action = ta_remove_insn;
8954 action->action = ta_none;
8955 /* Refresh the info in the r_rel. */
8956 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8957 r_type = ELF32_R_TYPE (irel->r_info);
8961 source_offset = offset_with_removed_text
8962 (&relax_info->action_list, irel->r_offset);
8963 irel->r_offset = source_offset;
8966 /* If the target section could have changed then
8967 we may need to change the relocation's target offset. */
8969 target_sec = r_reloc_get_section (&r_rel);
8971 /* For a reference to a discarded section from a DWARF section,
8972 i.e., where action_discarded is PRETEND, the symbol will
8973 eventually be modified to refer to the kept section (at least if
8974 the kept and discarded sections are the same size). Anticipate
8975 that here and adjust things accordingly. */
8976 if (! elf_xtensa_ignore_discarded_relocs (sec)
8977 && elf_xtensa_action_discarded (sec) == PRETEND
8978 && sec->sec_info_type != ELF_INFO_TYPE_STABS
8979 && target_sec != NULL
8980 && elf_discarded_section (target_sec))
8982 /* It would be natural to call _bfd_elf_check_kept_section
8983 here, but it's not exported from elflink.c. It's also a
8984 fairly expensive check. Adjusting the relocations to the
8985 discarded section is fairly harmless; it will only adjust
8986 some addends and difference values. If it turns out that
8987 _bfd_elf_check_kept_section fails later, it won't matter,
8988 so just compare the section names to find the right group
8990 asection *kept = target_sec->kept_section;
8993 if ((kept->flags & SEC_GROUP) != 0)
8995 asection *first = elf_next_in_group (kept);
8996 asection *s = first;
9001 if (strcmp (s->name, target_sec->name) == 0)
9006 s = elf_next_in_group (s);
9013 && ((target_sec->rawsize != 0
9014 ? target_sec->rawsize : target_sec->size)
9015 == (kept->rawsize != 0 ? kept->rawsize : kept->size)))
9019 target_relax_info = get_xtensa_relax_info (target_sec);
9020 if (target_relax_info
9021 && (target_relax_info->is_relaxable_literal_section
9022 || target_relax_info->is_relaxable_asm_section))
9025 target_sec = translate_reloc (&r_rel, &new_reloc, target_sec);
9027 if (r_type == R_XTENSA_DIFF8
9028 || r_type == R_XTENSA_DIFF16
9029 || r_type == R_XTENSA_DIFF32)
9031 bfd_vma diff_value = 0, new_end_offset, diff_mask = 0;
9033 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
9035 (*link_info->callbacks->reloc_dangerous)
9036 (link_info, _("invalid relocation address"),
9037 abfd, sec, old_source_offset);
9043 case R_XTENSA_DIFF8:
9045 bfd_get_8 (abfd, &contents[old_source_offset]);
9047 case R_XTENSA_DIFF16:
9049 bfd_get_16 (abfd, &contents[old_source_offset]);
9051 case R_XTENSA_DIFF32:
9053 bfd_get_32 (abfd, &contents[old_source_offset]);
9057 new_end_offset = offset_with_removed_text
9058 (&target_relax_info->action_list,
9059 r_rel.target_offset + diff_value);
9060 diff_value = new_end_offset - new_reloc.target_offset;
9064 case R_XTENSA_DIFF8:
9066 bfd_put_8 (abfd, diff_value,
9067 &contents[old_source_offset]);
9069 case R_XTENSA_DIFF16:
9071 bfd_put_16 (abfd, diff_value,
9072 &contents[old_source_offset]);
9074 case R_XTENSA_DIFF32:
9075 diff_mask = 0xffffffff;
9076 bfd_put_32 (abfd, diff_value,
9077 &contents[old_source_offset]);
9081 /* Check for overflow. */
9082 if ((diff_value & ~diff_mask) != 0)
9084 (*link_info->callbacks->reloc_dangerous)
9085 (link_info, _("overflow after relaxation"),
9086 abfd, sec, old_source_offset);
9090 pin_contents (sec, contents);
9093 /* If the relocation still references a section in the same
9094 input file, modify the relocation directly instead of
9095 adding a "fix" record. */
9096 if (target_sec->owner == abfd)
9098 unsigned r_symndx = ELF32_R_SYM (new_reloc.rela.r_info);
9099 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
9100 irel->r_addend = new_reloc.rela.r_addend;
9101 pin_internal_relocs (sec, internal_relocs);
9105 bfd_vma addend_displacement;
9108 addend_displacement =
9109 new_reloc.target_offset + new_reloc.virtual_offset;
9110 fix = reloc_bfd_fix_init (sec, source_offset, r_type,
9112 addend_displacement, TRUE);
9119 if ((relax_info->is_relaxable_literal_section
9120 || relax_info->is_relaxable_asm_section)
9121 && relax_info->action_list.head)
9123 /* Walk through the planned actions and build up a table
9124 of move, copy and fill records. Use the move, copy and
9125 fill records to perform the actions once. */
9128 bfd_size_type final_size, copy_size, orig_insn_size;
9129 bfd_byte *scratch = NULL;
9130 bfd_byte *dup_contents = NULL;
9131 bfd_size_type orig_size = sec->size;
9132 bfd_vma orig_dot = 0;
9133 bfd_vma orig_dot_copied = 0; /* Byte copied already from
9134 orig dot in physical memory. */
9135 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
9136 bfd_vma dup_dot = 0;
9138 text_action *action = relax_info->action_list.head;
9140 final_size = sec->size;
9141 for (action = relax_info->action_list.head; action;
9142 action = action->next)
9144 final_size -= action->removed_bytes;
9147 scratch = (bfd_byte *) bfd_zmalloc (final_size);
9148 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
9150 /* The dot is the current fill location. */
9152 print_action_list (stderr, &relax_info->action_list);
9155 for (action = relax_info->action_list.head; action;
9156 action = action->next)
9158 virtual_action = FALSE;
9159 if (action->offset > orig_dot)
9161 orig_dot += orig_dot_copied;
9162 orig_dot_copied = 0;
9164 /* Out of the virtual world. */
9167 if (action->offset > orig_dot)
9169 copy_size = action->offset - orig_dot;
9170 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9171 orig_dot += copy_size;
9172 dup_dot += copy_size;
9173 BFD_ASSERT (action->offset == orig_dot);
9175 else if (action->offset < orig_dot)
9177 if (action->action == ta_fill
9178 && action->offset - action->removed_bytes == orig_dot)
9180 /* This is OK because the fill only effects the dup_dot. */
9182 else if (action->action == ta_add_literal)
9184 /* TBD. Might need to handle this. */
9187 if (action->offset == orig_dot)
9189 if (action->virtual_offset > orig_dot_vo)
9191 if (orig_dot_vo == 0)
9193 /* Need to copy virtual_offset bytes. Probably four. */
9194 copy_size = action->virtual_offset - orig_dot_vo;
9195 memmove (&dup_contents[dup_dot],
9196 &contents[orig_dot], copy_size);
9197 orig_dot_copied = copy_size;
9198 dup_dot += copy_size;
9200 virtual_action = TRUE;
9203 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
9205 switch (action->action)
9207 case ta_remove_literal:
9208 case ta_remove_insn:
9209 BFD_ASSERT (action->removed_bytes >= 0);
9210 orig_dot += action->removed_bytes;
9213 case ta_narrow_insn:
9216 memmove (scratch, &contents[orig_dot], orig_insn_size);
9217 BFD_ASSERT (action->removed_bytes == 1);
9218 rv = narrow_instruction (scratch, final_size, 0);
9220 memmove (&dup_contents[dup_dot], scratch, copy_size);
9221 orig_dot += orig_insn_size;
9222 dup_dot += copy_size;
9226 if (action->removed_bytes >= 0)
9227 orig_dot += action->removed_bytes;
9230 /* Already zeroed in dup_contents. Just bump the
9232 dup_dot += (-action->removed_bytes);
9237 BFD_ASSERT (action->removed_bytes == 0);
9240 case ta_convert_longcall:
9241 case ta_remove_longcall:
9242 /* These will be removed or converted before we get here. */
9249 memmove (scratch, &contents[orig_dot], orig_insn_size);
9250 BFD_ASSERT (action->removed_bytes == -1);
9251 rv = widen_instruction (scratch, final_size, 0);
9253 memmove (&dup_contents[dup_dot], scratch, copy_size);
9254 orig_dot += orig_insn_size;
9255 dup_dot += copy_size;
9258 case ta_add_literal:
9261 BFD_ASSERT (action->removed_bytes == -4);
9262 /* TBD -- place the literal value here and insert
9264 memset (&dup_contents[dup_dot], 0, 4);
9265 pin_internal_relocs (sec, internal_relocs);
9266 pin_contents (sec, contents);
9268 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
9269 relax_info, &internal_relocs, &action->value))
9273 orig_dot_vo += copy_size;
9275 orig_dot += orig_insn_size;
9276 dup_dot += copy_size;
9280 /* Not implemented yet. */
9285 removed += action->removed_bytes;
9286 BFD_ASSERT (dup_dot <= final_size);
9287 BFD_ASSERT (orig_dot <= orig_size);
9290 orig_dot += orig_dot_copied;
9291 orig_dot_copied = 0;
9293 if (orig_dot != orig_size)
9295 copy_size = orig_size - orig_dot;
9296 BFD_ASSERT (orig_size > orig_dot);
9297 BFD_ASSERT (dup_dot + copy_size == final_size);
9298 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9299 orig_dot += copy_size;
9300 dup_dot += copy_size;
9302 BFD_ASSERT (orig_size == orig_dot);
9303 BFD_ASSERT (final_size == dup_dot);
9305 /* Move the dup_contents back. */
9306 if (final_size > orig_size)
9308 /* Contents need to be reallocated. Swap the dup_contents into
9310 sec->contents = dup_contents;
9312 contents = dup_contents;
9313 pin_contents (sec, contents);
9317 BFD_ASSERT (final_size <= orig_size);
9318 memset (contents, 0, orig_size);
9319 memcpy (contents, dup_contents, final_size);
9320 free (dup_contents);
9323 pin_contents (sec, contents);
9325 if (sec->rawsize == 0)
9326 sec->rawsize = sec->size;
9327 sec->size = final_size;
9331 release_internal_relocs (sec, internal_relocs);
9332 release_contents (sec, contents);
9338 translate_section_fixes (asection *sec)
9340 xtensa_relax_info *relax_info;
9343 relax_info = get_xtensa_relax_info (sec);
9347 for (r = relax_info->fix_list; r != NULL; r = r->next)
9348 if (!translate_reloc_bfd_fix (r))
9355 /* Translate a fix given the mapping in the relax info for the target
9356 section. If it has already been translated, no work is required. */
9359 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
9361 reloc_bfd_fix new_fix;
9363 xtensa_relax_info *relax_info;
9364 removed_literal *removed;
9365 bfd_vma new_offset, target_offset;
9367 if (fix->translated)
9370 sec = fix->target_sec;
9371 target_offset = fix->target_offset;
9373 relax_info = get_xtensa_relax_info (sec);
9376 fix->translated = TRUE;
9382 /* The fix does not need to be translated if the section cannot change. */
9383 if (!relax_info->is_relaxable_literal_section
9384 && !relax_info->is_relaxable_asm_section)
9386 fix->translated = TRUE;
9390 /* If the literal has been moved and this relocation was on an
9391 opcode, then the relocation should move to the new literal
9392 location. Otherwise, the relocation should move within the
9396 if (is_operand_relocation (fix->src_type))
9398 /* Check if the original relocation is against a literal being
9400 removed = find_removed_literal (&relax_info->removed_list,
9408 /* The fact that there is still a relocation to this literal indicates
9409 that the literal is being coalesced, not simply removed. */
9410 BFD_ASSERT (removed->to.abfd != NULL);
9412 /* This was moved to some other address (possibly another section). */
9413 new_sec = r_reloc_get_section (&removed->to);
9417 relax_info = get_xtensa_relax_info (sec);
9419 (!relax_info->is_relaxable_literal_section
9420 && !relax_info->is_relaxable_asm_section))
9422 target_offset = removed->to.target_offset;
9423 new_fix.target_sec = new_sec;
9424 new_fix.target_offset = target_offset;
9425 new_fix.translated = TRUE;
9430 target_offset = removed->to.target_offset;
9431 new_fix.target_sec = new_sec;
9434 /* The target address may have been moved within its section. */
9435 new_offset = offset_with_removed_text (&relax_info->action_list,
9438 new_fix.target_offset = new_offset;
9439 new_fix.target_offset = new_offset;
9440 new_fix.translated = TRUE;
9446 /* Fix up a relocation to take account of removed literals. */
9449 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec)
9451 xtensa_relax_info *relax_info;
9452 removed_literal *removed;
9453 bfd_vma target_offset, base_offset;
9456 *new_rel = *orig_rel;
9458 if (!r_reloc_is_defined (orig_rel))
9461 relax_info = get_xtensa_relax_info (sec);
9462 BFD_ASSERT (relax_info && (relax_info->is_relaxable_literal_section
9463 || relax_info->is_relaxable_asm_section));
9465 target_offset = orig_rel->target_offset;
9468 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
9470 /* Check if the original relocation is against a literal being
9472 removed = find_removed_literal (&relax_info->removed_list,
9475 if (removed && removed->to.abfd)
9479 /* The fact that there is still a relocation to this literal indicates
9480 that the literal is being coalesced, not simply removed. */
9481 BFD_ASSERT (removed->to.abfd != NULL);
9483 /* This was moved to some other address
9484 (possibly in another section). */
9485 *new_rel = removed->to;
9486 new_sec = r_reloc_get_section (new_rel);
9490 relax_info = get_xtensa_relax_info (sec);
9492 || (!relax_info->is_relaxable_literal_section
9493 && !relax_info->is_relaxable_asm_section))
9496 target_offset = new_rel->target_offset;
9499 /* Find the base offset of the reloc symbol, excluding any addend from the
9500 reloc or from the section contents (for a partial_inplace reloc). Then
9501 find the adjusted values of the offsets due to relaxation. The base
9502 offset is needed to determine the change to the reloc's addend; the reloc
9503 addend should not be adjusted due to relaxations located before the base
9506 base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend;
9507 act = relax_info->action_list.head;
9508 if (base_offset <= target_offset)
9510 int base_removed = removed_by_actions (&act, base_offset, FALSE);
9511 int addend_removed = removed_by_actions (&act, target_offset, FALSE);
9512 new_rel->target_offset = target_offset - base_removed - addend_removed;
9513 new_rel->rela.r_addend -= addend_removed;
9517 /* Handle a negative addend. The base offset comes first. */
9518 int tgt_removed = removed_by_actions (&act, target_offset, FALSE);
9519 int addend_removed = removed_by_actions (&act, base_offset, FALSE);
9520 new_rel->target_offset = target_offset - tgt_removed;
9521 new_rel->rela.r_addend += addend_removed;
9528 /* For dynamic links, there may be a dynamic relocation for each
9529 literal. The number of dynamic relocations must be computed in
9530 size_dynamic_sections, which occurs before relaxation. When a
9531 literal is removed, this function checks if there is a corresponding
9532 dynamic relocation and shrinks the size of the appropriate dynamic
9533 relocation section accordingly. At this point, the contents of the
9534 dynamic relocation sections have not yet been filled in, so there's
9535 nothing else that needs to be done. */
9538 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
9540 asection *input_section,
9541 Elf_Internal_Rela *rel)
9543 struct elf_xtensa_link_hash_table *htab;
9544 Elf_Internal_Shdr *symtab_hdr;
9545 struct elf_link_hash_entry **sym_hashes;
9546 unsigned long r_symndx;
9548 struct elf_link_hash_entry *h;
9549 bfd_boolean dynamic_symbol;
9551 htab = elf_xtensa_hash_table (info);
9555 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9556 sym_hashes = elf_sym_hashes (abfd);
9558 r_type = ELF32_R_TYPE (rel->r_info);
9559 r_symndx = ELF32_R_SYM (rel->r_info);
9561 if (r_symndx < symtab_hdr->sh_info)
9564 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9566 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
9568 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
9569 && (input_section->flags & SEC_ALLOC) != 0
9570 && (dynamic_symbol || info->shared))
9573 bfd_boolean is_plt = FALSE;
9575 if (dynamic_symbol && r_type == R_XTENSA_PLT)
9577 srel = htab->srelplt;
9581 srel = htab->srelgot;
9583 /* Reduce size of the .rela.* section by one reloc. */
9584 BFD_ASSERT (srel != NULL);
9585 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
9586 srel->size -= sizeof (Elf32_External_Rela);
9590 asection *splt, *sgotplt, *srelgot;
9591 int reloc_index, chunk;
9593 /* Find the PLT reloc index of the entry being removed. This
9594 is computed from the size of ".rela.plt". It is needed to
9595 figure out which PLT chunk to resize. Usually "last index
9596 = size - 1" since the index starts at zero, but in this
9597 context, the size has just been decremented so there's no
9598 need to subtract one. */
9599 reloc_index = srel->size / sizeof (Elf32_External_Rela);
9601 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
9602 splt = elf_xtensa_get_plt_section (info, chunk);
9603 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
9604 BFD_ASSERT (splt != NULL && sgotplt != NULL);
9606 /* Check if an entire PLT chunk has just been eliminated. */
9607 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
9609 /* The two magic GOT entries for that chunk can go away. */
9610 srelgot = htab->srelgot;
9611 BFD_ASSERT (srelgot != NULL);
9612 srelgot->reloc_count -= 2;
9613 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
9616 /* There should be only one entry left (and it will be
9618 BFD_ASSERT (sgotplt->size == 4);
9619 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
9622 BFD_ASSERT (sgotplt->size >= 4);
9623 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
9626 splt->size -= PLT_ENTRY_SIZE;
9632 /* Take an r_rel and move it to another section. This usually
9633 requires extending the interal_relocation array and pinning it. If
9634 the original r_rel is from the same BFD, we can complete this here.
9635 Otherwise, we add a fix record to let the final link fix the
9636 appropriate address. Contents and internal relocations for the
9637 section must be pinned after calling this routine. */
9640 move_literal (bfd *abfd,
9641 struct bfd_link_info *link_info,
9645 xtensa_relax_info *relax_info,
9646 Elf_Internal_Rela **internal_relocs_p,
9647 const literal_value *lit)
9649 Elf_Internal_Rela *new_relocs = NULL;
9650 size_t new_relocs_count = 0;
9651 Elf_Internal_Rela this_rela;
9652 const r_reloc *r_rel;
9654 r_rel = &lit->r_rel;
9655 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
9657 if (r_reloc_is_const (r_rel))
9658 bfd_put_32 (abfd, lit->value, contents + offset);
9663 asection *target_sec;
9667 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
9668 target_sec = r_reloc_get_section (r_rel);
9670 /* This is the difficult case. We have to create a fix up. */
9671 this_rela.r_offset = offset;
9672 this_rela.r_info = ELF32_R_INFO (0, r_type);
9673 this_rela.r_addend =
9674 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
9675 bfd_put_32 (abfd, lit->value, contents + offset);
9677 /* Currently, we cannot move relocations during a relocatable link. */
9678 BFD_ASSERT (!link_info->relocatable);
9679 fix = reloc_bfd_fix_init (sec, offset, r_type,
9680 r_reloc_get_section (r_rel),
9681 r_rel->target_offset + r_rel->virtual_offset,
9683 /* We also need to mark that relocations are needed here. */
9684 sec->flags |= SEC_RELOC;
9686 translate_reloc_bfd_fix (fix);
9687 /* This fix has not yet been translated. */
9690 /* Add the relocation. If we have already allocated our own
9691 space for the relocations and we have room for more, then use
9692 it. Otherwise, allocate new space and move the literals. */
9693 insert_at = sec->reloc_count;
9694 for (i = 0; i < sec->reloc_count; ++i)
9696 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
9703 if (*internal_relocs_p != relax_info->allocated_relocs
9704 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
9706 BFD_ASSERT (relax_info->allocated_relocs == NULL
9707 || sec->reloc_count == relax_info->relocs_count);
9709 if (relax_info->allocated_relocs_count == 0)
9710 new_relocs_count = (sec->reloc_count + 2) * 2;
9712 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
9714 new_relocs = (Elf_Internal_Rela *)
9715 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
9719 /* We could handle this more quickly by finding the split point. */
9721 memcpy (new_relocs, *internal_relocs_p,
9722 insert_at * sizeof (Elf_Internal_Rela));
9724 new_relocs[insert_at] = this_rela;
9726 if (insert_at != sec->reloc_count)
9727 memcpy (new_relocs + insert_at + 1,
9728 (*internal_relocs_p) + insert_at,
9729 (sec->reloc_count - insert_at)
9730 * sizeof (Elf_Internal_Rela));
9732 if (*internal_relocs_p != relax_info->allocated_relocs)
9734 /* The first time we re-allocate, we can only free the
9735 old relocs if they were allocated with bfd_malloc.
9736 This is not true when keep_memory is in effect. */
9737 if (!link_info->keep_memory)
9738 free (*internal_relocs_p);
9741 free (*internal_relocs_p);
9742 relax_info->allocated_relocs = new_relocs;
9743 relax_info->allocated_relocs_count = new_relocs_count;
9744 elf_section_data (sec)->relocs = new_relocs;
9746 relax_info->relocs_count = sec->reloc_count;
9747 *internal_relocs_p = new_relocs;
9751 if (insert_at != sec->reloc_count)
9754 for (idx = sec->reloc_count; idx > insert_at; idx--)
9755 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
9757 (*internal_relocs_p)[insert_at] = this_rela;
9759 if (relax_info->allocated_relocs)
9760 relax_info->relocs_count = sec->reloc_count;
9767 /* This is similar to relax_section except that when a target is moved,
9768 we shift addresses up. We also need to modify the size. This
9769 algorithm does NOT allow for relocations into the middle of the
9770 property sections. */
9773 relax_property_section (bfd *abfd,
9775 struct bfd_link_info *link_info)
9777 Elf_Internal_Rela *internal_relocs;
9780 bfd_boolean ok = TRUE;
9781 bfd_boolean is_full_prop_section;
9782 size_t last_zfill_target_offset = 0;
9783 asection *last_zfill_target_sec = NULL;
9784 bfd_size_type sec_size;
9785 bfd_size_type entry_size;
9787 sec_size = bfd_get_section_limit (abfd, sec);
9788 internal_relocs = retrieve_internal_relocs (abfd, sec,
9789 link_info->keep_memory);
9790 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9791 if (contents == NULL && sec_size != 0)
9797 is_full_prop_section = xtensa_is_proptable_section (sec);
9798 if (is_full_prop_section)
9803 if (internal_relocs)
9805 for (i = 0; i < sec->reloc_count; i++)
9807 Elf_Internal_Rela *irel;
9808 xtensa_relax_info *target_relax_info;
9810 asection *target_sec;
9812 bfd_byte *size_p, *flags_p;
9814 /* Locally change the source address.
9815 Translate the target to the new target address.
9816 If it points to this section and has been removed, MOVE IT.
9817 Also, don't forget to modify the associated SIZE at
9820 irel = &internal_relocs[i];
9821 r_type = ELF32_R_TYPE (irel->r_info);
9822 if (r_type == R_XTENSA_NONE)
9825 /* Find the literal value. */
9826 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
9827 size_p = &contents[irel->r_offset + 4];
9829 if (is_full_prop_section)
9830 flags_p = &contents[irel->r_offset + 8];
9831 BFD_ASSERT (irel->r_offset + entry_size <= sec_size);
9833 target_sec = r_reloc_get_section (&val.r_rel);
9834 target_relax_info = get_xtensa_relax_info (target_sec);
9836 if (target_relax_info
9837 && (target_relax_info->is_relaxable_literal_section
9838 || target_relax_info->is_relaxable_asm_section ))
9840 /* Translate the relocation's destination. */
9841 bfd_vma old_offset = val.r_rel.target_offset;
9843 long old_size, new_size;
9844 text_action *act = target_relax_info->action_list.head;
9845 new_offset = old_offset -
9846 removed_by_actions (&act, old_offset, FALSE);
9848 /* Assert that we are not out of bounds. */
9849 old_size = bfd_get_32 (abfd, size_p);
9850 new_size = old_size;
9854 /* Only the first zero-sized unreachable entry is
9855 allowed to expand. In this case the new offset
9856 should be the offset before the fill and the new
9857 size is the expansion size. For other zero-sized
9858 entries the resulting size should be zero with an
9859 offset before or after the fill address depending
9860 on whether the expanding unreachable entry
9862 if (last_zfill_target_sec == 0
9863 || last_zfill_target_sec != target_sec
9864 || last_zfill_target_offset != old_offset)
9866 bfd_vma new_end_offset = new_offset;
9868 /* Recompute the new_offset, but this time don't
9869 include any fill inserted by relaxation. */
9870 act = target_relax_info->action_list.head;
9871 new_offset = old_offset -
9872 removed_by_actions (&act, old_offset, TRUE);
9874 /* If it is not unreachable and we have not yet
9875 seen an unreachable at this address, place it
9876 before the fill address. */
9877 if (flags_p && (bfd_get_32 (abfd, flags_p)
9878 & XTENSA_PROP_UNREACHABLE) != 0)
9880 new_size = new_end_offset - new_offset;
9882 last_zfill_target_sec = target_sec;
9883 last_zfill_target_offset = old_offset;
9889 removed_by_actions (&act, old_offset + old_size, TRUE);
9891 if (new_size != old_size)
9893 bfd_put_32 (abfd, new_size, size_p);
9894 pin_contents (sec, contents);
9897 if (new_offset != old_offset)
9899 bfd_vma diff = new_offset - old_offset;
9900 irel->r_addend += diff;
9901 pin_internal_relocs (sec, internal_relocs);
9907 /* Combine adjacent property table entries. This is also done in
9908 finish_dynamic_sections() but at that point it's too late to
9909 reclaim the space in the output section, so we do this twice. */
9911 if (internal_relocs && (!link_info->relocatable
9912 || xtensa_is_littable_section (sec)))
9914 Elf_Internal_Rela *last_irel = NULL;
9915 Elf_Internal_Rela *irel, *next_rel, *rel_end;
9916 int removed_bytes = 0;
9918 flagword predef_flags;
9920 predef_flags = xtensa_get_property_predef_flags (sec);
9922 /* Walk over memory and relocations at the same time.
9923 This REQUIRES that the internal_relocs be sorted by offset. */
9924 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
9925 internal_reloc_compare);
9927 pin_internal_relocs (sec, internal_relocs);
9928 pin_contents (sec, contents);
9930 next_rel = internal_relocs;
9931 rel_end = internal_relocs + sec->reloc_count;
9933 BFD_ASSERT (sec->size % entry_size == 0);
9935 for (offset = 0; offset < sec->size; offset += entry_size)
9937 Elf_Internal_Rela *offset_rel, *extra_rel;
9938 bfd_vma bytes_to_remove, size, actual_offset;
9939 bfd_boolean remove_this_rel;
9942 /* Find the first relocation for the entry at the current offset.
9943 Adjust the offsets of any extra relocations for the previous
9948 for (irel = next_rel; irel < rel_end; irel++)
9950 if ((irel->r_offset == offset
9951 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9952 || irel->r_offset > offset)
9957 irel->r_offset -= removed_bytes;
9961 /* Find the next relocation (if there are any left). */
9965 for (irel = offset_rel + 1; irel < rel_end; irel++)
9967 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9975 /* Check if there are relocations on the current entry. There
9976 should usually be a relocation on the offset field. If there
9977 are relocations on the size or flags, then we can't optimize
9978 this entry. Also, find the next relocation to examine on the
9982 if (offset_rel->r_offset >= offset + entry_size)
9984 next_rel = offset_rel;
9985 /* There are no relocations on the current entry, but we
9986 might still be able to remove it if the size is zero. */
9989 else if (offset_rel->r_offset > offset
9991 && extra_rel->r_offset < offset + entry_size))
9993 /* There is a relocation on the size or flags, so we can't
9994 do anything with this entry. Continue with the next. */
9995 next_rel = offset_rel;
10000 BFD_ASSERT (offset_rel->r_offset == offset);
10001 offset_rel->r_offset -= removed_bytes;
10002 next_rel = offset_rel + 1;
10008 remove_this_rel = FALSE;
10009 bytes_to_remove = 0;
10010 actual_offset = offset - removed_bytes;
10011 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
10013 if (is_full_prop_section)
10014 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
10016 flags = predef_flags;
10019 && (flags & XTENSA_PROP_ALIGN) == 0
10020 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
10022 /* Always remove entries with zero size and no alignment. */
10023 bytes_to_remove = entry_size;
10025 remove_this_rel = TRUE;
10027 else if (offset_rel
10028 && ELF32_R_TYPE (offset_rel->r_info) == R_XTENSA_32)
10032 flagword old_flags;
10034 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
10035 bfd_vma old_address =
10036 (last_irel->r_addend
10037 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
10038 bfd_vma new_address =
10039 (offset_rel->r_addend
10040 + bfd_get_32 (abfd, &contents[actual_offset]));
10041 if (is_full_prop_section)
10042 old_flags = bfd_get_32
10043 (abfd, &contents[last_irel->r_offset + 8]);
10045 old_flags = predef_flags;
10047 if ((ELF32_R_SYM (offset_rel->r_info)
10048 == ELF32_R_SYM (last_irel->r_info))
10049 && old_address + old_size == new_address
10050 && old_flags == flags
10051 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
10052 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
10054 /* Fix the old size. */
10055 bfd_put_32 (abfd, old_size + size,
10056 &contents[last_irel->r_offset + 4]);
10057 bytes_to_remove = entry_size;
10058 remove_this_rel = TRUE;
10061 last_irel = offset_rel;
10064 last_irel = offset_rel;
10067 if (remove_this_rel)
10069 offset_rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
10070 offset_rel->r_offset = 0;
10073 if (bytes_to_remove != 0)
10075 removed_bytes += bytes_to_remove;
10076 if (offset + bytes_to_remove < sec->size)
10077 memmove (&contents[actual_offset],
10078 &contents[actual_offset + bytes_to_remove],
10079 sec->size - offset - bytes_to_remove);
10085 /* Fix up any extra relocations on the last entry. */
10086 for (irel = next_rel; irel < rel_end; irel++)
10087 irel->r_offset -= removed_bytes;
10089 /* Clear the removed bytes. */
10090 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
10092 if (sec->rawsize == 0)
10093 sec->rawsize = sec->size;
10094 sec->size -= removed_bytes;
10096 if (xtensa_is_littable_section (sec))
10098 asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
10100 sgotloc->size -= removed_bytes;
10106 release_internal_relocs (sec, internal_relocs);
10107 release_contents (sec, contents);
10112 /* Third relaxation pass. */
10114 /* Change symbol values to account for removed literals. */
10117 relax_section_symbols (bfd *abfd, asection *sec)
10119 xtensa_relax_info *relax_info;
10120 unsigned int sec_shndx;
10121 Elf_Internal_Shdr *symtab_hdr;
10122 Elf_Internal_Sym *isymbuf;
10123 unsigned i, num_syms, num_locals;
10125 relax_info = get_xtensa_relax_info (sec);
10126 BFD_ASSERT (relax_info);
10128 if (!relax_info->is_relaxable_literal_section
10129 && !relax_info->is_relaxable_asm_section)
10132 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
10134 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10135 isymbuf = retrieve_local_syms (abfd);
10137 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
10138 num_locals = symtab_hdr->sh_info;
10140 /* Adjust the local symbols defined in this section. */
10141 for (i = 0; i < num_locals; i++)
10143 Elf_Internal_Sym *isym = &isymbuf[i];
10145 if (isym->st_shndx == sec_shndx)
10147 text_action *act = relax_info->action_list.head;
10148 bfd_vma orig_addr = isym->st_value;
10150 isym->st_value -= removed_by_actions (&act, orig_addr, FALSE);
10152 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
10154 removed_by_actions (&act, orig_addr + isym->st_size, FALSE);
10158 /* Now adjust the global symbols defined in this section. */
10159 for (i = 0; i < (num_syms - num_locals); i++)
10161 struct elf_link_hash_entry *sym_hash;
10163 sym_hash = elf_sym_hashes (abfd)[i];
10165 if (sym_hash->root.type == bfd_link_hash_warning)
10166 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
10168 if ((sym_hash->root.type == bfd_link_hash_defined
10169 || sym_hash->root.type == bfd_link_hash_defweak)
10170 && sym_hash->root.u.def.section == sec)
10172 text_action *act = relax_info->action_list.head;
10173 bfd_vma orig_addr = sym_hash->root.u.def.value;
10175 sym_hash->root.u.def.value -=
10176 removed_by_actions (&act, orig_addr, FALSE);
10178 if (sym_hash->type == STT_FUNC)
10180 removed_by_actions (&act, orig_addr + sym_hash->size, FALSE);
10188 /* "Fix" handling functions, called while performing relocations. */
10191 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
10193 asection *input_section,
10194 bfd_byte *contents)
10197 asection *sec, *old_sec;
10198 bfd_vma old_offset;
10199 int r_type = ELF32_R_TYPE (rel->r_info);
10200 reloc_bfd_fix *fix;
10202 if (r_type == R_XTENSA_NONE)
10205 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10209 r_reloc_init (&r_rel, input_bfd, rel, contents,
10210 bfd_get_section_limit (input_bfd, input_section));
10211 old_sec = r_reloc_get_section (&r_rel);
10212 old_offset = r_rel.target_offset;
10214 if (!old_sec || !r_reloc_is_defined (&r_rel))
10216 if (r_type != R_XTENSA_ASM_EXPAND)
10218 (*_bfd_error_handler)
10219 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
10220 input_bfd, input_section, rel->r_offset,
10221 elf_howto_table[r_type].name);
10224 /* Leave it be. Resolution will happen in a later stage. */
10228 sec = fix->target_sec;
10229 rel->r_addend += ((sec->output_offset + fix->target_offset)
10230 - (old_sec->output_offset + old_offset));
10237 do_fix_for_final_link (Elf_Internal_Rela *rel,
10239 asection *input_section,
10240 bfd_byte *contents,
10241 bfd_vma *relocationp)
10244 int r_type = ELF32_R_TYPE (rel->r_info);
10245 reloc_bfd_fix *fix;
10246 bfd_vma fixup_diff;
10248 if (r_type == R_XTENSA_NONE)
10251 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10255 sec = fix->target_sec;
10257 fixup_diff = rel->r_addend;
10258 if (elf_howto_table[fix->src_type].partial_inplace)
10260 bfd_vma inplace_val;
10261 BFD_ASSERT (fix->src_offset
10262 < bfd_get_section_limit (input_bfd, input_section));
10263 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
10264 fixup_diff += inplace_val;
10267 *relocationp = (sec->output_section->vma
10268 + sec->output_offset
10269 + fix->target_offset - fixup_diff);
10273 /* Miscellaneous utility functions.... */
10276 elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
10278 struct elf_xtensa_link_hash_table *htab;
10284 htab = elf_xtensa_hash_table (info);
10291 dynobj = elf_hash_table (info)->dynobj;
10292 sprintf (plt_name, ".plt.%u", chunk);
10293 return bfd_get_section_by_name (dynobj, plt_name);
10298 elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
10300 struct elf_xtensa_link_hash_table *htab;
10306 htab = elf_xtensa_hash_table (info);
10309 return htab->sgotplt;
10312 dynobj = elf_hash_table (info)->dynobj;
10313 sprintf (got_name, ".got.plt.%u", chunk);
10314 return bfd_get_section_by_name (dynobj, got_name);
10318 /* Get the input section for a given symbol index.
10320 . a section symbol, return the section;
10321 . a common symbol, return the common section;
10322 . an undefined symbol, return the undefined section;
10323 . an indirect symbol, follow the links;
10324 . an absolute value, return the absolute section. */
10327 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
10329 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10330 asection *target_sec = NULL;
10331 if (r_symndx < symtab_hdr->sh_info)
10333 Elf_Internal_Sym *isymbuf;
10334 unsigned int section_index;
10336 isymbuf = retrieve_local_syms (abfd);
10337 section_index = isymbuf[r_symndx].st_shndx;
10339 if (section_index == SHN_UNDEF)
10340 target_sec = bfd_und_section_ptr;
10341 else if (section_index == SHN_ABS)
10342 target_sec = bfd_abs_section_ptr;
10343 else if (section_index == SHN_COMMON)
10344 target_sec = bfd_com_section_ptr;
10346 target_sec = bfd_section_from_elf_index (abfd, section_index);
10350 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10351 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
10353 while (h->root.type == bfd_link_hash_indirect
10354 || h->root.type == bfd_link_hash_warning)
10355 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10357 switch (h->root.type)
10359 case bfd_link_hash_defined:
10360 case bfd_link_hash_defweak:
10361 target_sec = h->root.u.def.section;
10363 case bfd_link_hash_common:
10364 target_sec = bfd_com_section_ptr;
10366 case bfd_link_hash_undefined:
10367 case bfd_link_hash_undefweak:
10368 target_sec = bfd_und_section_ptr;
10370 default: /* New indirect warning. */
10371 target_sec = bfd_und_section_ptr;
10379 static struct elf_link_hash_entry *
10380 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
10382 unsigned long indx;
10383 struct elf_link_hash_entry *h;
10384 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10386 if (r_symndx < symtab_hdr->sh_info)
10389 indx = r_symndx - symtab_hdr->sh_info;
10390 h = elf_sym_hashes (abfd)[indx];
10391 while (h->root.type == bfd_link_hash_indirect
10392 || h->root.type == bfd_link_hash_warning)
10393 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10398 /* Get the section-relative offset for a symbol number. */
10401 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
10403 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10404 bfd_vma offset = 0;
10406 if (r_symndx < symtab_hdr->sh_info)
10408 Elf_Internal_Sym *isymbuf;
10409 isymbuf = retrieve_local_syms (abfd);
10410 offset = isymbuf[r_symndx].st_value;
10414 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10415 struct elf_link_hash_entry *h =
10416 elf_sym_hashes (abfd)[indx];
10418 while (h->root.type == bfd_link_hash_indirect
10419 || h->root.type == bfd_link_hash_warning)
10420 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10421 if (h->root.type == bfd_link_hash_defined
10422 || h->root.type == bfd_link_hash_defweak)
10423 offset = h->root.u.def.value;
10430 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
10432 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
10433 struct elf_link_hash_entry *h;
10435 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
10436 if (h && h->root.type == bfd_link_hash_defweak)
10443 pcrel_reloc_fits (xtensa_opcode opc,
10445 bfd_vma self_address,
10446 bfd_vma dest_address)
10448 xtensa_isa isa = xtensa_default_isa;
10449 uint32 valp = dest_address;
10450 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
10451 || xtensa_operand_encode (isa, opc, opnd, &valp))
10458 xtensa_is_property_section (asection *sec)
10460 if (xtensa_is_insntable_section (sec)
10461 || xtensa_is_littable_section (sec)
10462 || xtensa_is_proptable_section (sec))
10470 xtensa_is_insntable_section (asection *sec)
10472 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
10473 || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
10481 xtensa_is_littable_section (asection *sec)
10483 if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
10484 || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
10492 xtensa_is_proptable_section (asection *sec)
10494 if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
10495 || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
10503 internal_reloc_compare (const void *ap, const void *bp)
10505 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10506 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10508 if (a->r_offset != b->r_offset)
10509 return (a->r_offset - b->r_offset);
10511 /* We don't need to sort on these criteria for correctness,
10512 but enforcing a more strict ordering prevents unstable qsort
10513 from behaving differently with different implementations.
10514 Without the code below we get correct but different results
10515 on Solaris 2.7 and 2.8. We would like to always produce the
10516 same results no matter the host. */
10518 if (a->r_info != b->r_info)
10519 return (a->r_info - b->r_info);
10521 return (a->r_addend - b->r_addend);
10526 internal_reloc_matches (const void *ap, const void *bp)
10528 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10529 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10531 /* Check if one entry overlaps with the other; this shouldn't happen
10532 except when searching for a match. */
10533 return (a->r_offset - b->r_offset);
10537 /* Predicate function used to look up a section in a particular group. */
10540 match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
10542 const char *gname = inf;
10543 const char *group_name = elf_group_name (sec);
10545 return (group_name == gname
10546 || (group_name != NULL
10548 && strcmp (group_name, gname) == 0));
10552 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
10555 xtensa_property_section_name (asection *sec, const char *base_name)
10557 const char *suffix, *group_name;
10558 char *prop_sec_name;
10560 group_name = elf_group_name (sec);
10563 suffix = strrchr (sec->name, '.');
10564 if (suffix == sec->name)
10566 prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
10567 + (suffix ? strlen (suffix) : 0));
10568 strcpy (prop_sec_name, base_name);
10570 strcat (prop_sec_name, suffix);
10572 else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
10574 char *linkonce_kind = 0;
10576 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
10577 linkonce_kind = "x.";
10578 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
10579 linkonce_kind = "p.";
10580 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
10581 linkonce_kind = "prop.";
10585 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
10586 + strlen (linkonce_kind) + 1);
10587 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
10588 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
10590 suffix = sec->name + linkonce_len;
10591 /* For backward compatibility, replace "t." instead of inserting
10592 the new linkonce_kind (but not for "prop" sections). */
10593 if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
10595 strcat (prop_sec_name + linkonce_len, suffix);
10598 prop_sec_name = strdup (base_name);
10600 return prop_sec_name;
10605 xtensa_get_property_section (asection *sec, const char *base_name)
10607 char *prop_sec_name;
10608 asection *prop_sec;
10610 prop_sec_name = xtensa_property_section_name (sec, base_name);
10611 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10612 match_section_group,
10613 (void *) elf_group_name (sec));
10614 free (prop_sec_name);
10620 xtensa_make_property_section (asection *sec, const char *base_name)
10622 char *prop_sec_name;
10623 asection *prop_sec;
10625 /* Check if the section already exists. */
10626 prop_sec_name = xtensa_property_section_name (sec, base_name);
10627 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10628 match_section_group,
10629 (void *) elf_group_name (sec));
10630 /* If not, create it. */
10633 flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
10634 flags |= (bfd_get_section_flags (sec->owner, sec)
10635 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
10637 prop_sec = bfd_make_section_anyway_with_flags
10638 (sec->owner, strdup (prop_sec_name), flags);
10642 elf_group_name (prop_sec) = elf_group_name (sec);
10645 free (prop_sec_name);
10651 xtensa_get_property_predef_flags (asection *sec)
10653 if (xtensa_is_insntable_section (sec))
10654 return (XTENSA_PROP_INSN
10655 | XTENSA_PROP_NO_TRANSFORM
10656 | XTENSA_PROP_INSN_NO_REORDER);
10658 if (xtensa_is_littable_section (sec))
10659 return (XTENSA_PROP_LITERAL
10660 | XTENSA_PROP_NO_TRANSFORM
10661 | XTENSA_PROP_INSN_NO_REORDER);
10667 /* Other functions called directly by the linker. */
10670 xtensa_callback_required_dependence (bfd *abfd,
10672 struct bfd_link_info *link_info,
10673 deps_callback_t callback,
10676 Elf_Internal_Rela *internal_relocs;
10677 bfd_byte *contents;
10679 bfd_boolean ok = TRUE;
10680 bfd_size_type sec_size;
10682 sec_size = bfd_get_section_limit (abfd, sec);
10684 /* ".plt*" sections have no explicit relocations but they contain L32R
10685 instructions that reference the corresponding ".got.plt*" sections. */
10686 if ((sec->flags & SEC_LINKER_CREATED) != 0
10687 && CONST_STRNEQ (sec->name, ".plt"))
10691 /* Find the corresponding ".got.plt*" section. */
10692 if (sec->name[4] == '\0')
10693 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
10699 BFD_ASSERT (sec->name[4] == '.');
10700 chunk = strtol (&sec->name[5], NULL, 10);
10702 sprintf (got_name, ".got.plt.%u", chunk);
10703 sgotplt = bfd_get_section_by_name (sec->owner, got_name);
10705 BFD_ASSERT (sgotplt);
10707 /* Assume worst-case offsets: L32R at the very end of the ".plt"
10708 section referencing a literal at the very beginning of
10709 ".got.plt". This is very close to the real dependence, anyway. */
10710 (*callback) (sec, sec_size, sgotplt, 0, closure);
10713 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
10714 when building uclibc, which runs "ld -b binary /dev/null". */
10715 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
10718 internal_relocs = retrieve_internal_relocs (abfd, sec,
10719 link_info->keep_memory);
10720 if (internal_relocs == NULL
10721 || sec->reloc_count == 0)
10724 /* Cache the contents for the duration of this scan. */
10725 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
10726 if (contents == NULL && sec_size != 0)
10732 if (!xtensa_default_isa)
10733 xtensa_default_isa = xtensa_isa_init (0, 0);
10735 for (i = 0; i < sec->reloc_count; i++)
10737 Elf_Internal_Rela *irel = &internal_relocs[i];
10738 if (is_l32r_relocation (abfd, sec, contents, irel))
10741 asection *target_sec;
10742 bfd_vma target_offset;
10744 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
10747 /* L32Rs must be local to the input file. */
10748 if (r_reloc_is_defined (&l32r_rel))
10750 target_sec = r_reloc_get_section (&l32r_rel);
10751 target_offset = l32r_rel.target_offset;
10753 (*callback) (sec, irel->r_offset, target_sec, target_offset,
10759 release_internal_relocs (sec, internal_relocs);
10760 release_contents (sec, contents);
10764 /* The default literal sections should always be marked as "code" (i.e.,
10765 SHF_EXECINSTR). This is particularly important for the Linux kernel
10766 module loader so that the literals are not placed after the text. */
10767 static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
10769 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10770 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10771 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10772 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 },
10773 { NULL, 0, 0, 0, 0 }
10777 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
10778 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
10779 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
10780 #define TARGET_BIG_NAME "elf32-xtensa-be"
10781 #define ELF_ARCH bfd_arch_xtensa
10783 #define ELF_MACHINE_CODE EM_XTENSA
10784 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
10787 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
10788 #else /* !XCHAL_HAVE_MMU */
10789 #define ELF_MAXPAGESIZE 1
10790 #endif /* !XCHAL_HAVE_MMU */
10791 #endif /* ELF_ARCH */
10793 #define elf_backend_can_gc_sections 1
10794 #define elf_backend_can_refcount 1
10795 #define elf_backend_plt_readonly 1
10796 #define elf_backend_got_header_size 4
10797 #define elf_backend_want_dynbss 0
10798 #define elf_backend_want_got_plt 1
10800 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
10802 #define bfd_elf32_mkobject elf_xtensa_mkobject
10804 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
10805 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
10806 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
10807 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
10808 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
10809 #define bfd_elf32_bfd_reloc_name_lookup \
10810 elf_xtensa_reloc_name_lookup
10811 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
10812 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
10814 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
10815 #define elf_backend_check_relocs elf_xtensa_check_relocs
10816 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
10817 #define elf_backend_discard_info elf_xtensa_discard_info
10818 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
10819 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
10820 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
10821 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
10822 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
10823 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
10824 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
10825 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
10826 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
10827 #define elf_backend_object_p elf_xtensa_object_p
10828 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
10829 #define elf_backend_relocate_section elf_xtensa_relocate_section
10830 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
10831 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
10832 #define elf_backend_omit_section_dynsym \
10833 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
10834 #define elf_backend_special_sections elf_xtensa_special_sections
10835 #define elf_backend_action_discarded elf_xtensa_action_discarded
10836 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
10838 #include "elf32-target.h"