1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 2 of the
9 License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
30 #include "elf/xtensa.h"
31 #include "xtensa-isa.h"
32 #include "xtensa-config.h"
34 #define XTENSA_NO_NOP_REMOVAL 0
36 /* Local helper functions. */
38 static bfd_boolean add_extra_plt_sections (struct bfd_link_info *, int);
39 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
40 static bfd_reloc_status_type bfd_elf_xtensa_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_boolean do_fix_for_relocatable_link
43 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *);
44 static void do_fix_for_final_link
45 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *, bfd_vma *);
47 /* Local functions to handle Xtensa configurability. */
49 static bfd_boolean is_indirect_call_opcode (xtensa_opcode);
50 static bfd_boolean is_direct_call_opcode (xtensa_opcode);
51 static bfd_boolean is_windowed_call_opcode (xtensa_opcode);
52 static xtensa_opcode get_const16_opcode (void);
53 static xtensa_opcode get_l32r_opcode (void);
54 static bfd_vma l32r_offset (bfd_vma, bfd_vma);
55 static int get_relocation_opnd (xtensa_opcode, int);
56 static int get_relocation_slot (int);
57 static xtensa_opcode get_relocation_opcode
58 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
59 static bfd_boolean is_l32r_relocation
60 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
61 static bfd_boolean is_alt_relocation (int);
62 static bfd_boolean is_operand_relocation (int);
63 static bfd_size_type insn_decode_len
64 (bfd_byte *, bfd_size_type, bfd_size_type);
65 static xtensa_opcode insn_decode_opcode
66 (bfd_byte *, bfd_size_type, bfd_size_type, int);
67 static bfd_boolean check_branch_target_aligned
68 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
69 static bfd_boolean check_loop_aligned
70 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
71 static bfd_boolean check_branch_target_aligned_address (bfd_vma, int);
72 static bfd_size_type get_asm_simplify_size
73 (bfd_byte *, bfd_size_type, bfd_size_type);
75 /* Functions for link-time code simplifications. */
77 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
78 (bfd_byte *, bfd_vma, bfd_vma, char **);
79 static bfd_reloc_status_type contract_asm_expansion
80 (bfd_byte *, bfd_vma, Elf_Internal_Rela *, char **);
81 static xtensa_opcode swap_callx_for_call_opcode (xtensa_opcode);
82 static xtensa_opcode get_expanded_call_opcode (bfd_byte *, int, bfd_boolean *);
84 /* Access to internal relocations, section contents and symbols. */
86 static Elf_Internal_Rela *retrieve_internal_relocs
87 (bfd *, asection *, bfd_boolean);
88 static void pin_internal_relocs (asection *, Elf_Internal_Rela *);
89 static void release_internal_relocs (asection *, Elf_Internal_Rela *);
90 static bfd_byte *retrieve_contents (bfd *, asection *, bfd_boolean);
91 static void pin_contents (asection *, bfd_byte *);
92 static void release_contents (asection *, bfd_byte *);
93 static Elf_Internal_Sym *retrieve_local_syms (bfd *);
95 /* Miscellaneous utility functions. */
97 static asection *elf_xtensa_get_plt_section (struct bfd_link_info *, int);
98 static asection *elf_xtensa_get_gotplt_section (struct bfd_link_info *, int);
99 static asection *get_elf_r_symndx_section (bfd *, unsigned long);
100 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
101 (bfd *, unsigned long);
102 static bfd_vma get_elf_r_symndx_offset (bfd *, unsigned long);
103 static bfd_boolean is_reloc_sym_weak (bfd *, Elf_Internal_Rela *);
104 static bfd_boolean pcrel_reloc_fits (xtensa_opcode, int, bfd_vma, bfd_vma);
105 static bfd_boolean xtensa_is_property_section (asection *);
106 static bfd_boolean xtensa_is_littable_section (asection *);
107 static int internal_reloc_compare (const void *, const void *);
108 static int internal_reloc_matches (const void *, const void *);
109 extern asection *xtensa_get_property_section (asection *, const char *);
110 static flagword xtensa_get_property_predef_flags (asection *);
112 /* Other functions called directly by the linker. */
114 typedef void (*deps_callback_t)
115 (asection *, bfd_vma, asection *, bfd_vma, void *);
116 extern bfd_boolean xtensa_callback_required_dependence
117 (bfd *, asection *, struct bfd_link_info *, deps_callback_t, void *);
120 /* Globally visible flag for choosing size optimization of NOP removal
121 instead of branch-target-aware minimization for NOP removal.
122 When nonzero, narrow all instructions and remove all NOPs possible
123 around longcall expansions. */
125 int elf32xtensa_size_opt;
128 /* The "new_section_hook" is used to set up a per-section
129 "xtensa_relax_info" data structure with additional information used
130 during relaxation. */
132 typedef struct xtensa_relax_info_struct xtensa_relax_info;
135 /* The GNU tools do not easily allow extending interfaces to pass around
136 the pointer to the Xtensa ISA information, so instead we add a global
137 variable here (in BFD) that can be used by any of the tools that need
140 xtensa_isa xtensa_default_isa;
143 /* When this is true, relocations may have been modified to refer to
144 symbols from other input files. The per-section list of "fix"
145 records needs to be checked when resolving relocations. */
147 static bfd_boolean relaxing_section = FALSE;
149 /* When this is true, during final links, literals that cannot be
150 coalesced and their relocations may be moved to other sections. */
152 int elf32xtensa_no_literal_movement = 1;
155 static reloc_howto_type elf_howto_table[] =
157 HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
158 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
160 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
161 bfd_elf_xtensa_reloc, "R_XTENSA_32",
162 TRUE, 0xffffffff, 0xffffffff, FALSE),
164 /* Replace a 32-bit value with a value from the runtime linker (only
165 used by linker-generated stub functions). The r_addend value is
166 special: 1 means to substitute a pointer to the runtime linker's
167 dynamic resolver function; 2 means to substitute the link map for
168 the shared object. */
169 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
170 NULL, "R_XTENSA_RTLD", FALSE, 0, 0, FALSE),
172 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
173 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
174 FALSE, 0, 0xffffffff, FALSE),
175 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
176 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
177 FALSE, 0, 0xffffffff, FALSE),
178 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
179 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
180 FALSE, 0, 0xffffffff, FALSE),
181 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
182 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
183 FALSE, 0, 0xffffffff, FALSE),
187 /* Old relocations for backward compatibility. */
188 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
189 bfd_elf_xtensa_reloc, "R_XTENSA_OP0", FALSE, 0, 0, TRUE),
190 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
191 bfd_elf_xtensa_reloc, "R_XTENSA_OP1", FALSE, 0, 0, TRUE),
192 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
193 bfd_elf_xtensa_reloc, "R_XTENSA_OP2", FALSE, 0, 0, TRUE),
195 /* Assembly auto-expansion. */
196 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
197 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND", FALSE, 0, 0, TRUE),
198 /* Relax assembly auto-expansion. */
199 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
200 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY", FALSE, 0, 0, TRUE),
205 /* GNU extension to record C++ vtable hierarchy. */
206 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
207 NULL, "R_XTENSA_GNU_VTINHERIT",
209 /* GNU extension to record C++ vtable member usage. */
210 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
211 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
214 /* Relocations for supporting difference of symbols. */
215 HOWTO (R_XTENSA_DIFF8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
216 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF8", FALSE, 0, 0xff, FALSE),
217 HOWTO (R_XTENSA_DIFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
218 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF16", FALSE, 0, 0xffff, FALSE),
219 HOWTO (R_XTENSA_DIFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
220 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF32", FALSE, 0, 0xffffffff, FALSE),
222 /* General immediate operand relocations. */
223 HOWTO (R_XTENSA_SLOT0_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
224 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_OP", FALSE, 0, 0, TRUE),
225 HOWTO (R_XTENSA_SLOT1_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
226 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_OP", FALSE, 0, 0, TRUE),
227 HOWTO (R_XTENSA_SLOT2_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
228 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_OP", FALSE, 0, 0, TRUE),
229 HOWTO (R_XTENSA_SLOT3_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
230 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_OP", FALSE, 0, 0, TRUE),
231 HOWTO (R_XTENSA_SLOT4_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
232 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_OP", FALSE, 0, 0, TRUE),
233 HOWTO (R_XTENSA_SLOT5_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
234 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_OP", FALSE, 0, 0, TRUE),
235 HOWTO (R_XTENSA_SLOT6_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
236 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_OP", FALSE, 0, 0, TRUE),
237 HOWTO (R_XTENSA_SLOT7_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
238 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_OP", FALSE, 0, 0, TRUE),
239 HOWTO (R_XTENSA_SLOT8_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
240 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_OP", FALSE, 0, 0, TRUE),
241 HOWTO (R_XTENSA_SLOT9_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
242 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_OP", FALSE, 0, 0, TRUE),
243 HOWTO (R_XTENSA_SLOT10_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
244 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_OP", FALSE, 0, 0, TRUE),
245 HOWTO (R_XTENSA_SLOT11_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
246 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_OP", FALSE, 0, 0, TRUE),
247 HOWTO (R_XTENSA_SLOT12_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
248 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_OP", FALSE, 0, 0, TRUE),
249 HOWTO (R_XTENSA_SLOT13_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
250 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_OP", FALSE, 0, 0, TRUE),
251 HOWTO (R_XTENSA_SLOT14_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
252 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_OP", FALSE, 0, 0, TRUE),
254 /* "Alternate" relocations. The meaning of these is opcode-specific. */
255 HOWTO (R_XTENSA_SLOT0_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
256 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_ALT", FALSE, 0, 0, TRUE),
257 HOWTO (R_XTENSA_SLOT1_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
258 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_ALT", FALSE, 0, 0, TRUE),
259 HOWTO (R_XTENSA_SLOT2_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
260 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_ALT", FALSE, 0, 0, TRUE),
261 HOWTO (R_XTENSA_SLOT3_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
262 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_ALT", FALSE, 0, 0, TRUE),
263 HOWTO (R_XTENSA_SLOT4_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
264 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_ALT", FALSE, 0, 0, TRUE),
265 HOWTO (R_XTENSA_SLOT5_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
266 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_ALT", FALSE, 0, 0, TRUE),
267 HOWTO (R_XTENSA_SLOT6_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
268 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_ALT", FALSE, 0, 0, TRUE),
269 HOWTO (R_XTENSA_SLOT7_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
270 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_ALT", FALSE, 0, 0, TRUE),
271 HOWTO (R_XTENSA_SLOT8_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
272 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_ALT", FALSE, 0, 0, TRUE),
273 HOWTO (R_XTENSA_SLOT9_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
274 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_ALT", FALSE, 0, 0, TRUE),
275 HOWTO (R_XTENSA_SLOT10_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
276 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_ALT", FALSE, 0, 0, TRUE),
277 HOWTO (R_XTENSA_SLOT11_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
278 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_ALT", FALSE, 0, 0, TRUE),
279 HOWTO (R_XTENSA_SLOT12_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
280 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_ALT", FALSE, 0, 0, TRUE),
281 HOWTO (R_XTENSA_SLOT13_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
282 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_ALT", FALSE, 0, 0, TRUE),
283 HOWTO (R_XTENSA_SLOT14_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
284 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_ALT", FALSE, 0, 0, TRUE),
289 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
294 static reloc_howto_type *
295 elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
296 bfd_reloc_code_real_type code)
301 TRACE ("BFD_RELOC_NONE");
302 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
305 TRACE ("BFD_RELOC_32");
306 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
308 case BFD_RELOC_XTENSA_DIFF8:
309 TRACE ("BFD_RELOC_XTENSA_DIFF8");
310 return &elf_howto_table[(unsigned) R_XTENSA_DIFF8 ];
312 case BFD_RELOC_XTENSA_DIFF16:
313 TRACE ("BFD_RELOC_XTENSA_DIFF16");
314 return &elf_howto_table[(unsigned) R_XTENSA_DIFF16 ];
316 case BFD_RELOC_XTENSA_DIFF32:
317 TRACE ("BFD_RELOC_XTENSA_DIFF32");
318 return &elf_howto_table[(unsigned) R_XTENSA_DIFF32 ];
320 case BFD_RELOC_XTENSA_RTLD:
321 TRACE ("BFD_RELOC_XTENSA_RTLD");
322 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
324 case BFD_RELOC_XTENSA_GLOB_DAT:
325 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
326 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
328 case BFD_RELOC_XTENSA_JMP_SLOT:
329 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
330 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
332 case BFD_RELOC_XTENSA_RELATIVE:
333 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
334 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
336 case BFD_RELOC_XTENSA_PLT:
337 TRACE ("BFD_RELOC_XTENSA_PLT");
338 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
340 case BFD_RELOC_XTENSA_OP0:
341 TRACE ("BFD_RELOC_XTENSA_OP0");
342 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
344 case BFD_RELOC_XTENSA_OP1:
345 TRACE ("BFD_RELOC_XTENSA_OP1");
346 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
348 case BFD_RELOC_XTENSA_OP2:
349 TRACE ("BFD_RELOC_XTENSA_OP2");
350 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
352 case BFD_RELOC_XTENSA_ASM_EXPAND:
353 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
354 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
356 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
357 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
358 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
360 case BFD_RELOC_VTABLE_INHERIT:
361 TRACE ("BFD_RELOC_VTABLE_INHERIT");
362 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
364 case BFD_RELOC_VTABLE_ENTRY:
365 TRACE ("BFD_RELOC_VTABLE_ENTRY");
366 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
369 if (code >= BFD_RELOC_XTENSA_SLOT0_OP
370 && code <= BFD_RELOC_XTENSA_SLOT14_OP)
372 unsigned n = (R_XTENSA_SLOT0_OP +
373 (code - BFD_RELOC_XTENSA_SLOT0_OP));
374 return &elf_howto_table[n];
377 if (code >= BFD_RELOC_XTENSA_SLOT0_ALT
378 && code <= BFD_RELOC_XTENSA_SLOT14_ALT)
380 unsigned n = (R_XTENSA_SLOT0_ALT +
381 (code - BFD_RELOC_XTENSA_SLOT0_ALT));
382 return &elf_howto_table[n];
393 /* Given an ELF "rela" relocation, find the corresponding howto and record
394 it in the BFD internal arelent representation of the relocation. */
397 elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
399 Elf_Internal_Rela *dst)
401 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
403 BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max);
404 cache_ptr->howto = &elf_howto_table[r_type];
408 /* Functions for the Xtensa ELF linker. */
410 /* The name of the dynamic interpreter. This is put in the .interp
413 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
415 /* The size in bytes of an entry in the procedure linkage table.
416 (This does _not_ include the space for the literals associated with
419 #define PLT_ENTRY_SIZE 16
421 /* For _really_ large PLTs, we may need to alternate between literals
422 and code to keep the literals within the 256K range of the L32R
423 instructions in the code. It's unlikely that anyone would ever need
424 such a big PLT, but an arbitrary limit on the PLT size would be bad.
425 Thus, we split the PLT into chunks. Since there's very little
426 overhead (2 extra literals) for each chunk, the chunk size is kept
427 small so that the code for handling multiple chunks get used and
428 tested regularly. With 254 entries, there are 1K of literals for
429 each chunk, and that seems like a nice round number. */
431 #define PLT_ENTRIES_PER_CHUNK 254
433 /* PLT entries are actually used as stub functions for lazy symbol
434 resolution. Once the symbol is resolved, the stub function is never
435 invoked. Note: the 32-byte frame size used here cannot be changed
436 without a corresponding change in the runtime linker. */
438 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
440 0x6c, 0x10, 0x04, /* entry sp, 32 */
441 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
442 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
443 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
444 0x0a, 0x80, 0x00, /* jx a8 */
448 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
450 0x36, 0x41, 0x00, /* entry sp, 32 */
451 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
452 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
453 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
454 0xa0, 0x08, 0x00, /* jx a8 */
458 /* Xtensa ELF linker hash table. */
460 struct elf_xtensa_link_hash_table
462 struct elf_link_hash_table elf;
464 /* Short-cuts to get to dynamic linker sections. */
471 asection *spltlittbl;
473 /* Total count of PLT relocations seen during check_relocs.
474 The actual PLT code must be split into multiple sections and all
475 the sections have to be created before size_dynamic_sections,
476 where we figure out the exact number of PLT entries that will be
477 needed. It is OK if this count is an overestimate, e.g., some
478 relocations may be removed by GC. */
482 /* Get the Xtensa ELF linker hash table from a link_info structure. */
484 #define elf_xtensa_hash_table(p) \
485 ((struct elf_xtensa_link_hash_table *) ((p)->hash))
487 /* Create an Xtensa ELF linker hash table. */
489 static struct bfd_link_hash_table *
490 elf_xtensa_link_hash_table_create (bfd *abfd)
492 struct elf_xtensa_link_hash_table *ret;
493 bfd_size_type amt = sizeof (struct elf_xtensa_link_hash_table);
495 ret = bfd_malloc (amt);
499 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
500 _bfd_elf_link_hash_newfunc,
501 sizeof (struct elf_link_hash_entry)))
513 ret->spltlittbl = NULL;
515 ret->plt_reloc_count = 0;
517 return &ret->elf.root;
520 static inline bfd_boolean
521 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry *h,
522 struct bfd_link_info *info)
524 /* Check if we should do dynamic things to this symbol. The
525 "ignore_protected" argument need not be set, because Xtensa code
526 does not require special handling of STV_PROTECTED to make function
527 pointer comparisons work properly. The PLT addresses are never
528 used for function pointers. */
530 return _bfd_elf_dynamic_symbol_p (h, info, 0);
535 property_table_compare (const void *ap, const void *bp)
537 const property_table_entry *a = (const property_table_entry *) ap;
538 const property_table_entry *b = (const property_table_entry *) bp;
540 if (a->address == b->address)
542 if (a->size != b->size)
543 return (a->size - b->size);
545 if ((a->flags & XTENSA_PROP_ALIGN) != (b->flags & XTENSA_PROP_ALIGN))
546 return ((b->flags & XTENSA_PROP_ALIGN)
547 - (a->flags & XTENSA_PROP_ALIGN));
549 if ((a->flags & XTENSA_PROP_ALIGN)
550 && (GET_XTENSA_PROP_ALIGNMENT (a->flags)
551 != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
552 return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
553 - GET_XTENSA_PROP_ALIGNMENT (b->flags));
555 if ((a->flags & XTENSA_PROP_UNREACHABLE)
556 != (b->flags & XTENSA_PROP_UNREACHABLE))
557 return ((b->flags & XTENSA_PROP_UNREACHABLE)
558 - (a->flags & XTENSA_PROP_UNREACHABLE));
560 return (a->flags - b->flags);
563 return (a->address - b->address);
568 property_table_matches (const void *ap, const void *bp)
570 const property_table_entry *a = (const property_table_entry *) ap;
571 const property_table_entry *b = (const property_table_entry *) bp;
573 /* Check if one entry overlaps with the other. */
574 if ((b->address >= a->address && b->address < (a->address + a->size))
575 || (a->address >= b->address && a->address < (b->address + b->size)))
578 return (a->address - b->address);
582 /* Get the literal table or property table entries for the given
583 section. Sets TABLE_P and returns the number of entries. On
584 error, returns a negative value. */
587 xtensa_read_table_entries (bfd *abfd,
589 property_table_entry **table_p,
590 const char *sec_name,
591 bfd_boolean output_addr)
593 asection *table_section;
594 bfd_size_type table_size = 0;
595 bfd_byte *table_data;
596 property_table_entry *blocks;
597 int blk, block_count;
598 bfd_size_type num_records;
599 Elf_Internal_Rela *internal_relocs;
600 bfd_vma section_addr;
601 flagword predef_flags;
602 bfd_size_type table_entry_size;
605 || !(section->flags & SEC_ALLOC)
606 || (section->flags & SEC_DEBUGGING))
612 table_section = xtensa_get_property_section (section, sec_name);
614 table_size = table_section->size;
622 predef_flags = xtensa_get_property_predef_flags (table_section);
623 table_entry_size = 12;
625 table_entry_size -= 4;
627 num_records = table_size / table_entry_size;
628 table_data = retrieve_contents (abfd, table_section, TRUE);
629 blocks = (property_table_entry *)
630 bfd_malloc (num_records * sizeof (property_table_entry));
634 section_addr = section->output_section->vma + section->output_offset;
636 section_addr = section->vma;
638 /* If the file has not yet been relocated, process the relocations
639 and sort out the table entries that apply to the specified section. */
640 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
641 if (internal_relocs && !table_section->reloc_done)
645 for (i = 0; i < table_section->reloc_count; i++)
647 Elf_Internal_Rela *rel = &internal_relocs[i];
648 unsigned long r_symndx;
650 if (ELF32_R_TYPE (rel->r_info) == R_XTENSA_NONE)
653 BFD_ASSERT (ELF32_R_TYPE (rel->r_info) == R_XTENSA_32);
654 r_symndx = ELF32_R_SYM (rel->r_info);
656 if (get_elf_r_symndx_section (abfd, r_symndx) == section)
658 bfd_vma sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
659 BFD_ASSERT (sym_off == 0);
660 blocks[block_count].address =
661 (section_addr + sym_off + rel->r_addend
662 + bfd_get_32 (abfd, table_data + rel->r_offset));
663 blocks[block_count].size =
664 bfd_get_32 (abfd, table_data + rel->r_offset + 4);
666 blocks[block_count].flags = predef_flags;
668 blocks[block_count].flags =
669 bfd_get_32 (abfd, table_data + rel->r_offset + 8);
676 /* The file has already been relocated and the addresses are
677 already in the table. */
679 bfd_size_type section_limit = bfd_get_section_limit (abfd, section);
681 for (off = 0; off < table_size; off += table_entry_size)
683 bfd_vma address = bfd_get_32 (abfd, table_data + off);
685 if (address >= section_addr
686 && address < section_addr + section_limit)
688 blocks[block_count].address = address;
689 blocks[block_count].size =
690 bfd_get_32 (abfd, table_data + off + 4);
692 blocks[block_count].flags = predef_flags;
694 blocks[block_count].flags =
695 bfd_get_32 (abfd, table_data + off + 8);
701 release_contents (table_section, table_data);
702 release_internal_relocs (table_section, internal_relocs);
706 /* Now sort them into address order for easy reference. */
707 qsort (blocks, block_count, sizeof (property_table_entry),
708 property_table_compare);
710 /* Check that the table contents are valid. Problems may occur,
711 for example, if an unrelocated object file is stripped. */
712 for (blk = 1; blk < block_count; blk++)
714 /* The only circumstance where two entries may legitimately
715 have the same address is when one of them is a zero-size
716 placeholder to mark a place where fill can be inserted.
717 The zero-size entry should come first. */
718 if (blocks[blk - 1].address == blocks[blk].address &&
719 blocks[blk - 1].size != 0)
721 (*_bfd_error_handler) (_("%B(%A): invalid property table"),
723 bfd_set_error (bfd_error_bad_value);
735 static property_table_entry *
736 elf_xtensa_find_property_entry (property_table_entry *property_table,
737 int property_table_size,
740 property_table_entry entry;
741 property_table_entry *rv;
743 if (property_table_size == 0)
746 entry.address = addr;
750 rv = bsearch (&entry, property_table, property_table_size,
751 sizeof (property_table_entry), property_table_matches);
757 elf_xtensa_in_literal_pool (property_table_entry *lit_table,
761 if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
768 /* Look through the relocs for a section during the first phase, and
769 calculate needed space in the dynamic reloc sections. */
772 elf_xtensa_check_relocs (bfd *abfd,
773 struct bfd_link_info *info,
775 const Elf_Internal_Rela *relocs)
777 struct elf_xtensa_link_hash_table *htab;
778 Elf_Internal_Shdr *symtab_hdr;
779 struct elf_link_hash_entry **sym_hashes;
780 const Elf_Internal_Rela *rel;
781 const Elf_Internal_Rela *rel_end;
783 if (info->relocatable)
786 htab = elf_xtensa_hash_table (info);
787 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
788 sym_hashes = elf_sym_hashes (abfd);
790 rel_end = relocs + sec->reloc_count;
791 for (rel = relocs; rel < rel_end; rel++)
794 unsigned long r_symndx;
795 struct elf_link_hash_entry *h;
797 r_symndx = ELF32_R_SYM (rel->r_info);
798 r_type = ELF32_R_TYPE (rel->r_info);
800 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
802 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
807 if (r_symndx < symtab_hdr->sh_info)
811 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
812 while (h->root.type == bfd_link_hash_indirect
813 || h->root.type == bfd_link_hash_warning)
814 h = (struct elf_link_hash_entry *) h->root.u.i.link;
823 if ((sec->flags & SEC_ALLOC) != 0)
825 if (h->got.refcount <= 0)
828 h->got.refcount += 1;
833 /* If this relocation is against a local symbol, then it's
834 exactly the same as a normal local GOT entry. */
838 if ((sec->flags & SEC_ALLOC) != 0)
840 if (h->plt.refcount <= 0)
846 h->plt.refcount += 1;
848 /* Keep track of the total PLT relocation count even if we
849 don't yet know whether the dynamic sections will be
851 htab->plt_reloc_count += 1;
853 if (elf_hash_table (info)->dynamic_sections_created)
855 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
862 if ((sec->flags & SEC_ALLOC) != 0)
864 bfd_signed_vma *local_got_refcounts;
866 /* This is a global offset table entry for a local symbol. */
867 local_got_refcounts = elf_local_got_refcounts (abfd);
868 if (local_got_refcounts == NULL)
872 size = symtab_hdr->sh_info;
873 size *= sizeof (bfd_signed_vma);
874 local_got_refcounts =
875 (bfd_signed_vma *) bfd_zalloc (abfd, size);
876 if (local_got_refcounts == NULL)
878 elf_local_got_refcounts (abfd) = local_got_refcounts;
880 local_got_refcounts[r_symndx] += 1;
887 case R_XTENSA_SLOT0_OP:
888 case R_XTENSA_SLOT1_OP:
889 case R_XTENSA_SLOT2_OP:
890 case R_XTENSA_SLOT3_OP:
891 case R_XTENSA_SLOT4_OP:
892 case R_XTENSA_SLOT5_OP:
893 case R_XTENSA_SLOT6_OP:
894 case R_XTENSA_SLOT7_OP:
895 case R_XTENSA_SLOT8_OP:
896 case R_XTENSA_SLOT9_OP:
897 case R_XTENSA_SLOT10_OP:
898 case R_XTENSA_SLOT11_OP:
899 case R_XTENSA_SLOT12_OP:
900 case R_XTENSA_SLOT13_OP:
901 case R_XTENSA_SLOT14_OP:
902 case R_XTENSA_SLOT0_ALT:
903 case R_XTENSA_SLOT1_ALT:
904 case R_XTENSA_SLOT2_ALT:
905 case R_XTENSA_SLOT3_ALT:
906 case R_XTENSA_SLOT4_ALT:
907 case R_XTENSA_SLOT5_ALT:
908 case R_XTENSA_SLOT6_ALT:
909 case R_XTENSA_SLOT7_ALT:
910 case R_XTENSA_SLOT8_ALT:
911 case R_XTENSA_SLOT9_ALT:
912 case R_XTENSA_SLOT10_ALT:
913 case R_XTENSA_SLOT11_ALT:
914 case R_XTENSA_SLOT12_ALT:
915 case R_XTENSA_SLOT13_ALT:
916 case R_XTENSA_SLOT14_ALT:
917 case R_XTENSA_ASM_EXPAND:
918 case R_XTENSA_ASM_SIMPLIFY:
920 case R_XTENSA_DIFF16:
921 case R_XTENSA_DIFF32:
922 /* Nothing to do for these. */
925 case R_XTENSA_GNU_VTINHERIT:
926 /* This relocation describes the C++ object vtable hierarchy.
927 Reconstruct it for later use during GC. */
928 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
932 case R_XTENSA_GNU_VTENTRY:
933 /* This relocation describes which C++ vtable entries are actually
934 used. Record for later use during GC. */
935 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
949 elf_xtensa_make_sym_local (struct bfd_link_info *info,
950 struct elf_link_hash_entry *h)
954 if (h->plt.refcount > 0)
956 /* Will use RELATIVE relocs instead of JMP_SLOT relocs. */
957 if (h->got.refcount < 0)
959 h->got.refcount += h->plt.refcount;
965 /* Don't need any dynamic relocations at all. */
973 elf_xtensa_hide_symbol (struct bfd_link_info *info,
974 struct elf_link_hash_entry *h,
975 bfd_boolean force_local)
977 /* For a shared link, move the plt refcount to the got refcount to leave
978 space for RELATIVE relocs. */
979 elf_xtensa_make_sym_local (info, h);
981 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
985 /* Return the section that should be marked against GC for a given
989 elf_xtensa_gc_mark_hook (asection *sec,
990 struct bfd_link_info *info,
991 Elf_Internal_Rela *rel,
992 struct elf_link_hash_entry *h,
993 Elf_Internal_Sym *sym)
996 switch (ELF32_R_TYPE (rel->r_info))
998 case R_XTENSA_GNU_VTINHERIT:
999 case R_XTENSA_GNU_VTENTRY:
1003 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1007 /* Update the GOT & PLT entry reference counts
1008 for the section being removed. */
1011 elf_xtensa_gc_sweep_hook (bfd *abfd,
1012 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1014 const Elf_Internal_Rela *relocs)
1016 Elf_Internal_Shdr *symtab_hdr;
1017 struct elf_link_hash_entry **sym_hashes;
1018 bfd_signed_vma *local_got_refcounts;
1019 const Elf_Internal_Rela *rel, *relend;
1021 if ((sec->flags & SEC_ALLOC) == 0)
1024 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1025 sym_hashes = elf_sym_hashes (abfd);
1026 local_got_refcounts = elf_local_got_refcounts (abfd);
1028 relend = relocs + sec->reloc_count;
1029 for (rel = relocs; rel < relend; rel++)
1031 unsigned long r_symndx;
1032 unsigned int r_type;
1033 struct elf_link_hash_entry *h = NULL;
1035 r_symndx = ELF32_R_SYM (rel->r_info);
1036 if (r_symndx >= symtab_hdr->sh_info)
1038 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1039 while (h->root.type == bfd_link_hash_indirect
1040 || h->root.type == bfd_link_hash_warning)
1041 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1044 r_type = ELF32_R_TYPE (rel->r_info);
1050 if (h->got.refcount > 0)
1057 if (h->plt.refcount > 0)
1062 if (local_got_refcounts[r_symndx] > 0)
1063 local_got_refcounts[r_symndx] -= 1;
1075 /* Create all the dynamic sections. */
1078 elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1080 struct elf_xtensa_link_hash_table *htab;
1081 flagword flags, noalloc_flags;
1083 htab = elf_xtensa_hash_table (info);
1085 /* First do all the standard stuff. */
1086 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
1088 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1089 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1090 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1091 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1093 /* Create any extra PLT sections in case check_relocs has already
1094 been called on all the non-dynamic input files. */
1095 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1098 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
1099 | SEC_LINKER_CREATED | SEC_READONLY);
1100 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
1102 /* Mark the ".got.plt" section READONLY. */
1103 if (htab->sgotplt == NULL
1104 || ! bfd_set_section_flags (dynobj, htab->sgotplt, flags))
1107 /* Create ".rela.got". */
1108 htab->srelgot = bfd_make_section_with_flags (dynobj, ".rela.got", flags);
1109 if (htab->srelgot == NULL
1110 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1113 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1114 htab->sgotloc = bfd_make_section_with_flags (dynobj, ".got.loc", flags);
1115 if (htab->sgotloc == NULL
1116 || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
1119 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1120 htab->spltlittbl = bfd_make_section_with_flags (dynobj, ".xt.lit.plt",
1122 if (htab->spltlittbl == NULL
1123 || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
1131 add_extra_plt_sections (struct bfd_link_info *info, int count)
1133 bfd *dynobj = elf_hash_table (info)->dynobj;
1136 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1137 ".got.plt" sections. */
1138 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1144 /* Stop when we find a section has already been created. */
1145 if (elf_xtensa_get_plt_section (info, chunk))
1148 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1149 | SEC_LINKER_CREATED | SEC_READONLY);
1151 sname = (char *) bfd_malloc (10);
1152 sprintf (sname, ".plt.%u", chunk);
1153 s = bfd_make_section_with_flags (dynobj, sname, flags | SEC_CODE);
1155 || ! bfd_set_section_alignment (dynobj, s, 2))
1158 sname = (char *) bfd_malloc (14);
1159 sprintf (sname, ".got.plt.%u", chunk);
1160 s = bfd_make_section_with_flags (dynobj, sname, flags);
1162 || ! bfd_set_section_alignment (dynobj, s, 2))
1170 /* Adjust a symbol defined by a dynamic object and referenced by a
1171 regular object. The current definition is in some section of the
1172 dynamic object, but we're not including those sections. We have to
1173 change the definition to something the rest of the link can
1177 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1178 struct elf_link_hash_entry *h)
1180 /* If this is a weak symbol, and there is a real definition, the
1181 processor independent code will have arranged for us to see the
1182 real definition first, and we can just use the same value. */
1185 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1186 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1187 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1188 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1192 /* This is a reference to a symbol defined by a dynamic object. The
1193 reference must go through the GOT, so there's no need for COPY relocs,
1201 elf_xtensa_fix_refcounts (struct elf_link_hash_entry *h, void *arg)
1203 struct bfd_link_info *info = (struct bfd_link_info *) arg;
1205 if (h->root.type == bfd_link_hash_warning)
1206 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1208 if (! elf_xtensa_dynamic_symbol_p (h, info))
1209 elf_xtensa_make_sym_local (info, h);
1216 elf_xtensa_allocate_plt_size (struct elf_link_hash_entry *h, void *arg)
1218 asection *srelplt = (asection *) arg;
1220 if (h->root.type == bfd_link_hash_warning)
1221 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1223 if (h->plt.refcount > 0)
1224 srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1231 elf_xtensa_allocate_got_size (struct elf_link_hash_entry *h, void *arg)
1233 asection *srelgot = (asection *) arg;
1235 if (h->root.type == bfd_link_hash_warning)
1236 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1238 if (h->got.refcount > 0)
1239 srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
1246 elf_xtensa_allocate_local_got_size (struct bfd_link_info *info)
1248 struct elf_xtensa_link_hash_table *htab;
1251 htab = elf_xtensa_hash_table (info);
1253 for (i = info->input_bfds; i; i = i->link_next)
1255 bfd_signed_vma *local_got_refcounts;
1256 bfd_size_type j, cnt;
1257 Elf_Internal_Shdr *symtab_hdr;
1259 local_got_refcounts = elf_local_got_refcounts (i);
1260 if (!local_got_refcounts)
1263 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1264 cnt = symtab_hdr->sh_info;
1266 for (j = 0; j < cnt; ++j)
1268 if (local_got_refcounts[j] > 0)
1269 htab->srelgot->size += (local_got_refcounts[j]
1270 * sizeof (Elf32_External_Rela));
1276 /* Set the sizes of the dynamic sections. */
1279 elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1280 struct bfd_link_info *info)
1282 struct elf_xtensa_link_hash_table *htab;
1284 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1285 bfd_boolean relplt, relgot;
1286 int plt_entries, plt_chunks, chunk;
1291 htab = elf_xtensa_hash_table (info);
1292 dynobj = elf_hash_table (info)->dynobj;
1295 srelgot = htab->srelgot;
1296 srelplt = htab->srelplt;
1298 if (elf_hash_table (info)->dynamic_sections_created)
1300 BFD_ASSERT (htab->srelgot != NULL
1301 && htab->srelplt != NULL
1302 && htab->sgot != NULL
1303 && htab->spltlittbl != NULL
1304 && htab->sgotloc != NULL);
1306 /* Set the contents of the .interp section to the interpreter. */
1307 if (info->executable)
1309 s = bfd_get_section_by_name (dynobj, ".interp");
1312 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1313 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1316 /* Allocate room for one word in ".got". */
1317 htab->sgot->size = 4;
1319 /* Adjust refcounts for symbols that we now know are not "dynamic". */
1320 elf_link_hash_traverse (elf_hash_table (info),
1321 elf_xtensa_fix_refcounts,
1324 /* Allocate space in ".rela.got" for literals that reference
1326 elf_link_hash_traverse (elf_hash_table (info),
1327 elf_xtensa_allocate_got_size,
1330 /* If we are generating a shared object, we also need space in
1331 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1332 reference local symbols. */
1334 elf_xtensa_allocate_local_got_size (info);
1336 /* Allocate space in ".rela.plt" for literals that have PLT entries. */
1337 elf_link_hash_traverse (elf_hash_table (info),
1338 elf_xtensa_allocate_plt_size,
1341 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1342 each PLT entry, we need the PLT code plus a 4-byte literal.
1343 For each chunk of ".plt", we also need two more 4-byte
1344 literals, two corresponding entries in ".rela.got", and an
1345 8-byte entry in ".xt.lit.plt". */
1346 spltlittbl = htab->spltlittbl;
1347 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
1349 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1351 /* Iterate over all the PLT chunks, including any extra sections
1352 created earlier because the initial count of PLT relocations
1353 was an overestimate. */
1355 (splt = elf_xtensa_get_plt_section (info, chunk)) != NULL;
1360 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
1361 BFD_ASSERT (sgotplt != NULL);
1363 if (chunk < plt_chunks - 1)
1364 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1365 else if (chunk == plt_chunks - 1)
1366 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1370 if (chunk_entries != 0)
1372 sgotplt->size = 4 * (chunk_entries + 2);
1373 splt->size = PLT_ENTRY_SIZE * chunk_entries;
1374 srelgot->size += 2 * sizeof (Elf32_External_Rela);
1375 spltlittbl->size += 8;
1384 /* Allocate space in ".got.loc" to match the total size of all the
1386 sgotloc = htab->sgotloc;
1387 sgotloc->size = spltlittbl->size;
1388 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1390 if (abfd->flags & DYNAMIC)
1392 for (s = abfd->sections; s != NULL; s = s->next)
1394 if (! elf_discarded_section (s)
1395 && xtensa_is_littable_section (s)
1397 sgotloc->size += s->size;
1402 /* Allocate memory for dynamic sections. */
1405 for (s = dynobj->sections; s != NULL; s = s->next)
1409 if ((s->flags & SEC_LINKER_CREATED) == 0)
1412 /* It's OK to base decisions on the section name, because none
1413 of the dynobj section names depend upon the input files. */
1414 name = bfd_get_section_name (dynobj, s);
1416 if (CONST_STRNEQ (name, ".rela"))
1420 if (strcmp (name, ".rela.plt") == 0)
1422 else if (strcmp (name, ".rela.got") == 0)
1425 /* We use the reloc_count field as a counter if we need
1426 to copy relocs into the output file. */
1430 else if (! CONST_STRNEQ (name, ".plt.")
1431 && ! CONST_STRNEQ (name, ".got.plt.")
1432 && strcmp (name, ".got") != 0
1433 && strcmp (name, ".plt") != 0
1434 && strcmp (name, ".got.plt") != 0
1435 && strcmp (name, ".xt.lit.plt") != 0
1436 && strcmp (name, ".got.loc") != 0)
1438 /* It's not one of our sections, so don't allocate space. */
1444 /* If we don't need this section, strip it from the output
1445 file. We must create the ".plt*" and ".got.plt*"
1446 sections in create_dynamic_sections and/or check_relocs
1447 based on a conservative estimate of the PLT relocation
1448 count, because the sections must be created before the
1449 linker maps input sections to output sections. The
1450 linker does that before size_dynamic_sections, where we
1451 compute the exact size of the PLT, so there may be more
1452 of these sections than are actually needed. */
1453 s->flags |= SEC_EXCLUDE;
1455 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
1457 /* Allocate memory for the section contents. */
1458 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1459 if (s->contents == NULL)
1464 if (elf_hash_table (info)->dynamic_sections_created)
1466 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1467 known until finish_dynamic_sections, but we need to get the relocs
1468 in place before they are sorted. */
1469 for (chunk = 0; chunk < plt_chunks; chunk++)
1471 Elf_Internal_Rela irela;
1475 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1478 loc = (srelgot->contents
1479 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1480 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1481 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1482 loc + sizeof (Elf32_External_Rela));
1483 srelgot->reloc_count += 2;
1486 /* Add some entries to the .dynamic section. We fill in the
1487 values later, in elf_xtensa_finish_dynamic_sections, but we
1488 must add the entries now so that we get the correct size for
1489 the .dynamic section. The DT_DEBUG entry is filled in by the
1490 dynamic linker and used by the debugger. */
1491 #define add_dynamic_entry(TAG, VAL) \
1492 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1494 if (info->executable)
1496 if (!add_dynamic_entry (DT_DEBUG, 0))
1502 if (!add_dynamic_entry (DT_PLTGOT, 0)
1503 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1504 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1505 || !add_dynamic_entry (DT_JMPREL, 0))
1511 if (!add_dynamic_entry (DT_RELA, 0)
1512 || !add_dynamic_entry (DT_RELASZ, 0)
1513 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1517 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1518 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1521 #undef add_dynamic_entry
1527 /* Perform the specified relocation. The instruction at (contents + address)
1528 is modified to set one operand to represent the value in "relocation". The
1529 operand position is determined by the relocation type recorded in the
1532 #define CALL_SEGMENT_BITS (30)
1533 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1535 static bfd_reloc_status_type
1536 elf_xtensa_do_reloc (reloc_howto_type *howto,
1538 asection *input_section,
1542 bfd_boolean is_weak_undef,
1543 char **error_message)
1546 xtensa_opcode opcode;
1547 xtensa_isa isa = xtensa_default_isa;
1548 static xtensa_insnbuf ibuff = NULL;
1549 static xtensa_insnbuf sbuff = NULL;
1550 bfd_vma self_address = 0;
1551 bfd_size_type input_size;
1557 ibuff = xtensa_insnbuf_alloc (isa);
1558 sbuff = xtensa_insnbuf_alloc (isa);
1561 input_size = bfd_get_section_limit (abfd, input_section);
1563 switch (howto->type)
1566 case R_XTENSA_DIFF8:
1567 case R_XTENSA_DIFF16:
1568 case R_XTENSA_DIFF32:
1569 return bfd_reloc_ok;
1571 case R_XTENSA_ASM_EXPAND:
1574 /* Check for windowed CALL across a 1GB boundary. */
1575 xtensa_opcode opcode =
1576 get_expanded_call_opcode (contents + address,
1577 input_size - address, 0);
1578 if (is_windowed_call_opcode (opcode))
1580 self_address = (input_section->output_section->vma
1581 + input_section->output_offset
1583 if ((self_address >> CALL_SEGMENT_BITS)
1584 != (relocation >> CALL_SEGMENT_BITS))
1586 *error_message = "windowed longcall crosses 1GB boundary; "
1588 return bfd_reloc_dangerous;
1592 return bfd_reloc_ok;
1594 case R_XTENSA_ASM_SIMPLIFY:
1596 /* Convert the L32R/CALLX to CALL. */
1597 bfd_reloc_status_type retval =
1598 elf_xtensa_do_asm_simplify (contents, address, input_size,
1600 if (retval != bfd_reloc_ok)
1601 return bfd_reloc_dangerous;
1603 /* The CALL needs to be relocated. Continue below for that part. */
1605 howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
1613 x = bfd_get_32 (abfd, contents + address);
1615 bfd_put_32 (abfd, x, contents + address);
1617 return bfd_reloc_ok;
1620 /* Only instruction slot-specific relocations handled below.... */
1621 slot = get_relocation_slot (howto->type);
1622 if (slot == XTENSA_UNDEFINED)
1624 *error_message = "unexpected relocation";
1625 return bfd_reloc_dangerous;
1628 /* Read the instruction into a buffer and decode the opcode. */
1629 xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
1630 input_size - address);
1631 fmt = xtensa_format_decode (isa, ibuff);
1632 if (fmt == XTENSA_UNDEFINED)
1634 *error_message = "cannot decode instruction format";
1635 return bfd_reloc_dangerous;
1638 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
1640 opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
1641 if (opcode == XTENSA_UNDEFINED)
1643 *error_message = "cannot decode instruction opcode";
1644 return bfd_reloc_dangerous;
1647 /* Check for opcode-specific "alternate" relocations. */
1648 if (is_alt_relocation (howto->type))
1650 if (opcode == get_l32r_opcode ())
1652 /* Handle the special-case of non-PC-relative L32R instructions. */
1653 bfd *output_bfd = input_section->output_section->owner;
1654 asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
1657 *error_message = "relocation references missing .lit4 section";
1658 return bfd_reloc_dangerous;
1660 self_address = ((lit4_sec->vma & ~0xfff)
1661 + 0x40000 - 3); /* -3 to compensate for do_reloc */
1662 newval = relocation;
1665 else if (opcode == get_const16_opcode ())
1667 /* ALT used for high 16 bits. */
1668 newval = relocation >> 16;
1673 /* No other "alternate" relocations currently defined. */
1674 *error_message = "unexpected relocation";
1675 return bfd_reloc_dangerous;
1678 else /* Not an "alternate" relocation.... */
1680 if (opcode == get_const16_opcode ())
1682 newval = relocation & 0xffff;
1687 /* ...normal PC-relative relocation.... */
1689 /* Determine which operand is being relocated. */
1690 opnd = get_relocation_opnd (opcode, howto->type);
1691 if (opnd == XTENSA_UNDEFINED)
1693 *error_message = "unexpected relocation";
1694 return bfd_reloc_dangerous;
1697 if (!howto->pc_relative)
1699 *error_message = "expected PC-relative relocation";
1700 return bfd_reloc_dangerous;
1703 /* Calculate the PC address for this instruction. */
1704 self_address = (input_section->output_section->vma
1705 + input_section->output_offset
1708 newval = relocation;
1712 /* Apply the relocation. */
1713 if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
1714 || xtensa_operand_encode (isa, opcode, opnd, &newval)
1715 || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
1718 const char *opname = xtensa_opcode_name (isa, opcode);
1721 msg = "cannot encode";
1722 if (is_direct_call_opcode (opcode))
1724 if ((relocation & 0x3) != 0)
1725 msg = "misaligned call target";
1727 msg = "call target out of range";
1729 else if (opcode == get_l32r_opcode ())
1731 if ((relocation & 0x3) != 0)
1732 msg = "misaligned literal target";
1733 else if (is_alt_relocation (howto->type))
1734 msg = "literal target out of range (too many literals)";
1735 else if (self_address > relocation)
1736 msg = "literal target out of range (try using text-section-literals)";
1738 msg = "literal placed after use";
1741 *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
1742 return bfd_reloc_dangerous;
1745 /* Check for calls across 1GB boundaries. */
1746 if (is_direct_call_opcode (opcode)
1747 && is_windowed_call_opcode (opcode))
1749 if ((self_address >> CALL_SEGMENT_BITS)
1750 != (relocation >> CALL_SEGMENT_BITS))
1753 "windowed call crosses 1GB boundary; return may fail";
1754 return bfd_reloc_dangerous;
1758 /* Write the modified instruction back out of the buffer. */
1759 xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
1760 xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
1761 input_size - address);
1762 return bfd_reloc_ok;
1767 vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
1769 /* To reduce the size of the memory leak,
1770 we only use a single message buffer. */
1771 static bfd_size_type alloc_size = 0;
1772 static char *message = NULL;
1773 bfd_size_type orig_len, len = 0;
1774 bfd_boolean is_append;
1776 VA_OPEN (ap, arglen);
1777 VA_FIXEDARG (ap, const char *, origmsg);
1779 is_append = (origmsg == message);
1781 orig_len = strlen (origmsg);
1782 len = orig_len + strlen (fmt) + arglen + 20;
1783 if (len > alloc_size)
1785 message = (char *) bfd_realloc (message, len);
1789 memcpy (message, origmsg, orig_len);
1790 vsprintf (message + orig_len, fmt, ap);
1796 /* This function is registered as the "special_function" in the
1797 Xtensa howto for handling simplify operations.
1798 bfd_perform_relocation / bfd_install_relocation use it to
1799 perform (install) the specified relocation. Since this replaces the code
1800 in bfd_perform_relocation, it is basically an Xtensa-specific,
1801 stripped-down version of bfd_perform_relocation. */
1803 static bfd_reloc_status_type
1804 bfd_elf_xtensa_reloc (bfd *abfd,
1805 arelent *reloc_entry,
1808 asection *input_section,
1810 char **error_message)
1813 bfd_reloc_status_type flag;
1814 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1815 bfd_vma output_base = 0;
1816 reloc_howto_type *howto = reloc_entry->howto;
1817 asection *reloc_target_output_section;
1818 bfd_boolean is_weak_undef;
1820 if (!xtensa_default_isa)
1821 xtensa_default_isa = xtensa_isa_init (0, 0);
1823 /* ELF relocs are against symbols. If we are producing relocatable
1824 output, and the reloc is against an external symbol, the resulting
1825 reloc will also be against the same symbol. In such a case, we
1826 don't want to change anything about the way the reloc is handled,
1827 since it will all be done at final link time. This test is similar
1828 to what bfd_elf_generic_reloc does except that it lets relocs with
1829 howto->partial_inplace go through even if the addend is non-zero.
1830 (The real problem is that partial_inplace is set for XTENSA_32
1831 relocs to begin with, but that's a long story and there's little we
1832 can do about it now....) */
1834 if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
1836 reloc_entry->address += input_section->output_offset;
1837 return bfd_reloc_ok;
1840 /* Is the address of the relocation really within the section? */
1841 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1842 return bfd_reloc_outofrange;
1844 /* Work out which section the relocation is targeted at and the
1845 initial relocation command value. */
1847 /* Get symbol value. (Common symbols are special.) */
1848 if (bfd_is_com_section (symbol->section))
1851 relocation = symbol->value;
1853 reloc_target_output_section = symbol->section->output_section;
1855 /* Convert input-section-relative symbol value to absolute. */
1856 if ((output_bfd && !howto->partial_inplace)
1857 || reloc_target_output_section == NULL)
1860 output_base = reloc_target_output_section->vma;
1862 relocation += output_base + symbol->section->output_offset;
1864 /* Add in supplied addend. */
1865 relocation += reloc_entry->addend;
1867 /* Here the variable relocation holds the final address of the
1868 symbol we are relocating against, plus any addend. */
1871 if (!howto->partial_inplace)
1873 /* This is a partial relocation, and we want to apply the relocation
1874 to the reloc entry rather than the raw data. Everything except
1875 relocations against section symbols has already been handled
1878 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
1879 reloc_entry->addend = relocation;
1880 reloc_entry->address += input_section->output_offset;
1881 return bfd_reloc_ok;
1885 reloc_entry->address += input_section->output_offset;
1886 reloc_entry->addend = 0;
1890 is_weak_undef = (bfd_is_und_section (symbol->section)
1891 && (symbol->flags & BSF_WEAK) != 0);
1892 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
1893 (bfd_byte *) data, (bfd_vma) octets,
1894 is_weak_undef, error_message);
1896 if (flag == bfd_reloc_dangerous)
1898 /* Add the symbol name to the error message. */
1899 if (! *error_message)
1900 *error_message = "";
1901 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
1902 strlen (symbol->name) + 17,
1904 (unsigned long) reloc_entry->addend);
1911 /* Set up an entry in the procedure linkage table. */
1914 elf_xtensa_create_plt_entry (struct bfd_link_info *info,
1916 unsigned reloc_index)
1918 asection *splt, *sgotplt;
1919 bfd_vma plt_base, got_base;
1920 bfd_vma code_offset, lit_offset;
1923 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
1924 splt = elf_xtensa_get_plt_section (info, chunk);
1925 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
1926 BFD_ASSERT (splt != NULL && sgotplt != NULL);
1928 plt_base = splt->output_section->vma + splt->output_offset;
1929 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1931 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
1932 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
1934 /* Fill in the literal entry. This is the offset of the dynamic
1935 relocation entry. */
1936 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
1937 sgotplt->contents + lit_offset);
1939 /* Fill in the entry in the procedure linkage table. */
1940 memcpy (splt->contents + code_offset,
1941 (bfd_big_endian (output_bfd)
1942 ? elf_xtensa_be_plt_entry
1943 : elf_xtensa_le_plt_entry),
1945 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
1946 plt_base + code_offset + 3),
1947 splt->contents + code_offset + 4);
1948 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
1949 plt_base + code_offset + 6),
1950 splt->contents + code_offset + 7);
1951 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
1952 plt_base + code_offset + 9),
1953 splt->contents + code_offset + 10);
1955 return plt_base + code_offset;
1959 /* Relocate an Xtensa ELF section. This is invoked by the linker for
1960 both relocatable and final links. */
1963 elf_xtensa_relocate_section (bfd *output_bfd,
1964 struct bfd_link_info *info,
1966 asection *input_section,
1968 Elf_Internal_Rela *relocs,
1969 Elf_Internal_Sym *local_syms,
1970 asection **local_sections)
1972 struct elf_xtensa_link_hash_table *htab;
1973 Elf_Internal_Shdr *symtab_hdr;
1974 Elf_Internal_Rela *rel;
1975 Elf_Internal_Rela *relend;
1976 struct elf_link_hash_entry **sym_hashes;
1977 property_table_entry *lit_table = 0;
1979 char *error_message = NULL;
1980 bfd_size_type input_size;
1982 if (!xtensa_default_isa)
1983 xtensa_default_isa = xtensa_isa_init (0, 0);
1985 htab = elf_xtensa_hash_table (info);
1986 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1987 sym_hashes = elf_sym_hashes (input_bfd);
1989 if (elf_hash_table (info)->dynamic_sections_created)
1991 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
1992 &lit_table, XTENSA_LIT_SEC_NAME,
1998 input_size = bfd_get_section_limit (input_bfd, input_section);
2001 relend = relocs + input_section->reloc_count;
2002 for (; rel < relend; rel++)
2005 reloc_howto_type *howto;
2006 unsigned long r_symndx;
2007 struct elf_link_hash_entry *h;
2008 Elf_Internal_Sym *sym;
2011 bfd_reloc_status_type r;
2012 bfd_boolean is_weak_undef;
2013 bfd_boolean unresolved_reloc;
2016 r_type = ELF32_R_TYPE (rel->r_info);
2017 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2018 || r_type == (int) R_XTENSA_GNU_VTENTRY)
2021 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2023 bfd_set_error (bfd_error_bad_value);
2026 howto = &elf_howto_table[r_type];
2028 r_symndx = ELF32_R_SYM (rel->r_info);
2030 if (info->relocatable)
2032 /* This is a relocatable link.
2033 1) If the reloc is against a section symbol, adjust
2034 according to the output section.
2035 2) If there is a new target for this relocation,
2036 the new target will be in the same output section.
2037 We adjust the relocation by the output section
2040 if (relaxing_section)
2042 /* Check if this references a section in another input file. */
2043 if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2046 r_type = ELF32_R_TYPE (rel->r_info);
2049 if (r_type == R_XTENSA_ASM_SIMPLIFY)
2051 char *error_message = NULL;
2052 /* Convert ASM_SIMPLIFY into the simpler relocation
2053 so that they never escape a relaxing link. */
2054 r = contract_asm_expansion (contents, input_size, rel,
2056 if (r != bfd_reloc_ok)
2058 if (!((*info->callbacks->reloc_dangerous)
2059 (info, error_message, input_bfd, input_section,
2063 r_type = ELF32_R_TYPE (rel->r_info);
2066 /* This is a relocatable link, so we don't have to change
2067 anything unless the reloc is against a section symbol,
2068 in which case we have to adjust according to where the
2069 section symbol winds up in the output section. */
2070 if (r_symndx < symtab_hdr->sh_info)
2072 sym = local_syms + r_symndx;
2073 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2075 sec = local_sections[r_symndx];
2076 rel->r_addend += sec->output_offset + sym->st_value;
2080 /* If there is an addend with a partial_inplace howto,
2081 then move the addend to the contents. This is a hack
2082 to work around problems with DWARF in relocatable links
2083 with some previous version of BFD. Now we can't easily get
2084 rid of the hack without breaking backward compatibility.... */
2087 howto = &elf_howto_table[r_type];
2088 if (howto->partial_inplace)
2090 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2091 rel->r_addend, contents,
2092 rel->r_offset, FALSE,
2094 if (r != bfd_reloc_ok)
2096 if (!((*info->callbacks->reloc_dangerous)
2097 (info, error_message, input_bfd, input_section,
2105 /* Done with work for relocatable link; continue with next reloc. */
2109 /* This is a final link. */
2114 is_weak_undef = FALSE;
2115 unresolved_reloc = FALSE;
2118 if (howto->partial_inplace)
2120 /* Because R_XTENSA_32 was made partial_inplace to fix some
2121 problems with DWARF info in partial links, there may be
2122 an addend stored in the contents. Take it out of there
2123 and move it back into the addend field of the reloc. */
2124 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2125 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2128 if (r_symndx < symtab_hdr->sh_info)
2130 sym = local_syms + r_symndx;
2131 sec = local_sections[r_symndx];
2132 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2136 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2137 r_symndx, symtab_hdr, sym_hashes,
2139 unresolved_reloc, warned);
2142 && !unresolved_reloc
2143 && h->root.type == bfd_link_hash_undefweak)
2144 is_weak_undef = TRUE;
2147 if (relaxing_section)
2149 /* Check if this references a section in another input file. */
2150 do_fix_for_final_link (rel, input_bfd, input_section, contents,
2153 /* Update some already cached values. */
2154 r_type = ELF32_R_TYPE (rel->r_info);
2155 howto = &elf_howto_table[r_type];
2158 /* Sanity check the address. */
2159 if (rel->r_offset >= input_size
2160 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2162 (*_bfd_error_handler)
2163 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2164 input_bfd, input_section, rel->r_offset, input_size);
2165 bfd_set_error (bfd_error_bad_value);
2169 /* Generate dynamic relocations. */
2170 if (elf_hash_table (info)->dynamic_sections_created)
2172 bfd_boolean dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
2174 if (dynamic_symbol && is_operand_relocation (r_type))
2176 /* This is an error. The symbol's real value won't be known
2177 until runtime and it's likely to be out of range anyway. */
2178 const char *name = h->root.root.string;
2179 error_message = vsprint_msg ("invalid relocation for dynamic "
2181 strlen (name) + 2, name);
2182 if (!((*info->callbacks->reloc_dangerous)
2183 (info, error_message, input_bfd, input_section,
2187 else if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
2188 && (input_section->flags & SEC_ALLOC) != 0
2189 && (dynamic_symbol || info->shared))
2191 Elf_Internal_Rela outrel;
2195 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2196 srel = htab->srelplt;
2198 srel = htab->srelgot;
2200 BFD_ASSERT (srel != NULL);
2203 _bfd_elf_section_offset (output_bfd, info,
2204 input_section, rel->r_offset);
2206 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2207 memset (&outrel, 0, sizeof outrel);
2210 outrel.r_offset += (input_section->output_section->vma
2211 + input_section->output_offset);
2213 /* Complain if the relocation is in a read-only section
2214 and not in a literal pool. */
2215 if ((input_section->flags & SEC_READONLY) != 0
2216 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
2220 _("dynamic relocation in read-only section");
2221 if (!((*info->callbacks->reloc_dangerous)
2222 (info, error_message, input_bfd, input_section,
2229 outrel.r_addend = rel->r_addend;
2232 if (r_type == R_XTENSA_32)
2235 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2238 else /* r_type == R_XTENSA_PLT */
2241 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2243 /* Create the PLT entry and set the initial
2244 contents of the literal entry to the address of
2247 elf_xtensa_create_plt_entry (info, output_bfd,
2250 unresolved_reloc = FALSE;
2254 /* Generate a RELATIVE relocation. */
2255 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2256 outrel.r_addend = 0;
2260 loc = (srel->contents
2261 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2262 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2263 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2268 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2269 because such sections are not SEC_ALLOC and thus ld.so will
2270 not process them. */
2271 if (unresolved_reloc
2272 && !((input_section->flags & SEC_DEBUGGING) != 0
2275 (*_bfd_error_handler)
2276 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2279 (long) rel->r_offset,
2281 h->root.root.string);
2287 /* r_symndx will be zero only for relocs against symbols from
2288 removed linkonce sections, or sections discarded by a linker
2289 script. For these relocs, we just want the section contents
2290 zeroed. Avoid any special processing. */
2291 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2295 /* There's no point in calling bfd_perform_relocation here.
2296 Just go directly to our "special function". */
2297 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2298 relocation + rel->r_addend,
2299 contents, rel->r_offset, is_weak_undef,
2302 if (r != bfd_reloc_ok && !warned)
2306 BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
2307 BFD_ASSERT (error_message != NULL);
2310 name = h->root.root.string;
2313 name = bfd_elf_string_from_elf_section
2314 (input_bfd, symtab_hdr->sh_link, sym->st_name);
2315 if (name && *name == '\0')
2316 name = bfd_section_name (input_bfd, sec);
2320 if (rel->r_addend == 0)
2321 error_message = vsprint_msg (error_message, ": %s",
2322 strlen (name) + 2, name);
2324 error_message = vsprint_msg (error_message, ": (%s+0x%x)",
2326 name, (int)rel->r_addend);
2329 if (!((*info->callbacks->reloc_dangerous)
2330 (info, error_message, input_bfd, input_section,
2339 input_section->reloc_done = TRUE;
2345 /* Finish up dynamic symbol handling. There's not much to do here since
2346 the PLT and GOT entries are all set up by relocate_section. */
2349 elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
2350 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2351 struct elf_link_hash_entry *h,
2352 Elf_Internal_Sym *sym)
2354 if (h->needs_plt && !h->def_regular)
2356 /* Mark the symbol as undefined, rather than as defined in
2357 the .plt section. Leave the value alone. */
2358 sym->st_shndx = SHN_UNDEF;
2359 /* If the symbol is weak, we do need to clear the value.
2360 Otherwise, the PLT entry would provide a definition for
2361 the symbol even if the symbol wasn't defined anywhere,
2362 and so the symbol would never be NULL. */
2363 if (!h->ref_regular_nonweak)
2367 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2368 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2369 || h == elf_hash_table (info)->hgot)
2370 sym->st_shndx = SHN_ABS;
2376 /* Combine adjacent literal table entries in the output. Adjacent
2377 entries within each input section may have been removed during
2378 relaxation, but we repeat the process here, even though it's too late
2379 to shrink the output section, because it's important to minimize the
2380 number of literal table entries to reduce the start-up work for the
2381 runtime linker. Returns the number of remaining table entries or -1
2385 elf_xtensa_combine_prop_entries (bfd *output_bfd,
2390 property_table_entry *table;
2391 bfd_size_type section_size, sgotloc_size;
2395 section_size = sxtlit->size;
2396 BFD_ASSERT (section_size % 8 == 0);
2397 num = section_size / 8;
2399 sgotloc_size = sgotloc->size;
2400 if (sgotloc_size != section_size)
2402 (*_bfd_error_handler)
2403 (_("internal inconsistency in size of .got.loc section"));
2407 table = bfd_malloc (num * sizeof (property_table_entry));
2411 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
2412 propagates to the output section, where it doesn't really apply and
2413 where it breaks the following call to bfd_malloc_and_get_section. */
2414 sxtlit->flags &= ~SEC_IN_MEMORY;
2416 if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
2424 /* There should never be any relocations left at this point, so this
2425 is quite a bit easier than what is done during relaxation. */
2427 /* Copy the raw contents into a property table array and sort it. */
2429 for (n = 0; n < num; n++)
2431 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
2432 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
2435 qsort (table, num, sizeof (property_table_entry), property_table_compare);
2437 for (n = 0; n < num; n++)
2439 bfd_boolean remove = FALSE;
2441 if (table[n].size == 0)
2444 (table[n-1].address + table[n-1].size == table[n].address))
2446 table[n-1].size += table[n].size;
2452 for (m = n; m < num - 1; m++)
2454 table[m].address = table[m+1].address;
2455 table[m].size = table[m+1].size;
2463 /* Copy the data back to the raw contents. */
2465 for (n = 0; n < num; n++)
2467 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
2468 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
2472 /* Clear the removed bytes. */
2473 if ((bfd_size_type) (num * 8) < section_size)
2474 memset (&contents[num * 8], 0, section_size - num * 8);
2476 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
2480 /* Copy the contents to ".got.loc". */
2481 memcpy (sgotloc->contents, contents, section_size);
2489 /* Finish up the dynamic sections. */
2492 elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
2493 struct bfd_link_info *info)
2495 struct elf_xtensa_link_hash_table *htab;
2497 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
2498 Elf32_External_Dyn *dyncon, *dynconend;
2499 int num_xtlit_entries;
2501 if (! elf_hash_table (info)->dynamic_sections_created)
2504 htab = elf_xtensa_hash_table (info);
2505 dynobj = elf_hash_table (info)->dynobj;
2506 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2507 BFD_ASSERT (sdyn != NULL);
2509 /* Set the first entry in the global offset table to the address of
2510 the dynamic section. */
2514 BFD_ASSERT (sgot->size == 4);
2516 bfd_put_32 (output_bfd, 0, sgot->contents);
2518 bfd_put_32 (output_bfd,
2519 sdyn->output_section->vma + sdyn->output_offset,
2523 srelplt = htab->srelplt;
2524 if (srelplt && srelplt->size != 0)
2526 asection *sgotplt, *srelgot, *spltlittbl;
2527 int chunk, plt_chunks, plt_entries;
2528 Elf_Internal_Rela irela;
2530 unsigned rtld_reloc;
2532 srelgot = htab->srelgot;
2533 spltlittbl = htab->spltlittbl;
2534 BFD_ASSERT (srelgot != NULL && spltlittbl != NULL);
2536 /* Find the first XTENSA_RTLD relocation. Presumably the rest
2537 of them follow immediately after.... */
2538 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
2540 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2541 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2542 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
2545 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
2547 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
2549 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
2551 for (chunk = 0; chunk < plt_chunks; chunk++)
2553 int chunk_entries = 0;
2555 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
2556 BFD_ASSERT (sgotplt != NULL);
2558 /* Emit special RTLD relocations for the first two entries in
2559 each chunk of the .got.plt section. */
2561 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2562 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2563 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2564 irela.r_offset = (sgotplt->output_section->vma
2565 + sgotplt->output_offset);
2566 irela.r_addend = 1; /* tell rtld to set value to resolver function */
2567 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2569 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2571 /* Next literal immediately follows the first. */
2572 loc += sizeof (Elf32_External_Rela);
2573 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2574 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2575 irela.r_offset = (sgotplt->output_section->vma
2576 + sgotplt->output_offset + 4);
2577 /* Tell rtld to set value to object's link map. */
2579 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2581 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2583 /* Fill in the literal table. */
2584 if (chunk < plt_chunks - 1)
2585 chunk_entries = PLT_ENTRIES_PER_CHUNK;
2587 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
2589 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
2590 bfd_put_32 (output_bfd,
2591 sgotplt->output_section->vma + sgotplt->output_offset,
2592 spltlittbl->contents + (chunk * 8) + 0);
2593 bfd_put_32 (output_bfd,
2594 8 + (chunk_entries * 4),
2595 spltlittbl->contents + (chunk * 8) + 4);
2598 /* All the dynamic relocations have been emitted at this point.
2599 Make sure the relocation sections are the correct size. */
2600 if (srelgot->size != (sizeof (Elf32_External_Rela)
2601 * srelgot->reloc_count)
2602 || srelplt->size != (sizeof (Elf32_External_Rela)
2603 * srelplt->reloc_count))
2606 /* The .xt.lit.plt section has just been modified. This must
2607 happen before the code below which combines adjacent literal
2608 table entries, and the .xt.lit.plt contents have to be forced to
2610 if (! bfd_set_section_contents (output_bfd,
2611 spltlittbl->output_section,
2612 spltlittbl->contents,
2613 spltlittbl->output_offset,
2616 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
2617 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
2620 /* Combine adjacent literal table entries. */
2621 BFD_ASSERT (! info->relocatable);
2622 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
2623 sgotloc = htab->sgotloc;
2624 BFD_ASSERT (sxtlit && sgotloc);
2626 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
2627 if (num_xtlit_entries < 0)
2630 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2631 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2632 for (; dyncon < dynconend; dyncon++)
2634 Elf_Internal_Dyn dyn;
2636 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2643 case DT_XTENSA_GOT_LOC_SZ:
2644 dyn.d_un.d_val = num_xtlit_entries;
2647 case DT_XTENSA_GOT_LOC_OFF:
2648 dyn.d_un.d_ptr = htab->sgotloc->vma;
2652 dyn.d_un.d_ptr = htab->sgot->vma;
2656 dyn.d_un.d_ptr = htab->srelplt->vma;
2660 dyn.d_un.d_val = htab->srelplt->size;
2664 /* Adjust RELASZ to not include JMPREL. This matches what
2665 glibc expects and what is done for several other ELF
2666 targets (e.g., i386, alpha), but the "correct" behavior
2667 seems to be unresolved. Since the linker script arranges
2668 for .rela.plt to follow all other relocation sections, we
2669 don't have to worry about changing the DT_RELA entry. */
2671 dyn.d_un.d_val -= htab->srelplt->size;
2675 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2682 /* Functions for dealing with the e_flags field. */
2684 /* Merge backend specific data from an object file to the output
2685 object file when linking. */
2688 elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2690 unsigned out_mach, in_mach;
2691 flagword out_flag, in_flag;
2693 /* Check if we have the same endianess. */
2694 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
2697 /* Don't even pretend to support mixed-format linking. */
2698 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2699 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2702 out_flag = elf_elfheader (obfd)->e_flags;
2703 in_flag = elf_elfheader (ibfd)->e_flags;
2705 out_mach = out_flag & EF_XTENSA_MACH;
2706 in_mach = in_flag & EF_XTENSA_MACH;
2707 if (out_mach != in_mach)
2709 (*_bfd_error_handler)
2710 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
2711 ibfd, out_mach, in_mach);
2712 bfd_set_error (bfd_error_wrong_format);
2716 if (! elf_flags_init (obfd))
2718 elf_flags_init (obfd) = TRUE;
2719 elf_elfheader (obfd)->e_flags = in_flag;
2721 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2722 && bfd_get_arch_info (obfd)->the_default)
2723 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2724 bfd_get_mach (ibfd));
2729 if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
2730 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
2732 if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
2733 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
2740 elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
2742 BFD_ASSERT (!elf_flags_init (abfd)
2743 || elf_elfheader (abfd)->e_flags == flags);
2745 elf_elfheader (abfd)->e_flags |= flags;
2746 elf_flags_init (abfd) = TRUE;
2753 elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
2755 FILE *f = (FILE *) farg;
2756 flagword e_flags = elf_elfheader (abfd)->e_flags;
2758 fprintf (f, "\nXtensa header:\n");
2759 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
2760 fprintf (f, "\nMachine = Base\n");
2762 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
2764 fprintf (f, "Insn tables = %s\n",
2765 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
2767 fprintf (f, "Literal tables = %s\n",
2768 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
2770 return _bfd_elf_print_private_bfd_data (abfd, farg);
2774 /* Set the right machine number for an Xtensa ELF file. */
2777 elf_xtensa_object_p (bfd *abfd)
2780 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
2785 mach = bfd_mach_xtensa;
2791 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
2796 /* The final processing done just before writing out an Xtensa ELF object
2797 file. This gets the Xtensa architecture right based on the machine
2801 elf_xtensa_final_write_processing (bfd *abfd,
2802 bfd_boolean linker ATTRIBUTE_UNUSED)
2807 switch (mach = bfd_get_mach (abfd))
2809 case bfd_mach_xtensa:
2810 val = E_XTENSA_MACH;
2816 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
2817 elf_elfheader (abfd)->e_flags |= val;
2821 static enum elf_reloc_type_class
2822 elf_xtensa_reloc_type_class (const Elf_Internal_Rela *rela)
2824 switch ((int) ELF32_R_TYPE (rela->r_info))
2826 case R_XTENSA_RELATIVE:
2827 return reloc_class_relative;
2828 case R_XTENSA_JMP_SLOT:
2829 return reloc_class_plt;
2831 return reloc_class_normal;
2837 elf_xtensa_discard_info_for_section (bfd *abfd,
2838 struct elf_reloc_cookie *cookie,
2839 struct bfd_link_info *info,
2843 bfd_vma section_size;
2844 bfd_vma offset, actual_offset;
2845 size_t removed_bytes = 0;
2847 section_size = sec->size;
2848 if (section_size == 0 || section_size % 8 != 0)
2851 if (sec->output_section
2852 && bfd_is_abs_section (sec->output_section))
2855 contents = retrieve_contents (abfd, sec, info->keep_memory);
2859 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
2862 release_contents (sec, contents);
2866 cookie->rel = cookie->rels;
2867 cookie->relend = cookie->rels + sec->reloc_count;
2869 for (offset = 0; offset < section_size; offset += 8)
2871 actual_offset = offset - removed_bytes;
2873 /* The ...symbol_deleted_p function will skip over relocs but it
2874 won't adjust their offsets, so do that here. */
2875 while (cookie->rel < cookie->relend
2876 && cookie->rel->r_offset < offset)
2878 cookie->rel->r_offset -= removed_bytes;
2882 while (cookie->rel < cookie->relend
2883 && cookie->rel->r_offset == offset)
2885 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
2887 /* Remove the table entry. (If the reloc type is NONE, then
2888 the entry has already been merged with another and deleted
2889 during relaxation.) */
2890 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
2892 /* Shift the contents up. */
2893 if (offset + 8 < section_size)
2894 memmove (&contents[actual_offset],
2895 &contents[actual_offset+8],
2896 section_size - offset - 8);
2900 /* Remove this relocation. */
2901 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
2904 /* Adjust the relocation offset for previous removals. This
2905 should not be done before calling ...symbol_deleted_p
2906 because it might mess up the offset comparisons there.
2907 Make sure the offset doesn't underflow in the case where
2908 the first entry is removed. */
2909 if (cookie->rel->r_offset >= removed_bytes)
2910 cookie->rel->r_offset -= removed_bytes;
2912 cookie->rel->r_offset = 0;
2918 if (removed_bytes != 0)
2920 /* Adjust any remaining relocs (shouldn't be any). */
2921 for (; cookie->rel < cookie->relend; cookie->rel++)
2923 if (cookie->rel->r_offset >= removed_bytes)
2924 cookie->rel->r_offset -= removed_bytes;
2926 cookie->rel->r_offset = 0;
2929 /* Clear the removed bytes. */
2930 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
2932 pin_contents (sec, contents);
2933 pin_internal_relocs (sec, cookie->rels);
2936 sec->size = section_size - removed_bytes;
2938 if (xtensa_is_littable_section (sec))
2940 asection *sgotloc = elf_xtensa_hash_table (info)->sgotloc;
2942 sgotloc->size -= removed_bytes;
2947 release_contents (sec, contents);
2948 release_internal_relocs (sec, cookie->rels);
2951 return (removed_bytes != 0);
2956 elf_xtensa_discard_info (bfd *abfd,
2957 struct elf_reloc_cookie *cookie,
2958 struct bfd_link_info *info)
2961 bfd_boolean changed = FALSE;
2963 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2965 if (xtensa_is_property_section (sec))
2967 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
2977 elf_xtensa_ignore_discarded_relocs (asection *sec)
2979 return xtensa_is_property_section (sec);
2984 elf_xtensa_action_discarded (asection *sec)
2986 if (strcmp (".xt_except_table", sec->name) == 0)
2989 if (strcmp (".xt_except_desc", sec->name) == 0)
2992 return _bfd_elf_default_action_discarded (sec);
2996 /* Support for core dump NOTE sections. */
2999 elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3004 /* The size for Xtensa is variable, so don't try to recognize the format
3005 based on the size. Just assume this is GNU/Linux. */
3008 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3011 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
3015 size = note->descsz - offset - 4;
3017 /* Make a ".reg/999" section. */
3018 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3019 size, note->descpos + offset);
3024 elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3026 switch (note->descsz)
3031 case 128: /* GNU/Linux elf_prpsinfo */
3032 elf_tdata (abfd)->core_program
3033 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3034 elf_tdata (abfd)->core_command
3035 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3038 /* Note that for some reason, a spurious space is tacked
3039 onto the end of the args in some (at least one anyway)
3040 implementations, so strip it off if it exists. */
3043 char *command = elf_tdata (abfd)->core_command;
3044 int n = strlen (command);
3046 if (0 < n && command[n - 1] == ' ')
3047 command[n - 1] = '\0';
3054 /* Generic Xtensa configurability stuff. */
3056 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3057 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3058 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3059 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3060 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3061 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3062 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3063 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3066 init_call_opcodes (void)
3068 if (callx0_op == XTENSA_UNDEFINED)
3070 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3071 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3072 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3073 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3074 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3075 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3076 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3077 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3083 is_indirect_call_opcode (xtensa_opcode opcode)
3085 init_call_opcodes ();
3086 return (opcode == callx0_op
3087 || opcode == callx4_op
3088 || opcode == callx8_op
3089 || opcode == callx12_op);
3094 is_direct_call_opcode (xtensa_opcode opcode)
3096 init_call_opcodes ();
3097 return (opcode == call0_op
3098 || opcode == call4_op
3099 || opcode == call8_op
3100 || opcode == call12_op);
3105 is_windowed_call_opcode (xtensa_opcode opcode)
3107 init_call_opcodes ();
3108 return (opcode == call4_op
3109 || opcode == call8_op
3110 || opcode == call12_op
3111 || opcode == callx4_op
3112 || opcode == callx8_op
3113 || opcode == callx12_op);
3117 static xtensa_opcode
3118 get_const16_opcode (void)
3120 static bfd_boolean done_lookup = FALSE;
3121 static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3124 const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3127 return const16_opcode;
3131 static xtensa_opcode
3132 get_l32r_opcode (void)
3134 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
3135 static bfd_boolean done_lookup = FALSE;
3139 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
3147 l32r_offset (bfd_vma addr, bfd_vma pc)
3151 offset = addr - ((pc+3) & -4);
3152 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3153 offset = (signed int) offset >> 2;
3154 BFD_ASSERT ((signed int) offset >> 16 == -1);
3160 get_relocation_opnd (xtensa_opcode opcode, int r_type)
3162 xtensa_isa isa = xtensa_default_isa;
3163 int last_immed, last_opnd, opi;
3165 if (opcode == XTENSA_UNDEFINED)
3166 return XTENSA_UNDEFINED;
3168 /* Find the last visible PC-relative immediate operand for the opcode.
3169 If there are no PC-relative immediates, then choose the last visible
3170 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3171 last_immed = XTENSA_UNDEFINED;
3172 last_opnd = xtensa_opcode_num_operands (isa, opcode);
3173 for (opi = last_opnd - 1; opi >= 0; opi--)
3175 if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
3177 if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
3182 if (last_immed == XTENSA_UNDEFINED
3183 && xtensa_operand_is_register (isa, opcode, opi) == 0)
3187 return XTENSA_UNDEFINED;
3189 /* If the operand number was specified in an old-style relocation,
3190 check for consistency with the operand computed above. */
3191 if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
3193 int reloc_opnd = r_type - R_XTENSA_OP0;
3194 if (reloc_opnd != last_immed)
3195 return XTENSA_UNDEFINED;
3203 get_relocation_slot (int r_type)
3213 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
3214 return r_type - R_XTENSA_SLOT0_OP;
3215 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
3216 return r_type - R_XTENSA_SLOT0_ALT;
3220 return XTENSA_UNDEFINED;
3224 /* Get the opcode for a relocation. */
3226 static xtensa_opcode
3227 get_relocation_opcode (bfd *abfd,
3230 Elf_Internal_Rela *irel)
3232 static xtensa_insnbuf ibuff = NULL;
3233 static xtensa_insnbuf sbuff = NULL;
3234 xtensa_isa isa = xtensa_default_isa;
3238 if (contents == NULL)
3239 return XTENSA_UNDEFINED;
3241 if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
3242 return XTENSA_UNDEFINED;
3246 ibuff = xtensa_insnbuf_alloc (isa);
3247 sbuff = xtensa_insnbuf_alloc (isa);
3250 /* Decode the instruction. */
3251 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
3252 sec->size - irel->r_offset);
3253 fmt = xtensa_format_decode (isa, ibuff);
3254 slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
3255 if (slot == XTENSA_UNDEFINED)
3256 return XTENSA_UNDEFINED;
3257 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
3258 return xtensa_opcode_decode (isa, fmt, slot, sbuff);
3263 is_l32r_relocation (bfd *abfd,
3266 Elf_Internal_Rela *irel)
3268 xtensa_opcode opcode;
3269 if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
3271 opcode = get_relocation_opcode (abfd, sec, contents, irel);
3272 return (opcode == get_l32r_opcode ());
3276 static bfd_size_type
3277 get_asm_simplify_size (bfd_byte *contents,
3278 bfd_size_type content_len,
3279 bfd_size_type offset)
3281 bfd_size_type insnlen, size = 0;
3283 /* Decode the size of the next two instructions. */
3284 insnlen = insn_decode_len (contents, content_len, offset);
3290 insnlen = insn_decode_len (contents, content_len, offset + size);
3300 is_alt_relocation (int r_type)
3302 return (r_type >= R_XTENSA_SLOT0_ALT
3303 && r_type <= R_XTENSA_SLOT14_ALT);
3308 is_operand_relocation (int r_type)
3318 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
3320 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
3329 #define MIN_INSN_LENGTH 2
3331 /* Return 0 if it fails to decode. */
3334 insn_decode_len (bfd_byte *contents,
3335 bfd_size_type content_len,
3336 bfd_size_type offset)
3339 xtensa_isa isa = xtensa_default_isa;
3341 static xtensa_insnbuf ibuff = NULL;
3343 if (offset + MIN_INSN_LENGTH > content_len)
3347 ibuff = xtensa_insnbuf_alloc (isa);
3348 xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
3349 content_len - offset);
3350 fmt = xtensa_format_decode (isa, ibuff);
3351 if (fmt == XTENSA_UNDEFINED)
3353 insn_len = xtensa_format_length (isa, fmt);
3354 if (insn_len == XTENSA_UNDEFINED)
3360 /* Decode the opcode for a single slot instruction.
3361 Return 0 if it fails to decode or the instruction is multi-slot. */
3364 insn_decode_opcode (bfd_byte *contents,
3365 bfd_size_type content_len,
3366 bfd_size_type offset,
3369 xtensa_isa isa = xtensa_default_isa;
3371 static xtensa_insnbuf insnbuf = NULL;
3372 static xtensa_insnbuf slotbuf = NULL;
3374 if (offset + MIN_INSN_LENGTH > content_len)
3375 return XTENSA_UNDEFINED;
3377 if (insnbuf == NULL)
3379 insnbuf = xtensa_insnbuf_alloc (isa);
3380 slotbuf = xtensa_insnbuf_alloc (isa);
3383 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
3384 content_len - offset);
3385 fmt = xtensa_format_decode (isa, insnbuf);
3386 if (fmt == XTENSA_UNDEFINED)
3387 return XTENSA_UNDEFINED;
3389 if (slot >= xtensa_format_num_slots (isa, fmt))
3390 return XTENSA_UNDEFINED;
3392 xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
3393 return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
3397 /* The offset is the offset in the contents.
3398 The address is the address of that offset. */
3401 check_branch_target_aligned (bfd_byte *contents,
3402 bfd_size_type content_length,
3406 bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
3409 return check_branch_target_aligned_address (address, insn_len);
3414 check_loop_aligned (bfd_byte *contents,
3415 bfd_size_type content_length,
3419 bfd_size_type loop_len, insn_len;
3420 xtensa_opcode opcode;
3422 opcode = insn_decode_opcode (contents, content_length, offset, 0);
3423 if (opcode == XTENSA_UNDEFINED
3424 || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
3430 loop_len = insn_decode_len (contents, content_length, offset);
3431 insn_len = insn_decode_len (contents, content_length, offset + loop_len);
3432 if (loop_len == 0 || insn_len == 0)
3438 return check_branch_target_aligned_address (address + loop_len, insn_len);
3443 check_branch_target_aligned_address (bfd_vma addr, int len)
3446 return (addr % 8 == 0);
3447 return ((addr >> 2) == ((addr + len - 1) >> 2));
3451 /* Instruction widening and narrowing. */
3453 /* When FLIX is available we need to access certain instructions only
3454 when they are 16-bit or 24-bit instructions. This table caches
3455 information about such instructions by walking through all the
3456 opcodes and finding the smallest single-slot format into which each
3459 static xtensa_format *op_single_fmt_table = NULL;
3463 init_op_single_format_table (void)
3465 xtensa_isa isa = xtensa_default_isa;
3466 xtensa_insnbuf ibuf;
3467 xtensa_opcode opcode;
3471 if (op_single_fmt_table)
3474 ibuf = xtensa_insnbuf_alloc (isa);
3475 num_opcodes = xtensa_isa_num_opcodes (isa);
3477 op_single_fmt_table = (xtensa_format *)
3478 bfd_malloc (sizeof (xtensa_format) * num_opcodes);
3479 for (opcode = 0; opcode < num_opcodes; opcode++)
3481 op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
3482 for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
3484 if (xtensa_format_num_slots (isa, fmt) == 1
3485 && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
3487 xtensa_opcode old_fmt = op_single_fmt_table[opcode];
3488 int fmt_length = xtensa_format_length (isa, fmt);
3489 if (old_fmt == XTENSA_UNDEFINED
3490 || fmt_length < xtensa_format_length (isa, old_fmt))
3491 op_single_fmt_table[opcode] = fmt;
3495 xtensa_insnbuf_free (isa, ibuf);
3499 static xtensa_format
3500 get_single_format (xtensa_opcode opcode)
3502 init_op_single_format_table ();
3503 return op_single_fmt_table[opcode];
3507 /* For the set of narrowable instructions we do NOT include the
3508 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
3509 involved during linker relaxation that may require these to
3510 re-expand in some conditions. Also, the narrowing "or" -> mov.n
3511 requires special case code to ensure it only works when op1 == op2. */
3519 struct string_pair narrowable[] =
3522 { "addi", "addi.n" },
3523 { "addmi", "addi.n" },
3524 { "l32i", "l32i.n" },
3525 { "movi", "movi.n" },
3527 { "retw", "retw.n" },
3528 { "s32i", "s32i.n" },
3529 { "or", "mov.n" } /* special case only when op1 == op2 */
3532 struct string_pair widenable[] =
3535 { "addi", "addi.n" },
3536 { "addmi", "addi.n" },
3537 { "beqz", "beqz.n" },
3538 { "bnez", "bnez.n" },
3539 { "l32i", "l32i.n" },
3540 { "movi", "movi.n" },
3542 { "retw", "retw.n" },
3543 { "s32i", "s32i.n" },
3544 { "or", "mov.n" } /* special case only when op1 == op2 */
3548 /* Check if an instruction can be "narrowed", i.e., changed from a standard
3549 3-byte instruction to a 2-byte "density" instruction. If it is valid,
3550 return the instruction buffer holding the narrow instruction. Otherwise,
3551 return 0. The set of valid narrowing are specified by a string table
3552 but require some special case operand checks in some cases. */
3554 static xtensa_insnbuf
3555 can_narrow_instruction (xtensa_insnbuf slotbuf,
3557 xtensa_opcode opcode)
3559 xtensa_isa isa = xtensa_default_isa;
3560 xtensa_format o_fmt;
3563 static xtensa_insnbuf o_insnbuf = NULL;
3564 static xtensa_insnbuf o_slotbuf = NULL;
3566 if (o_insnbuf == NULL)
3568 o_insnbuf = xtensa_insnbuf_alloc (isa);
3569 o_slotbuf = xtensa_insnbuf_alloc (isa);
3572 for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
3574 bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
3576 if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
3578 uint32 value, newval;
3579 int i, operand_count, o_operand_count;
3580 xtensa_opcode o_opcode;
3582 /* Address does not matter in this case. We might need to
3583 fix it to handle branches/jumps. */
3584 bfd_vma self_address = 0;
3586 o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
3587 if (o_opcode == XTENSA_UNDEFINED)
3589 o_fmt = get_single_format (o_opcode);
3590 if (o_fmt == XTENSA_UNDEFINED)
3593 if (xtensa_format_length (isa, fmt) != 3
3594 || xtensa_format_length (isa, o_fmt) != 2)
3597 xtensa_format_encode (isa, o_fmt, o_insnbuf);
3598 operand_count = xtensa_opcode_num_operands (isa, opcode);
3599 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
3601 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
3606 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
3611 uint32 rawval0, rawval1, rawval2;
3613 if (o_operand_count + 1 != operand_count
3614 || xtensa_operand_get_field (isa, opcode, 0,
3615 fmt, 0, slotbuf, &rawval0) != 0
3616 || xtensa_operand_get_field (isa, opcode, 1,
3617 fmt, 0, slotbuf, &rawval1) != 0
3618 || xtensa_operand_get_field (isa, opcode, 2,
3619 fmt, 0, slotbuf, &rawval2) != 0
3620 || rawval1 != rawval2
3621 || rawval0 == rawval1 /* it is a nop */)
3625 for (i = 0; i < o_operand_count; ++i)
3627 if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
3629 || xtensa_operand_decode (isa, opcode, i, &value))
3632 /* PC-relative branches need adjustment, but
3633 the PC-rel operand will always have a relocation. */
3635 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
3637 || xtensa_operand_encode (isa, o_opcode, i, &newval)
3638 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
3643 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
3653 /* Attempt to narrow an instruction. If the narrowing is valid, perform
3654 the action in-place directly into the contents and return TRUE. Otherwise,
3655 the return value is FALSE and the contents are not modified. */
3658 narrow_instruction (bfd_byte *contents,
3659 bfd_size_type content_length,
3660 bfd_size_type offset)
3662 xtensa_opcode opcode;
3663 bfd_size_type insn_len;
3664 xtensa_isa isa = xtensa_default_isa;
3666 xtensa_insnbuf o_insnbuf;
3668 static xtensa_insnbuf insnbuf = NULL;
3669 static xtensa_insnbuf slotbuf = NULL;
3671 if (insnbuf == NULL)
3673 insnbuf = xtensa_insnbuf_alloc (isa);
3674 slotbuf = xtensa_insnbuf_alloc (isa);
3677 BFD_ASSERT (offset < content_length);
3679 if (content_length < 2)
3682 /* We will hand-code a few of these for a little while.
3683 These have all been specified in the assembler aleady. */
3684 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
3685 content_length - offset);
3686 fmt = xtensa_format_decode (isa, insnbuf);
3687 if (xtensa_format_num_slots (isa, fmt) != 1)
3690 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
3693 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
3694 if (opcode == XTENSA_UNDEFINED)
3696 insn_len = xtensa_format_length (isa, fmt);
3697 if (insn_len > content_length)
3700 o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
3703 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
3704 content_length - offset);
3712 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
3713 "density" instruction to a standard 3-byte instruction. If it is valid,
3714 return the instruction buffer holding the wide instruction. Otherwise,
3715 return 0. The set of valid widenings are specified by a string table
3716 but require some special case operand checks in some cases. */
3718 static xtensa_insnbuf
3719 can_widen_instruction (xtensa_insnbuf slotbuf,
3721 xtensa_opcode opcode)
3723 xtensa_isa isa = xtensa_default_isa;
3724 xtensa_format o_fmt;
3727 static xtensa_insnbuf o_insnbuf = NULL;
3728 static xtensa_insnbuf o_slotbuf = NULL;
3730 if (o_insnbuf == NULL)
3732 o_insnbuf = xtensa_insnbuf_alloc (isa);
3733 o_slotbuf = xtensa_insnbuf_alloc (isa);
3736 for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
3738 bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
3739 bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
3740 || strcmp ("bnez", widenable[opi].wide) == 0);
3742 if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
3744 uint32 value, newval;
3745 int i, operand_count, o_operand_count, check_operand_count;
3746 xtensa_opcode o_opcode;
3748 /* Address does not matter in this case. We might need to fix it
3749 to handle branches/jumps. */
3750 bfd_vma self_address = 0;
3752 o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
3753 if (o_opcode == XTENSA_UNDEFINED)
3755 o_fmt = get_single_format (o_opcode);
3756 if (o_fmt == XTENSA_UNDEFINED)
3759 if (xtensa_format_length (isa, fmt) != 2
3760 || xtensa_format_length (isa, o_fmt) != 3)
3763 xtensa_format_encode (isa, o_fmt, o_insnbuf);
3764 operand_count = xtensa_opcode_num_operands (isa, opcode);
3765 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
3766 check_operand_count = o_operand_count;
3768 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
3773 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
3778 uint32 rawval0, rawval1;
3780 if (o_operand_count != operand_count + 1
3781 || xtensa_operand_get_field (isa, opcode, 0,
3782 fmt, 0, slotbuf, &rawval0) != 0
3783 || xtensa_operand_get_field (isa, opcode, 1,
3784 fmt, 0, slotbuf, &rawval1) != 0
3785 || rawval0 == rawval1 /* it is a nop */)
3789 check_operand_count--;
3791 for (i = 0; i < check_operand_count; i++)
3794 if (is_or && i == o_operand_count - 1)
3796 if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
3798 || xtensa_operand_decode (isa, opcode, new_i, &value))
3801 /* PC-relative branches need adjustment, but
3802 the PC-rel operand will always have a relocation. */
3804 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
3806 || xtensa_operand_encode (isa, o_opcode, i, &newval)
3807 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
3812 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
3822 /* Attempt to widen an instruction. If the widening is valid, perform
3823 the action in-place directly into the contents and return TRUE. Otherwise,
3824 the return value is FALSE and the contents are not modified. */
3827 widen_instruction (bfd_byte *contents,
3828 bfd_size_type content_length,
3829 bfd_size_type offset)
3831 xtensa_opcode opcode;
3832 bfd_size_type insn_len;
3833 xtensa_isa isa = xtensa_default_isa;
3835 xtensa_insnbuf o_insnbuf;
3837 static xtensa_insnbuf insnbuf = NULL;
3838 static xtensa_insnbuf slotbuf = NULL;
3840 if (insnbuf == NULL)
3842 insnbuf = xtensa_insnbuf_alloc (isa);
3843 slotbuf = xtensa_insnbuf_alloc (isa);
3846 BFD_ASSERT (offset < content_length);
3848 if (content_length < 2)
3851 /* We will hand-code a few of these for a little while.
3852 These have all been specified in the assembler aleady. */
3853 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
3854 content_length - offset);
3855 fmt = xtensa_format_decode (isa, insnbuf);
3856 if (xtensa_format_num_slots (isa, fmt) != 1)
3859 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
3862 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
3863 if (opcode == XTENSA_UNDEFINED)
3865 insn_len = xtensa_format_length (isa, fmt);
3866 if (insn_len > content_length)
3869 o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
3872 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
3873 content_length - offset);
3880 /* Code for transforming CALLs at link-time. */
3882 static bfd_reloc_status_type
3883 elf_xtensa_do_asm_simplify (bfd_byte *contents,
3885 bfd_vma content_length,
3886 char **error_message)
3888 static xtensa_insnbuf insnbuf = NULL;
3889 static xtensa_insnbuf slotbuf = NULL;
3890 xtensa_format core_format = XTENSA_UNDEFINED;
3891 xtensa_opcode opcode;
3892 xtensa_opcode direct_call_opcode;
3893 xtensa_isa isa = xtensa_default_isa;
3894 bfd_byte *chbuf = contents + address;
3897 if (insnbuf == NULL)
3899 insnbuf = xtensa_insnbuf_alloc (isa);
3900 slotbuf = xtensa_insnbuf_alloc (isa);
3903 if (content_length < address)
3905 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
3906 return bfd_reloc_other;
3909 opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
3910 direct_call_opcode = swap_callx_for_call_opcode (opcode);
3911 if (direct_call_opcode == XTENSA_UNDEFINED)
3913 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
3914 return bfd_reloc_other;
3917 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
3918 core_format = xtensa_format_lookup (isa, "x24");
3919 opcode = xtensa_opcode_lookup (isa, "or");
3920 xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
3921 for (opn = 0; opn < 3; opn++)
3924 xtensa_operand_encode (isa, opcode, opn, ®no);
3925 xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
3928 xtensa_format_encode (isa, core_format, insnbuf);
3929 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
3930 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
3932 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
3933 xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
3934 xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
3936 xtensa_format_encode (isa, core_format, insnbuf);
3937 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
3938 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
3939 content_length - address - 3);
3941 return bfd_reloc_ok;
3945 static bfd_reloc_status_type
3946 contract_asm_expansion (bfd_byte *contents,
3947 bfd_vma content_length,
3948 Elf_Internal_Rela *irel,
3949 char **error_message)
3951 bfd_reloc_status_type retval =
3952 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
3955 if (retval != bfd_reloc_ok)
3956 return bfd_reloc_dangerous;
3958 /* Update the irel->r_offset field so that the right immediate and
3959 the right instruction are modified during the relocation. */
3960 irel->r_offset += 3;
3961 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
3962 return bfd_reloc_ok;
3966 static xtensa_opcode
3967 swap_callx_for_call_opcode (xtensa_opcode opcode)
3969 init_call_opcodes ();
3971 if (opcode == callx0_op) return call0_op;
3972 if (opcode == callx4_op) return call4_op;
3973 if (opcode == callx8_op) return call8_op;
3974 if (opcode == callx12_op) return call12_op;
3976 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
3977 return XTENSA_UNDEFINED;
3981 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
3982 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
3983 If not, return XTENSA_UNDEFINED. */
3985 #define L32R_TARGET_REG_OPERAND 0
3986 #define CONST16_TARGET_REG_OPERAND 0
3987 #define CALLN_SOURCE_OPERAND 0
3989 static xtensa_opcode
3990 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
3992 static xtensa_insnbuf insnbuf = NULL;
3993 static xtensa_insnbuf slotbuf = NULL;
3995 xtensa_opcode opcode;
3996 xtensa_isa isa = xtensa_default_isa;
3997 uint32 regno, const16_regno, call_regno;
4000 if (insnbuf == NULL)
4002 insnbuf = xtensa_insnbuf_alloc (isa);
4003 slotbuf = xtensa_insnbuf_alloc (isa);
4006 xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4007 fmt = xtensa_format_decode (isa, insnbuf);
4008 if (fmt == XTENSA_UNDEFINED
4009 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4010 return XTENSA_UNDEFINED;
4012 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4013 if (opcode == XTENSA_UNDEFINED)
4014 return XTENSA_UNDEFINED;
4016 if (opcode == get_l32r_opcode ())
4019 *p_uses_l32r = TRUE;
4020 if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4021 fmt, 0, slotbuf, ®no)
4022 || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4024 return XTENSA_UNDEFINED;
4026 else if (opcode == get_const16_opcode ())
4029 *p_uses_l32r = FALSE;
4030 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4031 fmt, 0, slotbuf, ®no)
4032 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4034 return XTENSA_UNDEFINED;
4036 /* Check that the next instruction is also CONST16. */
4037 offset += xtensa_format_length (isa, fmt);
4038 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4039 fmt = xtensa_format_decode (isa, insnbuf);
4040 if (fmt == XTENSA_UNDEFINED
4041 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4042 return XTENSA_UNDEFINED;
4043 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4044 if (opcode != get_const16_opcode ())
4045 return XTENSA_UNDEFINED;
4047 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4048 fmt, 0, slotbuf, &const16_regno)
4049 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4051 || const16_regno != regno)
4052 return XTENSA_UNDEFINED;
4055 return XTENSA_UNDEFINED;
4057 /* Next instruction should be an CALLXn with operand 0 == regno. */
4058 offset += xtensa_format_length (isa, fmt);
4059 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4060 fmt = xtensa_format_decode (isa, insnbuf);
4061 if (fmt == XTENSA_UNDEFINED
4062 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4063 return XTENSA_UNDEFINED;
4064 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4065 if (opcode == XTENSA_UNDEFINED
4066 || !is_indirect_call_opcode (opcode))
4067 return XTENSA_UNDEFINED;
4069 if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4070 fmt, 0, slotbuf, &call_regno)
4071 || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4073 return XTENSA_UNDEFINED;
4075 if (call_regno != regno)
4076 return XTENSA_UNDEFINED;
4082 /* Data structures used during relaxation. */
4084 /* r_reloc: relocation values. */
4086 /* Through the relaxation process, we need to keep track of the values
4087 that will result from evaluating relocations. The standard ELF
4088 relocation structure is not sufficient for this purpose because we're
4089 operating on multiple input files at once, so we need to know which
4090 input file a relocation refers to. The r_reloc structure thus
4091 records both the input file (bfd) and ELF relocation.
4093 For efficiency, an r_reloc also contains a "target_offset" field to
4094 cache the target-section-relative offset value that is represented by
4097 The r_reloc also contains a virtual offset that allows multiple
4098 inserted literals to be placed at the same "address" with
4099 different offsets. */
4101 typedef struct r_reloc_struct r_reloc;
4103 struct r_reloc_struct
4106 Elf_Internal_Rela rela;
4107 bfd_vma target_offset;
4108 bfd_vma virtual_offset;
4112 /* The r_reloc structure is included by value in literal_value, but not
4113 every literal_value has an associated relocation -- some are simple
4114 constants. In such cases, we set all the fields in the r_reloc
4115 struct to zero. The r_reloc_is_const function should be used to
4116 detect this case. */
4119 r_reloc_is_const (const r_reloc *r_rel)
4121 return (r_rel->abfd == NULL);
4126 r_reloc_get_target_offset (const r_reloc *r_rel)
4128 bfd_vma target_offset;
4129 unsigned long r_symndx;
4131 BFD_ASSERT (!r_reloc_is_const (r_rel));
4132 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4133 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4134 return (target_offset + r_rel->rela.r_addend);
4138 static struct elf_link_hash_entry *
4139 r_reloc_get_hash_entry (const r_reloc *r_rel)
4141 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4142 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4147 r_reloc_get_section (const r_reloc *r_rel)
4149 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4150 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4155 r_reloc_is_defined (const r_reloc *r_rel)
4161 sec = r_reloc_get_section (r_rel);
4162 if (sec == bfd_abs_section_ptr
4163 || sec == bfd_com_section_ptr
4164 || sec == bfd_und_section_ptr)
4171 r_reloc_init (r_reloc *r_rel,
4173 Elf_Internal_Rela *irel,
4175 bfd_size_type content_length)
4178 reloc_howto_type *howto;
4182 r_rel->rela = *irel;
4184 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
4185 r_rel->virtual_offset = 0;
4186 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
4187 howto = &elf_howto_table[r_type];
4188 if (howto->partial_inplace)
4190 bfd_vma inplace_val;
4191 BFD_ASSERT (r_rel->rela.r_offset < content_length);
4193 inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
4194 r_rel->target_offset += inplace_val;
4198 memset (r_rel, 0, sizeof (r_reloc));
4205 print_r_reloc (FILE *fp, const r_reloc *r_rel)
4207 if (r_reloc_is_defined (r_rel))
4209 asection *sec = r_reloc_get_section (r_rel);
4210 fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
4212 else if (r_reloc_get_hash_entry (r_rel))
4213 fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
4215 fprintf (fp, " ?? + ");
4217 fprintf_vma (fp, r_rel->target_offset);
4218 if (r_rel->virtual_offset)
4220 fprintf (fp, " + ");
4221 fprintf_vma (fp, r_rel->virtual_offset);
4230 /* source_reloc: relocations that reference literals. */
4232 /* To determine whether literals can be coalesced, we need to first
4233 record all the relocations that reference the literals. The
4234 source_reloc structure below is used for this purpose. The
4235 source_reloc entries are kept in a per-literal-section array, sorted
4236 by offset within the literal section (i.e., target offset).
4238 The source_sec and r_rel.rela.r_offset fields identify the source of
4239 the relocation. The r_rel field records the relocation value, i.e.,
4240 the offset of the literal being referenced. The opnd field is needed
4241 to determine the range of the immediate field to which the relocation
4242 applies, so we can determine whether another literal with the same
4243 value is within range. The is_null field is true when the relocation
4244 is being removed (e.g., when an L32R is being removed due to a CALLX
4245 that is converted to a direct CALL). */
4247 typedef struct source_reloc_struct source_reloc;
4249 struct source_reloc_struct
4251 asection *source_sec;
4253 xtensa_opcode opcode;
4255 bfd_boolean is_null;
4256 bfd_boolean is_abs_literal;
4261 init_source_reloc (source_reloc *reloc,
4262 asection *source_sec,
4263 const r_reloc *r_rel,
4264 xtensa_opcode opcode,
4266 bfd_boolean is_abs_literal)
4268 reloc->source_sec = source_sec;
4269 reloc->r_rel = *r_rel;
4270 reloc->opcode = opcode;
4272 reloc->is_null = FALSE;
4273 reloc->is_abs_literal = is_abs_literal;
4277 /* Find the source_reloc for a particular source offset and relocation
4278 type. Note that the array is sorted by _target_ offset, so this is
4279 just a linear search. */
4281 static source_reloc *
4282 find_source_reloc (source_reloc *src_relocs,
4285 Elf_Internal_Rela *irel)
4289 for (i = 0; i < src_count; i++)
4291 if (src_relocs[i].source_sec == sec
4292 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
4293 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
4294 == ELF32_R_TYPE (irel->r_info)))
4295 return &src_relocs[i];
4303 source_reloc_compare (const void *ap, const void *bp)
4305 const source_reloc *a = (const source_reloc *) ap;
4306 const source_reloc *b = (const source_reloc *) bp;
4308 if (a->r_rel.target_offset != b->r_rel.target_offset)
4309 return (a->r_rel.target_offset - b->r_rel.target_offset);
4311 /* We don't need to sort on these criteria for correctness,
4312 but enforcing a more strict ordering prevents unstable qsort
4313 from behaving differently with different implementations.
4314 Without the code below we get correct but different results
4315 on Solaris 2.7 and 2.8. We would like to always produce the
4316 same results no matter the host. */
4318 if ((!a->is_null) - (!b->is_null))
4319 return ((!a->is_null) - (!b->is_null));
4320 return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
4324 /* Literal values and value hash tables. */
4326 /* Literals with the same value can be coalesced. The literal_value
4327 structure records the value of a literal: the "r_rel" field holds the
4328 information from the relocation on the literal (if there is one) and
4329 the "value" field holds the contents of the literal word itself.
4331 The value_map structure records a literal value along with the
4332 location of a literal holding that value. The value_map hash table
4333 is indexed by the literal value, so that we can quickly check if a
4334 particular literal value has been seen before and is thus a candidate
4337 typedef struct literal_value_struct literal_value;
4338 typedef struct value_map_struct value_map;
4339 typedef struct value_map_hash_table_struct value_map_hash_table;
4341 struct literal_value_struct
4344 unsigned long value;
4345 bfd_boolean is_abs_literal;
4348 struct value_map_struct
4350 literal_value val; /* The literal value. */
4351 r_reloc loc; /* Location of the literal. */
4355 struct value_map_hash_table_struct
4357 unsigned bucket_count;
4358 value_map **buckets;
4360 bfd_boolean has_last_loc;
4366 init_literal_value (literal_value *lit,
4367 const r_reloc *r_rel,
4368 unsigned long value,
4369 bfd_boolean is_abs_literal)
4371 lit->r_rel = *r_rel;
4373 lit->is_abs_literal = is_abs_literal;
4378 literal_value_equal (const literal_value *src1,
4379 const literal_value *src2,
4380 bfd_boolean final_static_link)
4382 struct elf_link_hash_entry *h1, *h2;
4384 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
4387 if (r_reloc_is_const (&src1->r_rel))
4388 return (src1->value == src2->value);
4390 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
4391 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
4394 if (src1->r_rel.target_offset != src2->r_rel.target_offset)
4397 if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
4400 if (src1->value != src2->value)
4403 /* Now check for the same section (if defined) or the same elf_hash
4404 (if undefined or weak). */
4405 h1 = r_reloc_get_hash_entry (&src1->r_rel);
4406 h2 = r_reloc_get_hash_entry (&src2->r_rel);
4407 if (r_reloc_is_defined (&src1->r_rel)
4408 && (final_static_link
4409 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
4410 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
4412 if (r_reloc_get_section (&src1->r_rel)
4413 != r_reloc_get_section (&src2->r_rel))
4418 /* Require that the hash entries (i.e., symbols) be identical. */
4419 if (h1 != h2 || h1 == 0)
4423 if (src1->is_abs_literal != src2->is_abs_literal)
4430 /* Must be power of 2. */
4431 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
4433 static value_map_hash_table *
4434 value_map_hash_table_init (void)
4436 value_map_hash_table *values;
4438 values = (value_map_hash_table *)
4439 bfd_zmalloc (sizeof (value_map_hash_table));
4440 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
4442 values->buckets = (value_map **)
4443 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
4444 if (values->buckets == NULL)
4449 values->has_last_loc = FALSE;
4456 value_map_hash_table_delete (value_map_hash_table *table)
4458 free (table->buckets);
4464 hash_bfd_vma (bfd_vma val)
4466 return (val >> 2) + (val >> 10);
4471 literal_value_hash (const literal_value *src)
4475 hash_val = hash_bfd_vma (src->value);
4476 if (!r_reloc_is_const (&src->r_rel))
4480 hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
4481 hash_val += hash_bfd_vma (src->r_rel.target_offset);
4482 hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
4484 /* Now check for the same section and the same elf_hash. */
4485 if (r_reloc_is_defined (&src->r_rel))
4486 sec_or_hash = r_reloc_get_section (&src->r_rel);
4488 sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
4489 hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
4495 /* Check if the specified literal_value has been seen before. */
4498 value_map_get_cached_value (value_map_hash_table *map,
4499 const literal_value *val,
4500 bfd_boolean final_static_link)
4506 idx = literal_value_hash (val);
4507 idx = idx & (map->bucket_count - 1);
4508 bucket = map->buckets[idx];
4509 for (map_e = bucket; map_e; map_e = map_e->next)
4511 if (literal_value_equal (&map_e->val, val, final_static_link))
4518 /* Record a new literal value. It is illegal to call this if VALUE
4519 already has an entry here. */
4522 add_value_map (value_map_hash_table *map,
4523 const literal_value *val,
4525 bfd_boolean final_static_link)
4527 value_map **bucket_p;
4530 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
4533 bfd_set_error (bfd_error_no_memory);
4537 BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
4541 idx = literal_value_hash (val);
4542 idx = idx & (map->bucket_count - 1);
4543 bucket_p = &map->buckets[idx];
4545 val_e->next = *bucket_p;
4548 /* FIXME: Consider resizing the hash table if we get too many entries. */
4554 /* Lists of text actions (ta_) for narrowing, widening, longcall
4555 conversion, space fill, code & literal removal, etc. */
4557 /* The following text actions are generated:
4559 "ta_remove_insn" remove an instruction or instructions
4560 "ta_remove_longcall" convert longcall to call
4561 "ta_convert_longcall" convert longcall to nop/call
4562 "ta_narrow_insn" narrow a wide instruction
4563 "ta_widen" widen a narrow instruction
4564 "ta_fill" add fill or remove fill
4565 removed < 0 is a fill; branches to the fill address will be
4566 changed to address + fill size (e.g., address - removed)
4567 removed >= 0 branches to the fill address will stay unchanged
4568 "ta_remove_literal" remove a literal; this action is
4569 indicated when a literal is removed
4571 "ta_add_literal" insert a new literal; this action is
4572 indicated when a literal has been moved.
4573 It may use a virtual_offset because
4574 multiple literals can be placed at the
4577 For each of these text actions, we also record the number of bytes
4578 removed by performing the text action. In the case of a "ta_widen"
4579 or a "ta_fill" that adds space, the removed_bytes will be negative. */
4581 typedef struct text_action_struct text_action;
4582 typedef struct text_action_list_struct text_action_list;
4583 typedef enum text_action_enum_t text_action_t;
4585 enum text_action_enum_t
4588 ta_remove_insn, /* removed = -size */
4589 ta_remove_longcall, /* removed = -size */
4590 ta_convert_longcall, /* removed = 0 */
4591 ta_narrow_insn, /* removed = -1 */
4592 ta_widen_insn, /* removed = +1 */
4593 ta_fill, /* removed = +size */
4599 /* Structure for a text action record. */
4600 struct text_action_struct
4602 text_action_t action;
4603 asection *sec; /* Optional */
4605 bfd_vma virtual_offset; /* Zero except for adding literals. */
4607 literal_value value; /* Only valid when adding literals. */
4613 /* List of all of the actions taken on a text section. */
4614 struct text_action_list_struct
4620 static text_action *
4621 find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
4625 /* It is not necessary to fill at the end of a section. */
4626 if (sec->size == offset)
4629 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
4631 text_action *t = *m_p;
4632 /* When the action is another fill at the same address,
4633 just increase the size. */
4634 if (t->offset == offset && t->action == ta_fill)
4642 compute_removed_action_diff (const text_action *ta,
4646 int removable_space)
4649 int current_removed = 0;
4652 current_removed = ta->removed_bytes;
4654 BFD_ASSERT (ta == NULL || ta->offset == offset);
4655 BFD_ASSERT (ta == NULL || ta->action == ta_fill);
4657 /* It is not necessary to fill at the end of a section. Clean this up. */
4658 if (sec->size == offset)
4659 new_removed = removable_space - 0;
4663 int added = -removed - current_removed;
4664 /* Ignore multiples of the section alignment. */
4665 added = ((1 << sec->alignment_power) - 1) & added;
4666 new_removed = (-added);
4668 /* Modify for removable. */
4669 space = removable_space - new_removed;
4670 new_removed = (removable_space
4671 - (((1 << sec->alignment_power) - 1) & space));
4673 return (new_removed - current_removed);
4678 adjust_fill_action (text_action *ta, int fill_diff)
4680 ta->removed_bytes += fill_diff;
4684 /* Add a modification action to the text. For the case of adding or
4685 removing space, modify any current fill and assume that
4686 "unreachable_space" bytes can be freely contracted. Note that a
4687 negative removed value is a fill. */
4690 text_action_add (text_action_list *l,
4691 text_action_t action,
4699 /* It is not necessary to fill at the end of a section. */
4700 if (action == ta_fill && sec->size == offset)
4703 /* It is not necessary to fill 0 bytes. */
4704 if (action == ta_fill && removed == 0)
4707 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
4709 text_action *t = *m_p;
4710 /* When the action is another fill at the same address,
4711 just increase the size. */
4712 if (t->offset == offset && t->action == ta_fill && action == ta_fill)
4714 t->removed_bytes += removed;
4719 /* Create a new record and fill it up. */
4720 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
4721 ta->action = action;
4723 ta->offset = offset;
4724 ta->removed_bytes = removed;
4731 text_action_add_literal (text_action_list *l,
4732 text_action_t action,
4734 const literal_value *value,
4739 asection *sec = r_reloc_get_section (loc);
4740 bfd_vma offset = loc->target_offset;
4741 bfd_vma virtual_offset = loc->virtual_offset;
4743 BFD_ASSERT (action == ta_add_literal);
4745 for (m_p = &l->head; *m_p != NULL; m_p = &(*m_p)->next)
4747 if ((*m_p)->offset > offset
4748 && ((*m_p)->offset != offset
4749 || (*m_p)->virtual_offset > virtual_offset))
4753 /* Create a new record and fill it up. */
4754 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
4755 ta->action = action;
4757 ta->offset = offset;
4758 ta->virtual_offset = virtual_offset;
4760 ta->removed_bytes = removed;
4767 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
4772 for (r = action_list->head; r && r->offset <= offset; r = r->next)
4774 if (r->offset < offset
4775 || (r->action == ta_fill && r->removed_bytes < 0))
4776 removed += r->removed_bytes;
4779 return (offset - removed);
4784 action_list_count (text_action_list *action_list)
4786 text_action *r = action_list->head;
4788 for (r = action_list->head; r != NULL; r = r->next)
4797 offset_with_removed_text_before_fill (text_action_list *action_list,
4803 for (r = action_list->head; r && r->offset < offset; r = r->next)
4804 removed += r->removed_bytes;
4806 return (offset - removed);
4810 /* The find_insn_action routine will only find non-fill actions. */
4812 static text_action *
4813 find_insn_action (text_action_list *action_list, bfd_vma offset)
4816 for (t = action_list->head; t; t = t->next)
4818 if (t->offset == offset)
4825 case ta_remove_insn:
4826 case ta_remove_longcall:
4827 case ta_convert_longcall:
4828 case ta_narrow_insn:
4831 case ta_remove_literal:
4832 case ta_add_literal:
4845 print_action_list (FILE *fp, text_action_list *action_list)
4849 fprintf (fp, "Text Action\n");
4850 for (r = action_list->head; r != NULL; r = r->next)
4852 const char *t = "unknown";
4855 case ta_remove_insn:
4856 t = "remove_insn"; break;
4857 case ta_remove_longcall:
4858 t = "remove_longcall"; break;
4859 case ta_convert_longcall:
4860 t = "remove_longcall"; break;
4861 case ta_narrow_insn:
4862 t = "narrow_insn"; break;
4864 t = "widen_insn"; break;
4869 case ta_remove_literal:
4870 t = "remove_literal"; break;
4871 case ta_add_literal:
4872 t = "add_literal"; break;
4875 fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
4876 r->sec->owner->filename,
4877 r->sec->name, r->offset, t, r->removed_bytes);
4884 /* Lists of literals being coalesced or removed. */
4886 /* In the usual case, the literal identified by "from" is being
4887 coalesced with another literal identified by "to". If the literal is
4888 unused and is being removed altogether, "to.abfd" will be NULL.
4889 The removed_literal entries are kept on a per-section list, sorted
4890 by the "from" offset field. */
4892 typedef struct removed_literal_struct removed_literal;
4893 typedef struct removed_literal_list_struct removed_literal_list;
4895 struct removed_literal_struct
4899 removed_literal *next;
4902 struct removed_literal_list_struct
4904 removed_literal *head;
4905 removed_literal *tail;
4909 /* Record that the literal at "from" is being removed. If "to" is not
4910 NULL, the "from" literal is being coalesced with the "to" literal. */
4913 add_removed_literal (removed_literal_list *removed_list,
4914 const r_reloc *from,
4917 removed_literal *r, *new_r, *next_r;
4919 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
4921 new_r->from = *from;
4925 new_r->to.abfd = NULL;
4928 r = removed_list->head;
4931 removed_list->head = new_r;
4932 removed_list->tail = new_r;
4934 /* Special check for common case of append. */
4935 else if (removed_list->tail->from.target_offset < from->target_offset)
4937 removed_list->tail->next = new_r;
4938 removed_list->tail = new_r;
4942 while (r->from.target_offset < from->target_offset && r->next)
4948 new_r->next = next_r;
4950 removed_list->tail = new_r;
4955 /* Check if the list of removed literals contains an entry for the
4956 given address. Return the entry if found. */
4958 static removed_literal *
4959 find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
4961 removed_literal *r = removed_list->head;
4962 while (r && r->from.target_offset < addr)
4964 if (r && r->from.target_offset == addr)
4973 print_removed_literals (FILE *fp, removed_literal_list *removed_list)
4976 r = removed_list->head;
4978 fprintf (fp, "Removed Literals\n");
4979 for (; r != NULL; r = r->next)
4981 print_r_reloc (fp, &r->from);
4982 fprintf (fp, " => ");
4983 if (r->to.abfd == NULL)
4984 fprintf (fp, "REMOVED");
4986 print_r_reloc (fp, &r->to);
4994 /* Per-section data for relaxation. */
4996 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
4998 struct xtensa_relax_info_struct
5000 bfd_boolean is_relaxable_literal_section;
5001 bfd_boolean is_relaxable_asm_section;
5002 int visited; /* Number of times visited. */
5004 source_reloc *src_relocs; /* Array[src_count]. */
5006 int src_next; /* Next src_relocs entry to assign. */
5008 removed_literal_list removed_list;
5009 text_action_list action_list;
5011 reloc_bfd_fix *fix_list;
5012 reloc_bfd_fix *fix_array;
5013 unsigned fix_array_count;
5015 /* Support for expanding the reloc array that is stored
5016 in the section structure. If the relocations have been
5017 reallocated, the newly allocated relocations will be referenced
5018 here along with the actual size allocated. The relocation
5019 count will always be found in the section structure. */
5020 Elf_Internal_Rela *allocated_relocs;
5021 unsigned relocs_count;
5022 unsigned allocated_relocs_count;
5025 struct elf_xtensa_section_data
5027 struct bfd_elf_section_data elf;
5028 xtensa_relax_info relax_info;
5033 elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
5035 if (!sec->used_by_bfd)
5037 struct elf_xtensa_section_data *sdata;
5038 bfd_size_type amt = sizeof (*sdata);
5040 sdata = bfd_zalloc (abfd, amt);
5043 sec->used_by_bfd = sdata;
5046 return _bfd_elf_new_section_hook (abfd, sec);
5050 static xtensa_relax_info *
5051 get_xtensa_relax_info (asection *sec)
5053 struct elf_xtensa_section_data *section_data;
5055 /* No info available if no section or if it is an output section. */
5056 if (!sec || sec == sec->output_section)
5059 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
5060 return §ion_data->relax_info;
5065 init_xtensa_relax_info (asection *sec)
5067 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5069 relax_info->is_relaxable_literal_section = FALSE;
5070 relax_info->is_relaxable_asm_section = FALSE;
5071 relax_info->visited = 0;
5073 relax_info->src_relocs = NULL;
5074 relax_info->src_count = 0;
5075 relax_info->src_next = 0;
5077 relax_info->removed_list.head = NULL;
5078 relax_info->removed_list.tail = NULL;
5080 relax_info->action_list.head = NULL;
5082 relax_info->fix_list = NULL;
5083 relax_info->fix_array = NULL;
5084 relax_info->fix_array_count = 0;
5086 relax_info->allocated_relocs = NULL;
5087 relax_info->relocs_count = 0;
5088 relax_info->allocated_relocs_count = 0;
5092 /* Coalescing literals may require a relocation to refer to a section in
5093 a different input file, but the standard relocation information
5094 cannot express that. Instead, the reloc_bfd_fix structures are used
5095 to "fix" the relocations that refer to sections in other input files.
5096 These structures are kept on per-section lists. The "src_type" field
5097 records the relocation type in case there are multiple relocations on
5098 the same location. FIXME: This is ugly; an alternative might be to
5099 add new symbols with the "owner" field to some other input file. */
5101 struct reloc_bfd_fix_struct
5105 unsigned src_type; /* Relocation type. */
5108 asection *target_sec;
5109 bfd_vma target_offset;
5110 bfd_boolean translated;
5112 reloc_bfd_fix *next;
5116 static reloc_bfd_fix *
5117 reloc_bfd_fix_init (asection *src_sec,
5121 asection *target_sec,
5122 bfd_vma target_offset,
5123 bfd_boolean translated)
5127 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
5128 fix->src_sec = src_sec;
5129 fix->src_offset = src_offset;
5130 fix->src_type = src_type;
5131 fix->target_abfd = target_abfd;
5132 fix->target_sec = target_sec;
5133 fix->target_offset = target_offset;
5134 fix->translated = translated;
5141 add_fix (asection *src_sec, reloc_bfd_fix *fix)
5143 xtensa_relax_info *relax_info;
5145 relax_info = get_xtensa_relax_info (src_sec);
5146 fix->next = relax_info->fix_list;
5147 relax_info->fix_list = fix;
5152 fix_compare (const void *ap, const void *bp)
5154 const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
5155 const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
5157 if (a->src_offset != b->src_offset)
5158 return (a->src_offset - b->src_offset);
5159 return (a->src_type - b->src_type);
5164 cache_fix_array (asection *sec)
5166 unsigned i, count = 0;
5168 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5170 if (relax_info == NULL)
5172 if (relax_info->fix_list == NULL)
5175 for (r = relax_info->fix_list; r != NULL; r = r->next)
5178 relax_info->fix_array =
5179 (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
5180 relax_info->fix_array_count = count;
5182 r = relax_info->fix_list;
5183 for (i = 0; i < count; i++, r = r->next)
5185 relax_info->fix_array[count - 1 - i] = *r;
5186 relax_info->fix_array[count - 1 - i].next = NULL;
5189 qsort (relax_info->fix_array, relax_info->fix_array_count,
5190 sizeof (reloc_bfd_fix), fix_compare);
5194 static reloc_bfd_fix *
5195 get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
5197 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5201 if (relax_info == NULL)
5203 if (relax_info->fix_list == NULL)
5206 if (relax_info->fix_array == NULL)
5207 cache_fix_array (sec);
5209 key.src_offset = offset;
5210 key.src_type = type;
5211 rv = bsearch (&key, relax_info->fix_array, relax_info->fix_array_count,
5212 sizeof (reloc_bfd_fix), fix_compare);
5217 /* Section caching. */
5219 typedef struct section_cache_struct section_cache_t;
5221 struct section_cache_struct
5225 bfd_byte *contents; /* Cache of the section contents. */
5226 bfd_size_type content_length;
5228 property_table_entry *ptbl; /* Cache of the section property table. */
5231 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
5232 unsigned reloc_count;
5237 init_section_cache (section_cache_t *sec_cache)
5239 memset (sec_cache, 0, sizeof (*sec_cache));
5244 clear_section_cache (section_cache_t *sec_cache)
5248 release_contents (sec_cache->sec, sec_cache->contents);
5249 release_internal_relocs (sec_cache->sec, sec_cache->relocs);
5250 if (sec_cache->ptbl)
5251 free (sec_cache->ptbl);
5252 memset (sec_cache, 0, sizeof (sec_cache));
5258 section_cache_section (section_cache_t *sec_cache,
5260 struct bfd_link_info *link_info)
5263 property_table_entry *prop_table = NULL;
5265 bfd_byte *contents = NULL;
5266 Elf_Internal_Rela *internal_relocs = NULL;
5267 bfd_size_type sec_size;
5271 if (sec == sec_cache->sec)
5275 sec_size = bfd_get_section_limit (abfd, sec);
5277 /* Get the contents. */
5278 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5279 if (contents == NULL && sec_size != 0)
5282 /* Get the relocations. */
5283 internal_relocs = retrieve_internal_relocs (abfd, sec,
5284 link_info->keep_memory);
5286 /* Get the entry table. */
5287 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
5288 XTENSA_PROP_SEC_NAME, FALSE);
5292 /* Fill in the new section cache. */
5293 clear_section_cache (sec_cache);
5294 memset (sec_cache, 0, sizeof (sec_cache));
5296 sec_cache->sec = sec;
5297 sec_cache->contents = contents;
5298 sec_cache->content_length = sec_size;
5299 sec_cache->relocs = internal_relocs;
5300 sec_cache->reloc_count = sec->reloc_count;
5301 sec_cache->pte_count = ptblsize;
5302 sec_cache->ptbl = prop_table;
5307 release_contents (sec, contents);
5308 release_internal_relocs (sec, internal_relocs);
5315 /* Extended basic blocks. */
5317 /* An ebb_struct represents an Extended Basic Block. Within this
5318 range, we guarantee that all instructions are decodable, the
5319 property table entries are contiguous, and no property table
5320 specifies a segment that cannot have instructions moved. This
5321 structure contains caches of the contents, property table and
5322 relocations for the specified section for easy use. The range is
5323 specified by ranges of indices for the byte offset, property table
5324 offsets and relocation offsets. These must be consistent. */
5326 typedef struct ebb_struct ebb_t;
5332 bfd_byte *contents; /* Cache of the section contents. */
5333 bfd_size_type content_length;
5335 property_table_entry *ptbl; /* Cache of the section property table. */
5338 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
5339 unsigned reloc_count;
5341 bfd_vma start_offset; /* Offset in section. */
5342 unsigned start_ptbl_idx; /* Offset in the property table. */
5343 unsigned start_reloc_idx; /* Offset in the relocations. */
5346 unsigned end_ptbl_idx;
5347 unsigned end_reloc_idx;
5349 bfd_boolean ends_section; /* Is this the last ebb in a section? */
5351 /* The unreachable property table at the end of this set of blocks;
5352 NULL if the end is not an unreachable block. */
5353 property_table_entry *ends_unreachable;
5357 enum ebb_target_enum
5360 EBB_DESIRE_TGT_ALIGN,
5361 EBB_REQUIRE_TGT_ALIGN,
5362 EBB_REQUIRE_LOOP_ALIGN,
5367 /* proposed_action_struct is similar to the text_action_struct except
5368 that is represents a potential transformation, not one that will
5369 occur. We build a list of these for an extended basic block
5370 and use them to compute the actual actions desired. We must be
5371 careful that the entire set of actual actions we perform do not
5372 break any relocations that would fit if the actions were not
5375 typedef struct proposed_action_struct proposed_action;
5377 struct proposed_action_struct
5379 enum ebb_target_enum align_type; /* for the target alignment */
5380 bfd_vma alignment_pow;
5381 text_action_t action;
5384 bfd_boolean do_action; /* If false, then we will not perform the action. */
5388 /* The ebb_constraint_struct keeps a set of proposed actions for an
5389 extended basic block. */
5391 typedef struct ebb_constraint_struct ebb_constraint;
5393 struct ebb_constraint_struct
5396 bfd_boolean start_movable;
5398 /* Bytes of extra space at the beginning if movable. */
5399 int start_extra_space;
5401 enum ebb_target_enum start_align;
5403 bfd_boolean end_movable;
5405 /* Bytes of extra space at the end if movable. */
5406 int end_extra_space;
5408 unsigned action_count;
5409 unsigned action_allocated;
5411 /* Array of proposed actions. */
5412 proposed_action *actions;
5414 /* Action alignments -- one for each proposed action. */
5415 enum ebb_target_enum *action_aligns;
5420 init_ebb_constraint (ebb_constraint *c)
5422 memset (c, 0, sizeof (ebb_constraint));
5427 free_ebb_constraint (ebb_constraint *c)
5435 init_ebb (ebb_t *ebb,
5438 bfd_size_type content_length,
5439 property_table_entry *prop_table,
5441 Elf_Internal_Rela *internal_relocs,
5442 unsigned reloc_count)
5444 memset (ebb, 0, sizeof (ebb_t));
5446 ebb->contents = contents;
5447 ebb->content_length = content_length;
5448 ebb->ptbl = prop_table;
5449 ebb->pte_count = ptblsize;
5450 ebb->relocs = internal_relocs;
5451 ebb->reloc_count = reloc_count;
5452 ebb->start_offset = 0;
5453 ebb->end_offset = ebb->content_length - 1;
5454 ebb->start_ptbl_idx = 0;
5455 ebb->end_ptbl_idx = ptblsize;
5456 ebb->start_reloc_idx = 0;
5457 ebb->end_reloc_idx = reloc_count;
5461 /* Extend the ebb to all decodable contiguous sections. The algorithm
5462 for building a basic block around an instruction is to push it
5463 forward until we hit the end of a section, an unreachable block or
5464 a block that cannot be transformed. Then we push it backwards
5465 searching for similar conditions. */
5467 static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
5468 static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
5469 static bfd_size_type insn_block_decodable_len
5470 (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
5473 extend_ebb_bounds (ebb_t *ebb)
5475 if (!extend_ebb_bounds_forward (ebb))
5477 if (!extend_ebb_bounds_backward (ebb))
5484 extend_ebb_bounds_forward (ebb_t *ebb)
5486 property_table_entry *the_entry, *new_entry;
5488 the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
5490 /* Stop when (1) we cannot decode an instruction, (2) we are at
5491 the end of the property tables, (3) we hit a non-contiguous property
5492 table entry, (4) we hit a NO_TRANSFORM region. */
5497 bfd_size_type insn_block_len;
5499 entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
5501 insn_block_decodable_len (ebb->contents, ebb->content_length,
5503 entry_end - ebb->end_offset);
5504 if (insn_block_len != (entry_end - ebb->end_offset))
5506 (*_bfd_error_handler)
5507 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
5508 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
5511 ebb->end_offset += insn_block_len;
5513 if (ebb->end_offset == ebb->sec->size)
5514 ebb->ends_section = TRUE;
5516 /* Update the reloc counter. */
5517 while (ebb->end_reloc_idx + 1 < ebb->reloc_count
5518 && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
5521 ebb->end_reloc_idx++;
5524 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
5527 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
5528 if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
5529 || ((new_entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) != 0)
5530 || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
5533 if (the_entry->address + the_entry->size != new_entry->address)
5536 the_entry = new_entry;
5537 ebb->end_ptbl_idx++;
5540 /* Quick check for an unreachable or end of file just at the end. */
5541 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
5543 if (ebb->end_offset == ebb->content_length)
5544 ebb->ends_section = TRUE;
5548 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
5549 if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
5550 && the_entry->address + the_entry->size == new_entry->address)
5551 ebb->ends_unreachable = new_entry;
5554 /* Any other ending requires exact alignment. */
5560 extend_ebb_bounds_backward (ebb_t *ebb)
5562 property_table_entry *the_entry, *new_entry;
5564 the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
5566 /* Stop when (1) we cannot decode the instructions in the current entry.
5567 (2) we are at the beginning of the property tables, (3) we hit a
5568 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
5572 bfd_vma block_begin;
5573 bfd_size_type insn_block_len;
5575 block_begin = the_entry->address - ebb->sec->vma;
5577 insn_block_decodable_len (ebb->contents, ebb->content_length,
5579 ebb->start_offset - block_begin);
5580 if (insn_block_len != ebb->start_offset - block_begin)
5582 (*_bfd_error_handler)
5583 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
5584 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
5587 ebb->start_offset -= insn_block_len;
5589 /* Update the reloc counter. */
5590 while (ebb->start_reloc_idx > 0
5591 && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
5592 >= ebb->start_offset))
5594 ebb->start_reloc_idx--;
5597 if (ebb->start_ptbl_idx == 0)
5600 new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
5601 if ((new_entry->flags & XTENSA_PROP_INSN) == 0
5602 || ((new_entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) != 0)
5603 || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
5605 if (new_entry->address + new_entry->size != the_entry->address)
5608 the_entry = new_entry;
5609 ebb->start_ptbl_idx--;
5615 static bfd_size_type
5616 insn_block_decodable_len (bfd_byte *contents,
5617 bfd_size_type content_len,
5618 bfd_vma block_offset,
5619 bfd_size_type block_len)
5621 bfd_vma offset = block_offset;
5623 while (offset < block_offset + block_len)
5625 bfd_size_type insn_len = 0;
5627 insn_len = insn_decode_len (contents, content_len, offset);
5629 return (offset - block_offset);
5632 return (offset - block_offset);
5637 ebb_propose_action (ebb_constraint *c,
5638 enum ebb_target_enum align_type,
5639 bfd_vma alignment_pow,
5640 text_action_t action,
5643 bfd_boolean do_action)
5645 proposed_action *act;
5647 if (c->action_allocated <= c->action_count)
5649 unsigned new_allocated, i;
5650 proposed_action *new_actions;
5652 new_allocated = (c->action_count + 2) * 2;
5653 new_actions = (proposed_action *)
5654 bfd_zmalloc (sizeof (proposed_action) * new_allocated);
5656 for (i = 0; i < c->action_count; i++)
5657 new_actions[i] = c->actions[i];
5660 c->actions = new_actions;
5661 c->action_allocated = new_allocated;
5664 act = &c->actions[c->action_count];
5665 act->align_type = align_type;
5666 act->alignment_pow = alignment_pow;
5667 act->action = action;
5668 act->offset = offset;
5669 act->removed_bytes = removed_bytes;
5670 act->do_action = do_action;
5676 /* Access to internal relocations, section contents and symbols. */
5678 /* During relaxation, we need to modify relocations, section contents,
5679 and symbol definitions, and we need to keep the original values from
5680 being reloaded from the input files, i.e., we need to "pin" the
5681 modified values in memory. We also want to continue to observe the
5682 setting of the "keep-memory" flag. The following functions wrap the
5683 standard BFD functions to take care of this for us. */
5685 static Elf_Internal_Rela *
5686 retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
5688 Elf_Internal_Rela *internal_relocs;
5690 if ((sec->flags & SEC_LINKER_CREATED) != 0)
5693 internal_relocs = elf_section_data (sec)->relocs;
5694 if (internal_relocs == NULL)
5695 internal_relocs = (_bfd_elf_link_read_relocs
5696 (abfd, sec, NULL, NULL, keep_memory));
5697 return internal_relocs;
5702 pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
5704 elf_section_data (sec)->relocs = internal_relocs;
5709 release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
5712 && elf_section_data (sec)->relocs != internal_relocs)
5713 free (internal_relocs);
5718 retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
5721 bfd_size_type sec_size;
5723 sec_size = bfd_get_section_limit (abfd, sec);
5724 contents = elf_section_data (sec)->this_hdr.contents;
5726 if (contents == NULL && sec_size != 0)
5728 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
5735 elf_section_data (sec)->this_hdr.contents = contents;
5742 pin_contents (asection *sec, bfd_byte *contents)
5744 elf_section_data (sec)->this_hdr.contents = contents;
5749 release_contents (asection *sec, bfd_byte *contents)
5751 if (contents && elf_section_data (sec)->this_hdr.contents != contents)
5756 static Elf_Internal_Sym *
5757 retrieve_local_syms (bfd *input_bfd)
5759 Elf_Internal_Shdr *symtab_hdr;
5760 Elf_Internal_Sym *isymbuf;
5763 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5764 locsymcount = symtab_hdr->sh_info;
5766 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5767 if (isymbuf == NULL && locsymcount != 0)
5768 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
5771 /* Save the symbols for this input file so they won't be read again. */
5772 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
5773 symtab_hdr->contents = (unsigned char *) isymbuf;
5779 /* Code for link-time relaxation. */
5781 /* Initialization for relaxation: */
5782 static bfd_boolean analyze_relocations (struct bfd_link_info *);
5783 static bfd_boolean find_relaxable_sections
5784 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
5785 static bfd_boolean collect_source_relocs
5786 (bfd *, asection *, struct bfd_link_info *);
5787 static bfd_boolean is_resolvable_asm_expansion
5788 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
5790 static Elf_Internal_Rela *find_associated_l32r_irel
5791 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
5792 static bfd_boolean compute_text_actions
5793 (bfd *, asection *, struct bfd_link_info *);
5794 static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
5795 static bfd_boolean compute_ebb_actions (ebb_constraint *);
5796 static bfd_boolean check_section_ebb_pcrels_fit
5797 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, const ebb_constraint *,
5798 const xtensa_opcode *);
5799 static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
5800 static void text_action_add_proposed
5801 (text_action_list *, const ebb_constraint *, asection *);
5802 static int compute_fill_extra_space (property_table_entry *);
5805 static bfd_boolean compute_removed_literals
5806 (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
5807 static Elf_Internal_Rela *get_irel_at_offset
5808 (asection *, Elf_Internal_Rela *, bfd_vma);
5809 static bfd_boolean is_removable_literal
5810 (const source_reloc *, int, const source_reloc *, int);
5811 static bfd_boolean remove_dead_literal
5812 (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
5813 Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
5814 static bfd_boolean identify_literal_placement
5815 (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
5816 value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
5817 source_reloc *, property_table_entry *, int, section_cache_t *,
5819 static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
5820 static bfd_boolean coalesce_shared_literal
5821 (asection *, source_reloc *, property_table_entry *, int, value_map *);
5822 static bfd_boolean move_shared_literal
5823 (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
5824 int, const r_reloc *, const literal_value *, section_cache_t *);
5827 static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
5828 static bfd_boolean translate_section_fixes (asection *);
5829 static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
5830 static void translate_reloc (const r_reloc *, r_reloc *);
5831 static void shrink_dynamic_reloc_sections
5832 (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
5833 static bfd_boolean move_literal
5834 (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
5835 xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
5836 static bfd_boolean relax_property_section
5837 (bfd *, asection *, struct bfd_link_info *);
5840 static bfd_boolean relax_section_symbols (bfd *, asection *);
5844 elf_xtensa_relax_section (bfd *abfd,
5846 struct bfd_link_info *link_info,
5849 static value_map_hash_table *values = NULL;
5850 static bfd_boolean relocations_analyzed = FALSE;
5851 xtensa_relax_info *relax_info;
5853 if (!relocations_analyzed)
5855 /* Do some overall initialization for relaxation. */
5856 values = value_map_hash_table_init ();
5859 relaxing_section = TRUE;
5860 if (!analyze_relocations (link_info))
5862 relocations_analyzed = TRUE;
5866 /* Don't mess with linker-created sections. */
5867 if ((sec->flags & SEC_LINKER_CREATED) != 0)
5870 relax_info = get_xtensa_relax_info (sec);
5871 BFD_ASSERT (relax_info != NULL);
5873 switch (relax_info->visited)
5876 /* Note: It would be nice to fold this pass into
5877 analyze_relocations, but it is important for this step that the
5878 sections be examined in link order. */
5879 if (!compute_removed_literals (abfd, sec, link_info, values))
5886 value_map_hash_table_delete (values);
5888 if (!relax_section (abfd, sec, link_info))
5894 if (!relax_section_symbols (abfd, sec))
5899 relax_info->visited++;
5904 /* Initialization for relaxation. */
5906 /* This function is called once at the start of relaxation. It scans
5907 all the input sections and marks the ones that are relaxable (i.e.,
5908 literal sections with L32R relocations against them), and then
5909 collects source_reloc information for all the relocations against
5910 those relaxable sections. During this process, it also detects
5911 longcalls, i.e., calls relaxed by the assembler into indirect
5912 calls, that can be optimized back into direct calls. Within each
5913 extended basic block (ebb) containing an optimized longcall, it
5914 computes a set of "text actions" that can be performed to remove
5915 the L32R associated with the longcall while optionally preserving
5916 branch target alignments. */
5919 analyze_relocations (struct bfd_link_info *link_info)
5923 bfd_boolean is_relaxable = FALSE;
5925 /* Initialize the per-section relaxation info. */
5926 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5927 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5929 init_xtensa_relax_info (sec);
5932 /* Mark relaxable sections (and count relocations against each one). */
5933 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5934 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5936 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
5940 /* Bail out if there are no relaxable sections. */
5944 /* Allocate space for source_relocs. */
5945 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5946 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5948 xtensa_relax_info *relax_info;
5950 relax_info = get_xtensa_relax_info (sec);
5951 if (relax_info->is_relaxable_literal_section
5952 || relax_info->is_relaxable_asm_section)
5954 relax_info->src_relocs = (source_reloc *)
5955 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
5959 /* Collect info on relocations against each relaxable section. */
5960 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5961 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5963 if (!collect_source_relocs (abfd, sec, link_info))
5967 /* Compute the text actions. */
5968 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5969 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5971 if (!compute_text_actions (abfd, sec, link_info))
5979 /* Find all the sections that might be relaxed. The motivation for
5980 this pass is that collect_source_relocs() needs to record _all_ the
5981 relocations that target each relaxable section. That is expensive
5982 and unnecessary unless the target section is actually going to be
5983 relaxed. This pass identifies all such sections by checking if
5984 they have L32Rs pointing to them. In the process, the total number
5985 of relocations targeting each section is also counted so that we
5986 know how much space to allocate for source_relocs against each
5987 relaxable literal section. */
5990 find_relaxable_sections (bfd *abfd,
5992 struct bfd_link_info *link_info,
5993 bfd_boolean *is_relaxable_p)
5995 Elf_Internal_Rela *internal_relocs;
5997 bfd_boolean ok = TRUE;
5999 xtensa_relax_info *source_relax_info;
6001 internal_relocs = retrieve_internal_relocs (abfd, sec,
6002 link_info->keep_memory);
6003 if (internal_relocs == NULL)
6006 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6007 if (contents == NULL && sec->size != 0)
6013 source_relax_info = get_xtensa_relax_info (sec);
6014 for (i = 0; i < sec->reloc_count; i++)
6016 Elf_Internal_Rela *irel = &internal_relocs[i];
6018 asection *target_sec;
6019 xtensa_relax_info *target_relax_info;
6021 /* If this section has not already been marked as "relaxable", and
6022 if it contains any ASM_EXPAND relocations (marking expanded
6023 longcalls) that can be optimized into direct calls, then mark
6024 the section as "relaxable". */
6025 if (source_relax_info
6026 && !source_relax_info->is_relaxable_asm_section
6027 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
6029 bfd_boolean is_reachable = FALSE;
6030 if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
6031 link_info, &is_reachable)
6034 source_relax_info->is_relaxable_asm_section = TRUE;
6035 *is_relaxable_p = TRUE;
6039 r_reloc_init (&r_rel, abfd, irel, contents,
6040 bfd_get_section_limit (abfd, sec));
6042 target_sec = r_reloc_get_section (&r_rel);
6043 target_relax_info = get_xtensa_relax_info (target_sec);
6044 if (!target_relax_info)
6047 /* Count PC-relative operand relocations against the target section.
6048 Note: The conditions tested here must match the conditions under
6049 which init_source_reloc is called in collect_source_relocs(). */
6050 if (is_operand_relocation (ELF32_R_TYPE (irel->r_info))
6051 && (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
6052 || is_l32r_relocation (abfd, sec, contents, irel)))
6053 target_relax_info->src_count++;
6055 if (is_l32r_relocation (abfd, sec, contents, irel)
6056 && r_reloc_is_defined (&r_rel))
6058 /* Mark the target section as relaxable. */
6059 target_relax_info->is_relaxable_literal_section = TRUE;
6060 *is_relaxable_p = TRUE;
6065 release_contents (sec, contents);
6066 release_internal_relocs (sec, internal_relocs);
6071 /* Record _all_ the relocations that point to relaxable sections, and
6072 get rid of ASM_EXPAND relocs by either converting them to
6073 ASM_SIMPLIFY or by removing them. */
6076 collect_source_relocs (bfd *abfd,
6078 struct bfd_link_info *link_info)
6080 Elf_Internal_Rela *internal_relocs;
6082 bfd_boolean ok = TRUE;
6084 bfd_size_type sec_size;
6086 internal_relocs = retrieve_internal_relocs (abfd, sec,
6087 link_info->keep_memory);
6088 if (internal_relocs == NULL)
6091 sec_size = bfd_get_section_limit (abfd, sec);
6092 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6093 if (contents == NULL && sec_size != 0)
6099 /* Record relocations against relaxable literal sections. */
6100 for (i = 0; i < sec->reloc_count; i++)
6102 Elf_Internal_Rela *irel = &internal_relocs[i];
6104 asection *target_sec;
6105 xtensa_relax_info *target_relax_info;
6107 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6109 target_sec = r_reloc_get_section (&r_rel);
6110 target_relax_info = get_xtensa_relax_info (target_sec);
6112 if (target_relax_info
6113 && (target_relax_info->is_relaxable_literal_section
6114 || target_relax_info->is_relaxable_asm_section))
6116 xtensa_opcode opcode = XTENSA_UNDEFINED;
6118 bfd_boolean is_abs_literal = FALSE;
6120 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
6122 /* None of the current alternate relocs are PC-relative,
6123 and only PC-relative relocs matter here. However, we
6124 still need to record the opcode for literal
6126 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6127 if (opcode == get_l32r_opcode ())
6129 is_abs_literal = TRUE;
6133 opcode = XTENSA_UNDEFINED;
6135 else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6137 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6138 opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
6141 if (opcode != XTENSA_UNDEFINED)
6143 int src_next = target_relax_info->src_next++;
6144 source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
6146 init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
6152 /* Now get rid of ASM_EXPAND relocations. At this point, the
6153 src_relocs array for the target literal section may still be
6154 incomplete, but it must at least contain the entries for the L32R
6155 relocations associated with ASM_EXPANDs because they were just
6156 added in the preceding loop over the relocations. */
6158 for (i = 0; i < sec->reloc_count; i++)
6160 Elf_Internal_Rela *irel = &internal_relocs[i];
6161 bfd_boolean is_reachable;
6163 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
6169 Elf_Internal_Rela *l32r_irel;
6171 asection *target_sec;
6172 xtensa_relax_info *target_relax_info;
6174 /* Mark the source_reloc for the L32R so that it will be
6175 removed in compute_removed_literals(), along with the
6176 associated literal. */
6177 l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
6178 irel, internal_relocs);
6179 if (l32r_irel == NULL)
6182 r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
6184 target_sec = r_reloc_get_section (&r_rel);
6185 target_relax_info = get_xtensa_relax_info (target_sec);
6187 if (target_relax_info
6188 && (target_relax_info->is_relaxable_literal_section
6189 || target_relax_info->is_relaxable_asm_section))
6191 source_reloc *s_reloc;
6193 /* Search the source_relocs for the entry corresponding to
6194 the l32r_irel. Note: The src_relocs array is not yet
6195 sorted, but it wouldn't matter anyway because we're
6196 searching by source offset instead of target offset. */
6197 s_reloc = find_source_reloc (target_relax_info->src_relocs,
6198 target_relax_info->src_next,
6200 BFD_ASSERT (s_reloc);
6201 s_reloc->is_null = TRUE;
6204 /* Convert this reloc to ASM_SIMPLIFY. */
6205 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
6206 R_XTENSA_ASM_SIMPLIFY);
6207 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
6209 pin_internal_relocs (sec, internal_relocs);
6213 /* It is resolvable but doesn't reach. We resolve now
6214 by eliminating the relocation -- the call will remain
6215 expanded into L32R/CALLX. */
6216 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
6217 pin_internal_relocs (sec, internal_relocs);
6222 release_contents (sec, contents);
6223 release_internal_relocs (sec, internal_relocs);
6228 /* Return TRUE if the asm expansion can be resolved. Generally it can
6229 be resolved on a final link or when a partial link locates it in the
6230 same section as the target. Set "is_reachable" flag if the target of
6231 the call is within the range of a direct call, given the current VMA
6232 for this section and the target section. */
6235 is_resolvable_asm_expansion (bfd *abfd,
6238 Elf_Internal_Rela *irel,
6239 struct bfd_link_info *link_info,
6240 bfd_boolean *is_reachable_p)
6242 asection *target_sec;
6243 bfd_vma target_offset;
6245 xtensa_opcode opcode, direct_call_opcode;
6246 bfd_vma self_address;
6247 bfd_vma dest_address;
6248 bfd_boolean uses_l32r;
6249 bfd_size_type sec_size;
6251 *is_reachable_p = FALSE;
6253 if (contents == NULL)
6256 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
6259 sec_size = bfd_get_section_limit (abfd, sec);
6260 opcode = get_expanded_call_opcode (contents + irel->r_offset,
6261 sec_size - irel->r_offset, &uses_l32r);
6262 /* Optimization of longcalls that use CONST16 is not yet implemented. */
6266 direct_call_opcode = swap_callx_for_call_opcode (opcode);
6267 if (direct_call_opcode == XTENSA_UNDEFINED)
6270 /* Check and see that the target resolves. */
6271 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6272 if (!r_reloc_is_defined (&r_rel))
6275 target_sec = r_reloc_get_section (&r_rel);
6276 target_offset = r_rel.target_offset;
6278 /* If the target is in a shared library, then it doesn't reach. This
6279 isn't supposed to come up because the compiler should never generate
6280 non-PIC calls on systems that use shared libraries, but the linker
6281 shouldn't crash regardless. */
6282 if (!target_sec->output_section)
6285 /* For relocatable sections, we can only simplify when the output
6286 section of the target is the same as the output section of the
6288 if (link_info->relocatable
6289 && (target_sec->output_section != sec->output_section
6290 || is_reloc_sym_weak (abfd, irel)))
6293 self_address = (sec->output_section->vma
6294 + sec->output_offset + irel->r_offset + 3);
6295 dest_address = (target_sec->output_section->vma
6296 + target_sec->output_offset + target_offset);
6298 *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
6299 self_address, dest_address);
6301 if ((self_address >> CALL_SEGMENT_BITS) !=
6302 (dest_address >> CALL_SEGMENT_BITS))
6309 static Elf_Internal_Rela *
6310 find_associated_l32r_irel (bfd *abfd,
6313 Elf_Internal_Rela *other_irel,
6314 Elf_Internal_Rela *internal_relocs)
6318 for (i = 0; i < sec->reloc_count; i++)
6320 Elf_Internal_Rela *irel = &internal_relocs[i];
6322 if (irel == other_irel)
6324 if (irel->r_offset != other_irel->r_offset)
6326 if (is_l32r_relocation (abfd, sec, contents, irel))
6334 static xtensa_opcode *
6335 build_reloc_opcodes (bfd *abfd,
6338 Elf_Internal_Rela *internal_relocs)
6341 xtensa_opcode *reloc_opcodes =
6342 (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
6343 for (i = 0; i < sec->reloc_count; i++)
6345 Elf_Internal_Rela *irel = &internal_relocs[i];
6346 reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
6348 return reloc_opcodes;
6352 /* The compute_text_actions function will build a list of potential
6353 transformation actions for code in the extended basic block of each
6354 longcall that is optimized to a direct call. From this list we
6355 generate a set of actions to actually perform that optimizes for
6356 space and, if not using size_opt, maintains branch target
6359 These actions to be performed are placed on a per-section list.
6360 The actual changes are performed by relax_section() in the second
6364 compute_text_actions (bfd *abfd,
6366 struct bfd_link_info *link_info)
6368 xtensa_opcode *reloc_opcodes = NULL;
6369 xtensa_relax_info *relax_info;
6371 Elf_Internal_Rela *internal_relocs;
6372 bfd_boolean ok = TRUE;
6374 property_table_entry *prop_table = 0;
6376 bfd_size_type sec_size;
6377 static bfd_boolean no_insn_move = FALSE;
6382 /* Do nothing if the section contains no optimized longcalls. */
6383 relax_info = get_xtensa_relax_info (sec);
6384 BFD_ASSERT (relax_info);
6385 if (!relax_info->is_relaxable_asm_section)
6388 internal_relocs = retrieve_internal_relocs (abfd, sec,
6389 link_info->keep_memory);
6391 if (internal_relocs)
6392 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
6393 internal_reloc_compare);
6395 sec_size = bfd_get_section_limit (abfd, sec);
6396 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6397 if (contents == NULL && sec_size != 0)
6403 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6404 XTENSA_PROP_SEC_NAME, FALSE);
6411 for (i = 0; i < sec->reloc_count; i++)
6413 Elf_Internal_Rela *irel = &internal_relocs[i];
6415 property_table_entry *the_entry;
6418 ebb_constraint ebb_table;
6419 bfd_size_type simplify_size;
6421 if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
6423 r_offset = irel->r_offset;
6425 simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
6426 if (simplify_size == 0)
6428 (*_bfd_error_handler)
6429 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
6430 sec->owner, sec, r_offset);
6434 /* If the instruction table is not around, then don't do this
6436 the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
6437 sec->vma + irel->r_offset);
6438 if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
6440 text_action_add (&relax_info->action_list,
6441 ta_convert_longcall, sec, r_offset,
6446 /* If the next longcall happens to be at the same address as an
6447 unreachable section of size 0, then skip forward. */
6448 ptbl_idx = the_entry - prop_table;
6449 while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
6450 && the_entry->size == 0
6451 && ptbl_idx + 1 < ptblsize
6452 && (prop_table[ptbl_idx + 1].address
6453 == prop_table[ptbl_idx].address))
6459 if (the_entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM)
6460 /* NO_REORDER is OK */
6463 init_ebb_constraint (&ebb_table);
6464 ebb = &ebb_table.ebb;
6465 init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
6466 internal_relocs, sec->reloc_count);
6467 ebb->start_offset = r_offset + simplify_size;
6468 ebb->end_offset = r_offset + simplify_size;
6469 ebb->start_ptbl_idx = ptbl_idx;
6470 ebb->end_ptbl_idx = ptbl_idx;
6471 ebb->start_reloc_idx = i;
6472 ebb->end_reloc_idx = i;
6474 /* Precompute the opcode for each relocation. */
6475 if (reloc_opcodes == NULL)
6476 reloc_opcodes = build_reloc_opcodes (abfd, sec, contents,
6479 if (!extend_ebb_bounds (ebb)
6480 || !compute_ebb_proposed_actions (&ebb_table)
6481 || !compute_ebb_actions (&ebb_table)
6482 || !check_section_ebb_pcrels_fit (abfd, sec, contents,
6483 internal_relocs, &ebb_table,
6485 || !check_section_ebb_reduces (&ebb_table))
6487 /* If anything goes wrong or we get unlucky and something does
6488 not fit, with our plan because of expansion between
6489 critical branches, just convert to a NOP. */
6491 text_action_add (&relax_info->action_list,
6492 ta_convert_longcall, sec, r_offset, 0);
6493 i = ebb_table.ebb.end_reloc_idx;
6494 free_ebb_constraint (&ebb_table);
6498 text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
6500 /* Update the index so we do not go looking at the relocations
6501 we have already processed. */
6502 i = ebb_table.ebb.end_reloc_idx;
6503 free_ebb_constraint (&ebb_table);
6507 if (relax_info->action_list.head)
6508 print_action_list (stderr, &relax_info->action_list);
6512 release_contents (sec, contents);
6513 release_internal_relocs (sec, internal_relocs);
6517 free (reloc_opcodes);
6523 /* Do not widen an instruction if it is preceeded by a
6524 loop opcode. It might cause misalignment. */
6527 prev_instr_is_a_loop (bfd_byte *contents,
6528 bfd_size_type content_length,
6529 bfd_size_type offset)
6531 xtensa_opcode prev_opcode;
6535 prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
6536 return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
6540 /* Find all of the possible actions for an extended basic block. */
6543 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
6545 const ebb_t *ebb = &ebb_table->ebb;
6546 unsigned rel_idx = ebb->start_reloc_idx;
6547 property_table_entry *entry, *start_entry, *end_entry;
6549 xtensa_isa isa = xtensa_default_isa;
6551 static xtensa_insnbuf insnbuf = NULL;
6552 static xtensa_insnbuf slotbuf = NULL;
6554 if (insnbuf == NULL)
6556 insnbuf = xtensa_insnbuf_alloc (isa);
6557 slotbuf = xtensa_insnbuf_alloc (isa);
6560 start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6561 end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6563 for (entry = start_entry; entry <= end_entry; entry++)
6565 bfd_vma start_offset, end_offset;
6566 bfd_size_type insn_len;
6568 start_offset = entry->address - ebb->sec->vma;
6569 end_offset = entry->address + entry->size - ebb->sec->vma;
6571 if (entry == start_entry)
6572 start_offset = ebb->start_offset;
6573 if (entry == end_entry)
6574 end_offset = ebb->end_offset;
6575 offset = start_offset;
6577 if (offset == entry->address - ebb->sec->vma
6578 && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
6580 enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
6581 BFD_ASSERT (offset != end_offset);
6582 if (offset == end_offset)
6585 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
6590 if (check_branch_target_aligned_address (offset, insn_len))
6591 align_type = EBB_REQUIRE_TGT_ALIGN;
6593 ebb_propose_action (ebb_table, align_type, 0,
6594 ta_none, offset, 0, TRUE);
6597 while (offset != end_offset)
6599 Elf_Internal_Rela *irel;
6600 xtensa_opcode opcode;
6602 while (rel_idx < ebb->end_reloc_idx
6603 && (ebb->relocs[rel_idx].r_offset < offset
6604 || (ebb->relocs[rel_idx].r_offset == offset
6605 && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
6606 != R_XTENSA_ASM_SIMPLIFY))))
6609 /* Check for longcall. */
6610 irel = &ebb->relocs[rel_idx];
6611 if (irel->r_offset == offset
6612 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
6614 bfd_size_type simplify_size;
6616 simplify_size = get_asm_simplify_size (ebb->contents,
6617 ebb->content_length,
6619 if (simplify_size == 0)
6622 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6623 ta_convert_longcall, offset, 0, TRUE);
6625 offset += simplify_size;
6629 if (offset + MIN_INSN_LENGTH > ebb->content_length)
6631 xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
6632 ebb->content_length - offset);
6633 fmt = xtensa_format_decode (isa, insnbuf);
6634 if (fmt == XTENSA_UNDEFINED)
6636 insn_len = xtensa_format_length (isa, fmt);
6637 if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
6640 if (xtensa_format_num_slots (isa, fmt) != 1)
6646 xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
6647 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
6648 if (opcode == XTENSA_UNDEFINED)
6651 if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
6652 && (entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) == 0
6653 && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
6655 /* Add an instruction narrow action. */
6656 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6657 ta_narrow_insn, offset, 0, FALSE);
6659 else if ((entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) == 0
6660 && can_widen_instruction (slotbuf, fmt, opcode) != 0
6661 && ! prev_instr_is_a_loop (ebb->contents,
6662 ebb->content_length, offset))
6664 /* Add an instruction widen action. */
6665 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6666 ta_widen_insn, offset, 0, FALSE);
6668 else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
6670 /* Check for branch targets. */
6671 ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
6672 ta_none, offset, 0, TRUE);
6679 if (ebb->ends_unreachable)
6681 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6682 ta_fill, ebb->end_offset, 0, TRUE);
6688 (*_bfd_error_handler)
6689 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6690 ebb->sec->owner, ebb->sec, offset);
6695 /* After all of the information has collected about the
6696 transformations possible in an EBB, compute the appropriate actions
6697 here in compute_ebb_actions. We still must check later to make
6698 sure that the actions do not break any relocations. The algorithm
6699 used here is pretty greedy. Basically, it removes as many no-ops
6700 as possible so that the end of the EBB has the same alignment
6701 characteristics as the original. First, it uses narrowing, then
6702 fill space at the end of the EBB, and finally widenings. If that
6703 does not work, it tries again with one fewer no-op removed. The
6704 optimization will only be performed if all of the branch targets
6705 that were aligned before transformation are also aligned after the
6708 When the size_opt flag is set, ignore the branch target alignments,
6709 narrow all wide instructions, and remove all no-ops unless the end
6710 of the EBB prevents it. */
6713 compute_ebb_actions (ebb_constraint *ebb_table)
6717 int removed_bytes = 0;
6718 ebb_t *ebb = &ebb_table->ebb;
6719 unsigned seg_idx_start = 0;
6720 unsigned seg_idx_end = 0;
6722 /* We perform this like the assembler relaxation algorithm: Start by
6723 assuming all instructions are narrow and all no-ops removed; then
6726 /* For each segment of this that has a solid constraint, check to
6727 see if there are any combinations that will keep the constraint.
6729 for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
6731 bfd_boolean requires_text_end_align = FALSE;
6732 unsigned longcall_count = 0;
6733 unsigned longcall_convert_count = 0;
6734 unsigned narrowable_count = 0;
6735 unsigned narrowable_convert_count = 0;
6736 unsigned widenable_count = 0;
6737 unsigned widenable_convert_count = 0;
6739 proposed_action *action = NULL;
6740 int align = (1 << ebb_table->ebb.sec->alignment_power);
6742 seg_idx_start = seg_idx_end;
6744 for (i = seg_idx_start; i < ebb_table->action_count; i++)
6746 action = &ebb_table->actions[i];
6747 if (action->action == ta_convert_longcall)
6749 if (action->action == ta_narrow_insn)
6751 if (action->action == ta_widen_insn)
6753 if (action->action == ta_fill)
6755 if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
6757 if (action->align_type == EBB_REQUIRE_TGT_ALIGN
6758 && !elf32xtensa_size_opt)
6763 if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
6764 requires_text_end_align = TRUE;
6766 if (elf32xtensa_size_opt && !requires_text_end_align
6767 && action->align_type != EBB_REQUIRE_LOOP_ALIGN
6768 && action->align_type != EBB_REQUIRE_TGT_ALIGN)
6770 longcall_convert_count = longcall_count;
6771 narrowable_convert_count = narrowable_count;
6772 widenable_convert_count = 0;
6776 /* There is a constraint. Convert the max number of longcalls. */
6777 narrowable_convert_count = 0;
6778 longcall_convert_count = 0;
6779 widenable_convert_count = 0;
6781 for (j = 0; j < longcall_count; j++)
6783 int removed = (longcall_count - j) * 3 & (align - 1);
6784 unsigned desire_narrow = (align - removed) & (align - 1);
6785 unsigned desire_widen = removed;
6786 if (desire_narrow <= narrowable_count)
6788 narrowable_convert_count = desire_narrow;
6789 narrowable_convert_count +=
6790 (align * ((narrowable_count - narrowable_convert_count)
6792 longcall_convert_count = (longcall_count - j);
6793 widenable_convert_count = 0;
6796 if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
6798 narrowable_convert_count = 0;
6799 longcall_convert_count = longcall_count - j;
6800 widenable_convert_count = desire_widen;
6806 /* Now the number of conversions are saved. Do them. */
6807 for (i = seg_idx_start; i < seg_idx_end; i++)
6809 action = &ebb_table->actions[i];
6810 switch (action->action)
6812 case ta_convert_longcall:
6813 if (longcall_convert_count != 0)
6815 action->action = ta_remove_longcall;
6816 action->do_action = TRUE;
6817 action->removed_bytes += 3;
6818 longcall_convert_count--;
6821 case ta_narrow_insn:
6822 if (narrowable_convert_count != 0)
6824 action->do_action = TRUE;
6825 action->removed_bytes += 1;
6826 narrowable_convert_count--;
6830 if (widenable_convert_count != 0)
6832 action->do_action = TRUE;
6833 action->removed_bytes -= 1;
6834 widenable_convert_count--;
6843 /* Now we move on to some local opts. Try to remove each of the
6844 remaining longcalls. */
6846 if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
6849 for (i = 0; i < ebb_table->action_count; i++)
6851 int old_removed_bytes = removed_bytes;
6852 proposed_action *action = &ebb_table->actions[i];
6854 if (action->do_action && action->action == ta_convert_longcall)
6856 bfd_boolean bad_alignment = FALSE;
6858 for (j = i + 1; j < ebb_table->action_count; j++)
6860 proposed_action *new_action = &ebb_table->actions[j];
6861 bfd_vma offset = new_action->offset;
6862 if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
6864 if (!check_branch_target_aligned
6865 (ebb_table->ebb.contents,
6866 ebb_table->ebb.content_length,
6867 offset, offset - removed_bytes))
6869 bad_alignment = TRUE;
6873 if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
6875 if (!check_loop_aligned (ebb_table->ebb.contents,
6876 ebb_table->ebb.content_length,
6878 offset - removed_bytes))
6880 bad_alignment = TRUE;
6884 if (new_action->action == ta_narrow_insn
6885 && !new_action->do_action
6886 && ebb_table->ebb.sec->alignment_power == 2)
6888 /* Narrow an instruction and we are done. */
6889 new_action->do_action = TRUE;
6890 new_action->removed_bytes += 1;
6891 bad_alignment = FALSE;
6894 if (new_action->action == ta_widen_insn
6895 && new_action->do_action
6896 && ebb_table->ebb.sec->alignment_power == 2)
6898 /* Narrow an instruction and we are done. */
6899 new_action->do_action = FALSE;
6900 new_action->removed_bytes += 1;
6901 bad_alignment = FALSE;
6907 action->removed_bytes += 3;
6908 action->action = ta_remove_longcall;
6909 action->do_action = TRUE;
6912 removed_bytes = old_removed_bytes;
6913 if (action->do_action)
6914 removed_bytes += action->removed_bytes;
6919 for (i = 0; i < ebb_table->action_count; ++i)
6921 proposed_action *action = &ebb_table->actions[i];
6922 if (action->do_action)
6923 removed_bytes += action->removed_bytes;
6926 if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
6927 && ebb->ends_unreachable)
6929 proposed_action *action;
6933 BFD_ASSERT (ebb_table->action_count != 0);
6934 action = &ebb_table->actions[ebb_table->action_count - 1];
6935 BFD_ASSERT (action->action == ta_fill);
6936 BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
6938 extra_space = compute_fill_extra_space (ebb->ends_unreachable);
6939 br = action->removed_bytes + removed_bytes + extra_space;
6940 br = br & ((1 << ebb->sec->alignment_power ) - 1);
6942 action->removed_bytes = extra_space - br;
6948 /* The xlate_map is a sorted array of address mappings designed to
6949 answer the offset_with_removed_text() query with a binary search instead
6950 of a linear search through the section's action_list. */
6952 typedef struct xlate_map_entry xlate_map_entry_t;
6953 typedef struct xlate_map xlate_map_t;
6955 struct xlate_map_entry
6957 unsigned orig_address;
6958 unsigned new_address;
6964 unsigned entry_count;
6965 xlate_map_entry_t *entry;
6970 xlate_compare (const void *a_v, const void *b_v)
6972 const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
6973 const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
6974 if (a->orig_address < b->orig_address)
6976 if (a->orig_address > (b->orig_address + b->size - 1))
6983 xlate_offset_with_removed_text (const xlate_map_t *map,
6984 text_action_list *action_list,
6987 xlate_map_entry_t tmp;
6989 xlate_map_entry_t *e;
6992 return offset_with_removed_text (action_list, offset);
6994 if (map->entry_count == 0)
6997 tmp.orig_address = offset;
6998 tmp.new_address = offset;
7001 r = bsearch (&offset, map->entry, map->entry_count,
7002 sizeof (xlate_map_entry_t), &xlate_compare);
7003 e = (xlate_map_entry_t *) r;
7005 BFD_ASSERT (e != NULL);
7008 return e->new_address - e->orig_address + offset;
7012 /* Build a binary searchable offset translation map from a section's
7015 static xlate_map_t *
7016 build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
7018 xlate_map_t *map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
7019 text_action_list *action_list = &relax_info->action_list;
7020 unsigned num_actions = 0;
7023 xlate_map_entry_t *current_entry;
7028 num_actions = action_list_count (action_list);
7029 map->entry = (xlate_map_entry_t *)
7030 bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
7031 if (map->entry == NULL)
7036 map->entry_count = 0;
7039 current_entry = &map->entry[0];
7041 current_entry->orig_address = 0;
7042 current_entry->new_address = 0;
7043 current_entry->size = 0;
7045 for (r = action_list->head; r != NULL; r = r->next)
7047 unsigned orig_size = 0;
7051 case ta_remove_insn:
7052 case ta_convert_longcall:
7053 case ta_remove_literal:
7054 case ta_add_literal:
7056 case ta_remove_longcall:
7059 case ta_narrow_insn:
7068 current_entry->size =
7069 r->offset + orig_size - current_entry->orig_address;
7070 if (current_entry->size != 0)
7075 current_entry->orig_address = r->offset + orig_size;
7076 removed += r->removed_bytes;
7077 current_entry->new_address = r->offset + orig_size - removed;
7078 current_entry->size = 0;
7081 current_entry->size = (bfd_get_section_limit (sec->owner, sec)
7082 - current_entry->orig_address);
7083 if (current_entry->size != 0)
7090 /* Free an offset translation map. */
7093 free_xlate_map (xlate_map_t *map)
7095 if (map && map->entry)
7102 /* Use check_section_ebb_pcrels_fit to make sure that all of the
7103 relocations in a section will fit if a proposed set of actions
7107 check_section_ebb_pcrels_fit (bfd *abfd,
7110 Elf_Internal_Rela *internal_relocs,
7111 const ebb_constraint *constraint,
7112 const xtensa_opcode *reloc_opcodes)
7115 Elf_Internal_Rela *irel;
7116 xlate_map_t *xmap = NULL;
7117 bfd_boolean ok = TRUE;
7118 xtensa_relax_info *relax_info;
7120 relax_info = get_xtensa_relax_info (sec);
7122 if (relax_info && sec->reloc_count > 100)
7124 xmap = build_xlate_map (sec, relax_info);
7125 /* NULL indicates out of memory, but the slow version
7126 can still be used. */
7129 for (i = 0; i < sec->reloc_count; i++)
7132 bfd_vma orig_self_offset, orig_target_offset;
7133 bfd_vma self_offset, target_offset;
7135 reloc_howto_type *howto;
7136 int self_removed_bytes, target_removed_bytes;
7138 irel = &internal_relocs[i];
7139 r_type = ELF32_R_TYPE (irel->r_info);
7141 howto = &elf_howto_table[r_type];
7142 /* We maintain the required invariant: PC-relative relocations
7143 that fit before linking must fit after linking. Thus we only
7144 need to deal with relocations to the same section that are
7146 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY
7147 || !howto->pc_relative)
7150 r_reloc_init (&r_rel, abfd, irel, contents,
7151 bfd_get_section_limit (abfd, sec));
7153 if (r_reloc_get_section (&r_rel) != sec)
7156 orig_self_offset = irel->r_offset;
7157 orig_target_offset = r_rel.target_offset;
7159 self_offset = orig_self_offset;
7160 target_offset = orig_target_offset;
7165 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
7168 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
7169 orig_target_offset);
7172 self_removed_bytes = 0;
7173 target_removed_bytes = 0;
7175 for (j = 0; j < constraint->action_count; ++j)
7177 proposed_action *action = &constraint->actions[j];
7178 bfd_vma offset = action->offset;
7179 int removed_bytes = action->removed_bytes;
7180 if (offset < orig_self_offset
7181 || (offset == orig_self_offset && action->action == ta_fill
7182 && action->removed_bytes < 0))
7183 self_removed_bytes += removed_bytes;
7184 if (offset < orig_target_offset
7185 || (offset == orig_target_offset && action->action == ta_fill
7186 && action->removed_bytes < 0))
7187 target_removed_bytes += removed_bytes;
7189 self_offset -= self_removed_bytes;
7190 target_offset -= target_removed_bytes;
7192 /* Try to encode it. Get the operand and check. */
7193 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7195 /* None of the current alternate relocs are PC-relative,
7196 and only PC-relative relocs matter here. */
7200 xtensa_opcode opcode;
7204 opcode = reloc_opcodes[i];
7206 opcode = get_relocation_opcode (abfd, sec, contents, irel);
7207 if (opcode == XTENSA_UNDEFINED)
7213 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7214 if (opnum == XTENSA_UNDEFINED)
7220 if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
7229 free_xlate_map (xmap);
7236 check_section_ebb_reduces (const ebb_constraint *constraint)
7241 for (i = 0; i < constraint->action_count; i++)
7243 const proposed_action *action = &constraint->actions[i];
7244 if (action->do_action)
7245 removed += action->removed_bytes;
7255 text_action_add_proposed (text_action_list *l,
7256 const ebb_constraint *ebb_table,
7261 for (i = 0; i < ebb_table->action_count; i++)
7263 proposed_action *action = &ebb_table->actions[i];
7265 if (!action->do_action)
7267 switch (action->action)
7269 case ta_remove_insn:
7270 case ta_remove_longcall:
7271 case ta_convert_longcall:
7272 case ta_narrow_insn:
7275 case ta_remove_literal:
7276 text_action_add (l, action->action, sec, action->offset,
7277 action->removed_bytes);
7290 compute_fill_extra_space (property_table_entry *entry)
7292 int fill_extra_space;
7297 if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
7300 fill_extra_space = entry->size;
7301 if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
7303 /* Fill bytes for alignment:
7304 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
7305 int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
7306 int nsm = (1 << pow) - 1;
7307 bfd_vma addr = entry->address + entry->size;
7308 bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
7309 fill_extra_space += align_fill;
7311 return fill_extra_space;
7315 /* First relaxation pass. */
7317 /* If the section contains relaxable literals, check each literal to
7318 see if it has the same value as another literal that has already
7319 been seen, either in the current section or a previous one. If so,
7320 add an entry to the per-section list of removed literals. The
7321 actual changes are deferred until the next pass. */
7324 compute_removed_literals (bfd *abfd,
7326 struct bfd_link_info *link_info,
7327 value_map_hash_table *values)
7329 xtensa_relax_info *relax_info;
7331 Elf_Internal_Rela *internal_relocs;
7332 source_reloc *src_relocs, *rel;
7333 bfd_boolean ok = TRUE;
7334 property_table_entry *prop_table = NULL;
7337 bfd_boolean last_loc_is_prev = FALSE;
7338 bfd_vma last_target_offset = 0;
7339 section_cache_t target_sec_cache;
7340 bfd_size_type sec_size;
7342 init_section_cache (&target_sec_cache);
7344 /* Do nothing if it is not a relaxable literal section. */
7345 relax_info = get_xtensa_relax_info (sec);
7346 BFD_ASSERT (relax_info);
7347 if (!relax_info->is_relaxable_literal_section)
7350 internal_relocs = retrieve_internal_relocs (abfd, sec,
7351 link_info->keep_memory);
7353 sec_size = bfd_get_section_limit (abfd, sec);
7354 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7355 if (contents == NULL && sec_size != 0)
7361 /* Sort the source_relocs by target offset. */
7362 src_relocs = relax_info->src_relocs;
7363 qsort (src_relocs, relax_info->src_count,
7364 sizeof (source_reloc), source_reloc_compare);
7365 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7366 internal_reloc_compare);
7368 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7369 XTENSA_PROP_SEC_NAME, FALSE);
7377 for (i = 0; i < relax_info->src_count; i++)
7379 Elf_Internal_Rela *irel = NULL;
7381 rel = &src_relocs[i];
7382 if (get_l32r_opcode () != rel->opcode)
7384 irel = get_irel_at_offset (sec, internal_relocs,
7385 rel->r_rel.target_offset);
7387 /* If the relocation on this is not a simple R_XTENSA_32 or
7388 R_XTENSA_PLT then do not consider it. This may happen when
7389 the difference of two symbols is used in a literal. */
7390 if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
7391 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
7394 /* If the target_offset for this relocation is the same as the
7395 previous relocation, then we've already considered whether the
7396 literal can be coalesced. Skip to the next one.... */
7397 if (i != 0 && prev_i != -1
7398 && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
7402 if (last_loc_is_prev &&
7403 last_target_offset + 4 != rel->r_rel.target_offset)
7404 last_loc_is_prev = FALSE;
7406 /* Check if the relocation was from an L32R that is being removed
7407 because a CALLX was converted to a direct CALL, and check if
7408 there are no other relocations to the literal. */
7409 if (is_removable_literal (rel, i, src_relocs, relax_info->src_count))
7411 if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
7412 irel, rel, prop_table, ptblsize))
7417 last_target_offset = rel->r_rel.target_offset;
7421 if (!identify_literal_placement (abfd, sec, contents, link_info,
7423 &last_loc_is_prev, irel,
7424 relax_info->src_count - i, rel,
7425 prop_table, ptblsize,
7426 &target_sec_cache, rel->is_abs_literal))
7431 last_target_offset = rel->r_rel.target_offset;
7435 print_removed_literals (stderr, &relax_info->removed_list);
7436 print_action_list (stderr, &relax_info->action_list);
7440 if (prop_table) free (prop_table);
7441 clear_section_cache (&target_sec_cache);
7443 release_contents (sec, contents);
7444 release_internal_relocs (sec, internal_relocs);
7449 static Elf_Internal_Rela *
7450 get_irel_at_offset (asection *sec,
7451 Elf_Internal_Rela *internal_relocs,
7455 Elf_Internal_Rela *irel;
7457 Elf_Internal_Rela key;
7459 if (!internal_relocs)
7462 key.r_offset = offset;
7463 irel = bsearch (&key, internal_relocs, sec->reloc_count,
7464 sizeof (Elf_Internal_Rela), internal_reloc_matches);
7468 /* bsearch does not guarantee which will be returned if there are
7469 multiple matches. We need the first that is not an alignment. */
7470 i = irel - internal_relocs;
7473 if (internal_relocs[i-1].r_offset != offset)
7477 for ( ; i < sec->reloc_count; i++)
7479 irel = &internal_relocs[i];
7480 r_type = ELF32_R_TYPE (irel->r_info);
7481 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
7490 is_removable_literal (const source_reloc *rel,
7492 const source_reloc *src_relocs,
7495 const source_reloc *curr_rel;
7499 for (++i; i < src_count; ++i)
7501 curr_rel = &src_relocs[i];
7502 /* If all others have the same target offset.... */
7503 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
7506 if (!curr_rel->is_null
7507 && !xtensa_is_property_section (curr_rel->source_sec)
7508 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
7516 remove_dead_literal (bfd *abfd,
7518 struct bfd_link_info *link_info,
7519 Elf_Internal_Rela *internal_relocs,
7520 Elf_Internal_Rela *irel,
7522 property_table_entry *prop_table,
7525 property_table_entry *entry;
7526 xtensa_relax_info *relax_info;
7528 relax_info = get_xtensa_relax_info (sec);
7532 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7533 sec->vma + rel->r_rel.target_offset);
7535 /* Mark the unused literal so that it will be removed. */
7536 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
7538 text_action_add (&relax_info->action_list,
7539 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7541 /* If the section is 4-byte aligned, do not add fill. */
7542 if (sec->alignment_power > 2)
7544 int fill_extra_space;
7545 bfd_vma entry_sec_offset;
7547 property_table_entry *the_add_entry;
7551 entry_sec_offset = entry->address - sec->vma + entry->size;
7553 entry_sec_offset = rel->r_rel.target_offset + 4;
7555 /* If the literal range is at the end of the section,
7557 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7559 fill_extra_space = compute_fill_extra_space (the_add_entry);
7561 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7562 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7563 -4, fill_extra_space);
7565 adjust_fill_action (fa, removed_diff);
7567 text_action_add (&relax_info->action_list,
7568 ta_fill, sec, entry_sec_offset, removed_diff);
7571 /* Zero out the relocation on this literal location. */
7574 if (elf_hash_table (link_info)->dynamic_sections_created)
7575 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
7577 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7578 pin_internal_relocs (sec, internal_relocs);
7581 /* Do not modify "last_loc_is_prev". */
7587 identify_literal_placement (bfd *abfd,
7590 struct bfd_link_info *link_info,
7591 value_map_hash_table *values,
7592 bfd_boolean *last_loc_is_prev_p,
7593 Elf_Internal_Rela *irel,
7594 int remaining_src_rels,
7596 property_table_entry *prop_table,
7598 section_cache_t *target_sec_cache,
7599 bfd_boolean is_abs_literal)
7603 xtensa_relax_info *relax_info;
7604 bfd_boolean literal_placed = FALSE;
7606 unsigned long value;
7607 bfd_boolean final_static_link;
7608 bfd_size_type sec_size;
7610 relax_info = get_xtensa_relax_info (sec);
7614 sec_size = bfd_get_section_limit (abfd, sec);
7617 (!link_info->relocatable
7618 && !elf_hash_table (link_info)->dynamic_sections_created);
7620 /* The placement algorithm first checks to see if the literal is
7621 already in the value map. If so and the value map is reachable
7622 from all uses, then the literal is moved to that location. If
7623 not, then we identify the last location where a fresh literal was
7624 placed. If the literal can be safely moved there, then we do so.
7625 If not, then we assume that the literal is not to move and leave
7626 the literal where it is, marking it as the last literal
7629 /* Find the literal value. */
7631 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7634 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
7635 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
7637 init_literal_value (&val, &r_rel, value, is_abs_literal);
7639 /* Check if we've seen another literal with the same value that
7640 is in the same output section. */
7641 val_map = value_map_get_cached_value (values, &val, final_static_link);
7644 && (r_reloc_get_section (&val_map->loc)->output_section
7645 == sec->output_section)
7646 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
7647 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
7649 /* No change to last_loc_is_prev. */
7650 literal_placed = TRUE;
7653 /* For relocatable links, do not try to move literals. To do it
7654 correctly might increase the number of relocations in an input
7655 section making the default relocatable linking fail. */
7656 if (!link_info->relocatable && !literal_placed
7657 && values->has_last_loc && !(*last_loc_is_prev_p))
7659 asection *target_sec = r_reloc_get_section (&values->last_loc);
7660 if (target_sec && target_sec->output_section == sec->output_section)
7662 /* Increment the virtual offset. */
7663 r_reloc try_loc = values->last_loc;
7664 try_loc.virtual_offset += 4;
7666 /* There is a last loc that was in the same output section. */
7667 if (relocations_reach (rel, remaining_src_rels, &try_loc)
7668 && move_shared_literal (sec, link_info, rel,
7669 prop_table, ptblsize,
7670 &try_loc, &val, target_sec_cache))
7672 values->last_loc.virtual_offset += 4;
7673 literal_placed = TRUE;
7675 val_map = add_value_map (values, &val, &try_loc,
7678 val_map->loc = try_loc;
7683 if (!literal_placed)
7685 /* Nothing worked, leave the literal alone but update the last loc. */
7686 values->has_last_loc = TRUE;
7687 values->last_loc = rel->r_rel;
7689 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
7691 val_map->loc = rel->r_rel;
7692 *last_loc_is_prev_p = TRUE;
7699 /* Check if the original relocations (presumably on L32R instructions)
7700 identified by reloc[0..N] can be changed to reference the literal
7701 identified by r_rel. If r_rel is out of range for any of the
7702 original relocations, then we don't want to coalesce the original
7703 literal with the one at r_rel. We only check reloc[0..N], where the
7704 offsets are all the same as for reloc[0] (i.e., they're all
7705 referencing the same literal) and where N is also bounded by the
7706 number of remaining entries in the "reloc" array. The "reloc" array
7707 is sorted by target offset so we know all the entries for the same
7708 literal will be contiguous. */
7711 relocations_reach (source_reloc *reloc,
7712 int remaining_relocs,
7713 const r_reloc *r_rel)
7715 bfd_vma from_offset, source_address, dest_address;
7719 if (!r_reloc_is_defined (r_rel))
7722 sec = r_reloc_get_section (r_rel);
7723 from_offset = reloc[0].r_rel.target_offset;
7725 for (i = 0; i < remaining_relocs; i++)
7727 if (reloc[i].r_rel.target_offset != from_offset)
7730 /* Ignore relocations that have been removed. */
7731 if (reloc[i].is_null)
7734 /* The original and new output section for these must be the same
7735 in order to coalesce. */
7736 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
7737 != sec->output_section)
7740 /* Absolute literals in the same output section can always be
7742 if (reloc[i].is_abs_literal)
7745 /* A literal with no PC-relative relocations can be moved anywhere. */
7746 if (reloc[i].opnd != -1)
7748 /* Otherwise, check to see that it fits. */
7749 source_address = (reloc[i].source_sec->output_section->vma
7750 + reloc[i].source_sec->output_offset
7751 + reloc[i].r_rel.rela.r_offset);
7752 dest_address = (sec->output_section->vma
7753 + sec->output_offset
7754 + r_rel->target_offset);
7756 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
7757 source_address, dest_address))
7766 /* Move a literal to another literal location because it is
7767 the same as the other literal value. */
7770 coalesce_shared_literal (asection *sec,
7772 property_table_entry *prop_table,
7776 property_table_entry *entry;
7778 property_table_entry *the_add_entry;
7780 xtensa_relax_info *relax_info;
7782 relax_info = get_xtensa_relax_info (sec);
7786 entry = elf_xtensa_find_property_entry
7787 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
7788 if (entry && (entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM))
7791 /* Mark that the literal will be coalesced. */
7792 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
7794 text_action_add (&relax_info->action_list,
7795 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7797 /* If the section is 4-byte aligned, do not add fill. */
7798 if (sec->alignment_power > 2)
7800 int fill_extra_space;
7801 bfd_vma entry_sec_offset;
7804 entry_sec_offset = entry->address - sec->vma + entry->size;
7806 entry_sec_offset = rel->r_rel.target_offset + 4;
7808 /* If the literal range is at the end of the section,
7810 fill_extra_space = 0;
7811 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7813 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7814 fill_extra_space = the_add_entry->size;
7816 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7817 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7818 -4, fill_extra_space);
7820 adjust_fill_action (fa, removed_diff);
7822 text_action_add (&relax_info->action_list,
7823 ta_fill, sec, entry_sec_offset, removed_diff);
7830 /* Move a literal to another location. This may actually increase the
7831 total amount of space used because of alignments so we need to do
7832 this carefully. Also, it may make a branch go out of range. */
7835 move_shared_literal (asection *sec,
7836 struct bfd_link_info *link_info,
7838 property_table_entry *prop_table,
7840 const r_reloc *target_loc,
7841 const literal_value *lit_value,
7842 section_cache_t *target_sec_cache)
7844 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
7845 text_action *fa, *target_fa;
7847 xtensa_relax_info *relax_info, *target_relax_info;
7848 asection *target_sec;
7850 ebb_constraint ebb_table;
7851 bfd_boolean relocs_fit;
7853 /* If this routine always returns FALSE, the literals that cannot be
7854 coalesced will not be moved. */
7855 if (elf32xtensa_no_literal_movement)
7858 relax_info = get_xtensa_relax_info (sec);
7862 target_sec = r_reloc_get_section (target_loc);
7863 target_relax_info = get_xtensa_relax_info (target_sec);
7865 /* Literals to undefined sections may not be moved because they
7866 must report an error. */
7867 if (bfd_is_und_section (target_sec))
7870 src_entry = elf_xtensa_find_property_entry
7871 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
7873 if (!section_cache_section (target_sec_cache, target_sec, link_info))
7876 target_entry = elf_xtensa_find_property_entry
7877 (target_sec_cache->ptbl, target_sec_cache->pte_count,
7878 target_sec->vma + target_loc->target_offset);
7883 /* Make sure that we have not broken any branches. */
7886 init_ebb_constraint (&ebb_table);
7887 ebb = &ebb_table.ebb;
7888 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
7889 target_sec_cache->content_length,
7890 target_sec_cache->ptbl, target_sec_cache->pte_count,
7891 target_sec_cache->relocs, target_sec_cache->reloc_count);
7893 /* Propose to add 4 bytes + worst-case alignment size increase to
7895 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
7896 ta_fill, target_loc->target_offset,
7897 -4 - (1 << target_sec->alignment_power), TRUE);
7899 /* Check all of the PC-relative relocations to make sure they still fit. */
7900 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
7901 target_sec_cache->contents,
7902 target_sec_cache->relocs,
7908 text_action_add_literal (&target_relax_info->action_list,
7909 ta_add_literal, target_loc, lit_value, -4);
7911 if (target_sec->alignment_power > 2 && target_entry != src_entry)
7913 /* May need to add or remove some fill to maintain alignment. */
7914 int fill_extra_space;
7915 bfd_vma entry_sec_offset;
7918 target_entry->address - target_sec->vma + target_entry->size;
7920 /* If the literal range is at the end of the section,
7922 fill_extra_space = 0;
7924 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
7925 target_sec_cache->pte_count,
7927 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7928 fill_extra_space = the_add_entry->size;
7930 target_fa = find_fill_action (&target_relax_info->action_list,
7931 target_sec, entry_sec_offset);
7932 removed_diff = compute_removed_action_diff (target_fa, target_sec,
7933 entry_sec_offset, 4,
7936 adjust_fill_action (target_fa, removed_diff);
7938 text_action_add (&target_relax_info->action_list,
7939 ta_fill, target_sec, entry_sec_offset, removed_diff);
7942 /* Mark that the literal will be moved to the new location. */
7943 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
7945 /* Remove the literal. */
7946 text_action_add (&relax_info->action_list,
7947 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7949 /* If the section is 4-byte aligned, do not add fill. */
7950 if (sec->alignment_power > 2 && target_entry != src_entry)
7952 int fill_extra_space;
7953 bfd_vma entry_sec_offset;
7956 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
7958 entry_sec_offset = rel->r_rel.target_offset+4;
7960 /* If the literal range is at the end of the section,
7962 fill_extra_space = 0;
7963 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7965 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7966 fill_extra_space = the_add_entry->size;
7968 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7969 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7970 -4, fill_extra_space);
7972 adjust_fill_action (fa, removed_diff);
7974 text_action_add (&relax_info->action_list,
7975 ta_fill, sec, entry_sec_offset, removed_diff);
7982 /* Second relaxation pass. */
7984 /* Modify all of the relocations to point to the right spot, and if this
7985 is a relaxable section, delete the unwanted literals and fix the
7989 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
7991 Elf_Internal_Rela *internal_relocs;
7992 xtensa_relax_info *relax_info;
7994 bfd_boolean ok = TRUE;
7996 bfd_boolean rv = FALSE;
7997 bfd_boolean virtual_action;
7998 bfd_size_type sec_size;
8000 sec_size = bfd_get_section_limit (abfd, sec);
8001 relax_info = get_xtensa_relax_info (sec);
8002 BFD_ASSERT (relax_info);
8004 /* First translate any of the fixes that have been added already. */
8005 translate_section_fixes (sec);
8007 /* Handle property sections (e.g., literal tables) specially. */
8008 if (xtensa_is_property_section (sec))
8010 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
8011 return relax_property_section (abfd, sec, link_info);
8014 internal_relocs = retrieve_internal_relocs (abfd, sec,
8015 link_info->keep_memory);
8016 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8017 if (contents == NULL && sec_size != 0)
8023 if (internal_relocs)
8025 for (i = 0; i < sec->reloc_count; i++)
8027 Elf_Internal_Rela *irel;
8028 xtensa_relax_info *target_relax_info;
8029 bfd_vma source_offset, old_source_offset;
8032 asection *target_sec;
8034 /* Locally change the source address.
8035 Translate the target to the new target address.
8036 If it points to this section and has been removed,
8040 irel = &internal_relocs[i];
8041 source_offset = irel->r_offset;
8042 old_source_offset = source_offset;
8044 r_type = ELF32_R_TYPE (irel->r_info);
8045 r_reloc_init (&r_rel, abfd, irel, contents,
8046 bfd_get_section_limit (abfd, sec));
8048 /* If this section could have changed then we may need to
8049 change the relocation's offset. */
8051 if (relax_info->is_relaxable_literal_section
8052 || relax_info->is_relaxable_asm_section)
8054 if (r_type != R_XTENSA_NONE
8055 && find_removed_literal (&relax_info->removed_list,
8058 /* Remove this relocation. */
8059 if (elf_hash_table (link_info)->dynamic_sections_created)
8060 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8061 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8062 irel->r_offset = offset_with_removed_text
8063 (&relax_info->action_list, irel->r_offset);
8064 pin_internal_relocs (sec, internal_relocs);
8068 if (r_type == R_XTENSA_ASM_SIMPLIFY)
8070 text_action *action =
8071 find_insn_action (&relax_info->action_list,
8073 if (action && (action->action == ta_convert_longcall
8074 || action->action == ta_remove_longcall))
8076 bfd_reloc_status_type retval;
8077 char *error_message = NULL;
8079 retval = contract_asm_expansion (contents, sec_size,
8080 irel, &error_message);
8081 if (retval != bfd_reloc_ok)
8083 (*link_info->callbacks->reloc_dangerous)
8084 (link_info, error_message, abfd, sec,
8088 /* Update the action so that the code that moves
8089 the contents will do the right thing. */
8090 if (action->action == ta_remove_longcall)
8091 action->action = ta_remove_insn;
8093 action->action = ta_none;
8094 /* Refresh the info in the r_rel. */
8095 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8096 r_type = ELF32_R_TYPE (irel->r_info);
8100 source_offset = offset_with_removed_text
8101 (&relax_info->action_list, irel->r_offset);
8102 irel->r_offset = source_offset;
8105 /* If the target section could have changed then
8106 we may need to change the relocation's target offset. */
8108 target_sec = r_reloc_get_section (&r_rel);
8109 target_relax_info = get_xtensa_relax_info (target_sec);
8111 if (target_relax_info
8112 && (target_relax_info->is_relaxable_literal_section
8113 || target_relax_info->is_relaxable_asm_section))
8117 bfd_vma addend_displacement;
8119 translate_reloc (&r_rel, &new_reloc);
8121 if (r_type == R_XTENSA_DIFF8
8122 || r_type == R_XTENSA_DIFF16
8123 || r_type == R_XTENSA_DIFF32)
8125 bfd_vma diff_value = 0, new_end_offset, diff_mask = 0;
8127 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
8129 (*link_info->callbacks->reloc_dangerous)
8130 (link_info, _("invalid relocation address"),
8131 abfd, sec, old_source_offset);
8137 case R_XTENSA_DIFF8:
8139 bfd_get_8 (abfd, &contents[old_source_offset]);
8141 case R_XTENSA_DIFF16:
8143 bfd_get_16 (abfd, &contents[old_source_offset]);
8145 case R_XTENSA_DIFF32:
8147 bfd_get_32 (abfd, &contents[old_source_offset]);
8151 new_end_offset = offset_with_removed_text
8152 (&target_relax_info->action_list,
8153 r_rel.target_offset + diff_value);
8154 diff_value = new_end_offset - new_reloc.target_offset;
8158 case R_XTENSA_DIFF8:
8160 bfd_put_8 (abfd, diff_value,
8161 &contents[old_source_offset]);
8163 case R_XTENSA_DIFF16:
8165 bfd_put_16 (abfd, diff_value,
8166 &contents[old_source_offset]);
8168 case R_XTENSA_DIFF32:
8169 diff_mask = 0xffffffff;
8170 bfd_put_32 (abfd, diff_value,
8171 &contents[old_source_offset]);
8175 /* Check for overflow. */
8176 if ((diff_value & ~diff_mask) != 0)
8178 (*link_info->callbacks->reloc_dangerous)
8179 (link_info, _("overflow after relaxation"),
8180 abfd, sec, old_source_offset);
8184 pin_contents (sec, contents);
8187 /* FIXME: If the relocation still references a section in
8188 the same input file, the relocation should be modified
8189 directly instead of adding a "fix" record. */
8191 addend_displacement =
8192 new_reloc.target_offset + new_reloc.virtual_offset;
8194 fix = reloc_bfd_fix_init (sec, source_offset, r_type, 0,
8195 r_reloc_get_section (&new_reloc),
8196 addend_displacement, TRUE);
8200 pin_internal_relocs (sec, internal_relocs);
8204 if ((relax_info->is_relaxable_literal_section
8205 || relax_info->is_relaxable_asm_section)
8206 && relax_info->action_list.head)
8208 /* Walk through the planned actions and build up a table
8209 of move, copy and fill records. Use the move, copy and
8210 fill records to perform the actions once. */
8212 bfd_size_type size = sec->size;
8214 bfd_size_type final_size, copy_size, orig_insn_size;
8215 bfd_byte *scratch = NULL;
8216 bfd_byte *dup_contents = NULL;
8217 bfd_size_type orig_size = size;
8218 bfd_vma orig_dot = 0;
8219 bfd_vma orig_dot_copied = 0; /* Byte copied already from
8220 orig dot in physical memory. */
8221 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
8222 bfd_vma dup_dot = 0;
8224 text_action *action = relax_info->action_list.head;
8226 final_size = sec->size;
8227 for (action = relax_info->action_list.head; action;
8228 action = action->next)
8230 final_size -= action->removed_bytes;
8233 scratch = (bfd_byte *) bfd_zmalloc (final_size);
8234 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
8236 /* The dot is the current fill location. */
8238 print_action_list (stderr, &relax_info->action_list);
8241 for (action = relax_info->action_list.head; action;
8242 action = action->next)
8244 virtual_action = FALSE;
8245 if (action->offset > orig_dot)
8247 orig_dot += orig_dot_copied;
8248 orig_dot_copied = 0;
8250 /* Out of the virtual world. */
8253 if (action->offset > orig_dot)
8255 copy_size = action->offset - orig_dot;
8256 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
8257 orig_dot += copy_size;
8258 dup_dot += copy_size;
8259 BFD_ASSERT (action->offset == orig_dot);
8261 else if (action->offset < orig_dot)
8263 if (action->action == ta_fill
8264 && action->offset - action->removed_bytes == orig_dot)
8266 /* This is OK because the fill only effects the dup_dot. */
8268 else if (action->action == ta_add_literal)
8270 /* TBD. Might need to handle this. */
8273 if (action->offset == orig_dot)
8275 if (action->virtual_offset > orig_dot_vo)
8277 if (orig_dot_vo == 0)
8279 /* Need to copy virtual_offset bytes. Probably four. */
8280 copy_size = action->virtual_offset - orig_dot_vo;
8281 memmove (&dup_contents[dup_dot],
8282 &contents[orig_dot], copy_size);
8283 orig_dot_copied = copy_size;
8284 dup_dot += copy_size;
8286 virtual_action = TRUE;
8289 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
8291 switch (action->action)
8293 case ta_remove_literal:
8294 case ta_remove_insn:
8295 BFD_ASSERT (action->removed_bytes >= 0);
8296 orig_dot += action->removed_bytes;
8299 case ta_narrow_insn:
8302 memmove (scratch, &contents[orig_dot], orig_insn_size);
8303 BFD_ASSERT (action->removed_bytes == 1);
8304 rv = narrow_instruction (scratch, final_size, 0);
8306 memmove (&dup_contents[dup_dot], scratch, copy_size);
8307 orig_dot += orig_insn_size;
8308 dup_dot += copy_size;
8312 if (action->removed_bytes >= 0)
8313 orig_dot += action->removed_bytes;
8316 /* Already zeroed in dup_contents. Just bump the
8318 dup_dot += (-action->removed_bytes);
8323 BFD_ASSERT (action->removed_bytes == 0);
8326 case ta_convert_longcall:
8327 case ta_remove_longcall:
8328 /* These will be removed or converted before we get here. */
8335 memmove (scratch, &contents[orig_dot], orig_insn_size);
8336 BFD_ASSERT (action->removed_bytes == -1);
8337 rv = widen_instruction (scratch, final_size, 0);
8339 memmove (&dup_contents[dup_dot], scratch, copy_size);
8340 orig_dot += orig_insn_size;
8341 dup_dot += copy_size;
8344 case ta_add_literal:
8347 BFD_ASSERT (action->removed_bytes == -4);
8348 /* TBD -- place the literal value here and insert
8350 memset (&dup_contents[dup_dot], 0, 4);
8351 pin_internal_relocs (sec, internal_relocs);
8352 pin_contents (sec, contents);
8354 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
8355 relax_info, &internal_relocs, &action->value))
8359 orig_dot_vo += copy_size;
8361 orig_dot += orig_insn_size;
8362 dup_dot += copy_size;
8366 /* Not implemented yet. */
8371 size -= action->removed_bytes;
8372 removed += action->removed_bytes;
8373 BFD_ASSERT (dup_dot <= final_size);
8374 BFD_ASSERT (orig_dot <= orig_size);
8377 orig_dot += orig_dot_copied;
8378 orig_dot_copied = 0;
8380 if (orig_dot != orig_size)
8382 copy_size = orig_size - orig_dot;
8383 BFD_ASSERT (orig_size > orig_dot);
8384 BFD_ASSERT (dup_dot + copy_size == final_size);
8385 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
8386 orig_dot += copy_size;
8387 dup_dot += copy_size;
8389 BFD_ASSERT (orig_size == orig_dot);
8390 BFD_ASSERT (final_size == dup_dot);
8392 /* Move the dup_contents back. */
8393 if (final_size > orig_size)
8395 /* Contents need to be reallocated. Swap the dup_contents into
8397 sec->contents = dup_contents;
8399 contents = dup_contents;
8400 pin_contents (sec, contents);
8404 BFD_ASSERT (final_size <= orig_size);
8405 memset (contents, 0, orig_size);
8406 memcpy (contents, dup_contents, final_size);
8407 free (dup_contents);
8410 pin_contents (sec, contents);
8412 sec->size = final_size;
8416 release_internal_relocs (sec, internal_relocs);
8417 release_contents (sec, contents);
8423 translate_section_fixes (asection *sec)
8425 xtensa_relax_info *relax_info;
8428 relax_info = get_xtensa_relax_info (sec);
8432 for (r = relax_info->fix_list; r != NULL; r = r->next)
8433 if (!translate_reloc_bfd_fix (r))
8440 /* Translate a fix given the mapping in the relax info for the target
8441 section. If it has already been translated, no work is required. */
8444 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
8446 reloc_bfd_fix new_fix;
8448 xtensa_relax_info *relax_info;
8449 removed_literal *removed;
8450 bfd_vma new_offset, target_offset;
8452 if (fix->translated)
8455 sec = fix->target_sec;
8456 target_offset = fix->target_offset;
8458 relax_info = get_xtensa_relax_info (sec);
8461 fix->translated = TRUE;
8467 /* The fix does not need to be translated if the section cannot change. */
8468 if (!relax_info->is_relaxable_literal_section
8469 && !relax_info->is_relaxable_asm_section)
8471 fix->translated = TRUE;
8475 /* If the literal has been moved and this relocation was on an
8476 opcode, then the relocation should move to the new literal
8477 location. Otherwise, the relocation should move within the
8481 if (is_operand_relocation (fix->src_type))
8483 /* Check if the original relocation is against a literal being
8485 removed = find_removed_literal (&relax_info->removed_list,
8493 /* The fact that there is still a relocation to this literal indicates
8494 that the literal is being coalesced, not simply removed. */
8495 BFD_ASSERT (removed->to.abfd != NULL);
8497 /* This was moved to some other address (possibly another section). */
8498 new_sec = r_reloc_get_section (&removed->to);
8502 relax_info = get_xtensa_relax_info (sec);
8504 (!relax_info->is_relaxable_literal_section
8505 && !relax_info->is_relaxable_asm_section))
8507 target_offset = removed->to.target_offset;
8508 new_fix.target_sec = new_sec;
8509 new_fix.target_offset = target_offset;
8510 new_fix.translated = TRUE;
8515 target_offset = removed->to.target_offset;
8516 new_fix.target_sec = new_sec;
8519 /* The target address may have been moved within its section. */
8520 new_offset = offset_with_removed_text (&relax_info->action_list,
8523 new_fix.target_offset = new_offset;
8524 new_fix.target_offset = new_offset;
8525 new_fix.translated = TRUE;
8531 /* Fix up a relocation to take account of removed literals. */
8534 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel)
8537 xtensa_relax_info *relax_info;
8538 removed_literal *removed;
8539 bfd_vma new_offset, target_offset, removed_bytes;
8541 *new_rel = *orig_rel;
8543 if (!r_reloc_is_defined (orig_rel))
8545 sec = r_reloc_get_section (orig_rel);
8547 relax_info = get_xtensa_relax_info (sec);
8548 BFD_ASSERT (relax_info);
8550 if (!relax_info->is_relaxable_literal_section
8551 && !relax_info->is_relaxable_asm_section)
8554 target_offset = orig_rel->target_offset;
8557 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
8559 /* Check if the original relocation is against a literal being
8561 removed = find_removed_literal (&relax_info->removed_list,
8564 if (removed && removed->to.abfd)
8568 /* The fact that there is still a relocation to this literal indicates
8569 that the literal is being coalesced, not simply removed. */
8570 BFD_ASSERT (removed->to.abfd != NULL);
8572 /* This was moved to some other address
8573 (possibly in another section). */
8574 *new_rel = removed->to;
8575 new_sec = r_reloc_get_section (new_rel);
8579 relax_info = get_xtensa_relax_info (sec);
8581 || (!relax_info->is_relaxable_literal_section
8582 && !relax_info->is_relaxable_asm_section))
8585 target_offset = new_rel->target_offset;
8588 /* ...and the target address may have been moved within its section. */
8589 new_offset = offset_with_removed_text (&relax_info->action_list,
8592 /* Modify the offset and addend. */
8593 removed_bytes = target_offset - new_offset;
8594 new_rel->target_offset = new_offset;
8595 new_rel->rela.r_addend -= removed_bytes;
8599 /* For dynamic links, there may be a dynamic relocation for each
8600 literal. The number of dynamic relocations must be computed in
8601 size_dynamic_sections, which occurs before relaxation. When a
8602 literal is removed, this function checks if there is a corresponding
8603 dynamic relocation and shrinks the size of the appropriate dynamic
8604 relocation section accordingly. At this point, the contents of the
8605 dynamic relocation sections have not yet been filled in, so there's
8606 nothing else that needs to be done. */
8609 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
8611 asection *input_section,
8612 Elf_Internal_Rela *rel)
8614 struct elf_xtensa_link_hash_table *htab;
8615 Elf_Internal_Shdr *symtab_hdr;
8616 struct elf_link_hash_entry **sym_hashes;
8617 unsigned long r_symndx;
8619 struct elf_link_hash_entry *h;
8620 bfd_boolean dynamic_symbol;
8622 htab = elf_xtensa_hash_table (info);
8623 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8624 sym_hashes = elf_sym_hashes (abfd);
8626 r_type = ELF32_R_TYPE (rel->r_info);
8627 r_symndx = ELF32_R_SYM (rel->r_info);
8629 if (r_symndx < symtab_hdr->sh_info)
8632 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8634 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
8636 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
8637 && (input_section->flags & SEC_ALLOC) != 0
8638 && (dynamic_symbol || info->shared))
8641 bfd_boolean is_plt = FALSE;
8643 if (dynamic_symbol && r_type == R_XTENSA_PLT)
8645 srel = htab->srelplt;
8649 srel = htab->srelgot;
8651 /* Reduce size of the .rela.* section by one reloc. */
8652 BFD_ASSERT (srel != NULL);
8653 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
8654 srel->size -= sizeof (Elf32_External_Rela);
8658 asection *splt, *sgotplt, *srelgot;
8659 int reloc_index, chunk;
8661 /* Find the PLT reloc index of the entry being removed. This
8662 is computed from the size of ".rela.plt". It is needed to
8663 figure out which PLT chunk to resize. Usually "last index
8664 = size - 1" since the index starts at zero, but in this
8665 context, the size has just been decremented so there's no
8666 need to subtract one. */
8667 reloc_index = srel->size / sizeof (Elf32_External_Rela);
8669 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
8670 splt = elf_xtensa_get_plt_section (info, chunk);
8671 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
8672 BFD_ASSERT (splt != NULL && sgotplt != NULL);
8674 /* Check if an entire PLT chunk has just been eliminated. */
8675 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
8677 /* The two magic GOT entries for that chunk can go away. */
8678 srelgot = htab->srelgot;
8679 BFD_ASSERT (srelgot != NULL);
8680 srelgot->reloc_count -= 2;
8681 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
8684 /* There should be only one entry left (and it will be
8686 BFD_ASSERT (sgotplt->size == 4);
8687 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
8690 BFD_ASSERT (sgotplt->size >= 4);
8691 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
8694 splt->size -= PLT_ENTRY_SIZE;
8700 /* Take an r_rel and move it to another section. This usually
8701 requires extending the interal_relocation array and pinning it. If
8702 the original r_rel is from the same BFD, we can complete this here.
8703 Otherwise, we add a fix record to let the final link fix the
8704 appropriate address. Contents and internal relocations for the
8705 section must be pinned after calling this routine. */
8708 move_literal (bfd *abfd,
8709 struct bfd_link_info *link_info,
8713 xtensa_relax_info *relax_info,
8714 Elf_Internal_Rela **internal_relocs_p,
8715 const literal_value *lit)
8717 Elf_Internal_Rela *new_relocs = NULL;
8718 size_t new_relocs_count = 0;
8719 Elf_Internal_Rela this_rela;
8720 const r_reloc *r_rel;
8722 r_rel = &lit->r_rel;
8723 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
8725 if (r_reloc_is_const (r_rel))
8726 bfd_put_32 (abfd, lit->value, contents + offset);
8731 asection *target_sec;
8735 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
8736 target_sec = r_reloc_get_section (r_rel);
8738 /* This is the difficult case. We have to create a fix up. */
8739 this_rela.r_offset = offset;
8740 this_rela.r_info = ELF32_R_INFO (0, r_type);
8741 this_rela.r_addend =
8742 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
8743 bfd_put_32 (abfd, lit->value, contents + offset);
8745 /* Currently, we cannot move relocations during a relocatable link. */
8746 BFD_ASSERT (!link_info->relocatable);
8747 fix = reloc_bfd_fix_init (sec, offset, r_type, r_rel->abfd,
8748 r_reloc_get_section (r_rel),
8749 r_rel->target_offset + r_rel->virtual_offset,
8751 /* We also need to mark that relocations are needed here. */
8752 sec->flags |= SEC_RELOC;
8754 translate_reloc_bfd_fix (fix);
8755 /* This fix has not yet been translated. */
8758 /* Add the relocation. If we have already allocated our own
8759 space for the relocations and we have room for more, then use
8760 it. Otherwise, allocate new space and move the literals. */
8761 insert_at = sec->reloc_count;
8762 for (i = 0; i < sec->reloc_count; ++i)
8764 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
8771 if (*internal_relocs_p != relax_info->allocated_relocs
8772 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
8774 BFD_ASSERT (relax_info->allocated_relocs == NULL
8775 || sec->reloc_count == relax_info->relocs_count);
8777 if (relax_info->allocated_relocs_count == 0)
8778 new_relocs_count = (sec->reloc_count + 2) * 2;
8780 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
8782 new_relocs = (Elf_Internal_Rela *)
8783 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
8787 /* We could handle this more quickly by finding the split point. */
8789 memcpy (new_relocs, *internal_relocs_p,
8790 insert_at * sizeof (Elf_Internal_Rela));
8792 new_relocs[insert_at] = this_rela;
8794 if (insert_at != sec->reloc_count)
8795 memcpy (new_relocs + insert_at + 1,
8796 (*internal_relocs_p) + insert_at,
8797 (sec->reloc_count - insert_at)
8798 * sizeof (Elf_Internal_Rela));
8800 if (*internal_relocs_p != relax_info->allocated_relocs)
8802 /* The first time we re-allocate, we can only free the
8803 old relocs if they were allocated with bfd_malloc.
8804 This is not true when keep_memory is in effect. */
8805 if (!link_info->keep_memory)
8806 free (*internal_relocs_p);
8809 free (*internal_relocs_p);
8810 relax_info->allocated_relocs = new_relocs;
8811 relax_info->allocated_relocs_count = new_relocs_count;
8812 elf_section_data (sec)->relocs = new_relocs;
8814 relax_info->relocs_count = sec->reloc_count;
8815 *internal_relocs_p = new_relocs;
8819 if (insert_at != sec->reloc_count)
8822 for (idx = sec->reloc_count; idx > insert_at; idx--)
8823 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
8825 (*internal_relocs_p)[insert_at] = this_rela;
8827 if (relax_info->allocated_relocs)
8828 relax_info->relocs_count = sec->reloc_count;
8835 /* This is similar to relax_section except that when a target is moved,
8836 we shift addresses up. We also need to modify the size. This
8837 algorithm does NOT allow for relocations into the middle of the
8838 property sections. */
8841 relax_property_section (bfd *abfd,
8843 struct bfd_link_info *link_info)
8845 Elf_Internal_Rela *internal_relocs;
8848 bfd_boolean ok = TRUE;
8849 bfd_boolean is_full_prop_section;
8850 size_t last_zfill_target_offset = 0;
8851 asection *last_zfill_target_sec = NULL;
8852 bfd_size_type sec_size;
8854 sec_size = bfd_get_section_limit (abfd, sec);
8855 internal_relocs = retrieve_internal_relocs (abfd, sec,
8856 link_info->keep_memory);
8857 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8858 if (contents == NULL && sec_size != 0)
8864 is_full_prop_section =
8865 ( CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
8866 || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."));
8868 if (internal_relocs)
8870 for (i = 0; i < sec->reloc_count; i++)
8872 Elf_Internal_Rela *irel;
8873 xtensa_relax_info *target_relax_info;
8875 asection *target_sec;
8877 bfd_byte *size_p, *flags_p;
8879 /* Locally change the source address.
8880 Translate the target to the new target address.
8881 If it points to this section and has been removed, MOVE IT.
8882 Also, don't forget to modify the associated SIZE at
8885 irel = &internal_relocs[i];
8886 r_type = ELF32_R_TYPE (irel->r_info);
8887 if (r_type == R_XTENSA_NONE)
8890 /* Find the literal value. */
8891 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
8892 size_p = &contents[irel->r_offset + 4];
8894 if (is_full_prop_section)
8896 flags_p = &contents[irel->r_offset + 8];
8897 BFD_ASSERT (irel->r_offset + 12 <= sec_size);
8900 BFD_ASSERT (irel->r_offset + 8 <= sec_size);
8902 target_sec = r_reloc_get_section (&val.r_rel);
8903 target_relax_info = get_xtensa_relax_info (target_sec);
8905 if (target_relax_info
8906 && (target_relax_info->is_relaxable_literal_section
8907 || target_relax_info->is_relaxable_asm_section ))
8909 /* Translate the relocation's destination. */
8910 bfd_vma new_offset, new_end_offset;
8911 long old_size, new_size;
8913 new_offset = offset_with_removed_text
8914 (&target_relax_info->action_list, val.r_rel.target_offset);
8916 /* Assert that we are not out of bounds. */
8917 old_size = bfd_get_32 (abfd, size_p);
8921 /* Only the first zero-sized unreachable entry is
8922 allowed to expand. In this case the new offset
8923 should be the offset before the fill and the new
8924 size is the expansion size. For other zero-sized
8925 entries the resulting size should be zero with an
8926 offset before or after the fill address depending
8927 on whether the expanding unreachable entry
8929 if (last_zfill_target_sec
8930 && last_zfill_target_sec == target_sec
8931 && last_zfill_target_offset == val.r_rel.target_offset)
8932 new_end_offset = new_offset;
8935 new_end_offset = new_offset;
8936 new_offset = offset_with_removed_text_before_fill
8937 (&target_relax_info->action_list,
8938 val.r_rel.target_offset);
8940 /* If it is not unreachable and we have not yet
8941 seen an unreachable at this address, place it
8942 before the fill address. */
8944 || (bfd_get_32 (abfd, flags_p)
8945 & XTENSA_PROP_UNREACHABLE) == 0)
8946 new_end_offset = new_offset;
8949 last_zfill_target_sec = target_sec;
8950 last_zfill_target_offset = val.r_rel.target_offset;
8956 new_end_offset = offset_with_removed_text_before_fill
8957 (&target_relax_info->action_list,
8958 val.r_rel.target_offset + old_size);
8961 new_size = new_end_offset - new_offset;
8963 if (new_size != old_size)
8965 bfd_put_32 (abfd, new_size, size_p);
8966 pin_contents (sec, contents);
8969 if (new_offset != val.r_rel.target_offset)
8971 bfd_vma diff = new_offset - val.r_rel.target_offset;
8972 irel->r_addend += diff;
8973 pin_internal_relocs (sec, internal_relocs);
8979 /* Combine adjacent property table entries. This is also done in
8980 finish_dynamic_sections() but at that point it's too late to
8981 reclaim the space in the output section, so we do this twice. */
8983 if (internal_relocs && (!link_info->relocatable
8984 || strcmp (sec->name, XTENSA_LIT_SEC_NAME) == 0))
8986 Elf_Internal_Rela *last_irel = NULL;
8987 int removed_bytes = 0;
8988 bfd_vma offset, last_irel_offset;
8989 bfd_vma section_size;
8990 bfd_size_type entry_size;
8991 flagword predef_flags;
8993 if (is_full_prop_section)
8998 predef_flags = xtensa_get_property_predef_flags (sec);
9000 /* Walk over memory and irels at the same time.
9001 This REQUIRES that the internal_relocs be sorted by offset. */
9002 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
9003 internal_reloc_compare);
9004 nexti = 0; /* Index into internal_relocs. */
9006 pin_internal_relocs (sec, internal_relocs);
9007 pin_contents (sec, contents);
9009 last_irel_offset = (bfd_vma) -1;
9010 section_size = sec->size;
9011 BFD_ASSERT (section_size % entry_size == 0);
9013 for (offset = 0; offset < section_size; offset += entry_size)
9015 Elf_Internal_Rela *irel, *next_irel;
9016 bfd_vma bytes_to_remove, size, actual_offset;
9017 bfd_boolean remove_this_irel;
9023 /* Find the next two relocations (if there are that many left),
9024 skipping over any R_XTENSA_NONE relocs. On entry, "nexti" is
9025 the starting reloc index. After these two loops, "i"
9026 is the index of the first non-NONE reloc past that starting
9027 index, and "nexti" is the index for the next non-NONE reloc
9030 for (i = nexti; i < sec->reloc_count; i++)
9032 if (ELF32_R_TYPE (internal_relocs[i].r_info) != R_XTENSA_NONE)
9034 irel = &internal_relocs[i];
9037 internal_relocs[i].r_offset -= removed_bytes;
9040 for (nexti = i + 1; nexti < sec->reloc_count; nexti++)
9042 if (ELF32_R_TYPE (internal_relocs[nexti].r_info)
9045 next_irel = &internal_relocs[nexti];
9048 internal_relocs[nexti].r_offset -= removed_bytes;
9051 remove_this_irel = FALSE;
9052 bytes_to_remove = 0;
9053 actual_offset = offset - removed_bytes;
9054 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
9056 if (is_full_prop_section)
9057 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
9059 flags = predef_flags;
9061 /* Check that the irels are sorted by offset,
9062 with only one per address. */
9063 BFD_ASSERT (!irel || (int) irel->r_offset > (int) last_irel_offset);
9064 BFD_ASSERT (!next_irel || next_irel->r_offset > irel->r_offset);
9066 /* Make sure there aren't relocs on the size or flag fields. */
9067 if ((irel && irel->r_offset == offset + 4)
9068 || (is_full_prop_section
9069 && irel && irel->r_offset == offset + 8))
9071 irel->r_offset -= removed_bytes;
9072 last_irel_offset = irel->r_offset;
9074 else if (next_irel && (next_irel->r_offset == offset + 4
9075 || (is_full_prop_section
9076 && next_irel->r_offset == offset + 8)))
9079 irel->r_offset -= removed_bytes;
9080 next_irel->r_offset -= removed_bytes;
9081 last_irel_offset = next_irel->r_offset;
9083 else if (size == 0 && (flags & XTENSA_PROP_ALIGN) == 0
9084 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
9086 /* Always remove entries with zero size and no alignment. */
9087 bytes_to_remove = entry_size;
9088 if (irel && irel->r_offset == offset)
9090 remove_this_irel = TRUE;
9092 irel->r_offset -= removed_bytes;
9093 last_irel_offset = irel->r_offset;
9096 else if (irel && irel->r_offset == offset)
9098 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32)
9104 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
9105 bfd_vma old_address =
9106 (last_irel->r_addend
9107 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
9108 bfd_vma new_address =
9110 + bfd_get_32 (abfd, &contents[actual_offset]));
9111 if (is_full_prop_section)
9112 old_flags = bfd_get_32
9113 (abfd, &contents[last_irel->r_offset + 8]);
9115 old_flags = predef_flags;
9117 if ((ELF32_R_SYM (irel->r_info)
9118 == ELF32_R_SYM (last_irel->r_info))
9119 && old_address + old_size == new_address
9120 && old_flags == flags
9121 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
9122 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
9124 /* Fix the old size. */
9125 bfd_put_32 (abfd, old_size + size,
9126 &contents[last_irel->r_offset + 4]);
9127 bytes_to_remove = entry_size;
9128 remove_this_irel = TRUE;
9137 irel->r_offset -= removed_bytes;
9138 last_irel_offset = irel->r_offset;
9141 if (remove_this_irel)
9143 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
9144 irel->r_offset -= bytes_to_remove;
9147 if (bytes_to_remove != 0)
9149 removed_bytes += bytes_to_remove;
9150 if (offset + bytes_to_remove < section_size)
9151 memmove (&contents[actual_offset],
9152 &contents[actual_offset + bytes_to_remove],
9153 section_size - offset - bytes_to_remove);
9159 /* Clear the removed bytes. */
9160 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
9162 sec->size = section_size - removed_bytes;
9164 if (xtensa_is_littable_section (sec))
9166 asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
9168 sgotloc->size -= removed_bytes;
9174 release_internal_relocs (sec, internal_relocs);
9175 release_contents (sec, contents);
9180 /* Third relaxation pass. */
9182 /* Change symbol values to account for removed literals. */
9185 relax_section_symbols (bfd *abfd, asection *sec)
9187 xtensa_relax_info *relax_info;
9188 unsigned int sec_shndx;
9189 Elf_Internal_Shdr *symtab_hdr;
9190 Elf_Internal_Sym *isymbuf;
9191 unsigned i, num_syms, num_locals;
9193 relax_info = get_xtensa_relax_info (sec);
9194 BFD_ASSERT (relax_info);
9196 if (!relax_info->is_relaxable_literal_section
9197 && !relax_info->is_relaxable_asm_section)
9200 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
9202 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9203 isymbuf = retrieve_local_syms (abfd);
9205 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
9206 num_locals = symtab_hdr->sh_info;
9208 /* Adjust the local symbols defined in this section. */
9209 for (i = 0; i < num_locals; i++)
9211 Elf_Internal_Sym *isym = &isymbuf[i];
9213 if (isym->st_shndx == sec_shndx)
9215 bfd_vma new_address = offset_with_removed_text
9216 (&relax_info->action_list, isym->st_value);
9217 bfd_vma new_size = isym->st_size;
9219 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
9221 bfd_vma new_end = offset_with_removed_text
9222 (&relax_info->action_list, isym->st_value + isym->st_size);
9223 new_size = new_end - new_address;
9226 isym->st_value = new_address;
9227 isym->st_size = new_size;
9231 /* Now adjust the global symbols defined in this section. */
9232 for (i = 0; i < (num_syms - num_locals); i++)
9234 struct elf_link_hash_entry *sym_hash;
9236 sym_hash = elf_sym_hashes (abfd)[i];
9238 if (sym_hash->root.type == bfd_link_hash_warning)
9239 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
9241 if ((sym_hash->root.type == bfd_link_hash_defined
9242 || sym_hash->root.type == bfd_link_hash_defweak)
9243 && sym_hash->root.u.def.section == sec)
9245 bfd_vma new_address = offset_with_removed_text
9246 (&relax_info->action_list, sym_hash->root.u.def.value);
9247 bfd_vma new_size = sym_hash->size;
9249 if (sym_hash->type == STT_FUNC)
9251 bfd_vma new_end = offset_with_removed_text
9252 (&relax_info->action_list,
9253 sym_hash->root.u.def.value + sym_hash->size);
9254 new_size = new_end - new_address;
9257 sym_hash->root.u.def.value = new_address;
9258 sym_hash->size = new_size;
9266 /* "Fix" handling functions, called while performing relocations. */
9269 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
9271 asection *input_section,
9275 asection *sec, *old_sec;
9277 int r_type = ELF32_R_TYPE (rel->r_info);
9280 if (r_type == R_XTENSA_NONE)
9283 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
9287 r_reloc_init (&r_rel, input_bfd, rel, contents,
9288 bfd_get_section_limit (input_bfd, input_section));
9289 old_sec = r_reloc_get_section (&r_rel);
9290 old_offset = r_rel.target_offset;
9292 if (!old_sec || !r_reloc_is_defined (&r_rel))
9294 if (r_type != R_XTENSA_ASM_EXPAND)
9296 (*_bfd_error_handler)
9297 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
9298 input_bfd, input_section, rel->r_offset,
9299 elf_howto_table[r_type].name);
9302 /* Leave it be. Resolution will happen in a later stage. */
9306 sec = fix->target_sec;
9307 rel->r_addend += ((sec->output_offset + fix->target_offset)
9308 - (old_sec->output_offset + old_offset));
9315 do_fix_for_final_link (Elf_Internal_Rela *rel,
9317 asection *input_section,
9319 bfd_vma *relocationp)
9322 int r_type = ELF32_R_TYPE (rel->r_info);
9326 if (r_type == R_XTENSA_NONE)
9329 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
9333 sec = fix->target_sec;
9335 fixup_diff = rel->r_addend;
9336 if (elf_howto_table[fix->src_type].partial_inplace)
9338 bfd_vma inplace_val;
9339 BFD_ASSERT (fix->src_offset
9340 < bfd_get_section_limit (input_bfd, input_section));
9341 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
9342 fixup_diff += inplace_val;
9345 *relocationp = (sec->output_section->vma
9346 + sec->output_offset
9347 + fix->target_offset - fixup_diff);
9351 /* Miscellaneous utility functions.... */
9354 elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
9356 struct elf_xtensa_link_hash_table *htab;
9362 htab = elf_xtensa_hash_table (info);
9366 dynobj = elf_hash_table (info)->dynobj;
9367 sprintf (plt_name, ".plt.%u", chunk);
9368 return bfd_get_section_by_name (dynobj, plt_name);
9373 elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
9375 struct elf_xtensa_link_hash_table *htab;
9381 htab = elf_xtensa_hash_table (info);
9382 return htab->sgotplt;
9385 dynobj = elf_hash_table (info)->dynobj;
9386 sprintf (got_name, ".got.plt.%u", chunk);
9387 return bfd_get_section_by_name (dynobj, got_name);
9391 /* Get the input section for a given symbol index.
9393 . a section symbol, return the section;
9394 . a common symbol, return the common section;
9395 . an undefined symbol, return the undefined section;
9396 . an indirect symbol, follow the links;
9397 . an absolute value, return the absolute section. */
9400 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
9402 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9403 asection *target_sec = NULL;
9404 if (r_symndx < symtab_hdr->sh_info)
9406 Elf_Internal_Sym *isymbuf;
9407 unsigned int section_index;
9409 isymbuf = retrieve_local_syms (abfd);
9410 section_index = isymbuf[r_symndx].st_shndx;
9412 if (section_index == SHN_UNDEF)
9413 target_sec = bfd_und_section_ptr;
9414 else if (section_index > 0 && section_index < SHN_LORESERVE)
9415 target_sec = bfd_section_from_elf_index (abfd, section_index);
9416 else if (section_index == SHN_ABS)
9417 target_sec = bfd_abs_section_ptr;
9418 else if (section_index == SHN_COMMON)
9419 target_sec = bfd_com_section_ptr;
9426 unsigned long indx = r_symndx - symtab_hdr->sh_info;
9427 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
9429 while (h->root.type == bfd_link_hash_indirect
9430 || h->root.type == bfd_link_hash_warning)
9431 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9433 switch (h->root.type)
9435 case bfd_link_hash_defined:
9436 case bfd_link_hash_defweak:
9437 target_sec = h->root.u.def.section;
9439 case bfd_link_hash_common:
9440 target_sec = bfd_com_section_ptr;
9442 case bfd_link_hash_undefined:
9443 case bfd_link_hash_undefweak:
9444 target_sec = bfd_und_section_ptr;
9446 default: /* New indirect warning. */
9447 target_sec = bfd_und_section_ptr;
9455 static struct elf_link_hash_entry *
9456 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
9459 struct elf_link_hash_entry *h;
9460 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9462 if (r_symndx < symtab_hdr->sh_info)
9465 indx = r_symndx - symtab_hdr->sh_info;
9466 h = elf_sym_hashes (abfd)[indx];
9467 while (h->root.type == bfd_link_hash_indirect
9468 || h->root.type == bfd_link_hash_warning)
9469 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9474 /* Get the section-relative offset for a symbol number. */
9477 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
9479 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9482 if (r_symndx < symtab_hdr->sh_info)
9484 Elf_Internal_Sym *isymbuf;
9485 isymbuf = retrieve_local_syms (abfd);
9486 offset = isymbuf[r_symndx].st_value;
9490 unsigned long indx = r_symndx - symtab_hdr->sh_info;
9491 struct elf_link_hash_entry *h =
9492 elf_sym_hashes (abfd)[indx];
9494 while (h->root.type == bfd_link_hash_indirect
9495 || h->root.type == bfd_link_hash_warning)
9496 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9497 if (h->root.type == bfd_link_hash_defined
9498 || h->root.type == bfd_link_hash_defweak)
9499 offset = h->root.u.def.value;
9506 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
9508 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
9509 struct elf_link_hash_entry *h;
9511 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
9512 if (h && h->root.type == bfd_link_hash_defweak)
9519 pcrel_reloc_fits (xtensa_opcode opc,
9521 bfd_vma self_address,
9522 bfd_vma dest_address)
9524 xtensa_isa isa = xtensa_default_isa;
9525 uint32 valp = dest_address;
9526 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
9527 || xtensa_operand_encode (isa, opc, opnd, &valp))
9533 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
9536 xtensa_is_property_section (asection *sec)
9538 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
9539 || CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
9540 || CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME))
9543 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0
9544 && (CONST_STRNEQ (&sec->name[linkonce_len], "x.")
9545 || CONST_STRNEQ (&sec->name[linkonce_len], "p.")
9546 || CONST_STRNEQ (&sec->name[linkonce_len], "prop.")))
9554 xtensa_is_littable_section (asection *sec)
9556 if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME))
9559 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0
9560 && sec->name[linkonce_len] == 'p'
9561 && sec->name[linkonce_len + 1] == '.')
9569 internal_reloc_compare (const void *ap, const void *bp)
9571 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
9572 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
9574 if (a->r_offset != b->r_offset)
9575 return (a->r_offset - b->r_offset);
9577 /* We don't need to sort on these criteria for correctness,
9578 but enforcing a more strict ordering prevents unstable qsort
9579 from behaving differently with different implementations.
9580 Without the code below we get correct but different results
9581 on Solaris 2.7 and 2.8. We would like to always produce the
9582 same results no matter the host. */
9584 if (a->r_info != b->r_info)
9585 return (a->r_info - b->r_info);
9587 return (a->r_addend - b->r_addend);
9592 internal_reloc_matches (const void *ap, const void *bp)
9594 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
9595 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
9597 /* Check if one entry overlaps with the other; this shouldn't happen
9598 except when searching for a match. */
9599 return (a->r_offset - b->r_offset);
9603 /* Predicate function used to look up a section in a particular group. */
9606 match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
9608 const char *gname = inf;
9609 const char *group_name = elf_group_name (sec);
9611 return (group_name == gname
9612 || (group_name != NULL
9614 && strcmp (group_name, gname) == 0));
9619 xtensa_get_property_section (asection *sec, const char *base_name)
9621 const char *suffix, *group_name;
9622 char *prop_sec_name;
9625 group_name = elf_group_name (sec);
9628 suffix = strrchr (sec->name, '.');
9629 if (suffix == sec->name)
9631 prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
9632 + (suffix ? strlen (suffix) : 0));
9633 strcpy (prop_sec_name, base_name);
9635 strcat (prop_sec_name, suffix);
9637 else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
9639 char *linkonce_kind = 0;
9641 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
9642 linkonce_kind = "x.";
9643 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
9644 linkonce_kind = "p.";
9645 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
9646 linkonce_kind = "prop.";
9650 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
9651 + strlen (linkonce_kind) + 1);
9652 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
9653 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
9655 suffix = sec->name + linkonce_len;
9656 /* For backward compatibility, replace "t." instead of inserting
9657 the new linkonce_kind (but not for "prop" sections). */
9658 if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
9660 strcat (prop_sec_name + linkonce_len, suffix);
9663 prop_sec_name = strdup (base_name);
9665 /* Check if the section already exists. */
9666 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
9667 match_section_group,
9668 (void *) group_name);
9669 /* If not, create it. */
9672 flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
9673 flags |= (bfd_get_section_flags (sec->owner, sec)
9674 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
9676 prop_sec = bfd_make_section_anyway_with_flags
9677 (sec->owner, strdup (prop_sec_name), flags);
9681 elf_group_name (prop_sec) = group_name;
9684 free (prop_sec_name);
9690 xtensa_get_property_predef_flags (asection *sec)
9692 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
9693 || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
9694 return (XTENSA_PROP_INSN
9695 | XTENSA_PROP_INSN_NO_TRANSFORM
9696 | XTENSA_PROP_INSN_NO_REORDER);
9698 if (xtensa_is_littable_section (sec))
9699 return (XTENSA_PROP_LITERAL
9700 | XTENSA_PROP_INSN_NO_TRANSFORM
9701 | XTENSA_PROP_INSN_NO_REORDER);
9707 /* Other functions called directly by the linker. */
9710 xtensa_callback_required_dependence (bfd *abfd,
9712 struct bfd_link_info *link_info,
9713 deps_callback_t callback,
9716 Elf_Internal_Rela *internal_relocs;
9719 bfd_boolean ok = TRUE;
9720 bfd_size_type sec_size;
9722 sec_size = bfd_get_section_limit (abfd, sec);
9724 /* ".plt*" sections have no explicit relocations but they contain L32R
9725 instructions that reference the corresponding ".got.plt*" sections. */
9726 if ((sec->flags & SEC_LINKER_CREATED) != 0
9727 && CONST_STRNEQ (sec->name, ".plt"))
9731 /* Find the corresponding ".got.plt*" section. */
9732 if (sec->name[4] == '\0')
9733 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
9739 BFD_ASSERT (sec->name[4] == '.');
9740 chunk = strtol (&sec->name[5], NULL, 10);
9742 sprintf (got_name, ".got.plt.%u", chunk);
9743 sgotplt = bfd_get_section_by_name (sec->owner, got_name);
9745 BFD_ASSERT (sgotplt);
9747 /* Assume worst-case offsets: L32R at the very end of the ".plt"
9748 section referencing a literal at the very beginning of
9749 ".got.plt". This is very close to the real dependence, anyway. */
9750 (*callback) (sec, sec_size, sgotplt, 0, closure);
9753 internal_relocs = retrieve_internal_relocs (abfd, sec,
9754 link_info->keep_memory);
9755 if (internal_relocs == NULL
9756 || sec->reloc_count == 0)
9759 /* Cache the contents for the duration of this scan. */
9760 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9761 if (contents == NULL && sec_size != 0)
9767 if (!xtensa_default_isa)
9768 xtensa_default_isa = xtensa_isa_init (0, 0);
9770 for (i = 0; i < sec->reloc_count; i++)
9772 Elf_Internal_Rela *irel = &internal_relocs[i];
9773 if (is_l32r_relocation (abfd, sec, contents, irel))
9776 asection *target_sec;
9777 bfd_vma target_offset;
9779 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
9782 /* L32Rs must be local to the input file. */
9783 if (r_reloc_is_defined (&l32r_rel))
9785 target_sec = r_reloc_get_section (&l32r_rel);
9786 target_offset = l32r_rel.target_offset;
9788 (*callback) (sec, irel->r_offset, target_sec, target_offset,
9794 release_internal_relocs (sec, internal_relocs);
9795 release_contents (sec, contents);
9799 /* The default literal sections should always be marked as "code" (i.e.,
9800 SHF_EXECINSTR). This is particularly important for the Linux kernel
9801 module loader so that the literals are not placed after the text. */
9802 static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
9804 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9805 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9806 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9807 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 },
9808 { NULL, 0, 0, 0, 0 }
9812 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
9813 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
9814 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
9815 #define TARGET_BIG_NAME "elf32-xtensa-be"
9816 #define ELF_ARCH bfd_arch_xtensa
9818 #define ELF_MACHINE_CODE EM_XTENSA
9819 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
9822 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
9823 #else /* !XCHAL_HAVE_MMU */
9824 #define ELF_MAXPAGESIZE 1
9825 #endif /* !XCHAL_HAVE_MMU */
9826 #endif /* ELF_ARCH */
9828 #define elf_backend_can_gc_sections 1
9829 #define elf_backend_can_refcount 1
9830 #define elf_backend_plt_readonly 1
9831 #define elf_backend_got_header_size 4
9832 #define elf_backend_want_dynbss 0
9833 #define elf_backend_want_got_plt 1
9835 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
9837 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
9838 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
9839 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
9840 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
9841 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
9842 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
9843 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
9845 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
9846 #define elf_backend_check_relocs elf_xtensa_check_relocs
9847 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
9848 #define elf_backend_discard_info elf_xtensa_discard_info
9849 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
9850 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
9851 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
9852 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
9853 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
9854 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
9855 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
9856 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
9857 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
9858 #define elf_backend_object_p elf_xtensa_object_p
9859 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
9860 #define elf_backend_relocate_section elf_xtensa_relocate_section
9861 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
9862 #define elf_backend_omit_section_dynsym \
9863 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
9864 #define elf_backend_special_sections elf_xtensa_special_sections
9865 #define elf_backend_action_discarded elf_xtensa_action_discarded
9867 #include "elf32-target.h"