1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright (C) 2003-2023 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 3 of the
9 License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
30 #include "elf/xtensa.h"
31 #include "splay-tree.h"
32 #include "xtensa-isa.h"
33 #include "xtensa-dynconfig.h"
35 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */
36 #define OCTETS_PER_BYTE(ABFD, SEC) 1
38 #define XTENSA_NO_NOP_REMOVAL 0
40 #ifndef XTHAL_ABI_UNDEFINED
41 #define XTHAL_ABI_UNDEFINED -1
44 /* Local helper functions. */
46 static bool add_extra_plt_sections (struct bfd_link_info
*, int);
47 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
48 static bfd_reloc_status_type bfd_elf_xtensa_reloc
49 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
50 static bool do_fix_for_relocatable_link
51 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*);
52 static void do_fix_for_final_link
53 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*, bfd_vma
*);
55 /* Local functions to handle Xtensa configurability. */
57 static bool is_indirect_call_opcode (xtensa_opcode
);
58 static bool is_direct_call_opcode (xtensa_opcode
);
59 static bool is_windowed_call_opcode (xtensa_opcode
);
60 static xtensa_opcode
get_const16_opcode (void);
61 static xtensa_opcode
get_l32r_opcode (void);
62 static bfd_vma
l32r_offset (bfd_vma
, bfd_vma
);
63 static int get_relocation_opnd (xtensa_opcode
, int);
64 static int get_relocation_slot (int);
65 static xtensa_opcode get_relocation_opcode
66 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
67 static bool is_l32r_relocation
68 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
69 static bool is_alt_relocation (int);
70 static bool is_operand_relocation (int);
71 static bfd_size_type insn_decode_len
72 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
73 static int insn_num_slots
74 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
75 static xtensa_opcode insn_decode_opcode
76 (bfd_byte
*, bfd_size_type
, bfd_size_type
, int);
77 static bool check_branch_target_aligned
78 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
79 static bool check_loop_aligned
80 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
81 static bool check_branch_target_aligned_address (bfd_vma
, int);
82 static bfd_size_type get_asm_simplify_size
83 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
85 /* Functions for link-time code simplifications. */
87 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
88 (bfd_byte
*, bfd_vma
, bfd_vma
, char **);
89 static bfd_reloc_status_type contract_asm_expansion
90 (bfd_byte
*, bfd_vma
, Elf_Internal_Rela
*, char **);
91 static xtensa_opcode
swap_callx_for_call_opcode (xtensa_opcode
);
92 static xtensa_opcode
get_expanded_call_opcode (bfd_byte
*, int, bool *);
94 /* Access to internal relocations, section contents and symbols. */
96 static Elf_Internal_Rela
*retrieve_internal_relocs
97 (bfd
*, asection
*, bool);
98 static void pin_internal_relocs (asection
*, Elf_Internal_Rela
*);
99 static void release_internal_relocs (asection
*, Elf_Internal_Rela
*);
100 static bfd_byte
*retrieve_contents (bfd
*, asection
*, bool);
101 static void pin_contents (asection
*, bfd_byte
*);
102 static void release_contents (asection
*, bfd_byte
*);
103 static Elf_Internal_Sym
*retrieve_local_syms (bfd
*);
105 /* Miscellaneous utility functions. */
107 static asection
*elf_xtensa_get_plt_section (struct bfd_link_info
*, int);
108 static asection
*elf_xtensa_get_gotplt_section (struct bfd_link_info
*, int);
109 static asection
*get_elf_r_symndx_section (bfd
*, unsigned long);
110 static struct elf_link_hash_entry
*get_elf_r_symndx_hash_entry
111 (bfd
*, unsigned long);
112 static bfd_vma
get_elf_r_symndx_offset (bfd
*, unsigned long);
113 static bool is_reloc_sym_weak (bfd
*, Elf_Internal_Rela
*);
114 static bool pcrel_reloc_fits (xtensa_opcode
, int, bfd_vma
, bfd_vma
);
115 static bool xtensa_is_property_section (asection
*);
116 static bool xtensa_is_insntable_section (asection
*);
117 static bool xtensa_is_littable_section (asection
*);
118 static bool xtensa_is_proptable_section (asection
*);
119 static int internal_reloc_compare (const void *, const void *);
120 static int internal_reloc_matches (const void *, const void *);
121 static asection
*xtensa_get_property_section (asection
*, const char *);
122 static flagword
xtensa_get_property_predef_flags (asection
*);
124 /* Other functions called directly by the linker. */
126 typedef void (*deps_callback_t
)
127 (asection
*, bfd_vma
, asection
*, bfd_vma
, void *);
128 extern bool xtensa_callback_required_dependence
129 (bfd
*, asection
*, struct bfd_link_info
*, deps_callback_t
, void *);
132 /* Globally visible flag for choosing size optimization of NOP removal
133 instead of branch-target-aware minimization for NOP removal.
134 When nonzero, narrow all instructions and remove all NOPs possible
135 around longcall expansions. */
137 int elf32xtensa_size_opt
;
140 /* The "new_section_hook" is used to set up a per-section
141 "xtensa_relax_info" data structure with additional information used
142 during relaxation. */
144 typedef struct xtensa_relax_info_struct xtensa_relax_info
;
147 /* The GNU tools do not easily allow extending interfaces to pass around
148 the pointer to the Xtensa ISA information, so instead we add a global
149 variable here (in BFD) that can be used by any of the tools that need
152 xtensa_isa xtensa_default_isa
;
155 /* When this is true, relocations may have been modified to refer to
156 symbols from other input files. The per-section list of "fix"
157 records needs to be checked when resolving relocations. */
159 static bool relaxing_section
= false;
161 /* When this is true, during final links, literals that cannot be
162 coalesced and their relocations may be moved to other sections. */
164 int elf32xtensa_no_literal_movement
= 1;
166 /* Place property records for a section into individual property section
167 with xt.prop. prefix. */
169 bool elf32xtensa_separate_props
= false;
171 /* Xtensa ABI. It affects PLT entry code. */
173 int elf32xtensa_abi
= XTHAL_ABI_UNDEFINED
;
175 /* Rename one of the generic section flags to better document how it
177 /* Whether relocations have been processed. */
178 #define reloc_done sec_flg0
180 static reloc_howto_type elf_howto_table
[] =
182 HOWTO (R_XTENSA_NONE
, 0, 0, 0, false, 0, complain_overflow_dont
,
183 bfd_elf_xtensa_reloc
, "R_XTENSA_NONE",
185 HOWTO (R_XTENSA_32
, 0, 4, 32, false, 0, complain_overflow_bitfield
,
186 bfd_elf_xtensa_reloc
, "R_XTENSA_32",
187 true, 0xffffffff, 0xffffffff, false),
189 /* Replace a 32-bit value with a value from the runtime linker (only
190 used by linker-generated stub functions). The r_addend value is
191 special: 1 means to substitute a pointer to the runtime linker's
192 dynamic resolver function; 2 means to substitute the link map for
193 the shared object. */
194 HOWTO (R_XTENSA_RTLD
, 0, 4, 32, false, 0, complain_overflow_dont
,
195 NULL
, "R_XTENSA_RTLD", false, 0, 0, false),
197 HOWTO (R_XTENSA_GLOB_DAT
, 0, 4, 32, false, 0, complain_overflow_bitfield
,
198 bfd_elf_generic_reloc
, "R_XTENSA_GLOB_DAT",
199 false, 0, 0xffffffff, false),
200 HOWTO (R_XTENSA_JMP_SLOT
, 0, 4, 32, false, 0, complain_overflow_bitfield
,
201 bfd_elf_generic_reloc
, "R_XTENSA_JMP_SLOT",
202 false, 0, 0xffffffff, false),
203 HOWTO (R_XTENSA_RELATIVE
, 0, 4, 32, false, 0, complain_overflow_bitfield
,
204 bfd_elf_generic_reloc
, "R_XTENSA_RELATIVE",
205 false, 0, 0xffffffff, false),
206 HOWTO (R_XTENSA_PLT
, 0, 4, 32, false, 0, complain_overflow_bitfield
,
207 bfd_elf_xtensa_reloc
, "R_XTENSA_PLT",
208 false, 0, 0xffffffff, false),
212 /* Old relocations for backward compatibility. */
213 HOWTO (R_XTENSA_OP0
, 0, 0, 0, true, 0, complain_overflow_dont
,
214 bfd_elf_xtensa_reloc
, "R_XTENSA_OP0", false, 0, 0, true),
215 HOWTO (R_XTENSA_OP1
, 0, 0, 0, true, 0, complain_overflow_dont
,
216 bfd_elf_xtensa_reloc
, "R_XTENSA_OP1", false, 0, 0, true),
217 HOWTO (R_XTENSA_OP2
, 0, 0, 0, true, 0, complain_overflow_dont
,
218 bfd_elf_xtensa_reloc
, "R_XTENSA_OP2", false, 0, 0, true),
220 /* Assembly auto-expansion. */
221 HOWTO (R_XTENSA_ASM_EXPAND
, 0, 0, 0, true, 0, complain_overflow_dont
,
222 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_EXPAND", false, 0, 0, true),
223 /* Relax assembly auto-expansion. */
224 HOWTO (R_XTENSA_ASM_SIMPLIFY
, 0, 0, 0, true, 0, complain_overflow_dont
,
225 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_SIMPLIFY", false, 0, 0, true),
229 HOWTO (R_XTENSA_32_PCREL
, 0, 4, 32, true, 0, complain_overflow_bitfield
,
230 bfd_elf_xtensa_reloc
, "R_XTENSA_32_PCREL",
231 false, 0, 0xffffffff, true),
233 /* GNU extension to record C++ vtable hierarchy. */
234 HOWTO (R_XTENSA_GNU_VTINHERIT
, 0, 4, 0, false, 0, complain_overflow_dont
,
235 NULL
, "R_XTENSA_GNU_VTINHERIT",
237 /* GNU extension to record C++ vtable member usage. */
238 HOWTO (R_XTENSA_GNU_VTENTRY
, 0, 4, 0, false, 0, complain_overflow_dont
,
239 _bfd_elf_rel_vtable_reloc_fn
, "R_XTENSA_GNU_VTENTRY",
242 /* Relocations for supporting difference of symbols. */
243 HOWTO (R_XTENSA_DIFF8
, 0, 1, 8, false, 0, complain_overflow_signed
,
244 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF8", false, 0, 0xff, false),
245 HOWTO (R_XTENSA_DIFF16
, 0, 2, 16, false, 0, complain_overflow_signed
,
246 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF16", false, 0, 0xffff, false),
247 HOWTO (R_XTENSA_DIFF32
, 0, 4, 32, false, 0, complain_overflow_signed
,
248 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF32", false, 0, 0xffffffff, false),
250 /* General immediate operand relocations. */
251 HOWTO (R_XTENSA_SLOT0_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
252 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_OP", false, 0, 0, true),
253 HOWTO (R_XTENSA_SLOT1_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
254 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_OP", false, 0, 0, true),
255 HOWTO (R_XTENSA_SLOT2_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
256 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_OP", false, 0, 0, true),
257 HOWTO (R_XTENSA_SLOT3_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
258 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_OP", false, 0, 0, true),
259 HOWTO (R_XTENSA_SLOT4_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
260 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_OP", false, 0, 0, true),
261 HOWTO (R_XTENSA_SLOT5_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
262 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_OP", false, 0, 0, true),
263 HOWTO (R_XTENSA_SLOT6_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
264 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_OP", false, 0, 0, true),
265 HOWTO (R_XTENSA_SLOT7_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
266 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_OP", false, 0, 0, true),
267 HOWTO (R_XTENSA_SLOT8_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
268 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_OP", false, 0, 0, true),
269 HOWTO (R_XTENSA_SLOT9_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
270 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_OP", false, 0, 0, true),
271 HOWTO (R_XTENSA_SLOT10_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
272 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_OP", false, 0, 0, true),
273 HOWTO (R_XTENSA_SLOT11_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
274 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_OP", false, 0, 0, true),
275 HOWTO (R_XTENSA_SLOT12_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
276 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_OP", false, 0, 0, true),
277 HOWTO (R_XTENSA_SLOT13_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
278 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_OP", false, 0, 0, true),
279 HOWTO (R_XTENSA_SLOT14_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
280 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_OP", false, 0, 0, true),
282 /* "Alternate" relocations. The meaning of these is opcode-specific. */
283 HOWTO (R_XTENSA_SLOT0_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
284 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_ALT", false, 0, 0, true),
285 HOWTO (R_XTENSA_SLOT1_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
286 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_ALT", false, 0, 0, true),
287 HOWTO (R_XTENSA_SLOT2_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
288 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_ALT", false, 0, 0, true),
289 HOWTO (R_XTENSA_SLOT3_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
290 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_ALT", false, 0, 0, true),
291 HOWTO (R_XTENSA_SLOT4_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
292 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_ALT", false, 0, 0, true),
293 HOWTO (R_XTENSA_SLOT5_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
294 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_ALT", false, 0, 0, true),
295 HOWTO (R_XTENSA_SLOT6_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
296 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_ALT", false, 0, 0, true),
297 HOWTO (R_XTENSA_SLOT7_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
298 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_ALT", false, 0, 0, true),
299 HOWTO (R_XTENSA_SLOT8_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
300 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_ALT", false, 0, 0, true),
301 HOWTO (R_XTENSA_SLOT9_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
302 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_ALT", false, 0, 0, true),
303 HOWTO (R_XTENSA_SLOT10_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
304 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_ALT", false, 0, 0, true),
305 HOWTO (R_XTENSA_SLOT11_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
306 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_ALT", false, 0, 0, true),
307 HOWTO (R_XTENSA_SLOT12_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
308 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_ALT", false, 0, 0, true),
309 HOWTO (R_XTENSA_SLOT13_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
310 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_ALT", false, 0, 0, true),
311 HOWTO (R_XTENSA_SLOT14_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
312 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_ALT", false, 0, 0, true),
314 /* TLS relocations. */
315 HOWTO (R_XTENSA_TLSDESC_FN
, 0, 4, 32, false, 0, complain_overflow_dont
,
316 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_FN",
317 false, 0, 0xffffffff, false),
318 HOWTO (R_XTENSA_TLSDESC_ARG
, 0, 4, 32, false, 0, complain_overflow_dont
,
319 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_ARG",
320 false, 0, 0xffffffff, false),
321 HOWTO (R_XTENSA_TLS_DTPOFF
, 0, 4, 32, false, 0, complain_overflow_dont
,
322 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_DTPOFF",
323 false, 0, 0xffffffff, false),
324 HOWTO (R_XTENSA_TLS_TPOFF
, 0, 4, 32, false, 0, complain_overflow_dont
,
325 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_TPOFF",
326 false, 0, 0xffffffff, false),
327 HOWTO (R_XTENSA_TLS_FUNC
, 0, 0, 0, false, 0, complain_overflow_dont
,
328 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_FUNC",
330 HOWTO (R_XTENSA_TLS_ARG
, 0, 0, 0, false, 0, complain_overflow_dont
,
331 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_ARG",
333 HOWTO (R_XTENSA_TLS_CALL
, 0, 0, 0, false, 0, complain_overflow_dont
,
334 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_CALL",
337 HOWTO (R_XTENSA_PDIFF8
, 0, 1, 8, false, 0, complain_overflow_bitfield
,
338 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF8", false, 0, 0xff, false),
339 HOWTO (R_XTENSA_PDIFF16
, 0, 2, 16, false, 0, complain_overflow_bitfield
,
340 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF16", false, 0, 0xffff, false),
341 HOWTO (R_XTENSA_PDIFF32
, 0, 4, 32, false, 0, complain_overflow_bitfield
,
342 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF32", false, 0, 0xffffffff, false),
344 HOWTO (R_XTENSA_NDIFF8
, 0, 1, 8, false, 0, complain_overflow_bitfield
,
345 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF8", false, 0, 0xff, false),
346 HOWTO (R_XTENSA_NDIFF16
, 0, 2, 16, false, 0, complain_overflow_bitfield
,
347 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF16", false, 0, 0xffff, false),
348 HOWTO (R_XTENSA_NDIFF32
, 0, 4, 32, false, 0, complain_overflow_bitfield
,
349 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF32", false, 0, 0xffffffff, false),
354 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
359 static reloc_howto_type
*
360 elf_xtensa_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
361 bfd_reloc_code_real_type code
)
366 TRACE ("BFD_RELOC_NONE");
367 return &elf_howto_table
[(unsigned) R_XTENSA_NONE
];
370 TRACE ("BFD_RELOC_32");
371 return &elf_howto_table
[(unsigned) R_XTENSA_32
];
373 case BFD_RELOC_32_PCREL
:
374 TRACE ("BFD_RELOC_32_PCREL");
375 return &elf_howto_table
[(unsigned) R_XTENSA_32_PCREL
];
377 case BFD_RELOC_XTENSA_DIFF8
:
378 TRACE ("BFD_RELOC_XTENSA_DIFF8");
379 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF8
];
381 case BFD_RELOC_XTENSA_DIFF16
:
382 TRACE ("BFD_RELOC_XTENSA_DIFF16");
383 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF16
];
385 case BFD_RELOC_XTENSA_DIFF32
:
386 TRACE ("BFD_RELOC_XTENSA_DIFF32");
387 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF32
];
389 case BFD_RELOC_XTENSA_PDIFF8
:
390 TRACE ("BFD_RELOC_XTENSA_PDIFF8");
391 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF8
];
393 case BFD_RELOC_XTENSA_PDIFF16
:
394 TRACE ("BFD_RELOC_XTENSA_PDIFF16");
395 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF16
];
397 case BFD_RELOC_XTENSA_PDIFF32
:
398 TRACE ("BFD_RELOC_XTENSA_PDIFF32");
399 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF32
];
401 case BFD_RELOC_XTENSA_NDIFF8
:
402 TRACE ("BFD_RELOC_XTENSA_NDIFF8");
403 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF8
];
405 case BFD_RELOC_XTENSA_NDIFF16
:
406 TRACE ("BFD_RELOC_XTENSA_NDIFF16");
407 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF16
];
409 case BFD_RELOC_XTENSA_NDIFF32
:
410 TRACE ("BFD_RELOC_XTENSA_NDIFF32");
411 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF32
];
413 case BFD_RELOC_XTENSA_RTLD
:
414 TRACE ("BFD_RELOC_XTENSA_RTLD");
415 return &elf_howto_table
[(unsigned) R_XTENSA_RTLD
];
417 case BFD_RELOC_XTENSA_GLOB_DAT
:
418 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
419 return &elf_howto_table
[(unsigned) R_XTENSA_GLOB_DAT
];
421 case BFD_RELOC_XTENSA_JMP_SLOT
:
422 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
423 return &elf_howto_table
[(unsigned) R_XTENSA_JMP_SLOT
];
425 case BFD_RELOC_XTENSA_RELATIVE
:
426 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
427 return &elf_howto_table
[(unsigned) R_XTENSA_RELATIVE
];
429 case BFD_RELOC_XTENSA_PLT
:
430 TRACE ("BFD_RELOC_XTENSA_PLT");
431 return &elf_howto_table
[(unsigned) R_XTENSA_PLT
];
433 case BFD_RELOC_XTENSA_OP0
:
434 TRACE ("BFD_RELOC_XTENSA_OP0");
435 return &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
437 case BFD_RELOC_XTENSA_OP1
:
438 TRACE ("BFD_RELOC_XTENSA_OP1");
439 return &elf_howto_table
[(unsigned) R_XTENSA_OP1
];
441 case BFD_RELOC_XTENSA_OP2
:
442 TRACE ("BFD_RELOC_XTENSA_OP2");
443 return &elf_howto_table
[(unsigned) R_XTENSA_OP2
];
445 case BFD_RELOC_XTENSA_ASM_EXPAND
:
446 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
447 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_EXPAND
];
449 case BFD_RELOC_XTENSA_ASM_SIMPLIFY
:
450 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
451 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_SIMPLIFY
];
453 case BFD_RELOC_VTABLE_INHERIT
:
454 TRACE ("BFD_RELOC_VTABLE_INHERIT");
455 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTINHERIT
];
457 case BFD_RELOC_VTABLE_ENTRY
:
458 TRACE ("BFD_RELOC_VTABLE_ENTRY");
459 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTENTRY
];
461 case BFD_RELOC_XTENSA_TLSDESC_FN
:
462 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
463 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_FN
];
465 case BFD_RELOC_XTENSA_TLSDESC_ARG
:
466 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
467 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_ARG
];
469 case BFD_RELOC_XTENSA_TLS_DTPOFF
:
470 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
471 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_DTPOFF
];
473 case BFD_RELOC_XTENSA_TLS_TPOFF
:
474 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
475 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_TPOFF
];
477 case BFD_RELOC_XTENSA_TLS_FUNC
:
478 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
479 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_FUNC
];
481 case BFD_RELOC_XTENSA_TLS_ARG
:
482 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
483 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_ARG
];
485 case BFD_RELOC_XTENSA_TLS_CALL
:
486 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
487 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_CALL
];
490 if (code
>= BFD_RELOC_XTENSA_SLOT0_OP
491 && code
<= BFD_RELOC_XTENSA_SLOT14_OP
)
493 unsigned n
= (R_XTENSA_SLOT0_OP
+
494 (code
- BFD_RELOC_XTENSA_SLOT0_OP
));
495 return &elf_howto_table
[n
];
498 if (code
>= BFD_RELOC_XTENSA_SLOT0_ALT
499 && code
<= BFD_RELOC_XTENSA_SLOT14_ALT
)
501 unsigned n
= (R_XTENSA_SLOT0_ALT
+
502 (code
- BFD_RELOC_XTENSA_SLOT0_ALT
));
503 return &elf_howto_table
[n
];
509 /* xgettext:c-format */
510 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
, (int) code
);
511 bfd_set_error (bfd_error_bad_value
);
516 static reloc_howto_type
*
517 elf_xtensa_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
522 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
523 if (elf_howto_table
[i
].name
!= NULL
524 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
525 return &elf_howto_table
[i
];
531 /* Given an ELF "rela" relocation, find the corresponding howto and record
532 it in the BFD internal arelent representation of the relocation. */
535 elf_xtensa_info_to_howto_rela (bfd
*abfd
,
537 Elf_Internal_Rela
*dst
)
539 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
541 if (r_type
>= (unsigned int) R_XTENSA_max
)
543 /* xgettext:c-format */
544 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
546 bfd_set_error (bfd_error_bad_value
);
549 cache_ptr
->howto
= &elf_howto_table
[r_type
];
554 /* Functions for the Xtensa ELF linker. */
556 /* The name of the dynamic interpreter. This is put in the .interp
559 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
561 /* The size in bytes of an entry in the procedure linkage table.
562 (This does _not_ include the space for the literals associated with
565 #define PLT_ENTRY_SIZE 16
567 /* For _really_ large PLTs, we may need to alternate between literals
568 and code to keep the literals within the 256K range of the L32R
569 instructions in the code. It's unlikely that anyone would ever need
570 such a big PLT, but an arbitrary limit on the PLT size would be bad.
571 Thus, we split the PLT into chunks. Since there's very little
572 overhead (2 extra literals) for each chunk, the chunk size is kept
573 small so that the code for handling multiple chunks get used and
574 tested regularly. With 254 entries, there are 1K of literals for
575 each chunk, and that seems like a nice round number. */
577 #define PLT_ENTRIES_PER_CHUNK 254
579 /* PLT entries are actually used as stub functions for lazy symbol
580 resolution. Once the symbol is resolved, the stub function is never
581 invoked. Note: the 32-byte frame size used here cannot be changed
582 without a corresponding change in the runtime linker. */
584 static const bfd_byte elf_xtensa_be_plt_entry
[][PLT_ENTRY_SIZE
] =
587 0x6c, 0x10, 0x04, /* entry sp, 32 */
588 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
589 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
590 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
591 0x0a, 0x80, 0x00, /* jx a8 */
595 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
596 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
597 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
598 0x0a, 0x80, 0x00, /* jx a8 */
603 static const bfd_byte elf_xtensa_le_plt_entry
[][PLT_ENTRY_SIZE
] =
606 0x36, 0x41, 0x00, /* entry sp, 32 */
607 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
608 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
609 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
610 0xa0, 0x08, 0x00, /* jx a8 */
614 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
615 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
616 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
617 0xa0, 0x08, 0x00, /* jx a8 */
622 /* The size of the thread control block. */
625 struct elf_xtensa_link_hash_entry
627 struct elf_link_hash_entry elf
;
629 bfd_signed_vma tlsfunc_refcount
;
631 #define GOT_UNKNOWN 0
633 #define GOT_TLS_GD 2 /* global or local dynamic */
634 #define GOT_TLS_IE 4 /* initial or local exec */
635 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
636 unsigned char tls_type
;
639 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
641 struct elf_xtensa_obj_tdata
643 struct elf_obj_tdata root
;
645 /* tls_type for each local got entry. */
646 char *local_got_tls_type
;
648 bfd_signed_vma
*local_tlsfunc_refcounts
;
651 #define elf_xtensa_tdata(abfd) \
652 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
654 #define elf_xtensa_local_got_tls_type(abfd) \
655 (elf_xtensa_tdata (abfd)->local_got_tls_type)
657 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
658 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
660 #define is_xtensa_elf(bfd) \
661 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
662 && elf_tdata (bfd) != NULL \
663 && elf_object_id (bfd) == XTENSA_ELF_DATA)
666 elf_xtensa_mkobject (bfd
*abfd
)
668 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_xtensa_obj_tdata
),
672 /* Xtensa ELF linker hash table. */
674 struct elf_xtensa_link_hash_table
676 struct elf_link_hash_table elf
;
678 /* Short-cuts to get to dynamic linker sections. */
680 asection
*spltlittbl
;
682 /* Total count of PLT relocations seen during check_relocs.
683 The actual PLT code must be split into multiple sections and all
684 the sections have to be created before size_dynamic_sections,
685 where we figure out the exact number of PLT entries that will be
686 needed. It is OK if this count is an overestimate, e.g., some
687 relocations may be removed by GC. */
690 struct elf_xtensa_link_hash_entry
*tlsbase
;
693 /* Get the Xtensa ELF linker hash table from a link_info structure. */
695 #define elf_xtensa_hash_table(p) \
696 ((is_elf_hash_table ((p)->hash) \
697 && elf_hash_table_id (elf_hash_table (p)) == XTENSA_ELF_DATA) \
698 ? (struct elf_xtensa_link_hash_table *) (p)->hash : NULL)
700 /* Create an entry in an Xtensa ELF linker hash table. */
702 static struct bfd_hash_entry
*
703 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
704 struct bfd_hash_table
*table
,
707 /* Allocate the structure if it has not already been allocated by a
711 entry
= bfd_hash_allocate (table
,
712 sizeof (struct elf_xtensa_link_hash_entry
));
717 /* Call the allocation method of the superclass. */
718 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
721 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (entry
);
722 eh
->tlsfunc_refcount
= 0;
723 eh
->tls_type
= GOT_UNKNOWN
;
729 /* Create an Xtensa ELF linker hash table. */
731 static struct bfd_link_hash_table
*
732 elf_xtensa_link_hash_table_create (bfd
*abfd
)
734 struct elf_link_hash_entry
*tlsbase
;
735 struct elf_xtensa_link_hash_table
*ret
;
736 size_t amt
= sizeof (struct elf_xtensa_link_hash_table
);
738 ret
= bfd_zmalloc (amt
);
742 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
743 elf_xtensa_link_hash_newfunc
,
744 sizeof (struct elf_xtensa_link_hash_entry
),
751 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
753 tlsbase
= elf_link_hash_lookup (&ret
->elf
, "_TLS_MODULE_BASE_",
755 tlsbase
->root
.type
= bfd_link_hash_new
;
756 tlsbase
->root
.u
.undef
.abfd
= NULL
;
757 tlsbase
->non_elf
= 0;
758 ret
->elf
.dt_pltgot_required
= true;
759 ret
->tlsbase
= elf_xtensa_hash_entry (tlsbase
);
760 ret
->tlsbase
->tls_type
= GOT_UNKNOWN
;
762 return &ret
->elf
.root
;
765 /* Copy the extra info we tack onto an elf_link_hash_entry. */
768 elf_xtensa_copy_indirect_symbol (struct bfd_link_info
*info
,
769 struct elf_link_hash_entry
*dir
,
770 struct elf_link_hash_entry
*ind
)
772 struct elf_xtensa_link_hash_entry
*edir
, *eind
;
774 edir
= elf_xtensa_hash_entry (dir
);
775 eind
= elf_xtensa_hash_entry (ind
);
777 if (ind
->root
.type
== bfd_link_hash_indirect
)
779 edir
->tlsfunc_refcount
+= eind
->tlsfunc_refcount
;
780 eind
->tlsfunc_refcount
= 0;
782 if (dir
->got
.refcount
<= 0)
784 edir
->tls_type
= eind
->tls_type
;
785 eind
->tls_type
= GOT_UNKNOWN
;
789 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
793 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
794 struct bfd_link_info
*info
)
796 /* Check if we should do dynamic things to this symbol. The
797 "ignore_protected" argument need not be set, because Xtensa code
798 does not require special handling of STV_PROTECTED to make function
799 pointer comparisons work properly. The PLT addresses are never
800 used for function pointers. */
802 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
807 property_table_compare (const void *ap
, const void *bp
)
809 const property_table_entry
*a
= (const property_table_entry
*) ap
;
810 const property_table_entry
*b
= (const property_table_entry
*) bp
;
812 if (a
->address
== b
->address
)
814 if (a
->size
!= b
->size
)
815 return (a
->size
- b
->size
);
817 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
818 return ((b
->flags
& XTENSA_PROP_ALIGN
)
819 - (a
->flags
& XTENSA_PROP_ALIGN
));
821 if ((a
->flags
& XTENSA_PROP_ALIGN
)
822 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
823 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
824 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
825 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
827 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
828 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
829 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
830 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
832 return (a
->flags
- b
->flags
);
835 return (a
->address
- b
->address
);
840 property_table_matches (const void *ap
, const void *bp
)
842 const property_table_entry
*a
= (const property_table_entry
*) ap
;
843 const property_table_entry
*b
= (const property_table_entry
*) bp
;
845 /* Check if one entry overlaps with the other. */
846 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
847 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
850 return (a
->address
- b
->address
);
854 /* Get the literal table or property table entries for the given
855 section. Sets TABLE_P and returns the number of entries. On
856 error, returns a negative value. */
859 xtensa_read_table_entries (bfd
*abfd
,
861 property_table_entry
**table_p
,
862 const char *sec_name
,
865 asection
*table_section
;
866 bfd_size_type table_size
= 0;
867 bfd_byte
*table_data
;
868 property_table_entry
*blocks
;
869 int blk
, block_count
;
870 bfd_size_type num_records
;
871 Elf_Internal_Rela
*internal_relocs
, *irel
, *rel_end
;
872 bfd_vma section_addr
, off
;
873 flagword predef_flags
;
874 bfd_size_type table_entry_size
, section_limit
;
876 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
878 || !(section
->flags
& SEC_ALLOC
)
879 || (section
->flags
& SEC_DEBUGGING
))
885 table_section
= xtensa_get_property_section (section
, sec_name
);
887 table_size
= table_section
->size
;
895 predef_flags
= xtensa_get_property_predef_flags (table_section
);
896 table_entry_size
= 12;
898 table_entry_size
-= 4;
900 num_records
= table_size
/ table_entry_size
;
902 table_data
= retrieve_contents (abfd
, table_section
, true);
903 if (table_data
== NULL
)
909 blocks
= (property_table_entry
*)
910 bfd_malloc (num_records
* sizeof (property_table_entry
));
914 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
916 section_addr
= section
->vma
;
918 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, true);
919 if (internal_relocs
&& !table_section
->reloc_done
)
921 qsort (internal_relocs
, table_section
->reloc_count
,
922 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
923 irel
= internal_relocs
;
928 section_limit
= bfd_get_section_limit (abfd
, section
);
929 rel_end
= internal_relocs
+ table_section
->reloc_count
;
931 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
933 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
935 /* Skip any relocations before the current offset. This should help
936 avoid confusion caused by unexpected relocations for the preceding
939 (irel
->r_offset
< off
940 || (irel
->r_offset
== off
941 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
948 if (irel
&& irel
->r_offset
== off
)
951 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
952 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
954 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
957 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
958 BFD_ASSERT (sym_off
== 0);
959 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
963 if (address
< section_addr
964 || address
>= section_addr
+ section_limit
)
968 blocks
[block_count
].address
= address
;
969 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
971 blocks
[block_count
].flags
= predef_flags
;
973 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
977 release_contents (table_section
, table_data
);
978 release_internal_relocs (table_section
, internal_relocs
);
982 /* Now sort them into address order for easy reference. */
983 qsort (blocks
, block_count
, sizeof (property_table_entry
),
984 property_table_compare
);
986 /* Check that the table contents are valid. Problems may occur,
987 for example, if an unrelocated object file is stripped. */
988 for (blk
= 1; blk
< block_count
; blk
++)
990 /* The only circumstance where two entries may legitimately
991 have the same address is when one of them is a zero-size
992 placeholder to mark a place where fill can be inserted.
993 The zero-size entry should come first. */
994 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
995 blocks
[blk
- 1].size
!= 0)
997 /* xgettext:c-format */
998 _bfd_error_handler (_("%pB(%pA): invalid property table"),
1000 bfd_set_error (bfd_error_bad_value
);
1012 static property_table_entry
*
1013 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
1014 int property_table_size
,
1017 property_table_entry entry
;
1018 property_table_entry
*rv
;
1020 if (property_table_size
== 0)
1023 entry
.address
= addr
;
1027 rv
= bsearch (&entry
, property_table
, property_table_size
,
1028 sizeof (property_table_entry
), property_table_matches
);
1034 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
1038 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
1045 /* Look through the relocs for a section during the first phase, and
1046 calculate needed space in the dynamic reloc sections. */
1049 elf_xtensa_check_relocs (bfd
*abfd
,
1050 struct bfd_link_info
*info
,
1052 const Elf_Internal_Rela
*relocs
)
1054 struct elf_xtensa_link_hash_table
*htab
;
1055 Elf_Internal_Shdr
*symtab_hdr
;
1056 struct elf_link_hash_entry
**sym_hashes
;
1057 const Elf_Internal_Rela
*rel
;
1058 const Elf_Internal_Rela
*rel_end
;
1060 if (bfd_link_relocatable (info
))
1063 BFD_ASSERT (is_xtensa_elf (abfd
));
1065 htab
= elf_xtensa_hash_table (info
);
1069 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1070 sym_hashes
= elf_sym_hashes (abfd
);
1072 rel_end
= relocs
+ sec
->reloc_count
;
1073 for (rel
= relocs
; rel
< rel_end
; rel
++)
1075 unsigned int r_type
;
1077 struct elf_link_hash_entry
*h
= NULL
;
1078 struct elf_xtensa_link_hash_entry
*eh
;
1079 int tls_type
, old_tls_type
;
1080 bool is_got
= false;
1081 bool is_plt
= false;
1082 bool is_tlsfunc
= false;
1084 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1085 r_type
= ELF32_R_TYPE (rel
->r_info
);
1087 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1089 /* xgettext:c-format */
1090 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1095 if (r_symndx
>= symtab_hdr
->sh_info
)
1097 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1098 while (h
->root
.type
== bfd_link_hash_indirect
1099 || h
->root
.type
== bfd_link_hash_warning
)
1100 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1102 eh
= elf_xtensa_hash_entry (h
);
1106 case R_XTENSA_TLSDESC_FN
:
1107 if (bfd_link_dll (info
))
1109 tls_type
= GOT_TLS_GD
;
1114 tls_type
= GOT_TLS_IE
;
1117 case R_XTENSA_TLSDESC_ARG
:
1118 if (bfd_link_dll (info
))
1120 tls_type
= GOT_TLS_GD
;
1125 tls_type
= GOT_TLS_IE
;
1126 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
1127 && elf_xtensa_dynamic_symbol_p (h
, info
))
1132 case R_XTENSA_TLS_DTPOFF
:
1133 if (bfd_link_dll (info
))
1134 tls_type
= GOT_TLS_GD
;
1136 tls_type
= GOT_TLS_IE
;
1139 case R_XTENSA_TLS_TPOFF
:
1140 tls_type
= GOT_TLS_IE
;
1141 if (bfd_link_pic (info
))
1142 info
->flags
|= DF_STATIC_TLS
;
1143 if (bfd_link_dll (info
) || elf_xtensa_dynamic_symbol_p (h
, info
))
1148 tls_type
= GOT_NORMAL
;
1153 tls_type
= GOT_NORMAL
;
1157 case R_XTENSA_GNU_VTINHERIT
:
1158 /* This relocation describes the C++ object vtable hierarchy.
1159 Reconstruct it for later use during GC. */
1160 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1164 case R_XTENSA_GNU_VTENTRY
:
1165 /* This relocation describes which C++ vtable entries are actually
1166 used. Record for later use during GC. */
1167 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1172 /* Nothing to do for any other relocations. */
1180 if (h
->plt
.refcount
<= 0)
1183 h
->plt
.refcount
= 1;
1186 h
->plt
.refcount
+= 1;
1188 /* Keep track of the total PLT relocation count even if we
1189 don't yet know whether the dynamic sections will be
1191 htab
->plt_reloc_count
+= 1;
1193 if (elf_hash_table (info
)->dynamic_sections_created
)
1195 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1201 if (h
->got
.refcount
<= 0)
1202 h
->got
.refcount
= 1;
1204 h
->got
.refcount
+= 1;
1208 eh
->tlsfunc_refcount
+= 1;
1210 old_tls_type
= eh
->tls_type
;
1214 /* Allocate storage the first time. */
1215 if (elf_local_got_refcounts (abfd
) == NULL
)
1217 bfd_size_type size
= symtab_hdr
->sh_info
;
1220 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1223 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1225 mem
= bfd_zalloc (abfd
, size
);
1228 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1230 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1233 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1234 = (bfd_signed_vma
*) mem
;
1237 /* This is a global offset table entry for a local symbol. */
1238 if (is_got
|| is_plt
)
1239 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1242 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1244 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1247 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1248 tls_type
|= old_tls_type
;
1249 /* If a TLS symbol is accessed using IE at least once,
1250 there is no point to use a dynamic model for it. */
1251 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1252 && ((old_tls_type
& GOT_TLS_GD
) == 0
1253 || (tls_type
& GOT_TLS_IE
) == 0))
1255 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1256 tls_type
= old_tls_type
;
1257 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1258 tls_type
|= old_tls_type
;
1262 /* xgettext:c-format */
1263 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1265 h
? h
->root
.root
.string
: "<local>");
1270 if (old_tls_type
!= tls_type
)
1273 eh
->tls_type
= tls_type
;
1275 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1284 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1285 struct elf_link_hash_entry
*h
)
1287 if (bfd_link_pic (info
))
1289 if (h
->plt
.refcount
> 0)
1291 /* For shared objects, there's no need for PLT entries for local
1292 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1293 if (h
->got
.refcount
< 0)
1294 h
->got
.refcount
= 0;
1295 h
->got
.refcount
+= h
->plt
.refcount
;
1296 h
->plt
.refcount
= 0;
1301 /* Don't need any dynamic relocations at all. */
1302 h
->plt
.refcount
= 0;
1303 h
->got
.refcount
= 0;
1309 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1310 struct elf_link_hash_entry
*h
,
1313 /* For a shared link, move the plt refcount to the got refcount to leave
1314 space for RELATIVE relocs. */
1315 elf_xtensa_make_sym_local (info
, h
);
1317 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1321 /* Return the section that should be marked against GC for a given
1325 elf_xtensa_gc_mark_hook (asection
*sec
,
1326 struct bfd_link_info
*info
,
1327 Elf_Internal_Rela
*rel
,
1328 struct elf_link_hash_entry
*h
,
1329 Elf_Internal_Sym
*sym
)
1331 /* Property sections are marked "KEEP" in the linker scripts, but they
1332 should not cause other sections to be marked. (This approach relies
1333 on elf_xtensa_discard_info to remove property table entries that
1334 describe discarded sections. Alternatively, it might be more
1335 efficient to avoid using "KEEP" in the linker scripts and instead use
1336 the gc_mark_extra_sections hook to mark only the property sections
1337 that describe marked sections. That alternative does not work well
1338 with the current property table sections, which do not correspond
1339 one-to-one with the sections they describe, but that should be fixed
1341 if (xtensa_is_property_section (sec
))
1345 switch (ELF32_R_TYPE (rel
->r_info
))
1347 case R_XTENSA_GNU_VTINHERIT
:
1348 case R_XTENSA_GNU_VTENTRY
:
1352 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1356 /* Create all the dynamic sections. */
1359 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1361 struct elf_xtensa_link_hash_table
*htab
;
1362 flagword flags
, noalloc_flags
;
1364 htab
= elf_xtensa_hash_table (info
);
1368 /* First do all the standard stuff. */
1369 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1372 /* Create any extra PLT sections in case check_relocs has already
1373 been called on all the non-dynamic input files. */
1374 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1377 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1378 | SEC_LINKER_CREATED
| SEC_READONLY
);
1379 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1381 /* Mark the ".got.plt" section READONLY. */
1382 if (htab
->elf
.sgotplt
== NULL
1383 || !bfd_set_section_flags (htab
->elf
.sgotplt
, flags
))
1386 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1387 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1389 if (htab
->sgotloc
== NULL
1390 || !bfd_set_section_alignment (htab
->sgotloc
, 2))
1393 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1394 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1396 if (htab
->spltlittbl
== NULL
1397 || !bfd_set_section_alignment (htab
->spltlittbl
, 2))
1405 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1407 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1410 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1411 ".got.plt" sections. */
1412 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1418 /* Stop when we find a section has already been created. */
1419 if (elf_xtensa_get_plt_section (info
, chunk
))
1422 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1423 | SEC_LINKER_CREATED
| SEC_READONLY
);
1425 sname
= (char *) bfd_malloc (10);
1426 sprintf (sname
, ".plt.%u", chunk
);
1427 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1429 || !bfd_set_section_alignment (s
, 2))
1432 sname
= (char *) bfd_malloc (14);
1433 sprintf (sname
, ".got.plt.%u", chunk
);
1434 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1436 || !bfd_set_section_alignment (s
, 2))
1444 /* Adjust a symbol defined by a dynamic object and referenced by a
1445 regular object. The current definition is in some section of the
1446 dynamic object, but we're not including those sections. We have to
1447 change the definition to something the rest of the link can
1451 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1452 struct elf_link_hash_entry
*h
)
1454 /* If this is a weak symbol, and there is a real definition, the
1455 processor independent code will have arranged for us to see the
1456 real definition first, and we can just use the same value. */
1457 if (h
->is_weakalias
)
1459 struct elf_link_hash_entry
*def
= weakdef (h
);
1460 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1461 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1462 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1466 /* This is a reference to a symbol defined by a dynamic object. The
1467 reference must go through the GOT, so there's no need for COPY relocs,
1475 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1477 struct bfd_link_info
*info
;
1478 struct elf_xtensa_link_hash_table
*htab
;
1479 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1481 if (h
->root
.type
== bfd_link_hash_indirect
)
1484 info
= (struct bfd_link_info
*) arg
;
1485 htab
= elf_xtensa_hash_table (info
);
1489 /* If we saw any use of an IE model for this symbol, we can then optimize
1490 away GOT entries for any TLSDESC_FN relocs. */
1491 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1493 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1494 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1497 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1498 elf_xtensa_make_sym_local (info
, h
);
1500 if (! elf_xtensa_dynamic_symbol_p (h
, info
)
1501 && h
->root
.type
== bfd_link_hash_undefweak
)
1504 if (h
->plt
.refcount
> 0)
1505 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1507 if (h
->got
.refcount
> 0)
1508 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1515 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1517 struct elf_xtensa_link_hash_table
*htab
;
1520 htab
= elf_xtensa_hash_table (info
);
1524 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1526 bfd_signed_vma
*local_got_refcounts
;
1527 bfd_size_type j
, cnt
;
1528 Elf_Internal_Shdr
*symtab_hdr
;
1530 local_got_refcounts
= elf_local_got_refcounts (i
);
1531 if (!local_got_refcounts
)
1534 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1535 cnt
= symtab_hdr
->sh_info
;
1537 for (j
= 0; j
< cnt
; ++j
)
1539 /* If we saw any use of an IE model for this symbol, we can
1540 then optimize away GOT entries for any TLSDESC_FN relocs. */
1541 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1543 bfd_signed_vma
*tlsfunc_refcount
1544 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1545 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1546 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1549 if (local_got_refcounts
[j
] > 0)
1550 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1551 * sizeof (Elf32_External_Rela
));
1557 /* Set the sizes of the dynamic sections. */
1560 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1561 struct bfd_link_info
*info
)
1563 struct elf_xtensa_link_hash_table
*htab
;
1565 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1566 bool relplt
, relgot
;
1567 int plt_entries
, plt_chunks
, chunk
;
1572 htab
= elf_xtensa_hash_table (info
);
1576 dynobj
= elf_hash_table (info
)->dynobj
;
1579 srelgot
= htab
->elf
.srelgot
;
1580 srelplt
= htab
->elf
.srelplt
;
1582 if (elf_hash_table (info
)->dynamic_sections_created
)
1584 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1585 && htab
->elf
.srelplt
!= NULL
1586 && htab
->elf
.sgot
!= NULL
1587 && htab
->spltlittbl
!= NULL
1588 && htab
->sgotloc
!= NULL
);
1590 /* Set the contents of the .interp section to the interpreter. */
1591 if (bfd_link_executable (info
) && !info
->nointerp
)
1593 s
= bfd_get_linker_section (dynobj
, ".interp");
1596 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1597 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1600 /* Allocate room for one word in ".got". */
1601 htab
->elf
.sgot
->size
= 4;
1603 /* Allocate space in ".rela.got" for literals that reference global
1604 symbols and space in ".rela.plt" for literals that have PLT
1606 elf_link_hash_traverse (elf_hash_table (info
),
1607 elf_xtensa_allocate_dynrelocs
,
1610 /* If we are generating a shared object, we also need space in
1611 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1612 reference local symbols. */
1613 if (bfd_link_pic (info
))
1614 elf_xtensa_allocate_local_got_size (info
);
1616 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1617 each PLT entry, we need the PLT code plus a 4-byte literal.
1618 For each chunk of ".plt", we also need two more 4-byte
1619 literals, two corresponding entries in ".rela.got", and an
1620 8-byte entry in ".xt.lit.plt". */
1621 spltlittbl
= htab
->spltlittbl
;
1622 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1624 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1626 /* Iterate over all the PLT chunks, including any extra sections
1627 created earlier because the initial count of PLT relocations
1628 was an overestimate. */
1630 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1635 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1636 BFD_ASSERT (sgotplt
!= NULL
);
1638 if (chunk
< plt_chunks
- 1)
1639 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1640 else if (chunk
== plt_chunks
- 1)
1641 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1645 if (chunk_entries
!= 0)
1647 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1648 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1649 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1650 spltlittbl
->size
+= 8;
1659 /* Allocate space in ".got.loc" to match the total size of all the
1661 sgotloc
= htab
->sgotloc
;
1662 sgotloc
->size
= spltlittbl
->size
;
1663 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1665 if (abfd
->flags
& DYNAMIC
)
1667 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1669 if (! discarded_section (s
)
1670 && xtensa_is_littable_section (s
)
1672 sgotloc
->size
+= s
->size
;
1677 /* Allocate memory for dynamic sections. */
1680 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1684 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1687 /* It's OK to base decisions on the section name, because none
1688 of the dynobj section names depend upon the input files. */
1689 name
= bfd_section_name (s
);
1691 if (startswith (name
, ".rela"))
1695 if (strcmp (name
, ".rela.plt") == 0)
1697 else if (strcmp (name
, ".rela.got") == 0)
1700 /* We use the reloc_count field as a counter if we need
1701 to copy relocs into the output file. */
1705 else if (! startswith (name
, ".plt.")
1706 && ! startswith (name
, ".got.plt.")
1707 && strcmp (name
, ".got") != 0
1708 && strcmp (name
, ".plt") != 0
1709 && strcmp (name
, ".got.plt") != 0
1710 && strcmp (name
, ".xt.lit.plt") != 0
1711 && strcmp (name
, ".got.loc") != 0)
1713 /* It's not one of our sections, so don't allocate space. */
1719 /* If we don't need this section, strip it from the output
1720 file. We must create the ".plt*" and ".got.plt*"
1721 sections in create_dynamic_sections and/or check_relocs
1722 based on a conservative estimate of the PLT relocation
1723 count, because the sections must be created before the
1724 linker maps input sections to output sections. The
1725 linker does that before size_dynamic_sections, where we
1726 compute the exact size of the PLT, so there may be more
1727 of these sections than are actually needed. */
1728 s
->flags
|= SEC_EXCLUDE
;
1730 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1732 /* Allocate memory for the section contents. */
1733 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1734 if (s
->contents
== NULL
)
1739 if (elf_hash_table (info
)->dynamic_sections_created
)
1741 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1742 known until finish_dynamic_sections, but we need to get the relocs
1743 in place before they are sorted. */
1744 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1746 Elf_Internal_Rela irela
;
1750 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1753 loc
= (srelgot
->contents
1754 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1755 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1756 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1757 loc
+ sizeof (Elf32_External_Rela
));
1758 srelgot
->reloc_count
+= 2;
1761 /* Add some entries to the .dynamic section. We fill in the
1762 values later, in elf_xtensa_finish_dynamic_sections, but we
1763 must add the entries now so that we get the correct size for
1764 the .dynamic section. The DT_DEBUG entry is filled in by the
1765 dynamic linker and used by the debugger. */
1766 #define add_dynamic_entry(TAG, VAL) \
1767 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1769 if (!_bfd_elf_add_dynamic_tags (output_bfd
, info
,
1773 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1774 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1777 #undef add_dynamic_entry
1783 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1784 struct bfd_link_info
*info
)
1786 struct elf_xtensa_link_hash_table
*htab
;
1789 htab
= elf_xtensa_hash_table (info
);
1793 tls_sec
= htab
->elf
.tls_sec
;
1795 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1797 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1798 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1799 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1801 tlsbase
->type
= STT_TLS
;
1802 if (!(_bfd_generic_link_add_one_symbol
1803 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1804 tls_sec
, 0, NULL
, false,
1805 bed
->collect
, &bh
)))
1807 tlsbase
->def_regular
= 1;
1808 tlsbase
->other
= STV_HIDDEN
;
1809 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, true);
1816 /* Return the base VMA address which should be subtracted from real addresses
1817 when resolving @dtpoff relocation.
1818 This is PT_TLS segment p_vaddr. */
1821 dtpoff_base (struct bfd_link_info
*info
)
1823 /* If tls_sec is NULL, we should have signalled an error already. */
1824 if (elf_hash_table (info
)->tls_sec
== NULL
)
1826 return elf_hash_table (info
)->tls_sec
->vma
;
1829 /* Return the relocation value for @tpoff relocation
1830 if STT_TLS virtual address is ADDRESS. */
1833 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1835 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1838 /* If tls_sec is NULL, we should have signalled an error already. */
1839 if (htab
->tls_sec
== NULL
)
1841 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1842 return address
- htab
->tls_sec
->vma
+ base
;
1845 /* Perform the specified relocation. The instruction at (contents + address)
1846 is modified to set one operand to represent the value in "relocation". The
1847 operand position is determined by the relocation type recorded in the
1850 #define CALL_SEGMENT_BITS (30)
1851 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1853 static bfd_reloc_status_type
1854 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1856 asection
*input_section
,
1861 char **error_message
)
1864 xtensa_opcode opcode
;
1865 xtensa_isa isa
= xtensa_default_isa
;
1866 static xtensa_insnbuf ibuff
= NULL
;
1867 static xtensa_insnbuf sbuff
= NULL
;
1868 bfd_vma self_address
;
1869 bfd_size_type input_size
;
1875 ibuff
= xtensa_insnbuf_alloc (isa
);
1876 sbuff
= xtensa_insnbuf_alloc (isa
);
1879 input_size
= bfd_get_section_limit (abfd
, input_section
);
1881 /* Calculate the PC address for this instruction. */
1882 self_address
= (input_section
->output_section
->vma
1883 + input_section
->output_offset
1886 switch (howto
->type
)
1889 case R_XTENSA_DIFF8
:
1890 case R_XTENSA_DIFF16
:
1891 case R_XTENSA_DIFF32
:
1892 case R_XTENSA_PDIFF8
:
1893 case R_XTENSA_PDIFF16
:
1894 case R_XTENSA_PDIFF32
:
1895 case R_XTENSA_NDIFF8
:
1896 case R_XTENSA_NDIFF16
:
1897 case R_XTENSA_NDIFF32
:
1898 case R_XTENSA_TLS_FUNC
:
1899 case R_XTENSA_TLS_ARG
:
1900 case R_XTENSA_TLS_CALL
:
1901 return bfd_reloc_ok
;
1903 case R_XTENSA_ASM_EXPAND
:
1906 /* Check for windowed CALL across a 1GB boundary. */
1907 opcode
= get_expanded_call_opcode (contents
+ address
,
1908 input_size
- address
, 0);
1909 if (is_windowed_call_opcode (opcode
))
1911 if ((self_address
>> CALL_SEGMENT_BITS
)
1912 != (relocation
>> CALL_SEGMENT_BITS
))
1914 *error_message
= "windowed longcall crosses 1GB boundary; "
1916 return bfd_reloc_dangerous
;
1920 return bfd_reloc_ok
;
1922 case R_XTENSA_ASM_SIMPLIFY
:
1924 /* Convert the L32R/CALLX to CALL. */
1925 bfd_reloc_status_type retval
=
1926 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1928 if (retval
!= bfd_reloc_ok
)
1929 return bfd_reloc_dangerous
;
1931 /* The CALL needs to be relocated. Continue below for that part. */
1934 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1941 x
= bfd_get_32 (abfd
, contents
+ address
);
1943 bfd_put_32 (abfd
, x
, contents
+ address
);
1945 return bfd_reloc_ok
;
1947 case R_XTENSA_32_PCREL
:
1948 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1949 return bfd_reloc_ok
;
1952 case R_XTENSA_TLSDESC_FN
:
1953 case R_XTENSA_TLSDESC_ARG
:
1954 case R_XTENSA_TLS_DTPOFF
:
1955 case R_XTENSA_TLS_TPOFF
:
1956 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1957 return bfd_reloc_ok
;
1960 /* Only instruction slot-specific relocations handled below.... */
1961 slot
= get_relocation_slot (howto
->type
);
1962 if (slot
== XTENSA_UNDEFINED
)
1964 *error_message
= "unexpected relocation";
1965 return bfd_reloc_dangerous
;
1968 if (input_size
<= address
)
1969 return bfd_reloc_outofrange
;
1970 /* Read the instruction into a buffer and decode the opcode. */
1971 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1972 input_size
- address
);
1973 fmt
= xtensa_format_decode (isa
, ibuff
);
1974 if (fmt
== XTENSA_UNDEFINED
)
1976 *error_message
= "cannot decode instruction format";
1977 return bfd_reloc_dangerous
;
1980 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1982 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1983 if (opcode
== XTENSA_UNDEFINED
)
1985 *error_message
= "cannot decode instruction opcode";
1986 return bfd_reloc_dangerous
;
1989 /* Check for opcode-specific "alternate" relocations. */
1990 if (is_alt_relocation (howto
->type
))
1992 if (opcode
== get_l32r_opcode ())
1994 /* Handle the special-case of non-PC-relative L32R instructions. */
1995 bfd
*output_bfd
= input_section
->output_section
->owner
;
1996 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
1999 *error_message
= "relocation references missing .lit4 section";
2000 return bfd_reloc_dangerous
;
2002 self_address
= ((lit4_sec
->vma
& ~0xfff)
2003 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2004 newval
= relocation
;
2007 else if (opcode
== get_const16_opcode ())
2009 /* ALT used for high 16 bits.
2010 Ignore 32-bit overflow. */
2011 newval
= (relocation
>> 16) & 0xffff;
2016 /* No other "alternate" relocations currently defined. */
2017 *error_message
= "unexpected relocation";
2018 return bfd_reloc_dangerous
;
2021 else /* Not an "alternate" relocation.... */
2023 if (opcode
== get_const16_opcode ())
2025 newval
= relocation
& 0xffff;
2030 /* ...normal PC-relative relocation.... */
2032 /* Determine which operand is being relocated. */
2033 opnd
= get_relocation_opnd (opcode
, howto
->type
);
2034 if (opnd
== XTENSA_UNDEFINED
)
2036 *error_message
= "unexpected relocation";
2037 return bfd_reloc_dangerous
;
2040 if (!howto
->pc_relative
)
2042 *error_message
= "expected PC-relative relocation";
2043 return bfd_reloc_dangerous
;
2046 newval
= relocation
;
2050 /* Apply the relocation. */
2051 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
2052 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
2053 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2056 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2059 msg
= "cannot encode";
2060 if (is_direct_call_opcode (opcode
))
2062 if ((relocation
& 0x3) != 0)
2063 msg
= "misaligned call target";
2065 msg
= "call target out of range";
2067 else if (opcode
== get_l32r_opcode ())
2069 if ((relocation
& 0x3) != 0)
2070 msg
= "misaligned literal target";
2071 else if (is_alt_relocation (howto
->type
))
2072 msg
= "literal target out of range (too many literals)";
2073 else if (self_address
> relocation
)
2074 msg
= "literal target out of range (try using text-section-literals)";
2076 msg
= "literal placed after use";
2079 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2080 return bfd_reloc_dangerous
;
2083 /* Check for calls across 1GB boundaries. */
2084 if (is_direct_call_opcode (opcode
)
2085 && is_windowed_call_opcode (opcode
))
2087 if ((self_address
>> CALL_SEGMENT_BITS
)
2088 != (relocation
>> CALL_SEGMENT_BITS
))
2091 "windowed call crosses 1GB boundary; return may fail";
2092 return bfd_reloc_dangerous
;
2096 /* Write the modified instruction back out of the buffer. */
2097 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2098 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2099 input_size
- address
);
2100 return bfd_reloc_ok
;
2105 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2107 /* To reduce the size of the memory leak,
2108 we only use a single message buffer. */
2109 static bfd_size_type alloc_size
= 0;
2110 static char *message
= NULL
;
2111 bfd_size_type orig_len
, len
= 0;
2115 va_start (ap
, arglen
);
2117 is_append
= (origmsg
== message
);
2119 orig_len
= strlen (origmsg
);
2120 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2121 if (len
> alloc_size
)
2123 message
= (char *) bfd_realloc_or_free (message
, len
);
2126 if (message
!= NULL
)
2129 memcpy (message
, origmsg
, orig_len
);
2130 vsprintf (message
+ orig_len
, fmt
, ap
);
2137 /* This function is registered as the "special_function" in the
2138 Xtensa howto for handling simplify operations.
2139 bfd_perform_relocation / bfd_install_relocation use it to
2140 perform (install) the specified relocation. Since this replaces the code
2141 in bfd_perform_relocation, it is basically an Xtensa-specific,
2142 stripped-down version of bfd_perform_relocation. */
2144 static bfd_reloc_status_type
2145 bfd_elf_xtensa_reloc (bfd
*abfd
,
2146 arelent
*reloc_entry
,
2149 asection
*input_section
,
2151 char **error_message
)
2154 bfd_reloc_status_type flag
;
2155 bfd_size_type octets
= (reloc_entry
->address
2156 * OCTETS_PER_BYTE (abfd
, input_section
));
2157 bfd_vma output_base
= 0;
2158 reloc_howto_type
*howto
= reloc_entry
->howto
;
2159 asection
*reloc_target_output_section
;
2162 if (!xtensa_default_isa
)
2163 xtensa_default_isa
= xtensa_isa_init (0, 0);
2165 /* ELF relocs are against symbols. If we are producing relocatable
2166 output, and the reloc is against an external symbol, the resulting
2167 reloc will also be against the same symbol. In such a case, we
2168 don't want to change anything about the way the reloc is handled,
2169 since it will all be done at final link time. This test is similar
2170 to what bfd_elf_generic_reloc does except that it lets relocs with
2171 howto->partial_inplace go through even if the addend is non-zero.
2172 (The real problem is that partial_inplace is set for XTENSA_32
2173 relocs to begin with, but that's a long story and there's little we
2174 can do about it now....) */
2176 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2178 reloc_entry
->address
+= input_section
->output_offset
;
2179 return bfd_reloc_ok
;
2182 /* Is the address of the relocation really within the section? */
2183 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2184 return bfd_reloc_outofrange
;
2186 /* Work out which section the relocation is targeted at and the
2187 initial relocation command value. */
2189 /* Get symbol value. (Common symbols are special.) */
2190 if (bfd_is_com_section (symbol
->section
))
2193 relocation
= symbol
->value
;
2195 reloc_target_output_section
= symbol
->section
->output_section
;
2197 /* Convert input-section-relative symbol value to absolute. */
2198 if ((output_bfd
&& !howto
->partial_inplace
)
2199 || reloc_target_output_section
== NULL
)
2202 output_base
= reloc_target_output_section
->vma
;
2204 relocation
+= output_base
+ symbol
->section
->output_offset
;
2206 /* Add in supplied addend. */
2207 relocation
+= reloc_entry
->addend
;
2209 /* Here the variable relocation holds the final address of the
2210 symbol we are relocating against, plus any addend. */
2213 if (!howto
->partial_inplace
)
2215 /* This is a partial relocation, and we want to apply the relocation
2216 to the reloc entry rather than the raw data. Everything except
2217 relocations against section symbols has already been handled
2220 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2221 reloc_entry
->addend
= relocation
;
2222 reloc_entry
->address
+= input_section
->output_offset
;
2223 return bfd_reloc_ok
;
2227 reloc_entry
->address
+= input_section
->output_offset
;
2228 reloc_entry
->addend
= 0;
2232 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2233 && (symbol
->flags
& BSF_WEAK
) != 0);
2234 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2235 (bfd_byte
*) data
, (bfd_vma
) octets
,
2236 is_weak_undef
, error_message
);
2238 if (flag
== bfd_reloc_dangerous
)
2240 /* Add the symbol name to the error message. */
2241 if (! *error_message
)
2242 *error_message
= "";
2243 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2244 strlen (symbol
->name
) + 17,
2246 (unsigned long) reloc_entry
->addend
);
2252 int xtensa_abi_choice (void)
2254 if (elf32xtensa_abi
== XTHAL_ABI_UNDEFINED
)
2257 return elf32xtensa_abi
;
2260 /* Set up an entry in the procedure linkage table. */
2263 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2265 unsigned reloc_index
)
2267 asection
*splt
, *sgotplt
;
2268 bfd_vma plt_base
, got_base
;
2269 bfd_vma code_offset
, lit_offset
, abi_offset
;
2271 int abi
= xtensa_abi_choice ();
2273 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2274 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2275 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2276 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2278 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2279 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2281 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2282 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2284 /* Fill in the literal entry. This is the offset of the dynamic
2285 relocation entry. */
2286 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2287 sgotplt
->contents
+ lit_offset
);
2289 /* Fill in the entry in the procedure linkage table. */
2290 memcpy (splt
->contents
+ code_offset
,
2291 (bfd_big_endian (output_bfd
)
2292 ? elf_xtensa_be_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]
2293 : elf_xtensa_le_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]),
2295 abi_offset
= abi
== XTHAL_ABI_WINDOWED
? 3 : 0;
2296 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2297 plt_base
+ code_offset
+ abi_offset
),
2298 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2299 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2300 plt_base
+ code_offset
+ abi_offset
+ 3),
2301 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2302 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2303 plt_base
+ code_offset
+ abi_offset
+ 6),
2304 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2306 return plt_base
+ code_offset
;
2310 static bool get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2313 replace_tls_insn (Elf_Internal_Rela
*rel
,
2315 asection
*input_section
,
2318 char **error_message
)
2320 static xtensa_insnbuf ibuff
= NULL
;
2321 static xtensa_insnbuf sbuff
= NULL
;
2322 xtensa_isa isa
= xtensa_default_isa
;
2324 xtensa_opcode old_op
, new_op
;
2325 bfd_size_type input_size
;
2327 unsigned dest_reg
, src_reg
;
2331 ibuff
= xtensa_insnbuf_alloc (isa
);
2332 sbuff
= xtensa_insnbuf_alloc (isa
);
2335 input_size
= bfd_get_section_limit (abfd
, input_section
);
2337 /* Read the instruction into a buffer and decode the opcode. */
2338 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2339 input_size
- rel
->r_offset
);
2340 fmt
= xtensa_format_decode (isa
, ibuff
);
2341 if (fmt
== XTENSA_UNDEFINED
)
2343 *error_message
= "cannot decode instruction format";
2347 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2348 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2350 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2351 if (old_op
== XTENSA_UNDEFINED
)
2353 *error_message
= "cannot decode instruction opcode";
2357 r_type
= ELF32_R_TYPE (rel
->r_info
);
2360 case R_XTENSA_TLS_FUNC
:
2361 case R_XTENSA_TLS_ARG
:
2362 if (old_op
!= get_l32r_opcode ()
2363 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2364 sbuff
, &dest_reg
) != 0)
2366 *error_message
= "cannot extract L32R destination for TLS access";
2371 case R_XTENSA_TLS_CALL
:
2372 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2373 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2374 sbuff
, &src_reg
) != 0)
2376 *error_message
= "cannot extract CALLXn operands for TLS access";
2389 case R_XTENSA_TLS_FUNC
:
2390 case R_XTENSA_TLS_ARG
:
2391 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2392 versions of Xtensa). */
2393 new_op
= xtensa_opcode_lookup (isa
, "nop");
2394 if (new_op
== XTENSA_UNDEFINED
)
2396 new_op
= xtensa_opcode_lookup (isa
, "or");
2397 if (new_op
== XTENSA_UNDEFINED
2398 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2399 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2401 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2403 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2406 *error_message
= "cannot encode OR for TLS access";
2412 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2414 *error_message
= "cannot encode NOP for TLS access";
2420 case R_XTENSA_TLS_CALL
:
2421 /* Read THREADPTR into the CALLX's return value register. */
2422 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2423 if (new_op
== XTENSA_UNDEFINED
2424 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2425 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2426 sbuff
, dest_reg
+ 2) != 0)
2428 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2438 case R_XTENSA_TLS_FUNC
:
2439 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2440 if (new_op
== XTENSA_UNDEFINED
2441 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2442 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2443 sbuff
, dest_reg
) != 0)
2445 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2450 case R_XTENSA_TLS_ARG
:
2451 /* Nothing to do. Keep the original L32R instruction. */
2454 case R_XTENSA_TLS_CALL
:
2455 /* Add the CALLX's src register (holding the THREADPTR value)
2456 to the first argument register (holding the offset) and put
2457 the result in the CALLX's return value register. */
2458 new_op
= xtensa_opcode_lookup (isa
, "add");
2459 if (new_op
== XTENSA_UNDEFINED
2460 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2461 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2462 sbuff
, dest_reg
+ 2) != 0
2463 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2464 sbuff
, dest_reg
+ 2) != 0
2465 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2466 sbuff
, src_reg
) != 0)
2468 *error_message
= "cannot encode ADD for TLS access";
2475 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2476 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2477 input_size
- rel
->r_offset
);
2483 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2484 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2485 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2486 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2487 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2488 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2489 || (R_TYPE) == R_XTENSA_TLS_ARG \
2490 || (R_TYPE) == R_XTENSA_TLS_CALL)
2492 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2493 both relocatable and final links. */
2496 elf_xtensa_relocate_section (bfd
*output_bfd
,
2497 struct bfd_link_info
*info
,
2499 asection
*input_section
,
2501 Elf_Internal_Rela
*relocs
,
2502 Elf_Internal_Sym
*local_syms
,
2503 asection
**local_sections
)
2505 struct elf_xtensa_link_hash_table
*htab
;
2506 Elf_Internal_Shdr
*symtab_hdr
;
2507 Elf_Internal_Rela
*rel
;
2508 Elf_Internal_Rela
*relend
;
2509 struct elf_link_hash_entry
**sym_hashes
;
2510 property_table_entry
*lit_table
= 0;
2512 char *local_got_tls_types
;
2513 char *error_message
= NULL
;
2514 bfd_size_type input_size
;
2517 if (!xtensa_default_isa
)
2518 xtensa_default_isa
= xtensa_isa_init (0, 0);
2520 if (!is_xtensa_elf (input_bfd
))
2522 bfd_set_error (bfd_error_wrong_format
);
2526 htab
= elf_xtensa_hash_table (info
);
2530 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2531 sym_hashes
= elf_sym_hashes (input_bfd
);
2532 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2534 if (elf_hash_table (info
)->dynamic_sections_created
)
2536 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2537 &lit_table
, XTENSA_LIT_SEC_NAME
,
2543 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2546 relend
= relocs
+ input_section
->reloc_count
;
2547 for (; rel
< relend
; rel
++)
2550 reloc_howto_type
*howto
;
2551 unsigned long r_symndx
;
2552 struct elf_link_hash_entry
*h
;
2553 Elf_Internal_Sym
*sym
;
2558 bfd_reloc_status_type r
;
2560 bool unresolved_reloc
;
2562 bool dynamic_symbol
;
2564 r_type
= ELF32_R_TYPE (rel
->r_info
);
2565 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2566 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2569 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2571 bfd_set_error (bfd_error_bad_value
);
2574 howto
= &elf_howto_table
[r_type
];
2576 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2581 is_weak_undef
= false;
2582 unresolved_reloc
= false;
2585 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2587 /* Because R_XTENSA_32 was made partial_inplace to fix some
2588 problems with DWARF info in partial links, there may be
2589 an addend stored in the contents. Take it out of there
2590 and move it back into the addend field of the reloc. */
2591 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2592 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2595 if (r_symndx
< symtab_hdr
->sh_info
)
2597 sym
= local_syms
+ r_symndx
;
2598 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2599 sec
= local_sections
[r_symndx
];
2600 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2606 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2607 r_symndx
, symtab_hdr
, sym_hashes
,
2609 unresolved_reloc
, warned
, ignored
);
2612 && !unresolved_reloc
2613 && h
->root
.type
== bfd_link_hash_undefweak
)
2614 is_weak_undef
= true;
2619 if (sec
!= NULL
&& discarded_section (sec
))
2620 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2621 rel
, 1, relend
, howto
, 0, contents
);
2623 if (bfd_link_relocatable (info
))
2626 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2628 /* This is a relocatable link.
2629 1) If the reloc is against a section symbol, adjust
2630 according to the output section.
2631 2) If there is a new target for this relocation,
2632 the new target will be in the same output section.
2633 We adjust the relocation by the output section
2636 if (relaxing_section
)
2638 /* Check if this references a section in another input file. */
2639 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2644 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2645 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2647 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2649 error_message
= NULL
;
2650 /* Convert ASM_SIMPLIFY into the simpler relocation
2651 so that they never escape a relaxing link. */
2652 r
= contract_asm_expansion (contents
, input_size
, rel
,
2654 if (r
!= bfd_reloc_ok
)
2655 (*info
->callbacks
->reloc_dangerous
)
2656 (info
, error_message
,
2657 input_bfd
, input_section
, rel
->r_offset
);
2659 r_type
= ELF32_R_TYPE (rel
->r_info
);
2662 /* This is a relocatable link, so we don't have to change
2663 anything unless the reloc is against a section symbol,
2664 in which case we have to adjust according to where the
2665 section symbol winds up in the output section. */
2666 if (r_symndx
< symtab_hdr
->sh_info
)
2668 sym
= local_syms
+ r_symndx
;
2669 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2671 sec
= local_sections
[r_symndx
];
2672 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2676 /* If there is an addend with a partial_inplace howto,
2677 then move the addend to the contents. This is a hack
2678 to work around problems with DWARF in relocatable links
2679 with some previous version of BFD. Now we can't easily get
2680 rid of the hack without breaking backward compatibility.... */
2682 howto
= &elf_howto_table
[r_type
];
2683 if (howto
->partial_inplace
&& rel
->r_addend
)
2685 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2686 rel
->r_addend
, contents
,
2687 rel
->r_offset
, false,
2693 /* Put the correct bits in the target instruction, even
2694 though the relocation will still be present in the output
2695 file. This makes disassembly clearer, as well as
2696 allowing loadable kernel modules to work without needing
2697 relocations on anything other than calls and l32r's. */
2699 /* If it is not in the same section, there is nothing we can do. */
2700 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2701 sym_sec
->output_section
== input_section
->output_section
)
2703 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2704 dest_addr
, contents
,
2705 rel
->r_offset
, false,
2709 if (r
!= bfd_reloc_ok
)
2710 (*info
->callbacks
->reloc_dangerous
)
2711 (info
, error_message
,
2712 input_bfd
, input_section
, rel
->r_offset
);
2714 /* Done with work for relocatable link; continue with next reloc. */
2718 /* This is a final link. */
2720 if (relaxing_section
)
2722 /* Check if this references a section in another input file. */
2723 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2727 /* Sanity check the address. */
2728 if (rel
->r_offset
>= input_size
2729 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2732 /* xgettext:c-format */
2733 (_("%pB(%pA+%#" PRIx64
"): "
2734 "relocation offset out of range (size=%#" PRIx64
")"),
2735 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2736 (uint64_t) input_size
);
2737 bfd_set_error (bfd_error_bad_value
);
2742 name
= h
->root
.root
.string
;
2745 name
= (bfd_elf_string_from_elf_section
2746 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2747 if (name
== NULL
|| *name
== '\0')
2748 name
= bfd_section_name (sec
);
2751 if (r_symndx
!= STN_UNDEF
2752 && r_type
!= R_XTENSA_NONE
2754 || h
->root
.type
== bfd_link_hash_defined
2755 || h
->root
.type
== bfd_link_hash_defweak
)
2756 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2759 ((sym_type
== STT_TLS
2760 /* xgettext:c-format */
2761 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2762 /* xgettext:c-format */
2763 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2766 (uint64_t) rel
->r_offset
,
2771 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2773 tls_type
= GOT_UNKNOWN
;
2775 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2776 else if (local_got_tls_types
)
2777 tls_type
= local_got_tls_types
[r_symndx
];
2783 if (elf_hash_table (info
)->dynamic_sections_created
2784 && (input_section
->flags
& SEC_ALLOC
) != 0
2785 && (dynamic_symbol
|| bfd_link_pic (info
)))
2787 Elf_Internal_Rela outrel
;
2791 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2792 srel
= htab
->elf
.srelplt
;
2794 srel
= htab
->elf
.srelgot
;
2796 BFD_ASSERT (srel
!= NULL
);
2799 _bfd_elf_section_offset (output_bfd
, info
,
2800 input_section
, rel
->r_offset
);
2802 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2803 memset (&outrel
, 0, sizeof outrel
);
2806 outrel
.r_offset
+= (input_section
->output_section
->vma
2807 + input_section
->output_offset
);
2809 /* Complain if the relocation is in a read-only section
2810 and not in a literal pool. */
2811 if ((input_section
->flags
& SEC_READONLY
) != 0
2812 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2816 _("dynamic relocation in read-only section");
2817 (*info
->callbacks
->reloc_dangerous
)
2818 (info
, error_message
,
2819 input_bfd
, input_section
, rel
->r_offset
);
2824 outrel
.r_addend
= rel
->r_addend
;
2827 if (r_type
== R_XTENSA_32
)
2830 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2833 else /* r_type == R_XTENSA_PLT */
2836 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2838 /* Create the PLT entry and set the initial
2839 contents of the literal entry to the address of
2842 elf_xtensa_create_plt_entry (info
, output_bfd
,
2845 unresolved_reloc
= false;
2847 else if (!is_weak_undef
)
2849 /* Generate a RELATIVE relocation. */
2850 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2851 outrel
.r_addend
= 0;
2859 loc
= (srel
->contents
2860 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2861 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2862 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2865 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2867 /* This should only happen for non-PIC code, which is not
2868 supposed to be used on systems with dynamic linking.
2869 Just ignore these relocations. */
2874 case R_XTENSA_TLS_TPOFF
:
2875 /* Switch to LE model for local symbols in an executable. */
2876 if (! bfd_link_dll (info
) && ! dynamic_symbol
)
2878 relocation
= tpoff (info
, relocation
);
2883 case R_XTENSA_TLSDESC_FN
:
2884 case R_XTENSA_TLSDESC_ARG
:
2886 if (r_type
== R_XTENSA_TLSDESC_FN
)
2888 if (! bfd_link_dll (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2889 r_type
= R_XTENSA_NONE
;
2891 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2893 if (bfd_link_dll (info
))
2895 if ((tls_type
& GOT_TLS_IE
) != 0)
2896 r_type
= R_XTENSA_TLS_TPOFF
;
2900 r_type
= R_XTENSA_TLS_TPOFF
;
2901 if (! dynamic_symbol
)
2903 relocation
= tpoff (info
, relocation
);
2909 if (r_type
== R_XTENSA_NONE
)
2910 /* Nothing to do here; skip to the next reloc. */
2913 if (! elf_hash_table (info
)->dynamic_sections_created
)
2916 _("TLS relocation invalid without dynamic sections");
2917 (*info
->callbacks
->reloc_dangerous
)
2918 (info
, error_message
,
2919 input_bfd
, input_section
, rel
->r_offset
);
2923 Elf_Internal_Rela outrel
;
2925 asection
*srel
= htab
->elf
.srelgot
;
2928 outrel
.r_offset
= (input_section
->output_section
->vma
2929 + input_section
->output_offset
2932 /* Complain if the relocation is in a read-only section
2933 and not in a literal pool. */
2934 if ((input_section
->flags
& SEC_READONLY
) != 0
2935 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2939 _("dynamic relocation in read-only section");
2940 (*info
->callbacks
->reloc_dangerous
)
2941 (info
, error_message
,
2942 input_bfd
, input_section
, rel
->r_offset
);
2945 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2947 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2949 outrel
.r_addend
= 0;
2952 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2954 unresolved_reloc
= false;
2957 loc
= (srel
->contents
2958 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2959 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2960 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2966 case R_XTENSA_TLS_DTPOFF
:
2967 if (! bfd_link_dll (info
))
2968 /* Switch from LD model to LE model. */
2969 relocation
= tpoff (info
, relocation
);
2971 relocation
-= dtpoff_base (info
);
2974 case R_XTENSA_TLS_FUNC
:
2975 case R_XTENSA_TLS_ARG
:
2976 case R_XTENSA_TLS_CALL
:
2977 /* Check if optimizing to IE or LE model. */
2978 if ((tls_type
& GOT_TLS_IE
) != 0)
2981 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
2982 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
2983 is_ld_model
, &error_message
))
2984 (*info
->callbacks
->reloc_dangerous
)
2985 (info
, error_message
,
2986 input_bfd
, input_section
, rel
->r_offset
);
2988 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
2990 /* Skip subsequent relocations on the same instruction. */
2991 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
2998 if (elf_hash_table (info
)->dynamic_sections_created
2999 && dynamic_symbol
&& (is_operand_relocation (r_type
)
3000 || r_type
== R_XTENSA_32_PCREL
))
3003 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3004 strlen (name
) + 2, name
);
3005 (*info
->callbacks
->reloc_dangerous
)
3006 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3012 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3013 because such sections are not SEC_ALLOC and thus ld.so will
3014 not process them. */
3015 if (unresolved_reloc
3016 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3018 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3019 rel
->r_offset
) != (bfd_vma
) -1)
3022 /* xgettext:c-format */
3023 (_("%pB(%pA+%#" PRIx64
"): "
3024 "unresolvable %s relocation against symbol `%s'"),
3027 (uint64_t) rel
->r_offset
,
3033 /* TLS optimizations may have changed r_type; update "howto". */
3034 howto
= &elf_howto_table
[r_type
];
3036 /* There's no point in calling bfd_perform_relocation here.
3037 Just go directly to our "special function". */
3038 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
3039 relocation
+ rel
->r_addend
,
3040 contents
, rel
->r_offset
, is_weak_undef
,
3043 if (r
!= bfd_reloc_ok
&& !warned
)
3045 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
3046 BFD_ASSERT (error_message
!= NULL
);
3048 if (rel
->r_addend
== 0)
3049 error_message
= vsprint_msg (error_message
, ": %s",
3050 strlen (name
) + 2, name
);
3052 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
3054 name
, (int) rel
->r_addend
);
3056 (*info
->callbacks
->reloc_dangerous
)
3057 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3062 input_section
->reloc_done
= true;
3068 /* Finish up dynamic symbol handling. There's not much to do here since
3069 the PLT and GOT entries are all set up by relocate_section. */
3072 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3073 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3074 struct elf_link_hash_entry
*h
,
3075 Elf_Internal_Sym
*sym
)
3077 if (h
->needs_plt
&& !h
->def_regular
)
3079 /* Mark the symbol as undefined, rather than as defined in
3080 the .plt section. Leave the value alone. */
3081 sym
->st_shndx
= SHN_UNDEF
;
3082 /* If the symbol is weak, we do need to clear the value.
3083 Otherwise, the PLT entry would provide a definition for
3084 the symbol even if the symbol wasn't defined anywhere,
3085 and so the symbol would never be NULL. */
3086 if (!h
->ref_regular_nonweak
)
3090 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3091 if (h
== elf_hash_table (info
)->hdynamic
3092 || h
== elf_hash_table (info
)->hgot
)
3093 sym
->st_shndx
= SHN_ABS
;
3099 /* Combine adjacent literal table entries in the output. Adjacent
3100 entries within each input section may have been removed during
3101 relaxation, but we repeat the process here, even though it's too late
3102 to shrink the output section, because it's important to minimize the
3103 number of literal table entries to reduce the start-up work for the
3104 runtime linker. Returns the number of remaining table entries or -1
3108 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3113 property_table_entry
*table
;
3114 bfd_size_type section_size
, sgotloc_size
;
3118 section_size
= sxtlit
->size
;
3119 if (section_size
== 0)
3122 BFD_ASSERT (section_size
% 8 == 0);
3123 num
= section_size
/ 8;
3125 sgotloc_size
= sgotloc
->size
;
3126 if (sgotloc_size
!= section_size
)
3129 (_("internal inconsistency in size of .got.loc section"));
3133 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3137 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3138 propagates to the output section, where it doesn't really apply and
3139 where it breaks the following call to bfd_malloc_and_get_section. */
3140 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3142 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3149 /* There should never be any relocations left at this point, so this
3150 is quite a bit easier than what is done during relaxation. */
3152 /* Copy the raw contents into a property table array and sort it. */
3154 for (n
= 0; n
< num
; n
++)
3156 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3157 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3160 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3162 for (n
= 0; n
< num
; n
++)
3164 bool remove_entry
= false;
3166 if (table
[n
].size
== 0)
3167 remove_entry
= true;
3169 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3171 table
[n
-1].size
+= table
[n
].size
;
3172 remove_entry
= true;
3177 for (m
= n
; m
< num
- 1; m
++)
3179 table
[m
].address
= table
[m
+1].address
;
3180 table
[m
].size
= table
[m
+1].size
;
3188 /* Copy the data back to the raw contents. */
3190 for (n
= 0; n
< num
; n
++)
3192 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3193 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3197 /* Clear the removed bytes. */
3198 if ((bfd_size_type
) (num
* 8) < section_size
)
3199 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3201 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3205 /* Copy the contents to ".got.loc". */
3206 memcpy (sgotloc
->contents
, contents
, section_size
);
3214 /* Finish up the dynamic sections. */
3217 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3218 struct bfd_link_info
*info
)
3220 struct elf_xtensa_link_hash_table
*htab
;
3222 asection
*sdyn
, *srelplt
, *srelgot
, *sgot
, *sxtlit
, *sgotloc
;
3223 Elf32_External_Dyn
*dyncon
, *dynconend
;
3224 int num_xtlit_entries
= 0;
3226 if (! elf_hash_table (info
)->dynamic_sections_created
)
3229 htab
= elf_xtensa_hash_table (info
);
3233 dynobj
= elf_hash_table (info
)->dynobj
;
3234 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3235 BFD_ASSERT (sdyn
!= NULL
);
3237 /* Set the first entry in the global offset table to the address of
3238 the dynamic section. */
3239 sgot
= htab
->elf
.sgot
;
3242 BFD_ASSERT (sgot
->size
== 4);
3244 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3246 bfd_put_32 (output_bfd
,
3247 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3251 srelplt
= htab
->elf
.srelplt
;
3252 srelgot
= htab
->elf
.srelgot
;
3253 if (srelplt
&& srelplt
->size
!= 0)
3255 asection
*sgotplt
, *spltlittbl
;
3256 int chunk
, plt_chunks
, plt_entries
;
3257 Elf_Internal_Rela irela
;
3259 unsigned rtld_reloc
;
3261 spltlittbl
= htab
->spltlittbl
;
3262 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3264 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3265 of them follow immediately after.... */
3266 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3268 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3269 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3270 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3273 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3275 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3277 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3279 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3281 int chunk_entries
= 0;
3283 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3284 BFD_ASSERT (sgotplt
!= NULL
);
3286 /* Emit special RTLD relocations for the first two entries in
3287 each chunk of the .got.plt section. */
3289 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3290 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3291 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3292 irela
.r_offset
= (sgotplt
->output_section
->vma
3293 + sgotplt
->output_offset
);
3294 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3295 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3297 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3299 /* Next literal immediately follows the first. */
3300 loc
+= sizeof (Elf32_External_Rela
);
3301 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3302 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3303 irela
.r_offset
= (sgotplt
->output_section
->vma
3304 + sgotplt
->output_offset
+ 4);
3305 /* Tell rtld to set value to object's link map. */
3307 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3309 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3311 /* Fill in the literal table. */
3312 if (chunk
< plt_chunks
- 1)
3313 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3315 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3317 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3318 bfd_put_32 (output_bfd
,
3319 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3320 spltlittbl
->contents
+ (chunk
* 8) + 0);
3321 bfd_put_32 (output_bfd
,
3322 8 + (chunk_entries
* 4),
3323 spltlittbl
->contents
+ (chunk
* 8) + 4);
3326 /* The .xt.lit.plt section has just been modified. This must
3327 happen before the code below which combines adjacent literal
3328 table entries, and the .xt.lit.plt contents have to be forced to
3330 if (! bfd_set_section_contents (output_bfd
,
3331 spltlittbl
->output_section
,
3332 spltlittbl
->contents
,
3333 spltlittbl
->output_offset
,
3336 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3337 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3340 /* All the dynamic relocations have been emitted at this point.
3341 Make sure the relocation sections are the correct size. */
3342 if ((srelgot
&& srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3343 * srelgot
->reloc_count
))
3344 || (srelplt
&& srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3345 * srelplt
->reloc_count
)))
3348 /* Combine adjacent literal table entries. */
3349 BFD_ASSERT (! bfd_link_relocatable (info
));
3350 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3351 sgotloc
= htab
->sgotloc
;
3352 BFD_ASSERT (sgotloc
);
3356 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3357 if (num_xtlit_entries
< 0)
3361 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3362 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3363 for (; dyncon
< dynconend
; dyncon
++)
3365 Elf_Internal_Dyn dyn
;
3367 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3374 case DT_XTENSA_GOT_LOC_SZ
:
3375 dyn
.d_un
.d_val
= num_xtlit_entries
;
3378 case DT_XTENSA_GOT_LOC_OFF
:
3379 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3380 + htab
->sgotloc
->output_offset
);
3384 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3385 + htab
->elf
.sgot
->output_offset
);
3389 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3390 + htab
->elf
.srelplt
->output_offset
);
3394 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3398 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3405 /* Functions for dealing with the e_flags field. */
3407 /* Merge backend specific data from an object file to the output
3408 object file when linking. */
3411 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3413 bfd
*obfd
= info
->output_bfd
;
3414 unsigned out_mach
, in_mach
;
3415 flagword out_flag
, in_flag
;
3417 /* Check if we have the same endianness. */
3418 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3421 /* Don't even pretend to support mixed-format linking. */
3422 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3423 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3426 out_flag
= elf_elfheader (obfd
)->e_flags
;
3427 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3429 out_mach
= out_flag
& EF_XTENSA_MACH
;
3430 in_mach
= in_flag
& EF_XTENSA_MACH
;
3431 if (out_mach
!= in_mach
)
3434 /* xgettext:c-format */
3435 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3436 ibfd
, out_mach
, in_mach
);
3437 bfd_set_error (bfd_error_wrong_format
);
3441 if (! elf_flags_init (obfd
))
3443 elf_flags_init (obfd
) = true;
3444 elf_elfheader (obfd
)->e_flags
= in_flag
;
3446 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3447 && bfd_get_arch_info (obfd
)->the_default
)
3448 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3449 bfd_get_mach (ibfd
));
3454 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3455 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3457 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3458 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3465 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3467 BFD_ASSERT (!elf_flags_init (abfd
)
3468 || elf_elfheader (abfd
)->e_flags
== flags
);
3470 elf_elfheader (abfd
)->e_flags
|= flags
;
3471 elf_flags_init (abfd
) = true;
3478 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3480 FILE *f
= (FILE *) farg
;
3481 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3483 fprintf (f
, "\nXtensa header:\n");
3484 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3485 fprintf (f
, "\nMachine = Base\n");
3487 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3489 fprintf (f
, "Insn tables = %s\n",
3490 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3492 fprintf (f
, "Literal tables = %s\n",
3493 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3495 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3499 /* Set the right machine number for an Xtensa ELF file. */
3502 elf_xtensa_object_p (bfd
*abfd
)
3505 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3510 mach
= bfd_mach_xtensa
;
3516 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3521 /* The final processing done just before writing out an Xtensa ELF object
3522 file. This gets the Xtensa architecture right based on the machine
3526 elf_xtensa_final_write_processing (bfd
*abfd
)
3529 unsigned long val
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3531 switch (mach
= bfd_get_mach (abfd
))
3533 case bfd_mach_xtensa
:
3534 val
= E_XTENSA_MACH
;
3540 elf_elfheader (abfd
)->e_flags
&= ~EF_XTENSA_MACH
;
3541 elf_elfheader (abfd
)->e_flags
|= val
;
3542 return _bfd_elf_final_write_processing (abfd
);
3546 static enum elf_reloc_type_class
3547 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3548 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3549 const Elf_Internal_Rela
*rela
)
3551 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3553 case R_XTENSA_RELATIVE
:
3554 return reloc_class_relative
;
3555 case R_XTENSA_JMP_SLOT
:
3556 return reloc_class_plt
;
3558 return reloc_class_normal
;
3564 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3565 struct elf_reloc_cookie
*cookie
,
3566 struct bfd_link_info
*info
,
3570 bfd_vma offset
, actual_offset
;
3571 bfd_size_type removed_bytes
= 0;
3572 bfd_size_type entry_size
;
3574 if (sec
->output_section
3575 && bfd_is_abs_section (sec
->output_section
))
3578 if (xtensa_is_proptable_section (sec
))
3583 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3586 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3590 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3593 release_contents (sec
, contents
);
3597 /* Sort the relocations. They should already be in order when
3598 relaxation is enabled, but it might not be. */
3599 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3600 internal_reloc_compare
);
3602 cookie
->rel
= cookie
->rels
;
3603 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3605 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3607 actual_offset
= offset
- removed_bytes
;
3609 /* The ...symbol_deleted_p function will skip over relocs but it
3610 won't adjust their offsets, so do that here. */
3611 while (cookie
->rel
< cookie
->relend
3612 && cookie
->rel
->r_offset
< offset
)
3614 cookie
->rel
->r_offset
-= removed_bytes
;
3618 while (cookie
->rel
< cookie
->relend
3619 && cookie
->rel
->r_offset
== offset
)
3621 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3623 /* Remove the table entry. (If the reloc type is NONE, then
3624 the entry has already been merged with another and deleted
3625 during relaxation.) */
3626 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3628 /* Shift the contents up. */
3629 if (offset
+ entry_size
< sec
->size
)
3630 memmove (&contents
[actual_offset
],
3631 &contents
[actual_offset
+ entry_size
],
3632 sec
->size
- offset
- entry_size
);
3633 removed_bytes
+= entry_size
;
3636 /* Remove this relocation. */
3637 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3640 /* Adjust the relocation offset for previous removals. This
3641 should not be done before calling ...symbol_deleted_p
3642 because it might mess up the offset comparisons there.
3643 Make sure the offset doesn't underflow in the case where
3644 the first entry is removed. */
3645 if (cookie
->rel
->r_offset
>= removed_bytes
)
3646 cookie
->rel
->r_offset
-= removed_bytes
;
3648 cookie
->rel
->r_offset
= 0;
3654 if (removed_bytes
!= 0)
3656 /* Adjust any remaining relocs (shouldn't be any). */
3657 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3659 if (cookie
->rel
->r_offset
>= removed_bytes
)
3660 cookie
->rel
->r_offset
-= removed_bytes
;
3662 cookie
->rel
->r_offset
= 0;
3665 /* Clear the removed bytes. */
3666 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3668 pin_contents (sec
, contents
);
3669 pin_internal_relocs (sec
, cookie
->rels
);
3672 if (sec
->rawsize
== 0)
3673 sec
->rawsize
= sec
->size
;
3674 sec
->size
-= removed_bytes
;
3676 if (xtensa_is_littable_section (sec
))
3678 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3680 sgotloc
->size
-= removed_bytes
;
3685 release_contents (sec
, contents
);
3686 release_internal_relocs (sec
, cookie
->rels
);
3689 return (removed_bytes
!= 0);
3694 elf_xtensa_discard_info (bfd
*abfd
,
3695 struct elf_reloc_cookie
*cookie
,
3696 struct bfd_link_info
*info
)
3699 bool changed
= false;
3701 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3703 if (xtensa_is_property_section (sec
))
3705 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3715 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3717 return xtensa_is_property_section (sec
);
3722 elf_xtensa_action_discarded (asection
*sec
)
3724 if (strcmp (".xt_except_table", sec
->name
) == 0)
3727 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3730 return _bfd_elf_default_action_discarded (sec
);
3734 /* Support for core dump NOTE sections. */
3737 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3742 if (elf_tdata (abfd
) == NULL
3743 || elf_tdata (abfd
)->core
== NULL
)
3746 /* The size for Xtensa is variable, so don't try to recognize the format
3747 based on the size. Just assume this is GNU/Linux. */
3748 if (note
== NULL
|| note
->descsz
< 28)
3752 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3755 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3759 size
= note
->descsz
- offset
- 4;
3761 /* Make a ".reg/999" section. */
3762 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3763 size
, note
->descpos
+ offset
);
3767 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3769 switch (note
->descsz
)
3774 case 128: /* GNU/Linux elf_prpsinfo */
3775 elf_tdata (abfd
)->core
->program
3776 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3777 elf_tdata (abfd
)->core
->command
3778 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3781 /* Note that for some reason, a spurious space is tacked
3782 onto the end of the args in some (at least one anyway)
3783 implementations, so strip it off if it exists. */
3786 char *command
= elf_tdata (abfd
)->core
->command
;
3787 int n
= strlen (command
);
3789 if (0 < n
&& command
[n
- 1] == ' ')
3790 command
[n
- 1] = '\0';
3797 /* Generic Xtensa configurability stuff. */
3799 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3800 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3801 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3802 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3803 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3804 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3805 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3806 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3809 init_call_opcodes (void)
3811 if (callx0_op
== XTENSA_UNDEFINED
)
3813 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3814 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3815 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3816 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3817 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3818 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3819 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3820 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3826 is_indirect_call_opcode (xtensa_opcode opcode
)
3828 init_call_opcodes ();
3829 return (opcode
== callx0_op
3830 || opcode
== callx4_op
3831 || opcode
== callx8_op
3832 || opcode
== callx12_op
);
3837 is_direct_call_opcode (xtensa_opcode opcode
)
3839 init_call_opcodes ();
3840 return (opcode
== call0_op
3841 || opcode
== call4_op
3842 || opcode
== call8_op
3843 || opcode
== call12_op
);
3848 is_windowed_call_opcode (xtensa_opcode opcode
)
3850 init_call_opcodes ();
3851 return (opcode
== call4_op
3852 || opcode
== call8_op
3853 || opcode
== call12_op
3854 || opcode
== callx4_op
3855 || opcode
== callx8_op
3856 || opcode
== callx12_op
);
3861 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3863 unsigned dst
= (unsigned) -1;
3865 init_call_opcodes ();
3866 if (opcode
== callx0_op
)
3868 else if (opcode
== callx4_op
)
3870 else if (opcode
== callx8_op
)
3872 else if (opcode
== callx12_op
)
3875 if (dst
== (unsigned) -1)
3883 static xtensa_opcode
3884 get_const16_opcode (void)
3886 static bool done_lookup
= false;
3887 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3890 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3893 return const16_opcode
;
3897 static xtensa_opcode
3898 get_l32r_opcode (void)
3900 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3901 static bool done_lookup
= false;
3905 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3913 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3917 offset
= addr
- ((pc
+3) & -4);
3918 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3919 offset
= (signed int) offset
>> 2;
3920 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3925 static xtensa_opcode
3926 get_rsr_lend_opcode (void)
3928 static xtensa_opcode rsr_lend_opcode
= XTENSA_UNDEFINED
;
3929 static bool done_lookup
= false;
3932 rsr_lend_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "rsr.lend");
3935 return rsr_lend_opcode
;
3938 static xtensa_opcode
3939 get_wsr_lbeg_opcode (void)
3941 static xtensa_opcode wsr_lbeg_opcode
= XTENSA_UNDEFINED
;
3942 static bool done_lookup
= false;
3945 wsr_lbeg_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "wsr.lbeg");
3948 return wsr_lbeg_opcode
;
3953 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3955 xtensa_isa isa
= xtensa_default_isa
;
3956 int last_immed
, last_opnd
, opi
;
3958 if (opcode
== XTENSA_UNDEFINED
)
3959 return XTENSA_UNDEFINED
;
3961 /* Find the last visible PC-relative immediate operand for the opcode.
3962 If there are no PC-relative immediates, then choose the last visible
3963 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3964 last_immed
= XTENSA_UNDEFINED
;
3965 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3966 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3968 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3970 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3975 if (last_immed
== XTENSA_UNDEFINED
3976 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3980 return XTENSA_UNDEFINED
;
3982 /* If the operand number was specified in an old-style relocation,
3983 check for consistency with the operand computed above. */
3984 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3986 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3987 if (reloc_opnd
!= last_immed
)
3988 return XTENSA_UNDEFINED
;
3996 get_relocation_slot (int r_type
)
4006 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4007 return r_type
- R_XTENSA_SLOT0_OP
;
4008 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4009 return r_type
- R_XTENSA_SLOT0_ALT
;
4013 return XTENSA_UNDEFINED
;
4017 /* Get the opcode for a relocation. */
4019 static xtensa_opcode
4020 get_relocation_opcode (bfd
*abfd
,
4023 Elf_Internal_Rela
*irel
)
4025 static xtensa_insnbuf ibuff
= NULL
;
4026 static xtensa_insnbuf sbuff
= NULL
;
4027 xtensa_isa isa
= xtensa_default_isa
;
4031 if (contents
== NULL
)
4032 return XTENSA_UNDEFINED
;
4034 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
4035 return XTENSA_UNDEFINED
;
4039 ibuff
= xtensa_insnbuf_alloc (isa
);
4040 sbuff
= xtensa_insnbuf_alloc (isa
);
4043 /* Decode the instruction. */
4044 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
4045 sec
->size
- irel
->r_offset
);
4046 fmt
= xtensa_format_decode (isa
, ibuff
);
4047 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
4048 if (slot
== XTENSA_UNDEFINED
)
4049 return XTENSA_UNDEFINED
;
4050 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
4051 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
4056 is_l32r_relocation (bfd
*abfd
,
4059 Elf_Internal_Rela
*irel
)
4061 xtensa_opcode opcode
;
4062 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
4064 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
4065 return (opcode
== get_l32r_opcode ());
4069 static bfd_size_type
4070 get_asm_simplify_size (bfd_byte
*contents
,
4071 bfd_size_type content_len
,
4072 bfd_size_type offset
)
4074 bfd_size_type insnlen
, size
= 0;
4076 /* Decode the size of the next two instructions. */
4077 insnlen
= insn_decode_len (contents
, content_len
, offset
);
4083 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
4093 is_alt_relocation (int r_type
)
4095 return (r_type
>= R_XTENSA_SLOT0_ALT
4096 && r_type
<= R_XTENSA_SLOT14_ALT
);
4101 is_operand_relocation (int r_type
)
4111 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4113 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4122 #define MIN_INSN_LENGTH 2
4124 /* Return 0 if it fails to decode. */
4127 insn_decode_len (bfd_byte
*contents
,
4128 bfd_size_type content_len
,
4129 bfd_size_type offset
)
4132 xtensa_isa isa
= xtensa_default_isa
;
4134 static xtensa_insnbuf ibuff
= NULL
;
4136 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4140 ibuff
= xtensa_insnbuf_alloc (isa
);
4141 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4142 content_len
- offset
);
4143 fmt
= xtensa_format_decode (isa
, ibuff
);
4144 if (fmt
== XTENSA_UNDEFINED
)
4146 insn_len
= xtensa_format_length (isa
, fmt
);
4147 if (insn_len
== XTENSA_UNDEFINED
)
4153 insn_num_slots (bfd_byte
*contents
,
4154 bfd_size_type content_len
,
4155 bfd_size_type offset
)
4157 xtensa_isa isa
= xtensa_default_isa
;
4159 static xtensa_insnbuf ibuff
= NULL
;
4161 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4162 return XTENSA_UNDEFINED
;
4165 ibuff
= xtensa_insnbuf_alloc (isa
);
4166 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4167 content_len
- offset
);
4168 fmt
= xtensa_format_decode (isa
, ibuff
);
4169 if (fmt
== XTENSA_UNDEFINED
)
4170 return XTENSA_UNDEFINED
;
4171 return xtensa_format_num_slots (isa
, fmt
);
4175 /* Decode the opcode for a single slot instruction.
4176 Return 0 if it fails to decode or the instruction is multi-slot. */
4179 insn_decode_opcode (bfd_byte
*contents
,
4180 bfd_size_type content_len
,
4181 bfd_size_type offset
,
4184 xtensa_isa isa
= xtensa_default_isa
;
4186 static xtensa_insnbuf insnbuf
= NULL
;
4187 static xtensa_insnbuf slotbuf
= NULL
;
4189 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4190 return XTENSA_UNDEFINED
;
4192 if (insnbuf
== NULL
)
4194 insnbuf
= xtensa_insnbuf_alloc (isa
);
4195 slotbuf
= xtensa_insnbuf_alloc (isa
);
4198 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4199 content_len
- offset
);
4200 fmt
= xtensa_format_decode (isa
, insnbuf
);
4201 if (fmt
== XTENSA_UNDEFINED
)
4202 return XTENSA_UNDEFINED
;
4204 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4205 return XTENSA_UNDEFINED
;
4207 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4208 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4212 /* The offset is the offset in the contents.
4213 The address is the address of that offset. */
4216 check_branch_target_aligned (bfd_byte
*contents
,
4217 bfd_size_type content_length
,
4221 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4224 return check_branch_target_aligned_address (address
, insn_len
);
4229 check_loop_aligned (bfd_byte
*contents
,
4230 bfd_size_type content_length
,
4234 bfd_size_type loop_len
, insn_len
;
4235 xtensa_opcode opcode
;
4237 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4238 if (opcode
== XTENSA_UNDEFINED
4239 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4245 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4246 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4247 if (loop_len
== 0 || insn_len
== 0)
4253 /* If this is relaxed loop, analyze first instruction of the actual loop
4254 body. It must be at offset 27 from the loop instruction address. */
4256 && insn_num_slots (contents
, content_length
, offset
+ loop_len
) == 1
4257 && insn_decode_opcode (contents
, content_length
,
4258 offset
+ loop_len
, 0) == get_rsr_lend_opcode()
4259 && insn_decode_len (contents
, content_length
, offset
+ loop_len
+ 3) == 3
4260 && insn_num_slots (contents
, content_length
, offset
+ loop_len
+ 3) == 1
4261 && insn_decode_opcode (contents
, content_length
,
4262 offset
+ loop_len
+ 3, 0) == get_wsr_lbeg_opcode())
4265 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4267 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4272 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4275 return (addr
% 8 == 0);
4276 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4280 /* Instruction widening and narrowing. */
4282 /* When FLIX is available we need to access certain instructions only
4283 when they are 16-bit or 24-bit instructions. This table caches
4284 information about such instructions by walking through all the
4285 opcodes and finding the smallest single-slot format into which each
4288 static xtensa_format
*op_single_fmt_table
= NULL
;
4292 init_op_single_format_table (void)
4294 xtensa_isa isa
= xtensa_default_isa
;
4295 xtensa_insnbuf ibuf
;
4296 xtensa_opcode opcode
;
4300 if (op_single_fmt_table
)
4303 ibuf
= xtensa_insnbuf_alloc (isa
);
4304 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4306 op_single_fmt_table
= (xtensa_format
*)
4307 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4308 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4310 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4311 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4313 if (xtensa_format_num_slots (isa
, fmt
) == 1
4314 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4316 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4317 int fmt_length
= xtensa_format_length (isa
, fmt
);
4318 if (old_fmt
== XTENSA_UNDEFINED
4319 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4320 op_single_fmt_table
[opcode
] = fmt
;
4324 xtensa_insnbuf_free (isa
, ibuf
);
4328 static xtensa_format
4329 get_single_format (xtensa_opcode opcode
)
4331 init_op_single_format_table ();
4332 return op_single_fmt_table
[opcode
];
4336 /* For the set of narrowable instructions we do NOT include the
4337 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4338 involved during linker relaxation that may require these to
4339 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4340 requires special case code to ensure it only works when op1 == op2. */
4348 const struct string_pair narrowable
[] =
4351 { "addi", "addi.n" },
4352 { "addmi", "addi.n" },
4353 { "l32i", "l32i.n" },
4354 { "movi", "movi.n" },
4356 { "retw", "retw.n" },
4357 { "s32i", "s32i.n" },
4358 { "or", "mov.n" } /* special case only when op1 == op2 */
4361 const struct string_pair widenable
[] =
4364 { "addi", "addi.n" },
4365 { "addmi", "addi.n" },
4366 { "beqz", "beqz.n" },
4367 { "bnez", "bnez.n" },
4368 { "l32i", "l32i.n" },
4369 { "movi", "movi.n" },
4371 { "retw", "retw.n" },
4372 { "s32i", "s32i.n" },
4373 { "or", "mov.n" } /* special case only when op1 == op2 */
4377 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4378 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4379 return the instruction buffer holding the narrow instruction. Otherwise,
4380 return 0. The set of valid narrowing are specified by a string table
4381 but require some special case operand checks in some cases. */
4383 static xtensa_insnbuf
4384 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4386 xtensa_opcode opcode
)
4388 xtensa_isa isa
= xtensa_default_isa
;
4389 xtensa_format o_fmt
;
4392 static xtensa_insnbuf o_insnbuf
= NULL
;
4393 static xtensa_insnbuf o_slotbuf
= NULL
;
4395 if (o_insnbuf
== NULL
)
4397 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4398 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4401 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4403 bool is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4405 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4407 uint32 value
, newval
;
4408 int i
, operand_count
, o_operand_count
;
4409 xtensa_opcode o_opcode
;
4411 /* Address does not matter in this case. We might need to
4412 fix it to handle branches/jumps. */
4413 bfd_vma self_address
= 0;
4415 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4416 if (o_opcode
== XTENSA_UNDEFINED
)
4418 o_fmt
= get_single_format (o_opcode
);
4419 if (o_fmt
== XTENSA_UNDEFINED
)
4422 if (xtensa_format_length (isa
, fmt
) != 3
4423 || xtensa_format_length (isa
, o_fmt
) != 2)
4426 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4427 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4428 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4430 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4435 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4440 uint32 rawval0
, rawval1
, rawval2
;
4442 if (o_operand_count
+ 1 != operand_count
4443 || xtensa_operand_get_field (isa
, opcode
, 0,
4444 fmt
, 0, slotbuf
, &rawval0
) != 0
4445 || xtensa_operand_get_field (isa
, opcode
, 1,
4446 fmt
, 0, slotbuf
, &rawval1
) != 0
4447 || xtensa_operand_get_field (isa
, opcode
, 2,
4448 fmt
, 0, slotbuf
, &rawval2
) != 0
4449 || rawval1
!= rawval2
4450 || rawval0
== rawval1
/* it is a nop */)
4454 for (i
= 0; i
< o_operand_count
; ++i
)
4456 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4458 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4461 /* PC-relative branches need adjustment, but
4462 the PC-rel operand will always have a relocation. */
4464 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4466 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4467 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4472 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4482 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4483 the action in-place directly into the contents and return TRUE. Otherwise,
4484 the return value is FALSE and the contents are not modified. */
4487 narrow_instruction (bfd_byte
*contents
,
4488 bfd_size_type content_length
,
4489 bfd_size_type offset
)
4491 xtensa_opcode opcode
;
4492 bfd_size_type insn_len
;
4493 xtensa_isa isa
= xtensa_default_isa
;
4495 xtensa_insnbuf o_insnbuf
;
4497 static xtensa_insnbuf insnbuf
= NULL
;
4498 static xtensa_insnbuf slotbuf
= NULL
;
4500 if (insnbuf
== NULL
)
4502 insnbuf
= xtensa_insnbuf_alloc (isa
);
4503 slotbuf
= xtensa_insnbuf_alloc (isa
);
4506 BFD_ASSERT (offset
< content_length
);
4508 if (content_length
< 2)
4511 /* We will hand-code a few of these for a little while.
4512 These have all been specified in the assembler aleady. */
4513 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4514 content_length
- offset
);
4515 fmt
= xtensa_format_decode (isa
, insnbuf
);
4516 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4519 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4522 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4523 if (opcode
== XTENSA_UNDEFINED
)
4525 insn_len
= xtensa_format_length (isa
, fmt
);
4526 if (insn_len
> content_length
)
4529 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4532 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4533 content_length
- offset
);
4541 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4542 "density" instruction to a standard 3-byte instruction. If it is valid,
4543 return the instruction buffer holding the wide instruction. Otherwise,
4544 return 0. The set of valid widenings are specified by a string table
4545 but require some special case operand checks in some cases. */
4547 static xtensa_insnbuf
4548 can_widen_instruction (xtensa_insnbuf slotbuf
,
4550 xtensa_opcode opcode
)
4552 xtensa_isa isa
= xtensa_default_isa
;
4553 xtensa_format o_fmt
;
4556 static xtensa_insnbuf o_insnbuf
= NULL
;
4557 static xtensa_insnbuf o_slotbuf
= NULL
;
4559 if (o_insnbuf
== NULL
)
4561 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4562 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4565 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4567 bool is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4568 bool is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4569 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4571 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4573 uint32 value
, newval
;
4574 int i
, operand_count
, o_operand_count
, check_operand_count
;
4575 xtensa_opcode o_opcode
;
4577 /* Address does not matter in this case. We might need to fix it
4578 to handle branches/jumps. */
4579 bfd_vma self_address
= 0;
4581 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4582 if (o_opcode
== XTENSA_UNDEFINED
)
4584 o_fmt
= get_single_format (o_opcode
);
4585 if (o_fmt
== XTENSA_UNDEFINED
)
4588 if (xtensa_format_length (isa
, fmt
) != 2
4589 || xtensa_format_length (isa
, o_fmt
) != 3)
4592 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4593 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4594 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4595 check_operand_count
= o_operand_count
;
4597 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4602 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4607 uint32 rawval0
, rawval1
;
4609 if (o_operand_count
!= operand_count
+ 1
4610 || xtensa_operand_get_field (isa
, opcode
, 0,
4611 fmt
, 0, slotbuf
, &rawval0
) != 0
4612 || xtensa_operand_get_field (isa
, opcode
, 1,
4613 fmt
, 0, slotbuf
, &rawval1
) != 0
4614 || rawval0
== rawval1
/* it is a nop */)
4618 check_operand_count
--;
4620 for (i
= 0; i
< check_operand_count
; i
++)
4623 if (is_or
&& i
== o_operand_count
- 1)
4625 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4627 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4630 /* PC-relative branches need adjustment, but
4631 the PC-rel operand will always have a relocation. */
4633 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4635 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4636 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4641 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4651 /* Attempt to widen an instruction. If the widening is valid, perform
4652 the action in-place directly into the contents and return TRUE. Otherwise,
4653 the return value is FALSE and the contents are not modified. */
4656 widen_instruction (bfd_byte
*contents
,
4657 bfd_size_type content_length
,
4658 bfd_size_type offset
)
4660 xtensa_opcode opcode
;
4661 bfd_size_type insn_len
;
4662 xtensa_isa isa
= xtensa_default_isa
;
4664 xtensa_insnbuf o_insnbuf
;
4666 static xtensa_insnbuf insnbuf
= NULL
;
4667 static xtensa_insnbuf slotbuf
= NULL
;
4669 if (insnbuf
== NULL
)
4671 insnbuf
= xtensa_insnbuf_alloc (isa
);
4672 slotbuf
= xtensa_insnbuf_alloc (isa
);
4675 BFD_ASSERT (offset
< content_length
);
4677 if (content_length
< 2)
4680 /* We will hand-code a few of these for a little while.
4681 These have all been specified in the assembler aleady. */
4682 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4683 content_length
- offset
);
4684 fmt
= xtensa_format_decode (isa
, insnbuf
);
4685 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4688 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4691 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4692 if (opcode
== XTENSA_UNDEFINED
)
4694 insn_len
= xtensa_format_length (isa
, fmt
);
4695 if (insn_len
> content_length
)
4698 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4701 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4702 content_length
- offset
);
4709 /* Code for transforming CALLs at link-time. */
4711 static bfd_reloc_status_type
4712 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4714 bfd_vma content_length
,
4715 char **error_message
)
4717 static xtensa_insnbuf insnbuf
= NULL
;
4718 static xtensa_insnbuf slotbuf
= NULL
;
4719 xtensa_format core_format
= XTENSA_UNDEFINED
;
4720 xtensa_opcode opcode
;
4721 xtensa_opcode direct_call_opcode
;
4722 xtensa_isa isa
= xtensa_default_isa
;
4723 bfd_byte
*chbuf
= contents
+ address
;
4726 if (insnbuf
== NULL
)
4728 insnbuf
= xtensa_insnbuf_alloc (isa
);
4729 slotbuf
= xtensa_insnbuf_alloc (isa
);
4732 if (content_length
< address
)
4734 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4735 return bfd_reloc_other
;
4738 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4739 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4740 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4742 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4743 return bfd_reloc_other
;
4746 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4747 core_format
= xtensa_format_lookup (isa
, "x24");
4748 opcode
= xtensa_opcode_lookup (isa
, "or");
4749 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4750 for (opn
= 0; opn
< 3; opn
++)
4753 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4754 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4757 xtensa_format_encode (isa
, core_format
, insnbuf
);
4758 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4759 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4761 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4762 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4763 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4765 xtensa_format_encode (isa
, core_format
, insnbuf
);
4766 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4767 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4768 content_length
- address
- 3);
4770 return bfd_reloc_ok
;
4774 static bfd_reloc_status_type
4775 contract_asm_expansion (bfd_byte
*contents
,
4776 bfd_vma content_length
,
4777 Elf_Internal_Rela
*irel
,
4778 char **error_message
)
4780 bfd_reloc_status_type retval
=
4781 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4784 if (retval
!= bfd_reloc_ok
)
4785 return bfd_reloc_dangerous
;
4787 /* Update the irel->r_offset field so that the right immediate and
4788 the right instruction are modified during the relocation. */
4789 irel
->r_offset
+= 3;
4790 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4791 return bfd_reloc_ok
;
4795 static xtensa_opcode
4796 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4798 init_call_opcodes ();
4800 if (opcode
== callx0_op
) return call0_op
;
4801 if (opcode
== callx4_op
) return call4_op
;
4802 if (opcode
== callx8_op
) return call8_op
;
4803 if (opcode
== callx12_op
) return call12_op
;
4805 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4806 return XTENSA_UNDEFINED
;
4810 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4811 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4812 If not, return XTENSA_UNDEFINED. */
4814 #define L32R_TARGET_REG_OPERAND 0
4815 #define CONST16_TARGET_REG_OPERAND 0
4816 #define CALLN_SOURCE_OPERAND 0
4818 static xtensa_opcode
4819 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bool *p_uses_l32r
)
4821 static xtensa_insnbuf insnbuf
= NULL
;
4822 static xtensa_insnbuf slotbuf
= NULL
;
4824 xtensa_opcode opcode
;
4825 xtensa_isa isa
= xtensa_default_isa
;
4826 uint32 regno
, const16_regno
, call_regno
;
4829 if (insnbuf
== NULL
)
4831 insnbuf
= xtensa_insnbuf_alloc (isa
);
4832 slotbuf
= xtensa_insnbuf_alloc (isa
);
4835 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4836 fmt
= xtensa_format_decode (isa
, insnbuf
);
4837 if (fmt
== XTENSA_UNDEFINED
4838 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4839 return XTENSA_UNDEFINED
;
4841 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4842 if (opcode
== XTENSA_UNDEFINED
)
4843 return XTENSA_UNDEFINED
;
4845 if (opcode
== get_l32r_opcode ())
4848 *p_uses_l32r
= true;
4849 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4850 fmt
, 0, slotbuf
, ®no
)
4851 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4853 return XTENSA_UNDEFINED
;
4855 else if (opcode
== get_const16_opcode ())
4858 *p_uses_l32r
= false;
4859 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4860 fmt
, 0, slotbuf
, ®no
)
4861 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4863 return XTENSA_UNDEFINED
;
4865 /* Check that the next instruction is also CONST16. */
4866 offset
+= xtensa_format_length (isa
, fmt
);
4867 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4868 fmt
= xtensa_format_decode (isa
, insnbuf
);
4869 if (fmt
== XTENSA_UNDEFINED
4870 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4871 return XTENSA_UNDEFINED
;
4872 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4873 if (opcode
!= get_const16_opcode ())
4874 return XTENSA_UNDEFINED
;
4876 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4877 fmt
, 0, slotbuf
, &const16_regno
)
4878 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4880 || const16_regno
!= regno
)
4881 return XTENSA_UNDEFINED
;
4884 return XTENSA_UNDEFINED
;
4886 /* Next instruction should be an CALLXn with operand 0 == regno. */
4887 offset
+= xtensa_format_length (isa
, fmt
);
4888 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4889 fmt
= xtensa_format_decode (isa
, insnbuf
);
4890 if (fmt
== XTENSA_UNDEFINED
4891 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4892 return XTENSA_UNDEFINED
;
4893 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4894 if (opcode
== XTENSA_UNDEFINED
4895 || !is_indirect_call_opcode (opcode
))
4896 return XTENSA_UNDEFINED
;
4898 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4899 fmt
, 0, slotbuf
, &call_regno
)
4900 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4902 return XTENSA_UNDEFINED
;
4904 if (call_regno
!= regno
)
4905 return XTENSA_UNDEFINED
;
4911 /* Data structures used during relaxation. */
4913 /* r_reloc: relocation values. */
4915 /* Through the relaxation process, we need to keep track of the values
4916 that will result from evaluating relocations. The standard ELF
4917 relocation structure is not sufficient for this purpose because we're
4918 operating on multiple input files at once, so we need to know which
4919 input file a relocation refers to. The r_reloc structure thus
4920 records both the input file (bfd) and ELF relocation.
4922 For efficiency, an r_reloc also contains a "target_offset" field to
4923 cache the target-section-relative offset value that is represented by
4926 The r_reloc also contains a virtual offset that allows multiple
4927 inserted literals to be placed at the same "address" with
4928 different offsets. */
4930 typedef struct r_reloc_struct r_reloc
;
4932 struct r_reloc_struct
4935 Elf_Internal_Rela rela
;
4936 bfd_vma target_offset
;
4937 bfd_vma virtual_offset
;
4941 /* The r_reloc structure is included by value in literal_value, but not
4942 every literal_value has an associated relocation -- some are simple
4943 constants. In such cases, we set all the fields in the r_reloc
4944 struct to zero. The r_reloc_is_const function should be used to
4945 detect this case. */
4948 r_reloc_is_const (const r_reloc
*r_rel
)
4950 return (r_rel
->abfd
== NULL
);
4955 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4957 bfd_vma target_offset
;
4958 unsigned long r_symndx
;
4960 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4961 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4962 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4963 return (target_offset
+ r_rel
->rela
.r_addend
);
4967 static struct elf_link_hash_entry
*
4968 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4970 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4971 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4976 r_reloc_get_section (const r_reloc
*r_rel
)
4978 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4979 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4984 r_reloc_is_defined (const r_reloc
*r_rel
)
4990 sec
= r_reloc_get_section (r_rel
);
4991 if (sec
== bfd_abs_section_ptr
4992 || sec
== bfd_com_section_ptr
4993 || sec
== bfd_und_section_ptr
)
5000 r_reloc_init (r_reloc
*r_rel
,
5002 Elf_Internal_Rela
*irel
,
5004 bfd_size_type content_length
)
5007 reloc_howto_type
*howto
;
5011 r_rel
->rela
= *irel
;
5013 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
5014 r_rel
->virtual_offset
= 0;
5015 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
5016 howto
= &elf_howto_table
[r_type
];
5017 if (howto
->partial_inplace
)
5019 bfd_vma inplace_val
;
5020 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
5022 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
5023 r_rel
->target_offset
+= inplace_val
;
5027 memset (r_rel
, 0, sizeof (r_reloc
));
5034 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
5036 if (r_reloc_is_defined (r_rel
))
5038 asection
*sec
= r_reloc_get_section (r_rel
);
5039 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
5041 else if (r_reloc_get_hash_entry (r_rel
))
5042 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
5044 fprintf (fp
, " ?? + ");
5046 fprintf (fp
, "%" PRIx64
, (uint64_t) r_rel
->target_offset
);
5047 if (r_rel
->virtual_offset
)
5048 fprintf (fp
, " + %" PRIx64
, (uint64_t) r_rel
->virtual_offset
);
5056 /* source_reloc: relocations that reference literals. */
5058 /* To determine whether literals can be coalesced, we need to first
5059 record all the relocations that reference the literals. The
5060 source_reloc structure below is used for this purpose. The
5061 source_reloc entries are kept in a per-literal-section array, sorted
5062 by offset within the literal section (i.e., target offset).
5064 The source_sec and r_rel.rela.r_offset fields identify the source of
5065 the relocation. The r_rel field records the relocation value, i.e.,
5066 the offset of the literal being referenced. The opnd field is needed
5067 to determine the range of the immediate field to which the relocation
5068 applies, so we can determine whether another literal with the same
5069 value is within range. The is_null field is true when the relocation
5070 is being removed (e.g., when an L32R is being removed due to a CALLX
5071 that is converted to a direct CALL). */
5073 typedef struct source_reloc_struct source_reloc
;
5075 struct source_reloc_struct
5077 asection
*source_sec
;
5079 xtensa_opcode opcode
;
5082 bool is_abs_literal
;
5087 init_source_reloc (source_reloc
*reloc
,
5088 asection
*source_sec
,
5089 const r_reloc
*r_rel
,
5090 xtensa_opcode opcode
,
5092 bool is_abs_literal
)
5094 reloc
->source_sec
= source_sec
;
5095 reloc
->r_rel
= *r_rel
;
5096 reloc
->opcode
= opcode
;
5098 reloc
->is_null
= false;
5099 reloc
->is_abs_literal
= is_abs_literal
;
5103 /* Find the source_reloc for a particular source offset and relocation
5104 type. Note that the array is sorted by _target_ offset, so this is
5105 just a linear search. */
5107 static source_reloc
*
5108 find_source_reloc (source_reloc
*src_relocs
,
5111 Elf_Internal_Rela
*irel
)
5115 for (i
= 0; i
< src_count
; i
++)
5117 if (src_relocs
[i
].source_sec
== sec
5118 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
5119 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
5120 == ELF32_R_TYPE (irel
->r_info
)))
5121 return &src_relocs
[i
];
5129 source_reloc_compare (const void *ap
, const void *bp
)
5131 const source_reloc
*a
= (const source_reloc
*) ap
;
5132 const source_reloc
*b
= (const source_reloc
*) bp
;
5134 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
5135 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5137 /* We don't need to sort on these criteria for correctness,
5138 but enforcing a more strict ordering prevents unstable qsort
5139 from behaving differently with different implementations.
5140 Without the code below we get correct but different results
5141 on Solaris 2.7 and 2.8. We would like to always produce the
5142 same results no matter the host. */
5144 if ((!a
->is_null
) - (!b
->is_null
))
5145 return ((!a
->is_null
) - (!b
->is_null
));
5146 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5150 /* Literal values and value hash tables. */
5152 /* Literals with the same value can be coalesced. The literal_value
5153 structure records the value of a literal: the "r_rel" field holds the
5154 information from the relocation on the literal (if there is one) and
5155 the "value" field holds the contents of the literal word itself.
5157 The value_map structure records a literal value along with the
5158 location of a literal holding that value. The value_map hash table
5159 is indexed by the literal value, so that we can quickly check if a
5160 particular literal value has been seen before and is thus a candidate
5163 typedef struct literal_value_struct literal_value
;
5164 typedef struct value_map_struct value_map
;
5165 typedef struct value_map_hash_table_struct value_map_hash_table
;
5167 struct literal_value_struct
5170 unsigned long value
;
5171 bool is_abs_literal
;
5174 struct value_map_struct
5176 literal_value val
; /* The literal value. */
5177 r_reloc loc
; /* Location of the literal. */
5181 struct value_map_hash_table_struct
5183 unsigned bucket_count
;
5184 value_map
**buckets
;
5192 init_literal_value (literal_value
*lit
,
5193 const r_reloc
*r_rel
,
5194 unsigned long value
,
5195 bool is_abs_literal
)
5197 lit
->r_rel
= *r_rel
;
5199 lit
->is_abs_literal
= is_abs_literal
;
5204 literal_value_equal (const literal_value
*src1
,
5205 const literal_value
*src2
,
5206 bool final_static_link
)
5208 struct elf_link_hash_entry
*h1
, *h2
;
5210 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5213 if (r_reloc_is_const (&src1
->r_rel
))
5214 return (src1
->value
== src2
->value
);
5216 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5217 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5220 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5223 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5226 if (src1
->value
!= src2
->value
)
5229 /* Now check for the same section (if defined) or the same elf_hash
5230 (if undefined or weak). */
5231 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5232 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5233 if (r_reloc_is_defined (&src1
->r_rel
)
5234 && (final_static_link
5235 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5236 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5238 if (r_reloc_get_section (&src1
->r_rel
)
5239 != r_reloc_get_section (&src2
->r_rel
))
5244 /* Require that the hash entries (i.e., symbols) be identical. */
5245 if (h1
!= h2
|| h1
== 0)
5249 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5256 /* Must be power of 2. */
5257 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5259 static value_map_hash_table
*
5260 value_map_hash_table_init (void)
5262 value_map_hash_table
*values
;
5264 values
= (value_map_hash_table
*)
5265 bfd_zmalloc (sizeof (value_map_hash_table
));
5266 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5268 values
->buckets
= (value_map
**)
5269 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5270 if (values
->buckets
== NULL
)
5275 values
->has_last_loc
= false;
5282 value_map_hash_table_delete (value_map_hash_table
*table
)
5284 free (table
->buckets
);
5290 hash_bfd_vma (bfd_vma val
)
5292 return (val
>> 2) + (val
>> 10);
5297 literal_value_hash (const literal_value
*src
)
5301 hash_val
= hash_bfd_vma (src
->value
);
5302 if (!r_reloc_is_const (&src
->r_rel
))
5306 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5307 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5308 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5310 /* Now check for the same section and the same elf_hash. */
5311 if (r_reloc_is_defined (&src
->r_rel
))
5312 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5314 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5315 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5321 /* Check if the specified literal_value has been seen before. */
5324 value_map_get_cached_value (value_map_hash_table
*map
,
5325 const literal_value
*val
,
5326 bool final_static_link
)
5332 idx
= literal_value_hash (val
);
5333 idx
= idx
& (map
->bucket_count
- 1);
5334 bucket
= map
->buckets
[idx
];
5335 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5337 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5344 /* Record a new literal value. It is illegal to call this if VALUE
5345 already has an entry here. */
5348 add_value_map (value_map_hash_table
*map
,
5349 const literal_value
*val
,
5351 bool final_static_link
)
5353 value_map
**bucket_p
;
5356 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5359 bfd_set_error (bfd_error_no_memory
);
5363 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5367 idx
= literal_value_hash (val
);
5368 idx
= idx
& (map
->bucket_count
- 1);
5369 bucket_p
= &map
->buckets
[idx
];
5371 val_e
->next
= *bucket_p
;
5374 /* FIXME: Consider resizing the hash table if we get too many entries. */
5380 /* Lists of text actions (ta_) for narrowing, widening, longcall
5381 conversion, space fill, code & literal removal, etc. */
5383 /* The following text actions are generated:
5385 "ta_remove_insn" remove an instruction or instructions
5386 "ta_remove_longcall" convert longcall to call
5387 "ta_convert_longcall" convert longcall to nop/call
5388 "ta_narrow_insn" narrow a wide instruction
5389 "ta_widen" widen a narrow instruction
5390 "ta_fill" add fill or remove fill
5391 removed < 0 is a fill; branches to the fill address will be
5392 changed to address + fill size (e.g., address - removed)
5393 removed >= 0 branches to the fill address will stay unchanged
5394 "ta_remove_literal" remove a literal; this action is
5395 indicated when a literal is removed
5397 "ta_add_literal" insert a new literal; this action is
5398 indicated when a literal has been moved.
5399 It may use a virtual_offset because
5400 multiple literals can be placed at the
5403 For each of these text actions, we also record the number of bytes
5404 removed by performing the text action. In the case of a "ta_widen"
5405 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5407 typedef struct text_action_struct text_action
;
5408 typedef struct text_action_list_struct text_action_list
;
5409 typedef enum text_action_enum_t text_action_t
;
5411 enum text_action_enum_t
5414 ta_remove_insn
, /* removed = -size */
5415 ta_remove_longcall
, /* removed = -size */
5416 ta_convert_longcall
, /* removed = 0 */
5417 ta_narrow_insn
, /* removed = -1 */
5418 ta_widen_insn
, /* removed = +1 */
5419 ta_fill
, /* removed = +size */
5425 /* Structure for a text action record. */
5426 struct text_action_struct
5428 text_action_t action
;
5429 asection
*sec
; /* Optional */
5431 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5433 literal_value value
; /* Only valid when adding literals. */
5436 struct removal_by_action_entry_struct
5441 int eq_removed_before_fill
;
5443 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5445 struct removal_by_action_map_struct
5448 removal_by_action_entry
*entry
;
5450 typedef struct removal_by_action_map_struct removal_by_action_map
;
5453 /* List of all of the actions taken on a text section. */
5454 struct text_action_list_struct
5458 removal_by_action_map map
;
5462 static text_action
*
5463 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5467 /* It is not necessary to fill at the end of a section. */
5468 if (sec
->size
== offset
)
5474 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5476 return (text_action
*)node
->value
;
5482 compute_removed_action_diff (const text_action
*ta
,
5486 int removable_space
)
5489 int current_removed
= 0;
5492 current_removed
= ta
->removed_bytes
;
5494 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5495 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5497 /* It is not necessary to fill at the end of a section. Clean this up. */
5498 if (sec
->size
== offset
)
5499 new_removed
= removable_space
- 0;
5503 int added
= -removed
- current_removed
;
5504 /* Ignore multiples of the section alignment. */
5505 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5506 new_removed
= (-added
);
5508 /* Modify for removable. */
5509 space
= removable_space
- new_removed
;
5510 new_removed
= (removable_space
5511 - (((1 << sec
->alignment_power
) - 1) & space
));
5513 return (new_removed
- current_removed
);
5518 adjust_fill_action (text_action
*ta
, int fill_diff
)
5520 ta
->removed_bytes
+= fill_diff
;
5525 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5527 text_action
*pa
= (text_action
*)a
;
5528 text_action
*pb
= (text_action
*)b
;
5529 static const int action_priority
[] =
5533 [ta_convert_longcall
] = 2,
5534 [ta_narrow_insn
] = 3,
5535 [ta_remove_insn
] = 4,
5536 [ta_remove_longcall
] = 5,
5537 [ta_remove_literal
] = 6,
5538 [ta_widen_insn
] = 7,
5539 [ta_add_literal
] = 8,
5542 if (pa
->offset
== pb
->offset
)
5544 if (pa
->action
== pb
->action
)
5546 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5549 return pa
->offset
< pb
->offset
? -1 : 1;
5552 static text_action
*
5553 action_first (text_action_list
*action_list
)
5555 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5556 return node
? (text_action
*)node
->value
: NULL
;
5559 static text_action
*
5560 action_next (text_action_list
*action_list
, text_action
*action
)
5562 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5563 (splay_tree_key
)action
);
5564 return node
? (text_action
*)node
->value
: NULL
;
5567 /* Add a modification action to the text. For the case of adding or
5568 removing space, modify any current fill and assume that
5569 "unreachable_space" bytes can be freely contracted. Note that a
5570 negative removed value is a fill. */
5573 text_action_add (text_action_list
*l
,
5574 text_action_t action
,
5582 /* It is not necessary to fill at the end of a section. */
5583 if (action
== ta_fill
&& sec
->size
== offset
)
5586 /* It is not necessary to fill 0 bytes. */
5587 if (action
== ta_fill
&& removed
== 0)
5593 if (action
== ta_fill
)
5595 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5599 ta
= (text_action
*)node
->value
;
5600 ta
->removed_bytes
+= removed
;
5605 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5607 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5608 ta
->action
= action
;
5610 ta
->offset
= offset
;
5611 ta
->removed_bytes
= removed
;
5612 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5618 text_action_add_literal (text_action_list
*l
,
5619 text_action_t action
,
5621 const literal_value
*value
,
5625 asection
*sec
= r_reloc_get_section (loc
);
5626 bfd_vma offset
= loc
->target_offset
;
5627 bfd_vma virtual_offset
= loc
->virtual_offset
;
5629 BFD_ASSERT (action
== ta_add_literal
);
5631 /* Create a new record and fill it up. */
5632 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5633 ta
->action
= action
;
5635 ta
->offset
= offset
;
5636 ta
->virtual_offset
= virtual_offset
;
5638 ta
->removed_bytes
= removed
;
5640 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5641 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5646 /* Find the total offset adjustment for the relaxations specified by
5647 text_actions, beginning from a particular starting action. This is
5648 typically used from offset_with_removed_text to search an entire list of
5649 actions, but it may also be called directly when adjusting adjacent offsets
5650 so that each search may begin where the previous one left off. */
5653 removed_by_actions (text_action_list
*action_list
,
5654 text_action
**p_start_action
,
5661 r
= *p_start_action
;
5664 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5666 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5671 if (r
->offset
> offset
)
5674 if (r
->offset
== offset
5675 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5678 removed
+= r
->removed_bytes
;
5680 r
= action_next (action_list
, r
);
5683 *p_start_action
= r
;
5689 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5691 text_action
*r
= action_first (action_list
);
5693 return offset
- removed_by_actions (action_list
, &r
, offset
, false);
5698 action_list_count (text_action_list
*action_list
)
5700 return action_list
->count
;
5703 typedef struct map_action_fn_context_struct map_action_fn_context
;
5704 struct map_action_fn_context_struct
5707 removal_by_action_map map
;
5712 map_action_fn (splay_tree_node node
, void *p
)
5714 map_action_fn_context
*ctx
= p
;
5715 text_action
*r
= (text_action
*)node
->value
;
5716 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5718 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5724 ++ctx
->map
.n_entries
;
5725 ctx
->eq_complete
= false;
5726 ientry
->offset
= r
->offset
;
5727 ientry
->eq_removed_before_fill
= ctx
->removed
;
5730 if (!ctx
->eq_complete
)
5732 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5734 ientry
->eq_removed
= ctx
->removed
;
5735 ctx
->eq_complete
= true;
5738 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5741 ctx
->removed
+= r
->removed_bytes
;
5742 ientry
->removed
= ctx
->removed
;
5747 map_removal_by_action (text_action_list
*action_list
)
5749 map_action_fn_context ctx
;
5752 ctx
.map
.n_entries
= 0;
5753 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5754 sizeof (removal_by_action_entry
));
5755 ctx
.eq_complete
= false;
5757 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5758 action_list
->map
= ctx
.map
;
5762 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5767 if (!action_list
->map
.entry
)
5768 map_removal_by_action (action_list
);
5770 if (!action_list
->map
.n_entries
)
5774 b
= action_list
->map
.n_entries
;
5778 unsigned c
= (a
+ b
) / 2;
5780 if (action_list
->map
.entry
[c
].offset
<= offset
)
5786 if (action_list
->map
.entry
[a
].offset
< offset
)
5788 return action_list
->map
.entry
[a
].removed
;
5790 else if (action_list
->map
.entry
[a
].offset
== offset
)
5792 return before_fill
?
5793 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5794 action_list
->map
.entry
[a
].eq_removed
;
5803 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5805 int removed
= removed_by_actions_map (action_list
, offset
, false);
5806 return offset
- removed
;
5810 /* The find_insn_action routine will only find non-fill actions. */
5812 static text_action
*
5813 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5815 static const text_action_t action
[] =
5817 ta_convert_longcall
,
5827 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5829 splay_tree_node node
;
5831 a
.action
= action
[i
];
5832 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5834 return (text_action
*)node
->value
;
5843 print_action (FILE *fp
, text_action
*r
)
5845 const char *t
= "unknown";
5848 case ta_remove_insn
:
5849 t
= "remove_insn"; break;
5850 case ta_remove_longcall
:
5851 t
= "remove_longcall"; break;
5852 case ta_convert_longcall
:
5853 t
= "convert_longcall"; break;
5854 case ta_narrow_insn
:
5855 t
= "narrow_insn"; break;
5857 t
= "widen_insn"; break;
5862 case ta_remove_literal
:
5863 t
= "remove_literal"; break;
5864 case ta_add_literal
:
5865 t
= "add_literal"; break;
5868 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5869 r
->sec
->owner
->filename
,
5870 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5874 print_action_list_fn (splay_tree_node node
, void *p
)
5876 text_action
*r
= (text_action
*)node
->value
;
5878 print_action (p
, r
);
5883 print_action_list (FILE *fp
, text_action_list
*action_list
)
5885 fprintf (fp
, "Text Action\n");
5886 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5892 /* Lists of literals being coalesced or removed. */
5894 /* In the usual case, the literal identified by "from" is being
5895 coalesced with another literal identified by "to". If the literal is
5896 unused and is being removed altogether, "to.abfd" will be NULL.
5897 The removed_literal entries are kept on a per-section list, sorted
5898 by the "from" offset field. */
5900 typedef struct removed_literal_struct removed_literal
;
5901 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5902 typedef struct removed_literal_list_struct removed_literal_list
;
5904 struct removed_literal_struct
5908 removed_literal
*next
;
5911 struct removed_literal_map_entry_struct
5914 removed_literal
*literal
;
5917 struct removed_literal_list_struct
5919 removed_literal
*head
;
5920 removed_literal
*tail
;
5923 removed_literal_map_entry
*map
;
5927 /* Record that the literal at "from" is being removed. If "to" is not
5928 NULL, the "from" literal is being coalesced with the "to" literal. */
5931 add_removed_literal (removed_literal_list
*removed_list
,
5932 const r_reloc
*from
,
5935 removed_literal
*r
, *new_r
, *next_r
;
5937 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5939 new_r
->from
= *from
;
5943 new_r
->to
.abfd
= NULL
;
5946 r
= removed_list
->head
;
5949 removed_list
->head
= new_r
;
5950 removed_list
->tail
= new_r
;
5952 /* Special check for common case of append. */
5953 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5955 removed_list
->tail
->next
= new_r
;
5956 removed_list
->tail
= new_r
;
5960 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5966 new_r
->next
= next_r
;
5968 removed_list
->tail
= new_r
;
5973 map_removed_literal (removed_literal_list
*removed_list
)
5977 removed_literal_map_entry
*map
= NULL
;
5978 removed_literal
*r
= removed_list
->head
;
5980 for (i
= 0; r
; ++i
, r
= r
->next
)
5984 n_map
= (n_map
* 2) + 2;
5985 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5987 map
[i
].addr
= r
->from
.target_offset
;
5990 removed_list
->map
= map
;
5991 removed_list
->n_map
= i
;
5995 removed_literal_compare (const void *a
, const void *b
)
5997 const bfd_vma
*key
= a
;
5998 const removed_literal_map_entry
*memb
= b
;
6000 if (*key
== memb
->addr
)
6003 return *key
< memb
->addr
? -1 : 1;
6006 /* Check if the list of removed literals contains an entry for the
6007 given address. Return the entry if found. */
6009 static removed_literal
*
6010 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
6012 removed_literal_map_entry
*p
;
6013 removed_literal
*r
= NULL
;
6015 if (removed_list
->map
== NULL
)
6016 map_removed_literal (removed_list
);
6018 if (removed_list
->map
!= NULL
)
6020 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
6021 sizeof (*removed_list
->map
), removed_literal_compare
);
6024 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
6036 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
6039 r
= removed_list
->head
;
6041 fprintf (fp
, "Removed Literals\n");
6042 for (; r
!= NULL
; r
= r
->next
)
6044 print_r_reloc (fp
, &r
->from
);
6045 fprintf (fp
, " => ");
6046 if (r
->to
.abfd
== NULL
)
6047 fprintf (fp
, "REMOVED");
6049 print_r_reloc (fp
, &r
->to
);
6057 /* Per-section data for relaxation. */
6059 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
6061 struct xtensa_relax_info_struct
6063 bool is_relaxable_literal_section
;
6064 bool is_relaxable_asm_section
;
6065 int visited
; /* Number of times visited. */
6067 source_reloc
*src_relocs
; /* Array[src_count]. */
6069 int src_next
; /* Next src_relocs entry to assign. */
6071 removed_literal_list removed_list
;
6072 text_action_list action_list
;
6074 reloc_bfd_fix
*fix_list
;
6075 reloc_bfd_fix
*fix_array
;
6076 unsigned fix_array_count
;
6078 /* Support for expanding the reloc array that is stored
6079 in the section structure. If the relocations have been
6080 reallocated, the newly allocated relocations will be referenced
6081 here along with the actual size allocated. The relocation
6082 count will always be found in the section structure. */
6083 Elf_Internal_Rela
*allocated_relocs
;
6084 unsigned relocs_count
;
6085 unsigned allocated_relocs_count
;
6088 struct elf_xtensa_section_data
6090 struct bfd_elf_section_data elf
;
6091 xtensa_relax_info relax_info
;
6096 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
6098 if (!sec
->used_by_bfd
)
6100 struct elf_xtensa_section_data
*sdata
;
6101 size_t amt
= sizeof (*sdata
);
6103 sdata
= bfd_zalloc (abfd
, amt
);
6106 sec
->used_by_bfd
= sdata
;
6109 return _bfd_elf_new_section_hook (abfd
, sec
);
6113 static xtensa_relax_info
*
6114 get_xtensa_relax_info (asection
*sec
)
6116 struct elf_xtensa_section_data
*section_data
;
6118 /* No info available if no section or if it is an output section. */
6119 if (!sec
|| sec
== sec
->output_section
)
6122 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
6123 return §ion_data
->relax_info
;
6128 init_xtensa_relax_info (asection
*sec
)
6130 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6132 relax_info
->is_relaxable_literal_section
= false;
6133 relax_info
->is_relaxable_asm_section
= false;
6134 relax_info
->visited
= 0;
6136 relax_info
->src_relocs
= NULL
;
6137 relax_info
->src_count
= 0;
6138 relax_info
->src_next
= 0;
6140 relax_info
->removed_list
.head
= NULL
;
6141 relax_info
->removed_list
.tail
= NULL
;
6143 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6145 relax_info
->action_list
.map
.n_entries
= 0;
6146 relax_info
->action_list
.map
.entry
= NULL
;
6148 relax_info
->fix_list
= NULL
;
6149 relax_info
->fix_array
= NULL
;
6150 relax_info
->fix_array_count
= 0;
6152 relax_info
->allocated_relocs
= NULL
;
6153 relax_info
->relocs_count
= 0;
6154 relax_info
->allocated_relocs_count
= 0;
6158 /* Coalescing literals may require a relocation to refer to a section in
6159 a different input file, but the standard relocation information
6160 cannot express that. Instead, the reloc_bfd_fix structures are used
6161 to "fix" the relocations that refer to sections in other input files.
6162 These structures are kept on per-section lists. The "src_type" field
6163 records the relocation type in case there are multiple relocations on
6164 the same location. FIXME: This is ugly; an alternative might be to
6165 add new symbols with the "owner" field to some other input file. */
6167 struct reloc_bfd_fix_struct
6171 unsigned src_type
; /* Relocation type. */
6173 asection
*target_sec
;
6174 bfd_vma target_offset
;
6177 reloc_bfd_fix
*next
;
6181 static reloc_bfd_fix
*
6182 reloc_bfd_fix_init (asection
*src_sec
,
6185 asection
*target_sec
,
6186 bfd_vma target_offset
,
6191 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6192 fix
->src_sec
= src_sec
;
6193 fix
->src_offset
= src_offset
;
6194 fix
->src_type
= src_type
;
6195 fix
->target_sec
= target_sec
;
6196 fix
->target_offset
= target_offset
;
6197 fix
->translated
= translated
;
6204 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6206 xtensa_relax_info
*relax_info
;
6208 relax_info
= get_xtensa_relax_info (src_sec
);
6209 fix
->next
= relax_info
->fix_list
;
6210 relax_info
->fix_list
= fix
;
6215 fix_compare (const void *ap
, const void *bp
)
6217 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6218 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6220 if (a
->src_offset
!= b
->src_offset
)
6221 return (a
->src_offset
- b
->src_offset
);
6222 return (a
->src_type
- b
->src_type
);
6227 cache_fix_array (asection
*sec
)
6229 unsigned i
, count
= 0;
6231 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6233 if (relax_info
== NULL
)
6235 if (relax_info
->fix_list
== NULL
)
6238 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6241 relax_info
->fix_array
=
6242 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6243 relax_info
->fix_array_count
= count
;
6245 r
= relax_info
->fix_list
;
6246 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6248 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6249 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6252 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6253 sizeof (reloc_bfd_fix
), fix_compare
);
6257 static reloc_bfd_fix
*
6258 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6260 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6264 if (relax_info
== NULL
)
6266 if (relax_info
->fix_list
== NULL
)
6269 if (relax_info
->fix_array
== NULL
)
6270 cache_fix_array (sec
);
6272 key
.src_offset
= offset
;
6273 key
.src_type
= type
;
6274 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6275 sizeof (reloc_bfd_fix
), fix_compare
);
6280 /* Section caching. */
6282 typedef struct section_cache_struct section_cache_t
;
6284 struct section_cache_struct
6288 bfd_byte
*contents
; /* Cache of the section contents. */
6289 bfd_size_type content_length
;
6291 property_table_entry
*ptbl
; /* Cache of the section property table. */
6294 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6295 unsigned reloc_count
;
6300 init_section_cache (section_cache_t
*sec_cache
)
6302 memset (sec_cache
, 0, sizeof (*sec_cache
));
6307 free_section_cache (section_cache_t
*sec_cache
)
6311 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6312 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6313 free (sec_cache
->ptbl
);
6319 section_cache_section (section_cache_t
*sec_cache
,
6321 struct bfd_link_info
*link_info
)
6324 property_table_entry
*prop_table
= NULL
;
6326 bfd_byte
*contents
= NULL
;
6327 Elf_Internal_Rela
*internal_relocs
= NULL
;
6328 bfd_size_type sec_size
;
6332 if (sec
== sec_cache
->sec
)
6336 sec_size
= bfd_get_section_limit (abfd
, sec
);
6338 /* Get the contents. */
6339 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6340 if (contents
== NULL
&& sec_size
!= 0)
6343 /* Get the relocations. */
6344 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6345 link_info
->keep_memory
);
6347 /* Get the entry table. */
6348 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6349 XTENSA_PROP_SEC_NAME
, false);
6353 /* Fill in the new section cache. */
6354 free_section_cache (sec_cache
);
6355 init_section_cache (sec_cache
);
6357 sec_cache
->sec
= sec
;
6358 sec_cache
->contents
= contents
;
6359 sec_cache
->content_length
= sec_size
;
6360 sec_cache
->relocs
= internal_relocs
;
6361 sec_cache
->reloc_count
= sec
->reloc_count
;
6362 sec_cache
->pte_count
= ptblsize
;
6363 sec_cache
->ptbl
= prop_table
;
6368 release_contents (sec
, contents
);
6369 release_internal_relocs (sec
, internal_relocs
);
6375 /* Extended basic blocks. */
6377 /* An ebb_struct represents an Extended Basic Block. Within this
6378 range, we guarantee that all instructions are decodable, the
6379 property table entries are contiguous, and no property table
6380 specifies a segment that cannot have instructions moved. This
6381 structure contains caches of the contents, property table and
6382 relocations for the specified section for easy use. The range is
6383 specified by ranges of indices for the byte offset, property table
6384 offsets and relocation offsets. These must be consistent. */
6386 typedef struct ebb_struct ebb_t
;
6392 bfd_byte
*contents
; /* Cache of the section contents. */
6393 bfd_size_type content_length
;
6395 property_table_entry
*ptbl
; /* Cache of the section property table. */
6398 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6399 unsigned reloc_count
;
6401 bfd_vma start_offset
; /* Offset in section. */
6402 unsigned start_ptbl_idx
; /* Offset in the property table. */
6403 unsigned start_reloc_idx
; /* Offset in the relocations. */
6406 unsigned end_ptbl_idx
;
6407 unsigned end_reloc_idx
;
6409 bool ends_section
; /* Is this the last ebb in a section? */
6411 /* The unreachable property table at the end of this set of blocks;
6412 NULL if the end is not an unreachable block. */
6413 property_table_entry
*ends_unreachable
;
6417 enum ebb_target_enum
6420 EBB_DESIRE_TGT_ALIGN
,
6421 EBB_REQUIRE_TGT_ALIGN
,
6422 EBB_REQUIRE_LOOP_ALIGN
,
6427 /* proposed_action_struct is similar to the text_action_struct except
6428 that is represents a potential transformation, not one that will
6429 occur. We build a list of these for an extended basic block
6430 and use them to compute the actual actions desired. We must be
6431 careful that the entire set of actual actions we perform do not
6432 break any relocations that would fit if the actions were not
6435 typedef struct proposed_action_struct proposed_action
;
6437 struct proposed_action_struct
6439 enum ebb_target_enum align_type
; /* for the target alignment */
6440 bfd_vma alignment_pow
;
6441 text_action_t action
;
6444 bool do_action
; /* If false, then we will not perform the action. */
6448 /* The ebb_constraint_struct keeps a set of proposed actions for an
6449 extended basic block. */
6451 typedef struct ebb_constraint_struct ebb_constraint
;
6453 struct ebb_constraint_struct
6458 /* Bytes of extra space at the beginning if movable. */
6459 int start_extra_space
;
6461 enum ebb_target_enum start_align
;
6465 /* Bytes of extra space at the end if movable. */
6466 int end_extra_space
;
6468 unsigned action_count
;
6469 unsigned action_allocated
;
6471 /* Array of proposed actions. */
6472 proposed_action
*actions
;
6474 /* Action alignments -- one for each proposed action. */
6475 enum ebb_target_enum
*action_aligns
;
6480 init_ebb_constraint (ebb_constraint
*c
)
6482 memset (c
, 0, sizeof (ebb_constraint
));
6487 free_ebb_constraint (ebb_constraint
*c
)
6494 init_ebb (ebb_t
*ebb
,
6497 bfd_size_type content_length
,
6498 property_table_entry
*prop_table
,
6500 Elf_Internal_Rela
*internal_relocs
,
6501 unsigned reloc_count
)
6503 memset (ebb
, 0, sizeof (ebb_t
));
6505 ebb
->contents
= contents
;
6506 ebb
->content_length
= content_length
;
6507 ebb
->ptbl
= prop_table
;
6508 ebb
->pte_count
= ptblsize
;
6509 ebb
->relocs
= internal_relocs
;
6510 ebb
->reloc_count
= reloc_count
;
6511 ebb
->start_offset
= 0;
6512 ebb
->end_offset
= ebb
->content_length
- 1;
6513 ebb
->start_ptbl_idx
= 0;
6514 ebb
->end_ptbl_idx
= ptblsize
;
6515 ebb
->start_reloc_idx
= 0;
6516 ebb
->end_reloc_idx
= reloc_count
;
6520 /* Extend the ebb to all decodable contiguous sections. The algorithm
6521 for building a basic block around an instruction is to push it
6522 forward until we hit the end of a section, an unreachable block or
6523 a block that cannot be transformed. Then we push it backwards
6524 searching for similar conditions. */
6526 static bool extend_ebb_bounds_forward (ebb_t
*);
6527 static bool extend_ebb_bounds_backward (ebb_t
*);
6528 static bfd_size_type insn_block_decodable_len
6529 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6532 extend_ebb_bounds (ebb_t
*ebb
)
6534 if (!extend_ebb_bounds_forward (ebb
))
6536 if (!extend_ebb_bounds_backward (ebb
))
6543 extend_ebb_bounds_forward (ebb_t
*ebb
)
6545 property_table_entry
*the_entry
, *new_entry
;
6547 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6549 /* Stop when (1) we cannot decode an instruction, (2) we are at
6550 the end of the property tables, (3) we hit a non-contiguous property
6551 table entry, (4) we hit a NO_TRANSFORM region. */
6556 bfd_size_type insn_block_len
;
6558 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6560 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6562 entry_end
- ebb
->end_offset
);
6563 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6566 /* xgettext:c-format */
6567 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6568 "possible configuration mismatch"),
6569 ebb
->sec
->owner
, ebb
->sec
,
6570 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6573 ebb
->end_offset
+= insn_block_len
;
6575 if (ebb
->end_offset
== ebb
->sec
->size
)
6576 ebb
->ends_section
= true;
6578 /* Update the reloc counter. */
6579 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6580 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6583 ebb
->end_reloc_idx
++;
6586 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6589 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6590 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6591 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6592 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6595 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6598 the_entry
= new_entry
;
6599 ebb
->end_ptbl_idx
++;
6602 /* Quick check for an unreachable or end of file just at the end. */
6603 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6605 if (ebb
->end_offset
== ebb
->content_length
)
6606 ebb
->ends_section
= true;
6610 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6611 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6612 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6613 ebb
->ends_unreachable
= new_entry
;
6616 /* Any other ending requires exact alignment. */
6622 extend_ebb_bounds_backward (ebb_t
*ebb
)
6624 property_table_entry
*the_entry
, *new_entry
;
6626 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6628 /* Stop when (1) we cannot decode the instructions in the current entry.
6629 (2) we are at the beginning of the property tables, (3) we hit a
6630 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6634 bfd_vma block_begin
;
6635 bfd_size_type insn_block_len
;
6637 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6639 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6641 ebb
->start_offset
- block_begin
);
6642 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6645 /* xgettext:c-format */
6646 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6647 "possible configuration mismatch"),
6648 ebb
->sec
->owner
, ebb
->sec
,
6649 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6652 ebb
->start_offset
-= insn_block_len
;
6654 /* Update the reloc counter. */
6655 while (ebb
->start_reloc_idx
> 0
6656 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6657 >= ebb
->start_offset
))
6659 ebb
->start_reloc_idx
--;
6662 if (ebb
->start_ptbl_idx
== 0)
6665 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6666 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6667 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6668 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6670 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6673 the_entry
= new_entry
;
6674 ebb
->start_ptbl_idx
--;
6680 static bfd_size_type
6681 insn_block_decodable_len (bfd_byte
*contents
,
6682 bfd_size_type content_len
,
6683 bfd_vma block_offset
,
6684 bfd_size_type block_len
)
6686 bfd_vma offset
= block_offset
;
6688 while (offset
< block_offset
+ block_len
)
6690 bfd_size_type insn_len
= 0;
6692 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6694 return (offset
- block_offset
);
6697 return (offset
- block_offset
);
6702 ebb_propose_action (ebb_constraint
*c
,
6703 enum ebb_target_enum align_type
,
6704 bfd_vma alignment_pow
,
6705 text_action_t action
,
6710 proposed_action
*act
;
6712 if (c
->action_allocated
<= c
->action_count
)
6714 unsigned new_allocated
, i
;
6715 proposed_action
*new_actions
;
6717 new_allocated
= (c
->action_count
+ 2) * 2;
6718 new_actions
= (proposed_action
*)
6719 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6721 for (i
= 0; i
< c
->action_count
; i
++)
6722 new_actions
[i
] = c
->actions
[i
];
6724 c
->actions
= new_actions
;
6725 c
->action_allocated
= new_allocated
;
6728 act
= &c
->actions
[c
->action_count
];
6729 act
->align_type
= align_type
;
6730 act
->alignment_pow
= alignment_pow
;
6731 act
->action
= action
;
6732 act
->offset
= offset
;
6733 act
->removed_bytes
= removed_bytes
;
6734 act
->do_action
= do_action
;
6740 /* Access to internal relocations, section contents and symbols. */
6742 /* During relaxation, we need to modify relocations, section contents,
6743 and symbol definitions, and we need to keep the original values from
6744 being reloaded from the input files, i.e., we need to "pin" the
6745 modified values in memory. We also want to continue to observe the
6746 setting of the "keep-memory" flag. The following functions wrap the
6747 standard BFD functions to take care of this for us. */
6749 static Elf_Internal_Rela
*
6750 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bool keep_memory
)
6752 Elf_Internal_Rela
*internal_relocs
;
6754 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6757 internal_relocs
= elf_section_data (sec
)->relocs
;
6758 if (internal_relocs
== NULL
)
6759 internal_relocs
= (_bfd_elf_link_read_relocs
6760 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6761 return internal_relocs
;
6766 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6768 elf_section_data (sec
)->relocs
= internal_relocs
;
6773 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6775 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
6776 free (internal_relocs
);
6781 retrieve_contents (bfd
*abfd
, asection
*sec
, bool keep_memory
)
6784 bfd_size_type sec_size
;
6786 sec_size
= bfd_get_section_limit (abfd
, sec
);
6787 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6789 if (contents
== NULL
&& sec_size
!= 0)
6791 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6797 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6804 pin_contents (asection
*sec
, bfd_byte
*contents
)
6806 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6811 release_contents (asection
*sec
, bfd_byte
*contents
)
6813 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6818 static Elf_Internal_Sym
*
6819 retrieve_local_syms (bfd
*input_bfd
)
6821 Elf_Internal_Shdr
*symtab_hdr
;
6822 Elf_Internal_Sym
*isymbuf
;
6825 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6826 locsymcount
= symtab_hdr
->sh_info
;
6828 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6829 if (isymbuf
== NULL
&& locsymcount
!= 0)
6830 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6833 /* Save the symbols for this input file so they won't be read again. */
6834 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6835 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6841 /* Code for link-time relaxation. */
6843 /* Initialization for relaxation: */
6844 static bool analyze_relocations (struct bfd_link_info
*);
6845 static bool find_relaxable_sections
6846 (bfd
*, asection
*, struct bfd_link_info
*, bool *);
6847 static bool collect_source_relocs
6848 (bfd
*, asection
*, struct bfd_link_info
*);
6849 static bool is_resolvable_asm_expansion
6850 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6852 static Elf_Internal_Rela
*find_associated_l32r_irel
6853 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6854 static bool compute_text_actions
6855 (bfd
*, asection
*, struct bfd_link_info
*);
6856 static bool compute_ebb_proposed_actions (ebb_constraint
*);
6857 static bool compute_ebb_actions (ebb_constraint
*);
6858 typedef struct reloc_range_list_struct reloc_range_list
;
6859 static bool check_section_ebb_pcrels_fit
6860 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6861 reloc_range_list
*, const ebb_constraint
*,
6862 const xtensa_opcode
*);
6863 static bool check_section_ebb_reduces (const ebb_constraint
*);
6864 static void text_action_add_proposed
6865 (text_action_list
*, const ebb_constraint
*, asection
*);
6868 static bool compute_removed_literals
6869 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6870 static Elf_Internal_Rela
*get_irel_at_offset
6871 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6872 static bool is_removable_literal
6873 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6874 property_table_entry
*, int);
6875 static bool remove_dead_literal
6876 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6877 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6878 static bool identify_literal_placement
6879 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6880 value_map_hash_table
*, bool *, Elf_Internal_Rela
*, int,
6881 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6883 static bool relocations_reach (source_reloc
*, int, const r_reloc
*);
6884 static bool coalesce_shared_literal
6885 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6886 static bool move_shared_literal
6887 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6888 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6891 static bool relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6892 static bool translate_section_fixes (asection
*);
6893 static bool translate_reloc_bfd_fix (reloc_bfd_fix
*);
6894 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6895 static void shrink_dynamic_reloc_sections
6896 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6897 static bool move_literal
6898 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6899 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6900 static bool relax_property_section
6901 (bfd
*, asection
*, struct bfd_link_info
*);
6904 static bool relax_section_symbols (bfd
*, asection
*);
6908 elf_xtensa_relax_section (bfd
*abfd
,
6910 struct bfd_link_info
*link_info
,
6913 static value_map_hash_table
*values
= NULL
;
6914 static bool relocations_analyzed
= false;
6915 xtensa_relax_info
*relax_info
;
6917 if (!relocations_analyzed
)
6919 /* Do some overall initialization for relaxation. */
6920 values
= value_map_hash_table_init ();
6923 relaxing_section
= true;
6924 if (!analyze_relocations (link_info
))
6926 relocations_analyzed
= true;
6930 /* Don't mess with linker-created sections. */
6931 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6934 relax_info
= get_xtensa_relax_info (sec
);
6935 BFD_ASSERT (relax_info
!= NULL
);
6937 switch (relax_info
->visited
)
6940 /* Note: It would be nice to fold this pass into
6941 analyze_relocations, but it is important for this step that the
6942 sections be examined in link order. */
6943 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6950 value_map_hash_table_delete (values
);
6952 if (!relax_section (abfd
, sec
, link_info
))
6958 if (!relax_section_symbols (abfd
, sec
))
6963 relax_info
->visited
++;
6968 /* Initialization for relaxation. */
6970 /* This function is called once at the start of relaxation. It scans
6971 all the input sections and marks the ones that are relaxable (i.e.,
6972 literal sections with L32R relocations against them), and then
6973 collects source_reloc information for all the relocations against
6974 those relaxable sections. During this process, it also detects
6975 longcalls, i.e., calls relaxed by the assembler into indirect
6976 calls, that can be optimized back into direct calls. Within each
6977 extended basic block (ebb) containing an optimized longcall, it
6978 computes a set of "text actions" that can be performed to remove
6979 the L32R associated with the longcall while optionally preserving
6980 branch target alignments. */
6983 analyze_relocations (struct bfd_link_info
*link_info
)
6987 bool is_relaxable
= false;
6989 /* Initialize the per-section relaxation info. */
6990 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6991 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6993 init_xtensa_relax_info (sec
);
6996 /* Mark relaxable sections (and count relocations against each one). */
6997 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6998 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7000 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
7004 /* Bail out if there are no relaxable sections. */
7008 /* Allocate space for source_relocs. */
7009 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7010 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7012 xtensa_relax_info
*relax_info
;
7014 relax_info
= get_xtensa_relax_info (sec
);
7015 if (relax_info
->is_relaxable_literal_section
7016 || relax_info
->is_relaxable_asm_section
)
7018 relax_info
->src_relocs
= (source_reloc
*)
7019 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
7022 relax_info
->src_count
= 0;
7025 /* Collect info on relocations against each relaxable section. */
7026 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7027 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7029 if (!collect_source_relocs (abfd
, sec
, link_info
))
7033 /* Compute the text actions. */
7034 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7035 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7037 if (!compute_text_actions (abfd
, sec
, link_info
))
7045 /* Find all the sections that might be relaxed. The motivation for
7046 this pass is that collect_source_relocs() needs to record _all_ the
7047 relocations that target each relaxable section. That is expensive
7048 and unnecessary unless the target section is actually going to be
7049 relaxed. This pass identifies all such sections by checking if
7050 they have L32Rs pointing to them. In the process, the total number
7051 of relocations targeting each section is also counted so that we
7052 know how much space to allocate for source_relocs against each
7053 relaxable literal section. */
7056 find_relaxable_sections (bfd
*abfd
,
7058 struct bfd_link_info
*link_info
,
7059 bool *is_relaxable_p
)
7061 Elf_Internal_Rela
*internal_relocs
;
7065 xtensa_relax_info
*source_relax_info
;
7068 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7069 link_info
->keep_memory
);
7070 if (internal_relocs
== NULL
)
7073 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7074 if (contents
== NULL
&& sec
->size
!= 0)
7080 source_relax_info
= get_xtensa_relax_info (sec
);
7081 for (i
= 0; i
< sec
->reloc_count
; i
++)
7083 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7085 asection
*target_sec
;
7086 xtensa_relax_info
*target_relax_info
;
7088 /* If this section has not already been marked as "relaxable", and
7089 if it contains any ASM_EXPAND relocations (marking expanded
7090 longcalls) that can be optimized into direct calls, then mark
7091 the section as "relaxable". */
7092 if (source_relax_info
7093 && !source_relax_info
->is_relaxable_asm_section
7094 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
7096 bool is_reachable
= false;
7097 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
7098 link_info
, &is_reachable
)
7101 source_relax_info
->is_relaxable_asm_section
= true;
7102 *is_relaxable_p
= true;
7106 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7107 bfd_get_section_limit (abfd
, sec
));
7109 target_sec
= r_reloc_get_section (&r_rel
);
7110 target_relax_info
= get_xtensa_relax_info (target_sec
);
7111 if (!target_relax_info
)
7114 /* Count PC-relative operand relocations against the target section.
7115 Note: The conditions tested here must match the conditions under
7116 which init_source_reloc is called in collect_source_relocs(). */
7117 is_l32r_reloc
= false;
7118 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7120 xtensa_opcode opcode
=
7121 get_relocation_opcode (abfd
, sec
, contents
, irel
);
7122 if (opcode
!= XTENSA_UNDEFINED
)
7124 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
7125 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
7127 target_relax_info
->src_count
++;
7131 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7133 /* Mark the target section as relaxable. */
7134 target_relax_info
->is_relaxable_literal_section
= true;
7135 *is_relaxable_p
= true;
7140 release_contents (sec
, contents
);
7141 release_internal_relocs (sec
, internal_relocs
);
7146 /* Record _all_ the relocations that point to relaxable sections, and
7147 get rid of ASM_EXPAND relocs by either converting them to
7148 ASM_SIMPLIFY or by removing them. */
7151 collect_source_relocs (bfd
*abfd
,
7153 struct bfd_link_info
*link_info
)
7155 Elf_Internal_Rela
*internal_relocs
;
7159 bfd_size_type sec_size
;
7161 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7162 link_info
->keep_memory
);
7163 if (internal_relocs
== NULL
)
7166 sec_size
= bfd_get_section_limit (abfd
, sec
);
7167 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7168 if (contents
== NULL
&& sec_size
!= 0)
7174 /* Record relocations against relaxable literal sections. */
7175 for (i
= 0; i
< sec
->reloc_count
; i
++)
7177 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7179 asection
*target_sec
;
7180 xtensa_relax_info
*target_relax_info
;
7182 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7184 target_sec
= r_reloc_get_section (&r_rel
);
7185 target_relax_info
= get_xtensa_relax_info (target_sec
);
7187 if (target_relax_info
7188 && (target_relax_info
->is_relaxable_literal_section
7189 || target_relax_info
->is_relaxable_asm_section
))
7191 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7193 bool is_abs_literal
= false;
7195 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7197 /* None of the current alternate relocs are PC-relative,
7198 and only PC-relative relocs matter here. However, we
7199 still need to record the opcode for literal
7201 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7202 if (opcode
== get_l32r_opcode ())
7204 is_abs_literal
= true;
7208 opcode
= XTENSA_UNDEFINED
;
7210 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7212 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7213 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7216 if (opcode
!= XTENSA_UNDEFINED
)
7218 int src_next
= target_relax_info
->src_next
++;
7219 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7221 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7227 /* Now get rid of ASM_EXPAND relocations. At this point, the
7228 src_relocs array for the target literal section may still be
7229 incomplete, but it must at least contain the entries for the L32R
7230 relocations associated with ASM_EXPANDs because they were just
7231 added in the preceding loop over the relocations. */
7233 for (i
= 0; i
< sec
->reloc_count
; i
++)
7235 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7238 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7244 Elf_Internal_Rela
*l32r_irel
;
7246 asection
*target_sec
;
7247 xtensa_relax_info
*target_relax_info
;
7249 /* Mark the source_reloc for the L32R so that it will be
7250 removed in compute_removed_literals(), along with the
7251 associated literal. */
7252 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7253 irel
, internal_relocs
);
7254 if (l32r_irel
== NULL
)
7257 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7259 target_sec
= r_reloc_get_section (&r_rel
);
7260 target_relax_info
= get_xtensa_relax_info (target_sec
);
7262 if (target_relax_info
7263 && (target_relax_info
->is_relaxable_literal_section
7264 || target_relax_info
->is_relaxable_asm_section
))
7266 source_reloc
*s_reloc
;
7268 /* Search the source_relocs for the entry corresponding to
7269 the l32r_irel. Note: The src_relocs array is not yet
7270 sorted, but it wouldn't matter anyway because we're
7271 searching by source offset instead of target offset. */
7272 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7273 target_relax_info
->src_next
,
7275 BFD_ASSERT (s_reloc
);
7276 s_reloc
->is_null
= true;
7279 /* Convert this reloc to ASM_SIMPLIFY. */
7280 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7281 R_XTENSA_ASM_SIMPLIFY
);
7282 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7284 pin_internal_relocs (sec
, internal_relocs
);
7288 /* It is resolvable but doesn't reach. We resolve now
7289 by eliminating the relocation -- the call will remain
7290 expanded into L32R/CALLX. */
7291 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7292 pin_internal_relocs (sec
, internal_relocs
);
7297 release_contents (sec
, contents
);
7298 release_internal_relocs (sec
, internal_relocs
);
7303 /* Return TRUE if the asm expansion can be resolved. Generally it can
7304 be resolved on a final link or when a partial link locates it in the
7305 same section as the target. Set "is_reachable" flag if the target of
7306 the call is within the range of a direct call, given the current VMA
7307 for this section and the target section. */
7310 is_resolvable_asm_expansion (bfd
*abfd
,
7313 Elf_Internal_Rela
*irel
,
7314 struct bfd_link_info
*link_info
,
7315 bool *is_reachable_p
)
7317 asection
*target_sec
;
7321 unsigned int first_align
;
7322 unsigned int adjust
;
7323 bfd_vma target_offset
;
7325 xtensa_opcode opcode
, direct_call_opcode
;
7326 bfd_vma self_address
;
7327 bfd_vma dest_address
;
7329 bfd_size_type sec_size
;
7331 *is_reachable_p
= false;
7333 if (contents
== NULL
)
7336 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7339 sec_size
= bfd_get_section_limit (abfd
, sec
);
7340 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7341 sec_size
- irel
->r_offset
, &uses_l32r
);
7342 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7346 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7347 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7350 /* Check and see that the target resolves. */
7351 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7352 if (!r_reloc_is_defined (&r_rel
))
7355 target_sec
= r_reloc_get_section (&r_rel
);
7356 target_offset
= r_rel
.target_offset
;
7358 /* If the target is in a shared library, then it doesn't reach. This
7359 isn't supposed to come up because the compiler should never generate
7360 non-PIC calls on systems that use shared libraries, but the linker
7361 shouldn't crash regardless. */
7362 if (!target_sec
->output_section
)
7365 /* For relocatable sections, we can only simplify when the output
7366 section of the target is the same as the output section of the
7368 if (bfd_link_relocatable (link_info
)
7369 && (target_sec
->output_section
!= sec
->output_section
7370 || is_reloc_sym_weak (abfd
, irel
)))
7373 if (target_sec
->output_section
!= sec
->output_section
)
7375 /* If the two sections are sufficiently far away that relaxation
7376 might take the call out of range, we can't simplify. For
7377 example, a positive displacement call into another memory
7378 could get moved to a lower address due to literal removal,
7379 but the destination won't move, and so the displacment might
7382 If the displacement is negative, assume the destination could
7383 move as far back as the start of the output section. The
7384 self_address will be at least as far into the output section
7385 as it is prior to relaxation.
7387 If the displacement is postive, assume the destination will be in
7388 it's pre-relaxed location (because relaxation only makes sections
7389 smaller). The self_address could go all the way to the beginning
7390 of the output section. */
7392 dest_address
= target_sec
->output_section
->vma
;
7393 self_address
= sec
->output_section
->vma
;
7395 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7396 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7398 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7399 /* Call targets should be four-byte aligned. */
7400 dest_address
= (dest_address
+ 3) & ~3;
7405 self_address
= (sec
->output_section
->vma
7406 + sec
->output_offset
+ irel
->r_offset
+ 3);
7407 dest_address
= (target_sec
->output_section
->vma
7408 + target_sec
->output_offset
+ target_offset
);
7411 /* Adjust addresses with alignments for the worst case to see if call insn
7412 can fit. Don't relax l32r + callx to call if the target can be out of
7413 range due to alignment.
7414 Caller and target addresses are highest and lowest address.
7415 Search all sections between caller and target, looking for max alignment.
7416 The adjustment is max alignment bytes. If the alignment at the lowest
7417 address is less than the adjustment, apply the adjustment to highest
7420 /* Start from lowest address.
7421 Lowest address aligmnet is from input section.
7422 Initial alignment (adjust) is from input section. */
7423 if (dest_address
> self_address
)
7425 s
= sec
->output_section
;
7426 last_vma
= dest_address
;
7427 first_align
= sec
->alignment_power
;
7428 adjust
= target_sec
->alignment_power
;
7432 s
= target_sec
->output_section
;
7433 last_vma
= self_address
;
7434 first_align
= target_sec
->alignment_power
;
7435 adjust
= sec
->alignment_power
;
7440 /* Find the largest alignment in output section list. */
7441 for (; s
&& s
->vma
>= first_vma
&& s
->vma
<= last_vma
; s
= s
->next
)
7443 if (s
->alignment_power
> adjust
)
7444 adjust
= s
->alignment_power
;
7447 if (adjust
> first_align
)
7449 /* Alignment may enlarge the range, adjust highest address. */
7450 adjust
= 1 << adjust
;
7451 if (dest_address
> self_address
)
7453 dest_address
+= adjust
;
7457 self_address
+= adjust
;
7461 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7462 self_address
, dest_address
);
7464 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7465 (dest_address
>> CALL_SEGMENT_BITS
))
7472 static Elf_Internal_Rela
*
7473 find_associated_l32r_irel (bfd
*abfd
,
7476 Elf_Internal_Rela
*other_irel
,
7477 Elf_Internal_Rela
*internal_relocs
)
7481 for (i
= 0; i
< sec
->reloc_count
; i
++)
7483 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7485 if (irel
== other_irel
)
7487 if (irel
->r_offset
!= other_irel
->r_offset
)
7489 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7497 static xtensa_opcode
*
7498 build_reloc_opcodes (bfd
*abfd
,
7501 Elf_Internal_Rela
*internal_relocs
)
7504 xtensa_opcode
*reloc_opcodes
=
7505 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7506 for (i
= 0; i
< sec
->reloc_count
; i
++)
7508 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7509 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7511 return reloc_opcodes
;
7514 struct reloc_range_struct
7517 bool add
; /* TRUE if start of a range, FALSE otherwise. */
7518 /* Original irel index in the array of relocations for a section. */
7519 unsigned irel_index
;
7521 typedef struct reloc_range_struct reloc_range
;
7523 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7524 struct reloc_range_list_entry_struct
7526 reloc_range_list_entry
*next
;
7527 reloc_range_list_entry
*prev
;
7528 Elf_Internal_Rela
*irel
;
7529 xtensa_opcode opcode
;
7533 struct reloc_range_list_struct
7535 /* The rest of the structure is only meaningful when ok is TRUE. */
7538 unsigned n_range
; /* Number of range markers. */
7539 reloc_range
*range
; /* Sorted range markers. */
7541 unsigned first
; /* Index of a first range element in the list. */
7542 unsigned last
; /* One past index of a last range element in the list. */
7544 unsigned n_list
; /* Number of list elements. */
7545 reloc_range_list_entry
*reloc
; /* */
7546 reloc_range_list_entry list_root
;
7550 reloc_range_compare (const void *a
, const void *b
)
7552 const reloc_range
*ra
= a
;
7553 const reloc_range
*rb
= b
;
7555 if (ra
->addr
!= rb
->addr
)
7556 return ra
->addr
< rb
->addr
? -1 : 1;
7557 if (ra
->add
!= rb
->add
)
7558 return ra
->add
? -1 : 1;
7563 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7565 Elf_Internal_Rela
*internal_relocs
,
7566 xtensa_opcode
*reloc_opcodes
,
7567 reloc_range_list
*list
)
7572 reloc_range
*ranges
= NULL
;
7573 reloc_range_list_entry
*reloc
=
7574 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7576 memset (list
, 0, sizeof (*list
));
7579 for (i
= 0; i
< sec
->reloc_count
; i
++)
7581 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7582 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7583 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7586 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7587 || r_type
== R_XTENSA_32_PCREL
7588 || !howto
->pc_relative
)
7591 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7592 bfd_get_section_limit (abfd
, sec
));
7594 if (r_reloc_get_section (&r_rel
) != sec
)
7599 max_n
= (max_n
+ 2) * 2;
7600 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7603 ranges
[n
].addr
= irel
->r_offset
;
7604 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7606 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7607 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7609 ranges
[n
].irel_index
= i
;
7610 ranges
[n
+ 1].irel_index
= i
;
7614 reloc
[i
].irel
= irel
;
7616 /* Every relocation won't possibly be checked in the optimized version of
7617 check_section_ebb_pcrels_fit, so this needs to be done here. */
7618 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7620 /* None of the current alternate relocs are PC-relative,
7621 and only PC-relative relocs matter here. */
7625 xtensa_opcode opcode
;
7629 opcode
= reloc_opcodes
[i
];
7631 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7633 if (opcode
== XTENSA_UNDEFINED
)
7639 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7640 if (opnum
== XTENSA_UNDEFINED
)
7646 /* Record relocation opcode and opnum as we've calculated them
7647 anyway and they won't change. */
7648 reloc
[i
].opcode
= opcode
;
7649 reloc
[i
].opnum
= opnum
;
7655 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7656 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7659 list
->range
= ranges
;
7660 list
->reloc
= reloc
;
7661 list
->list_root
.prev
= &list
->list_root
;
7662 list
->list_root
.next
= &list
->list_root
;
7671 static void reloc_range_list_append (reloc_range_list
*list
,
7672 unsigned irel_index
)
7674 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7676 entry
->prev
= list
->list_root
.prev
;
7677 entry
->next
= &list
->list_root
;
7678 entry
->prev
->next
= entry
;
7679 entry
->next
->prev
= entry
;
7683 static void reloc_range_list_remove (reloc_range_list
*list
,
7684 unsigned irel_index
)
7686 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7688 entry
->next
->prev
= entry
->prev
;
7689 entry
->prev
->next
= entry
->next
;
7693 /* Update relocation list object so that it lists all relocations that cross
7694 [first; last] range. Range bounds should not decrease with successive
7696 static void reloc_range_list_update_range (reloc_range_list
*list
,
7697 bfd_vma first
, bfd_vma last
)
7699 /* This should not happen: EBBs are iterated from lower addresses to higher.
7700 But even if that happens there's no need to break: just flush current list
7701 and start from scratch. */
7702 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7703 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7708 list
->list_root
.next
= &list
->list_root
;
7709 list
->list_root
.prev
= &list
->list_root
;
7710 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7713 for (; list
->last
< list
->n_range
&&
7714 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7715 if (list
->range
[list
->last
].add
)
7716 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7718 for (; list
->first
< list
->n_range
&&
7719 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7720 if (!list
->range
[list
->first
].add
)
7721 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7724 static void free_reloc_range_list (reloc_range_list
*list
)
7730 /* The compute_text_actions function will build a list of potential
7731 transformation actions for code in the extended basic block of each
7732 longcall that is optimized to a direct call. From this list we
7733 generate a set of actions to actually perform that optimizes for
7734 space and, if not using size_opt, maintains branch target
7737 These actions to be performed are placed on a per-section list.
7738 The actual changes are performed by relax_section() in the second
7742 compute_text_actions (bfd
*abfd
,
7744 struct bfd_link_info
*link_info
)
7746 xtensa_opcode
*reloc_opcodes
= NULL
;
7747 xtensa_relax_info
*relax_info
;
7749 Elf_Internal_Rela
*internal_relocs
;
7752 property_table_entry
*prop_table
= 0;
7754 bfd_size_type sec_size
;
7755 reloc_range_list relevant_relocs
;
7757 relax_info
= get_xtensa_relax_info (sec
);
7758 BFD_ASSERT (relax_info
);
7759 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7761 /* Do nothing if the section contains no optimized longcalls. */
7762 if (!relax_info
->is_relaxable_asm_section
)
7765 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7766 link_info
->keep_memory
);
7768 if (internal_relocs
)
7769 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7770 internal_reloc_compare
);
7772 sec_size
= bfd_get_section_limit (abfd
, sec
);
7773 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7774 if (contents
== NULL
&& sec_size
!= 0)
7780 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7781 XTENSA_PROP_SEC_NAME
, false);
7788 /* Precompute the opcode for each relocation. */
7789 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7791 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7794 for (i
= 0; i
< sec
->reloc_count
; i
++)
7796 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7798 property_table_entry
*the_entry
;
7801 ebb_constraint ebb_table
;
7802 bfd_size_type simplify_size
;
7804 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7806 r_offset
= irel
->r_offset
;
7808 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7809 if (simplify_size
== 0)
7812 /* xgettext:c-format */
7813 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7814 "XTENSA_ASM_SIMPLIFY relocation; "
7815 "possible configuration mismatch"),
7816 sec
->owner
, sec
, (uint64_t) r_offset
);
7820 /* If the instruction table is not around, then don't do this
7822 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7823 sec
->vma
+ irel
->r_offset
);
7824 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7826 text_action_add (&relax_info
->action_list
,
7827 ta_convert_longcall
, sec
, r_offset
,
7832 /* If the next longcall happens to be at the same address as an
7833 unreachable section of size 0, then skip forward. */
7834 ptbl_idx
= the_entry
- prop_table
;
7835 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7836 && the_entry
->size
== 0
7837 && ptbl_idx
+ 1 < ptblsize
7838 && (prop_table
[ptbl_idx
+ 1].address
7839 == prop_table
[ptbl_idx
].address
))
7845 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7846 /* NO_REORDER is OK */
7849 init_ebb_constraint (&ebb_table
);
7850 ebb
= &ebb_table
.ebb
;
7851 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7852 internal_relocs
, sec
->reloc_count
);
7853 ebb
->start_offset
= r_offset
+ simplify_size
;
7854 ebb
->end_offset
= r_offset
+ simplify_size
;
7855 ebb
->start_ptbl_idx
= ptbl_idx
;
7856 ebb
->end_ptbl_idx
= ptbl_idx
;
7857 ebb
->start_reloc_idx
= i
;
7858 ebb
->end_reloc_idx
= i
;
7860 if (!extend_ebb_bounds (ebb
)
7861 || !compute_ebb_proposed_actions (&ebb_table
)
7862 || !compute_ebb_actions (&ebb_table
)
7863 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7866 &ebb_table
, reloc_opcodes
)
7867 || !check_section_ebb_reduces (&ebb_table
))
7869 /* If anything goes wrong or we get unlucky and something does
7870 not fit, with our plan because of expansion between
7871 critical branches, just convert to a NOP. */
7873 text_action_add (&relax_info
->action_list
,
7874 ta_convert_longcall
, sec
, r_offset
, 0);
7875 i
= ebb_table
.ebb
.end_reloc_idx
;
7876 free_ebb_constraint (&ebb_table
);
7880 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7882 /* Update the index so we do not go looking at the relocations
7883 we have already processed. */
7884 i
= ebb_table
.ebb
.end_reloc_idx
;
7885 free_ebb_constraint (&ebb_table
);
7888 free_reloc_range_list (&relevant_relocs
);
7891 if (action_list_count (&relax_info
->action_list
))
7892 print_action_list (stderr
, &relax_info
->action_list
);
7896 release_contents (sec
, contents
);
7897 release_internal_relocs (sec
, internal_relocs
);
7899 free (reloc_opcodes
);
7905 /* Do not widen an instruction if it is preceeded by a
7906 loop opcode. It might cause misalignment. */
7909 prev_instr_is_a_loop (bfd_byte
*contents
,
7910 bfd_size_type content_length
,
7911 bfd_size_type offset
)
7913 xtensa_opcode prev_opcode
;
7917 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7918 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7922 /* Find all of the possible actions for an extended basic block. */
7925 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7927 const ebb_t
*ebb
= &ebb_table
->ebb
;
7928 unsigned rel_idx
= ebb
->start_reloc_idx
;
7929 property_table_entry
*entry
, *start_entry
, *end_entry
;
7931 xtensa_isa isa
= xtensa_default_isa
;
7933 static xtensa_insnbuf insnbuf
= NULL
;
7934 static xtensa_insnbuf slotbuf
= NULL
;
7936 if (insnbuf
== NULL
)
7938 insnbuf
= xtensa_insnbuf_alloc (isa
);
7939 slotbuf
= xtensa_insnbuf_alloc (isa
);
7942 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7943 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7945 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7947 bfd_vma start_offset
, end_offset
;
7948 bfd_size_type insn_len
;
7950 start_offset
= entry
->address
- ebb
->sec
->vma
;
7951 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7953 if (entry
== start_entry
)
7954 start_offset
= ebb
->start_offset
;
7955 if (entry
== end_entry
)
7956 end_offset
= ebb
->end_offset
;
7957 offset
= start_offset
;
7959 if (offset
== entry
->address
- ebb
->sec
->vma
7960 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7962 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7963 BFD_ASSERT (offset
!= end_offset
);
7964 if (offset
== end_offset
)
7967 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7972 if (check_branch_target_aligned_address (offset
, insn_len
))
7973 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7975 ebb_propose_action (ebb_table
, align_type
, 0,
7976 ta_none
, offset
, 0, true);
7979 while (offset
!= end_offset
)
7981 Elf_Internal_Rela
*irel
;
7982 xtensa_opcode opcode
;
7984 while (rel_idx
< ebb
->end_reloc_idx
7985 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7986 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7987 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
7988 != R_XTENSA_ASM_SIMPLIFY
))))
7991 /* Check for longcall. */
7992 irel
= &ebb
->relocs
[rel_idx
];
7993 if (irel
->r_offset
== offset
7994 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
7996 bfd_size_type simplify_size
;
7998 simplify_size
= get_asm_simplify_size (ebb
->contents
,
7999 ebb
->content_length
,
8001 if (simplify_size
== 0)
8004 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8005 ta_convert_longcall
, offset
, 0, true);
8007 offset
+= simplify_size
;
8011 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
8013 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
8014 ebb
->content_length
- offset
);
8015 fmt
= xtensa_format_decode (isa
, insnbuf
);
8016 if (fmt
== XTENSA_UNDEFINED
)
8018 insn_len
= xtensa_format_length (isa
, fmt
);
8019 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
8022 if (xtensa_format_num_slots (isa
, fmt
) != 1)
8028 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
8029 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
8030 if (opcode
== XTENSA_UNDEFINED
)
8033 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
8034 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8035 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
8037 /* Add an instruction narrow action. */
8038 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8039 ta_narrow_insn
, offset
, 0, false);
8041 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8042 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
8043 && ! prev_instr_is_a_loop (ebb
->contents
,
8044 ebb
->content_length
, offset
))
8046 /* Add an instruction widen action. */
8047 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8048 ta_widen_insn
, offset
, 0, false);
8050 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
8052 /* Check for branch targets. */
8053 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
8054 ta_none
, offset
, 0, true);
8061 if (ebb
->ends_unreachable
)
8063 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8064 ta_fill
, ebb
->end_offset
, 0, true);
8071 /* xgettext:c-format */
8072 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
8073 "possible configuration mismatch"),
8074 ebb
->sec
->owner
, ebb
->sec
, (uint64_t) offset
);
8079 /* After all of the information has collected about the
8080 transformations possible in an EBB, compute the appropriate actions
8081 here in compute_ebb_actions. We still must check later to make
8082 sure that the actions do not break any relocations. The algorithm
8083 used here is pretty greedy. Basically, it removes as many no-ops
8084 as possible so that the end of the EBB has the same alignment
8085 characteristics as the original. First, it uses narrowing, then
8086 fill space at the end of the EBB, and finally widenings. If that
8087 does not work, it tries again with one fewer no-op removed. The
8088 optimization will only be performed if all of the branch targets
8089 that were aligned before transformation are also aligned after the
8092 When the size_opt flag is set, ignore the branch target alignments,
8093 narrow all wide instructions, and remove all no-ops unless the end
8094 of the EBB prevents it. */
8097 compute_ebb_actions (ebb_constraint
*ebb_table
)
8101 int removed_bytes
= 0;
8102 ebb_t
*ebb
= &ebb_table
->ebb
;
8103 unsigned seg_idx_start
= 0;
8104 unsigned seg_idx_end
= 0;
8106 /* We perform this like the assembler relaxation algorithm: Start by
8107 assuming all instructions are narrow and all no-ops removed; then
8110 /* For each segment of this that has a solid constraint, check to
8111 see if there are any combinations that will keep the constraint.
8113 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
8115 bool requires_text_end_align
= false;
8116 unsigned longcall_count
= 0;
8117 unsigned longcall_convert_count
= 0;
8118 unsigned narrowable_count
= 0;
8119 unsigned narrowable_convert_count
= 0;
8120 unsigned widenable_count
= 0;
8121 unsigned widenable_convert_count
= 0;
8123 proposed_action
*action
= NULL
;
8124 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
8126 seg_idx_start
= seg_idx_end
;
8128 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
8130 action
= &ebb_table
->actions
[i
];
8131 if (action
->action
== ta_convert_longcall
)
8133 if (action
->action
== ta_narrow_insn
)
8135 if (action
->action
== ta_widen_insn
)
8137 if (action
->action
== ta_fill
)
8139 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8141 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
8142 && !elf32xtensa_size_opt
)
8147 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
8148 requires_text_end_align
= true;
8150 if (elf32xtensa_size_opt
&& !requires_text_end_align
8151 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
8152 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
8154 longcall_convert_count
= longcall_count
;
8155 narrowable_convert_count
= narrowable_count
;
8156 widenable_convert_count
= 0;
8160 /* There is a constraint. Convert the max number of longcalls. */
8161 narrowable_convert_count
= 0;
8162 longcall_convert_count
= 0;
8163 widenable_convert_count
= 0;
8165 for (j
= 0; j
< longcall_count
; j
++)
8167 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
8168 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
8169 unsigned desire_widen
= removed
;
8170 if (desire_narrow
<= narrowable_count
)
8172 narrowable_convert_count
= desire_narrow
;
8173 narrowable_convert_count
+=
8174 (align
* ((narrowable_count
- narrowable_convert_count
)
8176 longcall_convert_count
= (longcall_count
- j
);
8177 widenable_convert_count
= 0;
8180 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
8182 narrowable_convert_count
= 0;
8183 longcall_convert_count
= longcall_count
- j
;
8184 widenable_convert_count
= desire_widen
;
8190 /* Now the number of conversions are saved. Do them. */
8191 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
8193 action
= &ebb_table
->actions
[i
];
8194 switch (action
->action
)
8196 case ta_convert_longcall
:
8197 if (longcall_convert_count
!= 0)
8199 action
->action
= ta_remove_longcall
;
8200 action
->do_action
= true;
8201 action
->removed_bytes
+= 3;
8202 longcall_convert_count
--;
8205 case ta_narrow_insn
:
8206 if (narrowable_convert_count
!= 0)
8208 action
->do_action
= true;
8209 action
->removed_bytes
+= 1;
8210 narrowable_convert_count
--;
8214 if (widenable_convert_count
!= 0)
8216 action
->do_action
= true;
8217 action
->removed_bytes
-= 1;
8218 widenable_convert_count
--;
8227 /* Now we move on to some local opts. Try to remove each of the
8228 remaining longcalls. */
8230 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8233 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8235 int old_removed_bytes
= removed_bytes
;
8236 proposed_action
*action
= &ebb_table
->actions
[i
];
8238 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8240 bool bad_alignment
= false;
8242 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8244 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8245 bfd_vma offset
= new_action
->offset
;
8246 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8248 if (!check_branch_target_aligned
8249 (ebb_table
->ebb
.contents
,
8250 ebb_table
->ebb
.content_length
,
8251 offset
, offset
- removed_bytes
))
8253 bad_alignment
= true;
8257 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8259 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8260 ebb_table
->ebb
.content_length
,
8262 offset
- removed_bytes
))
8264 bad_alignment
= true;
8268 if (new_action
->action
== ta_narrow_insn
8269 && !new_action
->do_action
8270 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8272 /* Narrow an instruction and we are done. */
8273 new_action
->do_action
= true;
8274 new_action
->removed_bytes
+= 1;
8275 bad_alignment
= false;
8278 if (new_action
->action
== ta_widen_insn
8279 && new_action
->do_action
8280 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8282 /* Narrow an instruction and we are done. */
8283 new_action
->do_action
= false;
8284 new_action
->removed_bytes
+= 1;
8285 bad_alignment
= false;
8288 if (new_action
->do_action
)
8289 removed_bytes
+= new_action
->removed_bytes
;
8293 action
->removed_bytes
+= 3;
8294 action
->action
= ta_remove_longcall
;
8295 action
->do_action
= true;
8298 removed_bytes
= old_removed_bytes
;
8299 if (action
->do_action
)
8300 removed_bytes
+= action
->removed_bytes
;
8305 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8307 proposed_action
*action
= &ebb_table
->actions
[i
];
8308 if (action
->do_action
)
8309 removed_bytes
+= action
->removed_bytes
;
8312 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8313 && ebb
->ends_unreachable
)
8315 proposed_action
*action
;
8319 BFD_ASSERT (ebb_table
->action_count
!= 0);
8320 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8321 BFD_ASSERT (action
->action
== ta_fill
);
8322 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8324 extra_space
= xtensa_compute_fill_extra_space (ebb
->ends_unreachable
);
8325 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8326 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8328 action
->removed_bytes
= extra_space
- br
;
8334 /* The xlate_map is a sorted array of address mappings designed to
8335 answer the offset_with_removed_text() query with a binary search instead
8336 of a linear search through the section's action_list. */
8338 typedef struct xlate_map_entry xlate_map_entry_t
;
8339 typedef struct xlate_map xlate_map_t
;
8341 struct xlate_map_entry
8343 bfd_vma orig_address
;
8344 bfd_vma new_address
;
8350 unsigned entry_count
;
8351 xlate_map_entry_t
*entry
;
8356 xlate_compare (const void *a_v
, const void *b_v
)
8358 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8359 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8360 if (a
->orig_address
< b
->orig_address
)
8362 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8369 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8370 text_action_list
*action_list
,
8374 xlate_map_entry_t
*e
;
8375 struct xlate_map_entry se
;
8378 return offset_with_removed_text (action_list
, offset
);
8380 if (map
->entry_count
== 0)
8383 se
.orig_address
= offset
;
8384 r
= bsearch (&se
, map
->entry
, map
->entry_count
,
8385 sizeof (xlate_map_entry_t
), &xlate_compare
);
8386 e
= (xlate_map_entry_t
*) r
;
8388 /* There could be a jump past the end of the section,
8389 allow it using the last xlate map entry to translate its address. */
8392 e
= map
->entry
+ map
->entry_count
- 1;
8393 if (xlate_compare (&se
, e
) <= 0)
8396 BFD_ASSERT (e
!= NULL
);
8399 return e
->new_address
- e
->orig_address
+ offset
;
8402 typedef struct xlate_map_context_struct xlate_map_context
;
8403 struct xlate_map_context_struct
8406 xlate_map_entry_t
*current_entry
;
8411 xlate_map_fn (splay_tree_node node
, void *p
)
8413 text_action
*r
= (text_action
*)node
->value
;
8414 xlate_map_context
*ctx
= p
;
8415 unsigned orig_size
= 0;
8420 case ta_remove_insn
:
8421 case ta_convert_longcall
:
8422 case ta_remove_literal
:
8423 case ta_add_literal
:
8425 case ta_remove_longcall
:
8428 case ta_narrow_insn
:
8437 ctx
->current_entry
->size
=
8438 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8439 if (ctx
->current_entry
->size
!= 0)
8441 ctx
->current_entry
++;
8442 ctx
->map
->entry_count
++;
8444 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8445 ctx
->removed
+= r
->removed_bytes
;
8446 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8447 ctx
->current_entry
->size
= 0;
8451 /* Build a binary searchable offset translation map from a section's
8454 static xlate_map_t
*
8455 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8457 text_action_list
*action_list
= &relax_info
->action_list
;
8458 unsigned num_actions
= 0;
8459 xlate_map_context ctx
;
8461 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8463 if (ctx
.map
== NULL
)
8466 num_actions
= action_list_count (action_list
);
8467 ctx
.map
->entry
= (xlate_map_entry_t
*)
8468 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8469 if (ctx
.map
->entry
== NULL
)
8474 ctx
.map
->entry_count
= 0;
8477 ctx
.current_entry
= &ctx
.map
->entry
[0];
8479 ctx
.current_entry
->orig_address
= 0;
8480 ctx
.current_entry
->new_address
= 0;
8481 ctx
.current_entry
->size
= 0;
8483 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8485 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8486 - ctx
.current_entry
->orig_address
);
8487 if (ctx
.current_entry
->size
!= 0)
8488 ctx
.map
->entry_count
++;
8494 /* Free an offset translation map. */
8497 free_xlate_map (xlate_map_t
*map
)
8507 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8508 relocations in a section will fit if a proposed set of actions
8512 check_section_ebb_pcrels_fit (bfd
*abfd
,
8515 Elf_Internal_Rela
*internal_relocs
,
8516 reloc_range_list
*relevant_relocs
,
8517 const ebb_constraint
*constraint
,
8518 const xtensa_opcode
*reloc_opcodes
)
8521 unsigned n
= sec
->reloc_count
;
8522 Elf_Internal_Rela
*irel
;
8523 xlate_map_t
*xmap
= NULL
;
8525 xtensa_relax_info
*relax_info
;
8526 reloc_range_list_entry
*entry
= NULL
;
8528 relax_info
= get_xtensa_relax_info (sec
);
8530 if (relax_info
&& sec
->reloc_count
> 100)
8532 xmap
= build_xlate_map (sec
, relax_info
);
8533 /* NULL indicates out of memory, but the slow version
8534 can still be used. */
8537 if (relevant_relocs
&& constraint
->action_count
)
8539 if (!relevant_relocs
->ok
)
8546 bfd_vma min_offset
, max_offset
;
8547 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8549 for (i
= 1; i
< constraint
->action_count
; ++i
)
8551 proposed_action
*action
= &constraint
->actions
[i
];
8552 bfd_vma offset
= action
->offset
;
8554 if (offset
< min_offset
)
8555 min_offset
= offset
;
8556 if (offset
> max_offset
)
8557 max_offset
= offset
;
8559 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8561 n
= relevant_relocs
->n_list
;
8562 entry
= &relevant_relocs
->list_root
;
8567 relevant_relocs
= NULL
;
8570 for (i
= 0; i
< n
; i
++)
8573 bfd_vma orig_self_offset
, orig_target_offset
;
8574 bfd_vma self_offset
, target_offset
;
8576 reloc_howto_type
*howto
;
8577 int self_removed_bytes
, target_removed_bytes
;
8579 if (relevant_relocs
)
8581 entry
= entry
->next
;
8586 irel
= internal_relocs
+ i
;
8588 r_type
= ELF32_R_TYPE (irel
->r_info
);
8590 howto
= &elf_howto_table
[r_type
];
8591 /* We maintain the required invariant: PC-relative relocations
8592 that fit before linking must fit after linking. Thus we only
8593 need to deal with relocations to the same section that are
8595 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8596 || r_type
== R_XTENSA_32_PCREL
8597 || !howto
->pc_relative
)
8600 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8601 bfd_get_section_limit (abfd
, sec
));
8603 if (r_reloc_get_section (&r_rel
) != sec
)
8606 orig_self_offset
= irel
->r_offset
;
8607 orig_target_offset
= r_rel
.target_offset
;
8609 self_offset
= orig_self_offset
;
8610 target_offset
= orig_target_offset
;
8615 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8618 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8619 orig_target_offset
);
8622 self_removed_bytes
= 0;
8623 target_removed_bytes
= 0;
8625 for (j
= 0; j
< constraint
->action_count
; ++j
)
8627 proposed_action
*action
= &constraint
->actions
[j
];
8628 bfd_vma offset
= action
->offset
;
8629 int removed_bytes
= action
->removed_bytes
;
8630 if (offset
< orig_self_offset
8631 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8632 && action
->removed_bytes
< 0))
8633 self_removed_bytes
+= removed_bytes
;
8634 if (offset
< orig_target_offset
8635 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8636 && action
->removed_bytes
< 0))
8637 target_removed_bytes
+= removed_bytes
;
8639 self_offset
-= self_removed_bytes
;
8640 target_offset
-= target_removed_bytes
;
8642 /* Try to encode it. Get the operand and check. */
8643 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8645 /* None of the current alternate relocs are PC-relative,
8646 and only PC-relative relocs matter here. */
8650 xtensa_opcode opcode
;
8653 if (relevant_relocs
)
8655 opcode
= entry
->opcode
;
8656 opnum
= entry
->opnum
;
8661 opcode
= reloc_opcodes
[relevant_relocs
?
8662 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8664 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8665 if (opcode
== XTENSA_UNDEFINED
)
8671 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8672 if (opnum
== XTENSA_UNDEFINED
)
8679 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8687 free_xlate_map (xmap
);
8694 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8699 for (i
= 0; i
< constraint
->action_count
; i
++)
8701 const proposed_action
*action
= &constraint
->actions
[i
];
8702 if (action
->do_action
)
8703 removed
+= action
->removed_bytes
;
8713 text_action_add_proposed (text_action_list
*l
,
8714 const ebb_constraint
*ebb_table
,
8719 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8721 proposed_action
*action
= &ebb_table
->actions
[i
];
8723 if (!action
->do_action
)
8725 switch (action
->action
)
8727 case ta_remove_insn
:
8728 case ta_remove_longcall
:
8729 case ta_convert_longcall
:
8730 case ta_narrow_insn
:
8733 case ta_remove_literal
:
8734 text_action_add (l
, action
->action
, sec
, action
->offset
,
8735 action
->removed_bytes
);
8748 xtensa_compute_fill_extra_space (property_table_entry
*entry
)
8750 int fill_extra_space
;
8755 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8758 fill_extra_space
= entry
->size
;
8759 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8761 /* Fill bytes for alignment:
8762 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8763 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8764 int nsm
= (1 << pow
) - 1;
8765 bfd_vma addr
= entry
->address
+ entry
->size
;
8766 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8767 fill_extra_space
+= align_fill
;
8769 return fill_extra_space
;
8773 /* First relaxation pass. */
8775 /* If the section contains relaxable literals, check each literal to
8776 see if it has the same value as another literal that has already
8777 been seen, either in the current section or a previous one. If so,
8778 add an entry to the per-section list of removed literals. The
8779 actual changes are deferred until the next pass. */
8782 compute_removed_literals (bfd
*abfd
,
8784 struct bfd_link_info
*link_info
,
8785 value_map_hash_table
*values
)
8787 xtensa_relax_info
*relax_info
;
8789 Elf_Internal_Rela
*internal_relocs
;
8790 source_reloc
*src_relocs
, *rel
;
8792 property_table_entry
*prop_table
= NULL
;
8795 bool last_loc_is_prev
= false;
8796 bfd_vma last_target_offset
= 0;
8797 section_cache_t target_sec_cache
;
8798 bfd_size_type sec_size
;
8800 init_section_cache (&target_sec_cache
);
8802 /* Do nothing if it is not a relaxable literal section. */
8803 relax_info
= get_xtensa_relax_info (sec
);
8804 BFD_ASSERT (relax_info
);
8805 if (!relax_info
->is_relaxable_literal_section
)
8808 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8809 link_info
->keep_memory
);
8811 sec_size
= bfd_get_section_limit (abfd
, sec
);
8812 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8813 if (contents
== NULL
&& sec_size
!= 0)
8819 /* Sort the source_relocs by target offset. */
8820 src_relocs
= relax_info
->src_relocs
;
8821 qsort (src_relocs
, relax_info
->src_count
,
8822 sizeof (source_reloc
), source_reloc_compare
);
8823 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8824 internal_reloc_compare
);
8826 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8827 XTENSA_PROP_SEC_NAME
, false);
8835 for (i
= 0; i
< relax_info
->src_count
; i
++)
8837 Elf_Internal_Rela
*irel
= NULL
;
8839 rel
= &src_relocs
[i
];
8840 if (get_l32r_opcode () != rel
->opcode
)
8842 irel
= get_irel_at_offset (sec
, internal_relocs
,
8843 rel
->r_rel
.target_offset
);
8845 /* If the relocation on this is not a simple R_XTENSA_32 or
8846 R_XTENSA_PLT then do not consider it. This may happen when
8847 the difference of two symbols is used in a literal. */
8848 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8849 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8852 /* If the target_offset for this relocation is the same as the
8853 previous relocation, then we've already considered whether the
8854 literal can be coalesced. Skip to the next one.... */
8855 if (i
!= 0 && prev_i
!= -1
8856 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8860 if (last_loc_is_prev
&&
8861 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8862 last_loc_is_prev
= false;
8864 /* Check if the relocation was from an L32R that is being removed
8865 because a CALLX was converted to a direct CALL, and check if
8866 there are no other relocations to the literal. */
8867 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8868 sec
, prop_table
, ptblsize
))
8870 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8871 irel
, rel
, prop_table
, ptblsize
))
8876 last_target_offset
= rel
->r_rel
.target_offset
;
8880 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8882 &last_loc_is_prev
, irel
,
8883 relax_info
->src_count
- i
, rel
,
8884 prop_table
, ptblsize
,
8885 &target_sec_cache
, rel
->is_abs_literal
))
8890 last_target_offset
= rel
->r_rel
.target_offset
;
8894 print_removed_literals (stderr
, &relax_info
->removed_list
);
8895 print_action_list (stderr
, &relax_info
->action_list
);
8900 free_section_cache (&target_sec_cache
);
8902 release_contents (sec
, contents
);
8903 release_internal_relocs (sec
, internal_relocs
);
8908 static Elf_Internal_Rela
*
8909 get_irel_at_offset (asection
*sec
,
8910 Elf_Internal_Rela
*internal_relocs
,
8914 Elf_Internal_Rela
*irel
;
8916 Elf_Internal_Rela key
;
8918 if (!internal_relocs
)
8921 key
.r_offset
= offset
;
8922 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8923 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8927 /* bsearch does not guarantee which will be returned if there are
8928 multiple matches. We need the first that is not an alignment. */
8929 i
= irel
- internal_relocs
;
8932 if (internal_relocs
[i
-1].r_offset
!= offset
)
8936 for ( ; i
< sec
->reloc_count
; i
++)
8938 irel
= &internal_relocs
[i
];
8939 r_type
= ELF32_R_TYPE (irel
->r_info
);
8940 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8949 is_removable_literal (const source_reloc
*rel
,
8951 const source_reloc
*src_relocs
,
8954 property_table_entry
*prop_table
,
8957 const source_reloc
*curr_rel
;
8958 property_table_entry
*entry
;
8963 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8964 sec
->vma
+ rel
->r_rel
.target_offset
);
8965 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8968 for (++i
; i
< src_count
; ++i
)
8970 curr_rel
= &src_relocs
[i
];
8971 /* If all others have the same target offset.... */
8972 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8975 if (!curr_rel
->is_null
8976 && !xtensa_is_property_section (curr_rel
->source_sec
)
8977 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8985 remove_dead_literal (bfd
*abfd
,
8987 struct bfd_link_info
*link_info
,
8988 Elf_Internal_Rela
*internal_relocs
,
8989 Elf_Internal_Rela
*irel
,
8991 property_table_entry
*prop_table
,
8994 property_table_entry
*entry
;
8995 xtensa_relax_info
*relax_info
;
8997 relax_info
= get_xtensa_relax_info (sec
);
9001 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9002 sec
->vma
+ rel
->r_rel
.target_offset
);
9004 /* Mark the unused literal so that it will be removed. */
9005 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
9007 text_action_add (&relax_info
->action_list
,
9008 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9010 /* If the section is 4-byte aligned, do not add fill. */
9011 if (sec
->alignment_power
> 2)
9013 int fill_extra_space
;
9014 bfd_vma entry_sec_offset
;
9016 property_table_entry
*the_add_entry
;
9020 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9022 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9024 /* If the literal range is at the end of the section,
9026 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9028 fill_extra_space
= xtensa_compute_fill_extra_space (the_add_entry
);
9030 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9031 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9032 -4, fill_extra_space
);
9034 adjust_fill_action (fa
, removed_diff
);
9036 text_action_add (&relax_info
->action_list
,
9037 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9040 /* Zero out the relocation on this literal location. */
9043 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9044 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9046 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9047 pin_internal_relocs (sec
, internal_relocs
);
9050 /* Do not modify "last_loc_is_prev". */
9056 identify_literal_placement (bfd
*abfd
,
9059 struct bfd_link_info
*link_info
,
9060 value_map_hash_table
*values
,
9061 bool *last_loc_is_prev_p
,
9062 Elf_Internal_Rela
*irel
,
9063 int remaining_src_rels
,
9065 property_table_entry
*prop_table
,
9067 section_cache_t
*target_sec_cache
,
9068 bool is_abs_literal
)
9072 xtensa_relax_info
*relax_info
;
9073 bool literal_placed
= false;
9075 unsigned long value
;
9076 bool final_static_link
;
9077 bfd_size_type sec_size
;
9079 relax_info
= get_xtensa_relax_info (sec
);
9083 sec_size
= bfd_get_section_limit (abfd
, sec
);
9086 (!bfd_link_relocatable (link_info
)
9087 && !elf_hash_table (link_info
)->dynamic_sections_created
);
9089 /* The placement algorithm first checks to see if the literal is
9090 already in the value map. If so and the value map is reachable
9091 from all uses, then the literal is moved to that location. If
9092 not, then we identify the last location where a fresh literal was
9093 placed. If the literal can be safely moved there, then we do so.
9094 If not, then we assume that the literal is not to move and leave
9095 the literal where it is, marking it as the last literal
9098 /* Find the literal value. */
9100 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9103 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
9104 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
9106 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
9108 /* Check if we've seen another literal with the same value that
9109 is in the same output section. */
9110 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
9113 && (r_reloc_get_section (&val_map
->loc
)->output_section
9114 == sec
->output_section
)
9115 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
9116 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
9118 /* No change to last_loc_is_prev. */
9119 literal_placed
= true;
9122 /* For relocatable links, do not try to move literals. To do it
9123 correctly might increase the number of relocations in an input
9124 section making the default relocatable linking fail. */
9125 if (!bfd_link_relocatable (link_info
) && !literal_placed
9126 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
9128 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
9129 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
9131 /* Increment the virtual offset. */
9132 r_reloc try_loc
= values
->last_loc
;
9133 try_loc
.virtual_offset
+= 4;
9135 /* There is a last loc that was in the same output section. */
9136 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
9137 && move_shared_literal (sec
, link_info
, rel
,
9138 prop_table
, ptblsize
,
9139 &try_loc
, &val
, target_sec_cache
))
9141 values
->last_loc
.virtual_offset
+= 4;
9142 literal_placed
= true;
9144 val_map
= add_value_map (values
, &val
, &try_loc
,
9147 val_map
->loc
= try_loc
;
9152 if (!literal_placed
)
9154 /* Nothing worked, leave the literal alone but update the last loc. */
9155 values
->has_last_loc
= true;
9156 values
->last_loc
= rel
->r_rel
;
9158 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
9160 val_map
->loc
= rel
->r_rel
;
9161 *last_loc_is_prev_p
= true;
9168 /* Check if the original relocations (presumably on L32R instructions)
9169 identified by reloc[0..N] can be changed to reference the literal
9170 identified by r_rel. If r_rel is out of range for any of the
9171 original relocations, then we don't want to coalesce the original
9172 literal with the one at r_rel. We only check reloc[0..N], where the
9173 offsets are all the same as for reloc[0] (i.e., they're all
9174 referencing the same literal) and where N is also bounded by the
9175 number of remaining entries in the "reloc" array. The "reloc" array
9176 is sorted by target offset so we know all the entries for the same
9177 literal will be contiguous. */
9180 relocations_reach (source_reloc
*reloc
,
9181 int remaining_relocs
,
9182 const r_reloc
*r_rel
)
9184 bfd_vma from_offset
, source_address
, dest_address
;
9188 if (!r_reloc_is_defined (r_rel
))
9191 sec
= r_reloc_get_section (r_rel
);
9192 from_offset
= reloc
[0].r_rel
.target_offset
;
9194 for (i
= 0; i
< remaining_relocs
; i
++)
9196 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9199 /* Ignore relocations that have been removed. */
9200 if (reloc
[i
].is_null
)
9203 /* The original and new output section for these must be the same
9204 in order to coalesce. */
9205 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9206 != sec
->output_section
)
9209 /* Absolute literals in the same output section can always be
9211 if (reloc
[i
].is_abs_literal
)
9214 /* A literal with no PC-relative relocations can be moved anywhere. */
9215 if (reloc
[i
].opnd
!= -1)
9217 /* Otherwise, check to see that it fits. */
9218 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9219 + reloc
[i
].source_sec
->output_offset
9220 + reloc
[i
].r_rel
.rela
.r_offset
);
9221 dest_address
= (sec
->output_section
->vma
9222 + sec
->output_offset
9223 + r_rel
->target_offset
);
9225 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9226 source_address
, dest_address
))
9235 /* Move a literal to another literal location because it is
9236 the same as the other literal value. */
9239 coalesce_shared_literal (asection
*sec
,
9241 property_table_entry
*prop_table
,
9245 property_table_entry
*entry
;
9247 property_table_entry
*the_add_entry
;
9249 xtensa_relax_info
*relax_info
;
9251 relax_info
= get_xtensa_relax_info (sec
);
9255 entry
= elf_xtensa_find_property_entry
9256 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9257 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9260 /* Mark that the literal will be coalesced. */
9261 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9263 text_action_add (&relax_info
->action_list
,
9264 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9266 /* If the section is 4-byte aligned, do not add fill. */
9267 if (sec
->alignment_power
> 2)
9269 int fill_extra_space
;
9270 bfd_vma entry_sec_offset
;
9273 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9275 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9277 /* If the literal range is at the end of the section,
9279 fill_extra_space
= 0;
9280 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9282 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9283 fill_extra_space
= the_add_entry
->size
;
9285 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9286 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9287 -4, fill_extra_space
);
9289 adjust_fill_action (fa
, removed_diff
);
9291 text_action_add (&relax_info
->action_list
,
9292 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9299 /* Move a literal to another location. This may actually increase the
9300 total amount of space used because of alignments so we need to do
9301 this carefully. Also, it may make a branch go out of range. */
9304 move_shared_literal (asection
*sec
,
9305 struct bfd_link_info
*link_info
,
9307 property_table_entry
*prop_table
,
9309 const r_reloc
*target_loc
,
9310 const literal_value
*lit_value
,
9311 section_cache_t
*target_sec_cache
)
9313 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9314 text_action
*fa
, *target_fa
;
9316 xtensa_relax_info
*relax_info
, *target_relax_info
;
9317 asection
*target_sec
;
9319 ebb_constraint ebb_table
;
9322 /* If this routine always returns FALSE, the literals that cannot be
9323 coalesced will not be moved. */
9324 if (elf32xtensa_no_literal_movement
)
9327 relax_info
= get_xtensa_relax_info (sec
);
9331 target_sec
= r_reloc_get_section (target_loc
);
9332 target_relax_info
= get_xtensa_relax_info (target_sec
);
9334 /* Literals to undefined sections may not be moved because they
9335 must report an error. */
9336 if (bfd_is_und_section (target_sec
))
9339 src_entry
= elf_xtensa_find_property_entry
9340 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9342 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9345 target_entry
= elf_xtensa_find_property_entry
9346 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9347 target_sec
->vma
+ target_loc
->target_offset
);
9352 /* Make sure that we have not broken any branches. */
9355 init_ebb_constraint (&ebb_table
);
9356 ebb
= &ebb_table
.ebb
;
9357 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9358 target_sec_cache
->content_length
,
9359 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9360 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9362 /* Propose to add 4 bytes + worst-case alignment size increase to
9364 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9365 ta_fill
, target_loc
->target_offset
,
9366 -4 - (1 << target_sec
->alignment_power
), true);
9368 /* Check all of the PC-relative relocations to make sure they still fit. */
9369 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9370 target_sec_cache
->contents
,
9371 target_sec_cache
->relocs
, NULL
,
9377 text_action_add_literal (&target_relax_info
->action_list
,
9378 ta_add_literal
, target_loc
, lit_value
, -4);
9380 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9382 /* May need to add or remove some fill to maintain alignment. */
9383 int fill_extra_space
;
9384 bfd_vma entry_sec_offset
;
9387 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9389 /* If the literal range is at the end of the section,
9391 fill_extra_space
= 0;
9393 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9394 target_sec_cache
->pte_count
,
9396 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9397 fill_extra_space
= the_add_entry
->size
;
9399 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9400 target_sec
, entry_sec_offset
);
9401 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9402 entry_sec_offset
, 4,
9405 adjust_fill_action (target_fa
, removed_diff
);
9407 text_action_add (&target_relax_info
->action_list
,
9408 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9411 /* Mark that the literal will be moved to the new location. */
9412 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9414 /* Remove the literal. */
9415 text_action_add (&relax_info
->action_list
,
9416 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9418 /* If the section is 4-byte aligned, do not add fill. */
9419 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9421 int fill_extra_space
;
9422 bfd_vma entry_sec_offset
;
9425 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9427 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9429 /* If the literal range is at the end of the section,
9431 fill_extra_space
= 0;
9432 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9434 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9435 fill_extra_space
= the_add_entry
->size
;
9437 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9438 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9439 -4, fill_extra_space
);
9441 adjust_fill_action (fa
, removed_diff
);
9443 text_action_add (&relax_info
->action_list
,
9444 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9451 /* Second relaxation pass. */
9454 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9456 bfd_size_type
*final_size
= p
;
9457 text_action
*action
= (text_action
*)node
->value
;
9459 *final_size
-= action
->removed_bytes
;
9463 /* Modify all of the relocations to point to the right spot, and if this
9464 is a relaxable section, delete the unwanted literals and fix the
9468 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9470 Elf_Internal_Rela
*internal_relocs
;
9471 xtensa_relax_info
*relax_info
;
9476 bool virtual_action
;
9477 bfd_size_type sec_size
;
9479 sec_size
= bfd_get_section_limit (abfd
, sec
);
9480 relax_info
= get_xtensa_relax_info (sec
);
9481 BFD_ASSERT (relax_info
);
9483 /* First translate any of the fixes that have been added already. */
9484 translate_section_fixes (sec
);
9486 /* Handle property sections (e.g., literal tables) specially. */
9487 if (xtensa_is_property_section (sec
))
9489 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9490 return relax_property_section (abfd
, sec
, link_info
);
9493 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9494 link_info
->keep_memory
);
9495 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9498 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9499 if (contents
== NULL
&& sec_size
!= 0)
9505 if (internal_relocs
)
9507 for (i
= 0; i
< sec
->reloc_count
; i
++)
9509 Elf_Internal_Rela
*irel
;
9510 xtensa_relax_info
*target_relax_info
;
9511 bfd_vma source_offset
, old_source_offset
;
9514 asection
*target_sec
;
9516 /* Locally change the source address.
9517 Translate the target to the new target address.
9518 If it points to this section and has been removed,
9522 irel
= &internal_relocs
[i
];
9523 source_offset
= irel
->r_offset
;
9524 old_source_offset
= source_offset
;
9526 r_type
= ELF32_R_TYPE (irel
->r_info
);
9527 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9528 bfd_get_section_limit (abfd
, sec
));
9530 /* If this section could have changed then we may need to
9531 change the relocation's offset. */
9533 if (relax_info
->is_relaxable_literal_section
9534 || relax_info
->is_relaxable_asm_section
)
9536 pin_internal_relocs (sec
, internal_relocs
);
9538 if (r_type
!= R_XTENSA_NONE
9539 && find_removed_literal (&relax_info
->removed_list
,
9542 /* Remove this relocation. */
9543 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9544 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9545 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9546 irel
->r_offset
= offset_with_removed_text_map
9547 (&relax_info
->action_list
, irel
->r_offset
);
9551 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9553 text_action
*action
=
9554 find_insn_action (&relax_info
->action_list
,
9556 if (action
&& (action
->action
== ta_convert_longcall
9557 || action
->action
== ta_remove_longcall
))
9559 bfd_reloc_status_type retval
;
9560 char *error_message
= NULL
;
9562 retval
= contract_asm_expansion (contents
, sec_size
,
9563 irel
, &error_message
);
9564 if (retval
!= bfd_reloc_ok
)
9566 (*link_info
->callbacks
->reloc_dangerous
)
9567 (link_info
, error_message
, abfd
, sec
,
9571 /* Update the action so that the code that moves
9572 the contents will do the right thing. */
9573 /* ta_remove_longcall and ta_remove_insn actions are
9574 grouped together in the tree as well as
9575 ta_convert_longcall and ta_none, so that changes below
9576 can be done w/o removing and reinserting action into
9579 if (action
->action
== ta_remove_longcall
)
9580 action
->action
= ta_remove_insn
;
9582 action
->action
= ta_none
;
9583 /* Refresh the info in the r_rel. */
9584 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9585 r_type
= ELF32_R_TYPE (irel
->r_info
);
9589 source_offset
= offset_with_removed_text_map
9590 (&relax_info
->action_list
, irel
->r_offset
);
9591 irel
->r_offset
= source_offset
;
9594 /* If the target section could have changed then
9595 we may need to change the relocation's target offset. */
9597 target_sec
= r_reloc_get_section (&r_rel
);
9599 /* For a reference to a discarded section from a DWARF section,
9600 i.e., where action_discarded is PRETEND, the symbol will
9601 eventually be modified to refer to the kept section (at least if
9602 the kept and discarded sections are the same size). Anticipate
9603 that here and adjust things accordingly. */
9604 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9605 && elf_xtensa_action_discarded (sec
) == PRETEND
9606 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9607 && target_sec
!= NULL
9608 && discarded_section (target_sec
))
9610 /* It would be natural to call _bfd_elf_check_kept_section
9611 here, but it's not exported from elflink.c. It's also a
9612 fairly expensive check. Adjusting the relocations to the
9613 discarded section is fairly harmless; it will only adjust
9614 some addends and difference values. If it turns out that
9615 _bfd_elf_check_kept_section fails later, it won't matter,
9616 so just compare the section names to find the right group
9618 asection
*kept
= target_sec
->kept_section
;
9621 if ((kept
->flags
& SEC_GROUP
) != 0)
9623 asection
*first
= elf_next_in_group (kept
);
9624 asection
*s
= first
;
9629 if (strcmp (s
->name
, target_sec
->name
) == 0)
9634 s
= elf_next_in_group (s
);
9641 && ((target_sec
->rawsize
!= 0
9642 ? target_sec
->rawsize
: target_sec
->size
)
9643 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9647 target_relax_info
= get_xtensa_relax_info (target_sec
);
9648 if (target_relax_info
9649 && (target_relax_info
->is_relaxable_literal_section
9650 || target_relax_info
->is_relaxable_asm_section
))
9653 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9655 if (r_type
== R_XTENSA_DIFF8
9656 || r_type
== R_XTENSA_DIFF16
9657 || r_type
== R_XTENSA_DIFF32
9658 || r_type
== R_XTENSA_PDIFF8
9659 || r_type
== R_XTENSA_PDIFF16
9660 || r_type
== R_XTENSA_PDIFF32
9661 || r_type
== R_XTENSA_NDIFF8
9662 || r_type
== R_XTENSA_NDIFF16
9663 || r_type
== R_XTENSA_NDIFF32
)
9665 bfd_signed_vma diff_value
= 0;
9666 bfd_vma new_end_offset
, diff_mask
= 0;
9668 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9670 (*link_info
->callbacks
->reloc_dangerous
)
9671 (link_info
, _("invalid relocation address"),
9672 abfd
, sec
, old_source_offset
);
9678 case R_XTENSA_DIFF8
:
9681 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9683 case R_XTENSA_DIFF16
:
9686 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9688 case R_XTENSA_DIFF32
:
9689 diff_mask
= 0x7fffffff;
9691 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9693 case R_XTENSA_PDIFF8
:
9694 case R_XTENSA_NDIFF8
:
9697 bfd_get_8 (abfd
, &contents
[old_source_offset
]);
9699 case R_XTENSA_PDIFF16
:
9700 case R_XTENSA_NDIFF16
:
9703 bfd_get_16 (abfd
, &contents
[old_source_offset
]);
9705 case R_XTENSA_PDIFF32
:
9706 case R_XTENSA_NDIFF32
:
9707 diff_mask
= 0xffffffff;
9709 bfd_get_32 (abfd
, &contents
[old_source_offset
]);
9713 if (r_type
>= R_XTENSA_NDIFF8
9714 && r_type
<= R_XTENSA_NDIFF32
9716 diff_value
|= ~diff_mask
;
9718 new_end_offset
= offset_with_removed_text_map
9719 (&target_relax_info
->action_list
,
9720 r_rel
.target_offset
+ diff_value
);
9721 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9725 case R_XTENSA_DIFF8
:
9726 bfd_put_signed_8 (abfd
, diff_value
,
9727 &contents
[old_source_offset
]);
9729 case R_XTENSA_DIFF16
:
9730 bfd_put_signed_16 (abfd
, diff_value
,
9731 &contents
[old_source_offset
]);
9733 case R_XTENSA_DIFF32
:
9734 bfd_put_signed_32 (abfd
, diff_value
,
9735 &contents
[old_source_offset
]);
9737 case R_XTENSA_PDIFF8
:
9738 case R_XTENSA_NDIFF8
:
9739 bfd_put_8 (abfd
, diff_value
,
9740 &contents
[old_source_offset
]);
9742 case R_XTENSA_PDIFF16
:
9743 case R_XTENSA_NDIFF16
:
9744 bfd_put_16 (abfd
, diff_value
,
9745 &contents
[old_source_offset
]);
9747 case R_XTENSA_PDIFF32
:
9748 case R_XTENSA_NDIFF32
:
9749 bfd_put_32 (abfd
, diff_value
,
9750 &contents
[old_source_offset
]);
9754 /* Check for overflow. Sign bits must be all zeroes or
9755 all ones. When sign bits are all ones diff_value
9757 if (((diff_value
& ~diff_mask
) != 0
9758 && (diff_value
& ~diff_mask
) != ~diff_mask
)
9759 || (diff_value
&& (bfd_vma
) diff_value
== ~diff_mask
))
9761 (*link_info
->callbacks
->reloc_dangerous
)
9762 (link_info
, _("overflow after relaxation"),
9763 abfd
, sec
, old_source_offset
);
9767 pin_contents (sec
, contents
);
9770 /* If the relocation still references a section in the same
9771 input file, modify the relocation directly instead of
9772 adding a "fix" record. */
9773 if (target_sec
->owner
== abfd
)
9775 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9776 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9777 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9778 pin_internal_relocs (sec
, internal_relocs
);
9782 bfd_vma addend_displacement
;
9785 addend_displacement
=
9786 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9787 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9789 addend_displacement
, true);
9796 if ((relax_info
->is_relaxable_literal_section
9797 || relax_info
->is_relaxable_asm_section
)
9798 && action_list_count (&relax_info
->action_list
))
9800 /* Walk through the planned actions and build up a table
9801 of move, copy and fill records. Use the move, copy and
9802 fill records to perform the actions once. */
9804 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9805 bfd_byte
*scratch
= NULL
;
9806 bfd_byte
*dup_contents
= NULL
;
9807 bfd_size_type orig_size
= sec
->size
;
9808 bfd_vma orig_dot
= 0;
9809 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9810 orig dot in physical memory. */
9811 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9812 bfd_vma dup_dot
= 0;
9814 text_action
*action
;
9816 final_size
= sec
->size
;
9818 splay_tree_foreach (relax_info
->action_list
.tree
,
9819 action_remove_bytes_fn
, &final_size
);
9820 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9821 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9823 /* The dot is the current fill location. */
9825 print_action_list (stderr
, &relax_info
->action_list
);
9828 for (action
= action_first (&relax_info
->action_list
); action
;
9829 action
= action_next (&relax_info
->action_list
, action
))
9831 virtual_action
= false;
9832 if (action
->offset
> orig_dot
)
9834 orig_dot
+= orig_dot_copied
;
9835 orig_dot_copied
= 0;
9837 /* Out of the virtual world. */
9840 if (action
->offset
> orig_dot
)
9842 copy_size
= action
->offset
- orig_dot
;
9843 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9844 orig_dot
+= copy_size
;
9845 dup_dot
+= copy_size
;
9846 BFD_ASSERT (action
->offset
== orig_dot
);
9848 else if (action
->offset
< orig_dot
)
9850 if (action
->action
== ta_fill
9851 && action
->offset
- action
->removed_bytes
== orig_dot
)
9853 /* This is OK because the fill only effects the dup_dot. */
9855 else if (action
->action
== ta_add_literal
)
9857 /* TBD. Might need to handle this. */
9860 if (action
->offset
== orig_dot
)
9862 if (action
->virtual_offset
> orig_dot_vo
)
9864 if (orig_dot_vo
== 0)
9866 /* Need to copy virtual_offset bytes. Probably four. */
9867 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9868 memmove (&dup_contents
[dup_dot
],
9869 &contents
[orig_dot
], copy_size
);
9870 orig_dot_copied
= copy_size
;
9871 dup_dot
+= copy_size
;
9873 virtual_action
= true;
9876 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9878 switch (action
->action
)
9880 case ta_remove_literal
:
9881 case ta_remove_insn
:
9882 BFD_ASSERT (action
->removed_bytes
>= 0);
9883 orig_dot
+= action
->removed_bytes
;
9886 case ta_narrow_insn
:
9889 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9890 BFD_ASSERT (action
->removed_bytes
== 1);
9891 rv
= narrow_instruction (scratch
, final_size
, 0);
9893 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9894 orig_dot
+= orig_insn_size
;
9895 dup_dot
+= copy_size
;
9899 if (action
->removed_bytes
>= 0)
9900 orig_dot
+= action
->removed_bytes
;
9903 /* Already zeroed in dup_contents. Just bump the
9905 dup_dot
+= (-action
->removed_bytes
);
9910 BFD_ASSERT (action
->removed_bytes
== 0);
9913 case ta_convert_longcall
:
9914 case ta_remove_longcall
:
9915 /* These will be removed or converted before we get here. */
9922 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9923 BFD_ASSERT (action
->removed_bytes
== -1);
9924 rv
= widen_instruction (scratch
, final_size
, 0);
9926 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9927 orig_dot
+= orig_insn_size
;
9928 dup_dot
+= copy_size
;
9931 case ta_add_literal
:
9934 BFD_ASSERT (action
->removed_bytes
== -4);
9935 /* TBD -- place the literal value here and insert
9937 memset (&dup_contents
[dup_dot
], 0, 4);
9938 pin_internal_relocs (sec
, internal_relocs
);
9939 pin_contents (sec
, contents
);
9941 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9942 relax_info
, &internal_relocs
, &action
->value
))
9946 orig_dot_vo
+= copy_size
;
9948 orig_dot
+= orig_insn_size
;
9949 dup_dot
+= copy_size
;
9953 /* Not implemented yet. */
9958 BFD_ASSERT (dup_dot
<= final_size
);
9959 BFD_ASSERT (orig_dot
<= orig_size
);
9962 orig_dot
+= orig_dot_copied
;
9963 orig_dot_copied
= 0;
9965 if (orig_dot
!= orig_size
)
9967 copy_size
= orig_size
- orig_dot
;
9968 BFD_ASSERT (orig_size
> orig_dot
);
9969 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9970 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9971 orig_dot
+= copy_size
;
9972 dup_dot
+= copy_size
;
9974 BFD_ASSERT (orig_size
== orig_dot
);
9975 BFD_ASSERT (final_size
== dup_dot
);
9977 /* Move the dup_contents back. */
9978 if (final_size
> orig_size
)
9980 /* Contents need to be reallocated. Swap the dup_contents into
9982 sec
->contents
= dup_contents
;
9984 contents
= dup_contents
;
9985 pin_contents (sec
, contents
);
9989 BFD_ASSERT (final_size
<= orig_size
);
9990 memset (contents
, 0, orig_size
);
9991 memcpy (contents
, dup_contents
, final_size
);
9992 free (dup_contents
);
9995 pin_contents (sec
, contents
);
9997 if (sec
->rawsize
== 0)
9998 sec
->rawsize
= sec
->size
;
9999 sec
->size
= final_size
;
10003 release_internal_relocs (sec
, internal_relocs
);
10004 release_contents (sec
, contents
);
10010 translate_section_fixes (asection
*sec
)
10012 xtensa_relax_info
*relax_info
;
10015 relax_info
= get_xtensa_relax_info (sec
);
10019 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
10020 if (!translate_reloc_bfd_fix (r
))
10027 /* Translate a fix given the mapping in the relax info for the target
10028 section. If it has already been translated, no work is required. */
10031 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
10033 reloc_bfd_fix new_fix
;
10035 xtensa_relax_info
*relax_info
;
10036 removed_literal
*removed
;
10037 bfd_vma new_offset
, target_offset
;
10039 if (fix
->translated
)
10042 sec
= fix
->target_sec
;
10043 target_offset
= fix
->target_offset
;
10045 relax_info
= get_xtensa_relax_info (sec
);
10048 fix
->translated
= true;
10054 /* The fix does not need to be translated if the section cannot change. */
10055 if (!relax_info
->is_relaxable_literal_section
10056 && !relax_info
->is_relaxable_asm_section
)
10058 fix
->translated
= true;
10062 /* If the literal has been moved and this relocation was on an
10063 opcode, then the relocation should move to the new literal
10064 location. Otherwise, the relocation should move within the
10068 if (is_operand_relocation (fix
->src_type
))
10070 /* Check if the original relocation is against a literal being
10072 removed
= find_removed_literal (&relax_info
->removed_list
,
10080 /* The fact that there is still a relocation to this literal indicates
10081 that the literal is being coalesced, not simply removed. */
10082 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10084 /* This was moved to some other address (possibly another section). */
10085 new_sec
= r_reloc_get_section (&removed
->to
);
10086 if (new_sec
!= sec
)
10089 relax_info
= get_xtensa_relax_info (sec
);
10091 (!relax_info
->is_relaxable_literal_section
10092 && !relax_info
->is_relaxable_asm_section
))
10094 target_offset
= removed
->to
.target_offset
;
10095 new_fix
.target_sec
= new_sec
;
10096 new_fix
.target_offset
= target_offset
;
10097 new_fix
.translated
= true;
10102 target_offset
= removed
->to
.target_offset
;
10103 new_fix
.target_sec
= new_sec
;
10106 /* The target address may have been moved within its section. */
10107 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
10110 new_fix
.target_offset
= new_offset
;
10111 new_fix
.target_offset
= new_offset
;
10112 new_fix
.translated
= true;
10118 /* Fix up a relocation to take account of removed literals. */
10121 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
10123 xtensa_relax_info
*relax_info
;
10124 removed_literal
*removed
;
10125 bfd_vma target_offset
, base_offset
;
10127 *new_rel
= *orig_rel
;
10129 if (!r_reloc_is_defined (orig_rel
))
10132 relax_info
= get_xtensa_relax_info (sec
);
10133 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
10134 || relax_info
->is_relaxable_asm_section
));
10136 target_offset
= orig_rel
->target_offset
;
10139 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
10141 /* Check if the original relocation is against a literal being
10143 removed
= find_removed_literal (&relax_info
->removed_list
,
10146 if (removed
&& removed
->to
.abfd
)
10150 /* The fact that there is still a relocation to this literal indicates
10151 that the literal is being coalesced, not simply removed. */
10152 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10154 /* This was moved to some other address
10155 (possibly in another section). */
10156 *new_rel
= removed
->to
;
10157 new_sec
= r_reloc_get_section (new_rel
);
10158 if (new_sec
!= sec
)
10161 relax_info
= get_xtensa_relax_info (sec
);
10163 || (!relax_info
->is_relaxable_literal_section
10164 && !relax_info
->is_relaxable_asm_section
))
10167 target_offset
= new_rel
->target_offset
;
10170 /* Find the base offset of the reloc symbol, excluding any addend from the
10171 reloc or from the section contents (for a partial_inplace reloc). Then
10172 find the adjusted values of the offsets due to relaxation. The base
10173 offset is needed to determine the change to the reloc's addend; the reloc
10174 addend should not be adjusted due to relaxations located before the base
10177 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
10178 if (base_offset
<= target_offset
)
10180 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
10181 base_offset
, false);
10182 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10183 target_offset
, false) -
10186 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
10187 new_rel
->rela
.r_addend
-= addend_removed
;
10191 /* Handle a negative addend. The base offset comes first. */
10192 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
10193 target_offset
, false);
10194 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10195 base_offset
, false) -
10198 new_rel
->target_offset
= target_offset
- tgt_removed
;
10199 new_rel
->rela
.r_addend
+= addend_removed
;
10206 /* For dynamic links, there may be a dynamic relocation for each
10207 literal. The number of dynamic relocations must be computed in
10208 size_dynamic_sections, which occurs before relaxation. When a
10209 literal is removed, this function checks if there is a corresponding
10210 dynamic relocation and shrinks the size of the appropriate dynamic
10211 relocation section accordingly. At this point, the contents of the
10212 dynamic relocation sections have not yet been filled in, so there's
10213 nothing else that needs to be done. */
10216 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
10218 asection
*input_section
,
10219 Elf_Internal_Rela
*rel
)
10221 struct elf_xtensa_link_hash_table
*htab
;
10222 Elf_Internal_Shdr
*symtab_hdr
;
10223 struct elf_link_hash_entry
**sym_hashes
;
10224 unsigned long r_symndx
;
10226 struct elf_link_hash_entry
*h
;
10227 bool dynamic_symbol
;
10229 htab
= elf_xtensa_hash_table (info
);
10233 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10234 sym_hashes
= elf_sym_hashes (abfd
);
10236 r_type
= ELF32_R_TYPE (rel
->r_info
);
10237 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10239 if (r_symndx
< symtab_hdr
->sh_info
)
10242 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10244 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10246 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10247 && (input_section
->flags
& SEC_ALLOC
) != 0
10249 || (bfd_link_pic (info
)
10250 && (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
))))
10253 bool is_plt
= false;
10255 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10257 srel
= htab
->elf
.srelplt
;
10261 srel
= htab
->elf
.srelgot
;
10263 /* Reduce size of the .rela.* section by one reloc. */
10264 BFD_ASSERT (srel
!= NULL
);
10265 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10266 srel
->size
-= sizeof (Elf32_External_Rela
);
10270 asection
*splt
, *sgotplt
, *srelgot
;
10271 int reloc_index
, chunk
;
10273 /* Find the PLT reloc index of the entry being removed. This
10274 is computed from the size of ".rela.plt". It is needed to
10275 figure out which PLT chunk to resize. Usually "last index
10276 = size - 1" since the index starts at zero, but in this
10277 context, the size has just been decremented so there's no
10278 need to subtract one. */
10279 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10281 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10282 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10283 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10284 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10286 /* Check if an entire PLT chunk has just been eliminated. */
10287 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10289 /* The two magic GOT entries for that chunk can go away. */
10290 srelgot
= htab
->elf
.srelgot
;
10291 BFD_ASSERT (srelgot
!= NULL
);
10292 srelgot
->reloc_count
-= 2;
10293 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10294 sgotplt
->size
-= 8;
10296 /* There should be only one entry left (and it will be
10298 BFD_ASSERT (sgotplt
->size
== 4);
10299 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10302 BFD_ASSERT (sgotplt
->size
>= 4);
10303 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10305 sgotplt
->size
-= 4;
10306 splt
->size
-= PLT_ENTRY_SIZE
;
10312 /* Take an r_rel and move it to another section. This usually
10313 requires extending the interal_relocation array and pinning it. If
10314 the original r_rel is from the same BFD, we can complete this here.
10315 Otherwise, we add a fix record to let the final link fix the
10316 appropriate address. Contents and internal relocations for the
10317 section must be pinned after calling this routine. */
10320 move_literal (bfd
*abfd
,
10321 struct bfd_link_info
*link_info
,
10324 bfd_byte
*contents
,
10325 xtensa_relax_info
*relax_info
,
10326 Elf_Internal_Rela
**internal_relocs_p
,
10327 const literal_value
*lit
)
10329 Elf_Internal_Rela
*new_relocs
= NULL
;
10330 size_t new_relocs_count
= 0;
10331 Elf_Internal_Rela this_rela
;
10332 const r_reloc
*r_rel
;
10334 r_rel
= &lit
->r_rel
;
10335 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10337 if (r_reloc_is_const (r_rel
))
10338 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10343 reloc_bfd_fix
*fix
;
10344 unsigned insert_at
;
10346 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10348 /* This is the difficult case. We have to create a fix up. */
10349 this_rela
.r_offset
= offset
;
10350 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10351 this_rela
.r_addend
=
10352 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10353 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10355 /* Currently, we cannot move relocations during a relocatable link. */
10356 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10357 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10358 r_reloc_get_section (r_rel
),
10359 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10361 /* We also need to mark that relocations are needed here. */
10362 sec
->flags
|= SEC_RELOC
;
10364 translate_reloc_bfd_fix (fix
);
10365 /* This fix has not yet been translated. */
10366 add_fix (sec
, fix
);
10368 /* Add the relocation. If we have already allocated our own
10369 space for the relocations and we have room for more, then use
10370 it. Otherwise, allocate new space and move the literals. */
10371 insert_at
= sec
->reloc_count
;
10372 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10374 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10381 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10382 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10384 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10385 || sec
->reloc_count
== relax_info
->relocs_count
);
10387 if (relax_info
->allocated_relocs_count
== 0)
10388 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10390 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10392 new_relocs
= (Elf_Internal_Rela
*)
10393 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10397 /* We could handle this more quickly by finding the split point. */
10398 if (insert_at
!= 0)
10399 memcpy (new_relocs
, *internal_relocs_p
,
10400 insert_at
* sizeof (Elf_Internal_Rela
));
10402 new_relocs
[insert_at
] = this_rela
;
10404 if (insert_at
!= sec
->reloc_count
)
10405 memcpy (new_relocs
+ insert_at
+ 1,
10406 (*internal_relocs_p
) + insert_at
,
10407 (sec
->reloc_count
- insert_at
)
10408 * sizeof (Elf_Internal_Rela
));
10410 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10412 /* The first time we re-allocate, we can only free the
10413 old relocs if they were allocated with bfd_malloc.
10414 This is not true when keep_memory is in effect. */
10415 if (!link_info
->keep_memory
)
10416 free (*internal_relocs_p
);
10419 free (*internal_relocs_p
);
10420 relax_info
->allocated_relocs
= new_relocs
;
10421 relax_info
->allocated_relocs_count
= new_relocs_count
;
10422 elf_section_data (sec
)->relocs
= new_relocs
;
10423 sec
->reloc_count
++;
10424 relax_info
->relocs_count
= sec
->reloc_count
;
10425 *internal_relocs_p
= new_relocs
;
10429 if (insert_at
!= sec
->reloc_count
)
10432 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10433 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10435 (*internal_relocs_p
)[insert_at
] = this_rela
;
10436 sec
->reloc_count
++;
10437 if (relax_info
->allocated_relocs
)
10438 relax_info
->relocs_count
= sec
->reloc_count
;
10445 /* This is similar to relax_section except that when a target is moved,
10446 we shift addresses up. We also need to modify the size. This
10447 algorithm does NOT allow for relocations into the middle of the
10448 property sections. */
10451 relax_property_section (bfd
*abfd
,
10453 struct bfd_link_info
*link_info
)
10455 Elf_Internal_Rela
*internal_relocs
;
10456 bfd_byte
*contents
;
10459 bool is_full_prop_section
;
10460 size_t last_zfill_target_offset
= 0;
10461 asection
*last_zfill_target_sec
= NULL
;
10462 bfd_size_type sec_size
;
10463 bfd_size_type entry_size
;
10465 sec_size
= bfd_get_section_limit (abfd
, sec
);
10466 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10467 link_info
->keep_memory
);
10468 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10469 if (contents
== NULL
&& sec_size
!= 0)
10475 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10476 if (is_full_prop_section
)
10481 if (internal_relocs
)
10483 for (i
= 0; i
< sec
->reloc_count
; i
++)
10485 Elf_Internal_Rela
*irel
;
10486 xtensa_relax_info
*target_relax_info
;
10488 asection
*target_sec
;
10490 bfd_byte
*size_p
, *flags_p
;
10492 /* Locally change the source address.
10493 Translate the target to the new target address.
10494 If it points to this section and has been removed, MOVE IT.
10495 Also, don't forget to modify the associated SIZE at
10498 irel
= &internal_relocs
[i
];
10499 r_type
= ELF32_R_TYPE (irel
->r_info
);
10500 if (r_type
== R_XTENSA_NONE
)
10503 /* Find the literal value. */
10504 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10505 size_p
= &contents
[irel
->r_offset
+ 4];
10507 if (is_full_prop_section
)
10508 flags_p
= &contents
[irel
->r_offset
+ 8];
10509 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10511 target_sec
= r_reloc_get_section (&val
.r_rel
);
10512 target_relax_info
= get_xtensa_relax_info (target_sec
);
10514 if (target_relax_info
10515 && (target_relax_info
->is_relaxable_literal_section
10516 || target_relax_info
->is_relaxable_asm_section
))
10518 /* Translate the relocation's destination. */
10519 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10520 bfd_vma new_offset
;
10521 long old_size
, new_size
;
10522 int removed_by_old_offset
=
10523 removed_by_actions_map (&target_relax_info
->action_list
,
10524 old_offset
, false);
10525 new_offset
= old_offset
- removed_by_old_offset
;
10527 /* Assert that we are not out of bounds. */
10528 old_size
= bfd_get_32 (abfd
, size_p
);
10529 new_size
= old_size
;
10533 /* Only the first zero-sized unreachable entry is
10534 allowed to expand. In this case the new offset
10535 should be the offset before the fill and the new
10536 size is the expansion size. For other zero-sized
10537 entries the resulting size should be zero with an
10538 offset before or after the fill address depending
10539 on whether the expanding unreachable entry
10541 if (last_zfill_target_sec
== 0
10542 || last_zfill_target_sec
!= target_sec
10543 || last_zfill_target_offset
!= old_offset
)
10545 bfd_vma new_end_offset
= new_offset
;
10547 /* Recompute the new_offset, but this time don't
10548 include any fill inserted by relaxation. */
10549 removed_by_old_offset
=
10550 removed_by_actions_map (&target_relax_info
->action_list
,
10552 new_offset
= old_offset
- removed_by_old_offset
;
10554 /* If it is not unreachable and we have not yet
10555 seen an unreachable at this address, place it
10556 before the fill address. */
10557 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10558 & XTENSA_PROP_UNREACHABLE
) != 0)
10560 new_size
= new_end_offset
- new_offset
;
10562 last_zfill_target_sec
= target_sec
;
10563 last_zfill_target_offset
= old_offset
;
10569 int removed_by_old_offset_size
=
10570 removed_by_actions_map (&target_relax_info
->action_list
,
10571 old_offset
+ old_size
, true);
10572 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10575 if (new_size
!= old_size
)
10577 bfd_put_32 (abfd
, new_size
, size_p
);
10578 pin_contents (sec
, contents
);
10581 if (new_offset
!= old_offset
)
10583 bfd_vma diff
= new_offset
- old_offset
;
10584 irel
->r_addend
+= diff
;
10585 pin_internal_relocs (sec
, internal_relocs
);
10591 /* Combine adjacent property table entries. This is also done in
10592 finish_dynamic_sections() but at that point it's too late to
10593 reclaim the space in the output section, so we do this twice. */
10595 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10596 || xtensa_is_littable_section (sec
)))
10598 Elf_Internal_Rela
*last_irel
= NULL
;
10599 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10600 int removed_bytes
= 0;
10602 flagword predef_flags
;
10604 predef_flags
= xtensa_get_property_predef_flags (sec
);
10606 /* Walk over memory and relocations at the same time.
10607 This REQUIRES that the internal_relocs be sorted by offset. */
10608 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10609 internal_reloc_compare
);
10611 pin_internal_relocs (sec
, internal_relocs
);
10612 pin_contents (sec
, contents
);
10614 next_rel
= internal_relocs
;
10615 rel_end
= internal_relocs
+ sec
->reloc_count
;
10617 BFD_ASSERT (sec
->size
% entry_size
== 0);
10619 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10621 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10622 bfd_vma bytes_to_remove
, size
, actual_offset
;
10623 bool remove_this_rel
;
10626 /* Find the first relocation for the entry at the current offset.
10627 Adjust the offsets of any extra relocations for the previous
10632 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10634 if ((irel
->r_offset
== offset
10635 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10636 || irel
->r_offset
> offset
)
10641 irel
->r_offset
-= removed_bytes
;
10645 /* Find the next relocation (if there are any left). */
10649 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10651 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10659 /* Check if there are relocations on the current entry. There
10660 should usually be a relocation on the offset field. If there
10661 are relocations on the size or flags, then we can't optimize
10662 this entry. Also, find the next relocation to examine on the
10666 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10668 next_rel
= offset_rel
;
10669 /* There are no relocations on the current entry, but we
10670 might still be able to remove it if the size is zero. */
10673 else if (offset_rel
->r_offset
> offset
10675 && extra_rel
->r_offset
< offset
+ entry_size
))
10677 /* There is a relocation on the size or flags, so we can't
10678 do anything with this entry. Continue with the next. */
10679 next_rel
= offset_rel
;
10684 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10685 offset_rel
->r_offset
-= removed_bytes
;
10686 next_rel
= offset_rel
+ 1;
10692 remove_this_rel
= false;
10693 bytes_to_remove
= 0;
10694 actual_offset
= offset
- removed_bytes
;
10695 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10697 if (is_full_prop_section
)
10698 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10700 flags
= predef_flags
;
10703 && (flags
& XTENSA_PROP_ALIGN
) == 0
10704 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10706 /* Always remove entries with zero size and no alignment. */
10707 bytes_to_remove
= entry_size
;
10709 remove_this_rel
= true;
10711 else if (offset_rel
10712 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10716 flagword old_flags
;
10718 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10719 bfd_vma old_address
=
10720 (last_irel
->r_addend
10721 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10722 bfd_vma new_address
=
10723 (offset_rel
->r_addend
10724 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10725 if (is_full_prop_section
)
10726 old_flags
= bfd_get_32
10727 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10729 old_flags
= predef_flags
;
10731 if ((ELF32_R_SYM (offset_rel
->r_info
)
10732 == ELF32_R_SYM (last_irel
->r_info
))
10733 && old_address
+ old_size
== new_address
10734 && old_flags
== flags
10735 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10736 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10738 /* Fix the old size. */
10739 bfd_put_32 (abfd
, old_size
+ size
,
10740 &contents
[last_irel
->r_offset
+ 4]);
10741 bytes_to_remove
= entry_size
;
10742 remove_this_rel
= true;
10745 last_irel
= offset_rel
;
10748 last_irel
= offset_rel
;
10751 if (remove_this_rel
)
10753 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10754 offset_rel
->r_offset
= 0;
10757 if (bytes_to_remove
!= 0)
10759 removed_bytes
+= bytes_to_remove
;
10760 if (offset
+ bytes_to_remove
< sec
->size
)
10761 memmove (&contents
[actual_offset
],
10762 &contents
[actual_offset
+ bytes_to_remove
],
10763 sec
->size
- offset
- bytes_to_remove
);
10769 /* Fix up any extra relocations on the last entry. */
10770 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10771 irel
->r_offset
-= removed_bytes
;
10773 /* Clear the removed bytes. */
10774 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10776 if (sec
->rawsize
== 0)
10777 sec
->rawsize
= sec
->size
;
10778 sec
->size
-= removed_bytes
;
10780 if (xtensa_is_littable_section (sec
))
10782 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10784 sgotloc
->size
-= removed_bytes
;
10790 release_internal_relocs (sec
, internal_relocs
);
10791 release_contents (sec
, contents
);
10796 /* Third relaxation pass. */
10798 /* Change symbol values to account for removed literals. */
10801 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10803 xtensa_relax_info
*relax_info
;
10804 unsigned int sec_shndx
;
10805 Elf_Internal_Shdr
*symtab_hdr
;
10806 Elf_Internal_Sym
*isymbuf
;
10807 unsigned i
, num_syms
, num_locals
;
10809 relax_info
= get_xtensa_relax_info (sec
);
10810 BFD_ASSERT (relax_info
);
10812 if (!relax_info
->is_relaxable_literal_section
10813 && !relax_info
->is_relaxable_asm_section
)
10816 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10818 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10819 isymbuf
= retrieve_local_syms (abfd
);
10821 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10822 num_locals
= symtab_hdr
->sh_info
;
10824 /* Adjust the local symbols defined in this section. */
10825 for (i
= 0; i
< num_locals
; i
++)
10827 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10829 if (isym
->st_shndx
== sec_shndx
)
10831 bfd_vma orig_addr
= isym
->st_value
;
10832 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10835 isym
->st_value
-= removed
;
10836 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10838 removed_by_actions_map (&relax_info
->action_list
,
10839 orig_addr
+ isym
->st_size
, false) -
10844 /* Now adjust the global symbols defined in this section. */
10845 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10847 struct elf_link_hash_entry
*sym_hash
;
10849 sym_hash
= elf_sym_hashes (abfd
)[i
];
10851 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10852 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10854 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10855 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10856 && sym_hash
->root
.u
.def
.section
== sec
)
10858 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10859 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10862 sym_hash
->root
.u
.def
.value
-= removed
;
10864 if (sym_hash
->type
== STT_FUNC
)
10866 removed_by_actions_map (&relax_info
->action_list
,
10867 orig_addr
+ sym_hash
->size
, false) -
10876 /* "Fix" handling functions, called while performing relocations. */
10879 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10881 asection
*input_section
,
10882 bfd_byte
*contents
)
10885 asection
*sec
, *old_sec
;
10886 bfd_vma old_offset
;
10887 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10888 reloc_bfd_fix
*fix
;
10890 if (r_type
== R_XTENSA_NONE
)
10893 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10897 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10898 bfd_get_section_limit (input_bfd
, input_section
));
10899 old_sec
= r_reloc_get_section (&r_rel
);
10900 old_offset
= r_rel
.target_offset
;
10902 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10904 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10907 /* xgettext:c-format */
10908 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10909 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10910 elf_howto_table
[r_type
].name
);
10913 /* Leave it be. Resolution will happen in a later stage. */
10917 sec
= fix
->target_sec
;
10918 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10919 - (old_sec
->output_offset
+ old_offset
));
10926 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10928 asection
*input_section
,
10929 bfd_byte
*contents
,
10930 bfd_vma
*relocationp
)
10933 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10934 reloc_bfd_fix
*fix
;
10935 bfd_vma fixup_diff
;
10937 if (r_type
== R_XTENSA_NONE
)
10940 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10944 sec
= fix
->target_sec
;
10946 fixup_diff
= rel
->r_addend
;
10947 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10949 bfd_vma inplace_val
;
10950 BFD_ASSERT (fix
->src_offset
10951 < bfd_get_section_limit (input_bfd
, input_section
));
10952 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10953 fixup_diff
+= inplace_val
;
10956 *relocationp
= (sec
->output_section
->vma
10957 + sec
->output_offset
10958 + fix
->target_offset
- fixup_diff
);
10962 /* Miscellaneous utility functions.... */
10965 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10971 return elf_hash_table (info
)->splt
;
10973 dynobj
= elf_hash_table (info
)->dynobj
;
10974 sprintf (plt_name
, ".plt.%u", chunk
);
10975 return bfd_get_linker_section (dynobj
, plt_name
);
10980 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10986 return elf_hash_table (info
)->sgotplt
;
10988 dynobj
= elf_hash_table (info
)->dynobj
;
10989 sprintf (got_name
, ".got.plt.%u", chunk
);
10990 return bfd_get_linker_section (dynobj
, got_name
);
10994 /* Get the input section for a given symbol index.
10996 . a section symbol, return the section;
10997 . a common symbol, return the common section;
10998 . an undefined symbol, return the undefined section;
10999 . an indirect symbol, follow the links;
11000 . an absolute value, return the absolute section. */
11003 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
11005 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11006 asection
*target_sec
= NULL
;
11007 if (r_symndx
< symtab_hdr
->sh_info
)
11009 Elf_Internal_Sym
*isymbuf
;
11010 unsigned int section_index
;
11012 isymbuf
= retrieve_local_syms (abfd
);
11013 section_index
= isymbuf
[r_symndx
].st_shndx
;
11015 if (section_index
== SHN_UNDEF
)
11016 target_sec
= bfd_und_section_ptr
;
11017 else if (section_index
== SHN_ABS
)
11018 target_sec
= bfd_abs_section_ptr
;
11019 else if (section_index
== SHN_COMMON
)
11020 target_sec
= bfd_com_section_ptr
;
11022 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
11026 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11027 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
11029 while (h
->root
.type
== bfd_link_hash_indirect
11030 || h
->root
.type
== bfd_link_hash_warning
)
11031 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11033 switch (h
->root
.type
)
11035 case bfd_link_hash_defined
:
11036 case bfd_link_hash_defweak
:
11037 target_sec
= h
->root
.u
.def
.section
;
11039 case bfd_link_hash_common
:
11040 target_sec
= bfd_com_section_ptr
;
11042 case bfd_link_hash_undefined
:
11043 case bfd_link_hash_undefweak
:
11044 target_sec
= bfd_und_section_ptr
;
11046 default: /* New indirect warning. */
11047 target_sec
= bfd_und_section_ptr
;
11055 static struct elf_link_hash_entry
*
11056 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
11058 unsigned long indx
;
11059 struct elf_link_hash_entry
*h
;
11060 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11062 if (r_symndx
< symtab_hdr
->sh_info
)
11065 indx
= r_symndx
- symtab_hdr
->sh_info
;
11066 h
= elf_sym_hashes (abfd
)[indx
];
11067 while (h
->root
.type
== bfd_link_hash_indirect
11068 || h
->root
.type
== bfd_link_hash_warning
)
11069 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11074 /* Get the section-relative offset for a symbol number. */
11077 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
11079 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11080 bfd_vma offset
= 0;
11082 if (r_symndx
< symtab_hdr
->sh_info
)
11084 Elf_Internal_Sym
*isymbuf
;
11085 isymbuf
= retrieve_local_syms (abfd
);
11086 offset
= isymbuf
[r_symndx
].st_value
;
11090 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11091 struct elf_link_hash_entry
*h
=
11092 elf_sym_hashes (abfd
)[indx
];
11094 while (h
->root
.type
== bfd_link_hash_indirect
11095 || h
->root
.type
== bfd_link_hash_warning
)
11096 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11097 if (h
->root
.type
== bfd_link_hash_defined
11098 || h
->root
.type
== bfd_link_hash_defweak
)
11099 offset
= h
->root
.u
.def
.value
;
11106 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
11108 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
11109 struct elf_link_hash_entry
*h
;
11111 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
11112 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
11119 pcrel_reloc_fits (xtensa_opcode opc
,
11121 bfd_vma self_address
,
11122 bfd_vma dest_address
)
11124 xtensa_isa isa
= xtensa_default_isa
;
11125 uint32 valp
= dest_address
;
11126 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
11127 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
11134 xtensa_is_property_section (asection
*sec
)
11136 if (xtensa_is_insntable_section (sec
)
11137 || xtensa_is_littable_section (sec
)
11138 || xtensa_is_proptable_section (sec
))
11146 xtensa_is_insntable_section (asection
*sec
)
11148 if (startswith (sec
->name
, XTENSA_INSN_SEC_NAME
)
11149 || startswith (sec
->name
, ".gnu.linkonce.x."))
11157 xtensa_is_littable_section (asection
*sec
)
11159 if (startswith (sec
->name
, XTENSA_LIT_SEC_NAME
)
11160 || startswith (sec
->name
, ".gnu.linkonce.p."))
11168 xtensa_is_proptable_section (asection
*sec
)
11170 if (startswith (sec
->name
, XTENSA_PROP_SEC_NAME
)
11171 || startswith (sec
->name
, ".gnu.linkonce.prop."))
11179 internal_reloc_compare (const void *ap
, const void *bp
)
11181 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11182 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11184 if (a
->r_offset
!= b
->r_offset
)
11185 return (a
->r_offset
- b
->r_offset
);
11187 /* We don't need to sort on these criteria for correctness,
11188 but enforcing a more strict ordering prevents unstable qsort
11189 from behaving differently with different implementations.
11190 Without the code below we get correct but different results
11191 on Solaris 2.7 and 2.8. We would like to always produce the
11192 same results no matter the host. */
11194 if (a
->r_info
!= b
->r_info
)
11195 return (a
->r_info
- b
->r_info
);
11197 return (a
->r_addend
- b
->r_addend
);
11202 internal_reloc_matches (const void *ap
, const void *bp
)
11204 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11205 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11207 /* Check if one entry overlaps with the other; this shouldn't happen
11208 except when searching for a match. */
11209 return (a
->r_offset
- b
->r_offset
);
11213 /* Predicate function used to look up a section in a particular group. */
11216 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
11218 const char *gname
= inf
;
11219 const char *group_name
= elf_group_name (sec
);
11221 return (group_name
== gname
11222 || (group_name
!= NULL
11224 && strcmp (group_name
, gname
) == 0));
11229 xtensa_add_names (const char *base
, const char *suffix
)
11233 size_t base_len
= strlen (base
);
11234 size_t suffix_len
= strlen (suffix
);
11235 char *str
= bfd_malloc (base_len
+ suffix_len
+ 1);
11237 memcpy (str
, base
, base_len
);
11238 memcpy (str
+ base_len
, suffix
, suffix_len
+ 1);
11243 return strdup (base
);
11247 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11250 xtensa_property_section_name (asection
*sec
, const char *base_name
,
11251 bool separate_sections
)
11253 const char *suffix
, *group_name
;
11254 char *prop_sec_name
;
11256 group_name
= elf_group_name (sec
);
11259 suffix
= strrchr (sec
->name
, '.');
11260 if (suffix
== sec
->name
)
11262 prop_sec_name
= xtensa_add_names (base_name
, suffix
);
11264 else if (startswith (sec
->name
, ".gnu.linkonce."))
11266 char *linkonce_kind
= 0;
11268 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11269 linkonce_kind
= "x.";
11270 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11271 linkonce_kind
= "p.";
11272 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11273 linkonce_kind
= "prop.";
11277 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11278 + strlen (linkonce_kind
) + 1);
11279 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11280 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11282 suffix
= sec
->name
+ linkonce_len
;
11283 /* For backward compatibility, replace "t." instead of inserting
11284 the new linkonce_kind (but not for "prop" sections). */
11285 if (startswith (suffix
, "t.") && linkonce_kind
[1] == '.')
11287 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11291 prop_sec_name
= xtensa_add_names (base_name
,
11292 separate_sections
? sec
->name
: NULL
);
11295 return prop_sec_name
;
11300 xtensa_get_separate_property_section (asection
*sec
, const char *base_name
,
11301 bool separate_section
)
11303 char *prop_sec_name
;
11304 asection
*prop_sec
;
11306 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11308 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11309 match_section_group
,
11310 (void *) elf_group_name (sec
));
11311 free (prop_sec_name
);
11316 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11318 asection
*prop_sec
;
11320 /* Try individual property section first. */
11321 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, true);
11323 /* Refer to a common property section if individual is not present. */
11325 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, false);
11332 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11334 char *prop_sec_name
;
11335 asection
*prop_sec
;
11337 /* Check if the section already exists. */
11338 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11339 elf32xtensa_separate_props
);
11340 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11341 match_section_group
,
11342 (void *) elf_group_name (sec
));
11343 /* If not, create it. */
11346 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11347 flags
|= (bfd_section_flags (sec
)
11348 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11350 prop_sec
= bfd_make_section_anyway_with_flags
11351 (sec
->owner
, strdup (prop_sec_name
), flags
);
11355 elf_group_name (prop_sec
) = elf_group_name (sec
);
11358 free (prop_sec_name
);
11364 xtensa_get_property_predef_flags (asection
*sec
)
11366 if (xtensa_is_insntable_section (sec
))
11367 return (XTENSA_PROP_INSN
11368 | XTENSA_PROP_NO_TRANSFORM
11369 | XTENSA_PROP_INSN_NO_REORDER
);
11371 if (xtensa_is_littable_section (sec
))
11372 return (XTENSA_PROP_LITERAL
11373 | XTENSA_PROP_NO_TRANSFORM
11374 | XTENSA_PROP_INSN_NO_REORDER
);
11380 /* Other functions called directly by the linker. */
11383 xtensa_callback_required_dependence (bfd
*abfd
,
11385 struct bfd_link_info
*link_info
,
11386 deps_callback_t callback
,
11389 Elf_Internal_Rela
*internal_relocs
;
11390 bfd_byte
*contents
;
11393 bfd_size_type sec_size
;
11395 sec_size
= bfd_get_section_limit (abfd
, sec
);
11397 /* ".plt*" sections have no explicit relocations but they contain L32R
11398 instructions that reference the corresponding ".got.plt*" sections. */
11399 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11400 && startswith (sec
->name
, ".plt"))
11404 /* Find the corresponding ".got.plt*" section. */
11405 if (sec
->name
[4] == '\0')
11406 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11412 BFD_ASSERT (sec
->name
[4] == '.');
11413 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11415 sprintf (got_name
, ".got.plt.%u", chunk
);
11416 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11418 BFD_ASSERT (sgotplt
);
11420 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11421 section referencing a literal at the very beginning of
11422 ".got.plt". This is very close to the real dependence, anyway. */
11423 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11426 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11427 when building uclibc, which runs "ld -b binary /dev/null". */
11428 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11431 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11432 link_info
->keep_memory
);
11433 if (internal_relocs
== NULL
11434 || sec
->reloc_count
== 0)
11437 /* Cache the contents for the duration of this scan. */
11438 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11439 if (contents
== NULL
&& sec_size
!= 0)
11445 if (!xtensa_default_isa
)
11446 xtensa_default_isa
= xtensa_isa_init (0, 0);
11448 for (i
= 0; i
< sec
->reloc_count
; i
++)
11450 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11451 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11454 asection
*target_sec
;
11455 bfd_vma target_offset
;
11457 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11460 /* L32Rs must be local to the input file. */
11461 if (r_reloc_is_defined (&l32r_rel
))
11463 target_sec
= r_reloc_get_section (&l32r_rel
);
11464 target_offset
= l32r_rel
.target_offset
;
11466 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11472 release_internal_relocs (sec
, internal_relocs
);
11473 release_contents (sec
, contents
);
11477 /* The default literal sections should always be marked as "code" (i.e.,
11478 SHF_EXECINSTR). This is particularly important for the Linux kernel
11479 module loader so that the literals are not placed after the text. */
11480 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11482 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11483 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11484 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11485 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11486 { NULL
, 0, 0, 0, 0 }
11489 #define ELF_TARGET_ID XTENSA_ELF_DATA
11491 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11492 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11493 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11494 #define TARGET_BIG_NAME "elf32-xtensa-be"
11495 #define ELF_ARCH bfd_arch_xtensa
11497 #define ELF_MACHINE_CODE EM_XTENSA
11498 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11500 #define ELF_MAXPAGESIZE 0x1000
11501 #endif /* ELF_ARCH */
11503 #define elf_backend_can_gc_sections 1
11504 #define elf_backend_can_refcount 1
11505 #define elf_backend_plt_readonly 1
11506 #define elf_backend_got_header_size 4
11507 #define elf_backend_want_dynbss 0
11508 #define elf_backend_want_got_plt 1
11509 #define elf_backend_dtrel_excludes_plt 1
11511 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11513 #define bfd_elf32_mkobject elf_xtensa_mkobject
11515 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11516 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11517 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11518 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11519 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11520 #define bfd_elf32_bfd_reloc_name_lookup \
11521 elf_xtensa_reloc_name_lookup
11522 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11523 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11525 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11526 #define elf_backend_check_relocs elf_xtensa_check_relocs
11527 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11528 #define elf_backend_discard_info elf_xtensa_discard_info
11529 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11530 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11531 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11532 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11533 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11534 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11535 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11536 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11537 #define elf_backend_object_p elf_xtensa_object_p
11538 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11539 #define elf_backend_relocate_section elf_xtensa_relocate_section
11540 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11541 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11542 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11543 #define elf_backend_special_sections elf_xtensa_special_sections
11544 #define elf_backend_action_discarded elf_xtensa_action_discarded
11545 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11547 #include "elf32-target.h"