1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright (C) 2003-2021 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 3 of the
9 License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
30 #include "elf/xtensa.h"
31 #include "splay-tree.h"
32 #include "xtensa-isa.h"
33 #include "xtensa-config.h"
35 /* 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
44 #ifndef XTHAL_ABI_UNDEFINED
45 #define XTHAL_ABI_UNDEFINED -1
48 #ifndef XTHAL_ABI_WINDOWED
49 #define XTHAL_ABI_WINDOWED 0
52 #ifndef XTHAL_ABI_CALL0
53 #define XTHAL_ABI_CALL0 1
56 /* Local helper functions. */
58 static bool add_extra_plt_sections (struct bfd_link_info
*, int);
59 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
60 static bfd_reloc_status_type bfd_elf_xtensa_reloc
61 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
62 static bool do_fix_for_relocatable_link
63 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*);
64 static void do_fix_for_final_link
65 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*, bfd_vma
*);
67 /* Local functions to handle Xtensa configurability. */
69 static bool is_indirect_call_opcode (xtensa_opcode
);
70 static bool is_direct_call_opcode (xtensa_opcode
);
71 static bool is_windowed_call_opcode (xtensa_opcode
);
72 static xtensa_opcode
get_const16_opcode (void);
73 static xtensa_opcode
get_l32r_opcode (void);
74 static bfd_vma
l32r_offset (bfd_vma
, bfd_vma
);
75 static int get_relocation_opnd (xtensa_opcode
, int);
76 static int get_relocation_slot (int);
77 static xtensa_opcode get_relocation_opcode
78 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
79 static bool is_l32r_relocation
80 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
81 static bool is_alt_relocation (int);
82 static bool is_operand_relocation (int);
83 static bfd_size_type insn_decode_len
84 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
85 static int insn_num_slots
86 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
87 static xtensa_opcode insn_decode_opcode
88 (bfd_byte
*, bfd_size_type
, bfd_size_type
, int);
89 static bool check_branch_target_aligned
90 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
91 static bool check_loop_aligned
92 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
93 static bool check_branch_target_aligned_address (bfd_vma
, int);
94 static bfd_size_type get_asm_simplify_size
95 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
97 /* Functions for link-time code simplifications. */
99 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
100 (bfd_byte
*, bfd_vma
, bfd_vma
, char **);
101 static bfd_reloc_status_type contract_asm_expansion
102 (bfd_byte
*, bfd_vma
, Elf_Internal_Rela
*, char **);
103 static xtensa_opcode
swap_callx_for_call_opcode (xtensa_opcode
);
104 static xtensa_opcode
get_expanded_call_opcode (bfd_byte
*, int, bool *);
106 /* Access to internal relocations, section contents and symbols. */
108 static Elf_Internal_Rela
*retrieve_internal_relocs
109 (bfd
*, asection
*, bool);
110 static void pin_internal_relocs (asection
*, Elf_Internal_Rela
*);
111 static void release_internal_relocs (asection
*, Elf_Internal_Rela
*);
112 static bfd_byte
*retrieve_contents (bfd
*, asection
*, bool);
113 static void pin_contents (asection
*, bfd_byte
*);
114 static void release_contents (asection
*, bfd_byte
*);
115 static Elf_Internal_Sym
*retrieve_local_syms (bfd
*);
117 /* Miscellaneous utility functions. */
119 static asection
*elf_xtensa_get_plt_section (struct bfd_link_info
*, int);
120 static asection
*elf_xtensa_get_gotplt_section (struct bfd_link_info
*, int);
121 static asection
*get_elf_r_symndx_section (bfd
*, unsigned long);
122 static struct elf_link_hash_entry
*get_elf_r_symndx_hash_entry
123 (bfd
*, unsigned long);
124 static bfd_vma
get_elf_r_symndx_offset (bfd
*, unsigned long);
125 static bool is_reloc_sym_weak (bfd
*, Elf_Internal_Rela
*);
126 static bool pcrel_reloc_fits (xtensa_opcode
, int, bfd_vma
, bfd_vma
);
127 static bool xtensa_is_property_section (asection
*);
128 static bool xtensa_is_insntable_section (asection
*);
129 static bool xtensa_is_littable_section (asection
*);
130 static bool xtensa_is_proptable_section (asection
*);
131 static int internal_reloc_compare (const void *, const void *);
132 static int internal_reloc_matches (const void *, const void *);
133 static asection
*xtensa_get_property_section (asection
*, const char *);
134 static flagword
xtensa_get_property_predef_flags (asection
*);
136 /* Other functions called directly by the linker. */
138 typedef void (*deps_callback_t
)
139 (asection
*, bfd_vma
, asection
*, bfd_vma
, void *);
140 extern bool xtensa_callback_required_dependence
141 (bfd
*, asection
*, struct bfd_link_info
*, deps_callback_t
, void *);
144 /* Globally visible flag for choosing size optimization of NOP removal
145 instead of branch-target-aware minimization for NOP removal.
146 When nonzero, narrow all instructions and remove all NOPs possible
147 around longcall expansions. */
149 int elf32xtensa_size_opt
;
152 /* The "new_section_hook" is used to set up a per-section
153 "xtensa_relax_info" data structure with additional information used
154 during relaxation. */
156 typedef struct xtensa_relax_info_struct xtensa_relax_info
;
159 /* The GNU tools do not easily allow extending interfaces to pass around
160 the pointer to the Xtensa ISA information, so instead we add a global
161 variable here (in BFD) that can be used by any of the tools that need
164 xtensa_isa xtensa_default_isa
;
167 /* When this is true, relocations may have been modified to refer to
168 symbols from other input files. The per-section list of "fix"
169 records needs to be checked when resolving relocations. */
171 static bool relaxing_section
= false;
173 /* When this is true, during final links, literals that cannot be
174 coalesced and their relocations may be moved to other sections. */
176 int elf32xtensa_no_literal_movement
= 1;
178 /* Place property records for a section into individual property section
179 with xt.prop. prefix. */
181 bool elf32xtensa_separate_props
= false;
183 /* Xtensa ABI. It affects PLT entry code. */
185 int elf32xtensa_abi
= XTHAL_ABI_UNDEFINED
;
187 /* Rename one of the generic section flags to better document how it
189 /* Whether relocations have been processed. */
190 #define reloc_done sec_flg0
192 static reloc_howto_type elf_howto_table
[] =
194 HOWTO (R_XTENSA_NONE
, 0, 3, 0, false, 0, complain_overflow_dont
,
195 bfd_elf_xtensa_reloc
, "R_XTENSA_NONE",
197 HOWTO (R_XTENSA_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
198 bfd_elf_xtensa_reloc
, "R_XTENSA_32",
199 true, 0xffffffff, 0xffffffff, false),
201 /* Replace a 32-bit value with a value from the runtime linker (only
202 used by linker-generated stub functions). The r_addend value is
203 special: 1 means to substitute a pointer to the runtime linker's
204 dynamic resolver function; 2 means to substitute the link map for
205 the shared object. */
206 HOWTO (R_XTENSA_RTLD
, 0, 2, 32, false, 0, complain_overflow_dont
,
207 NULL
, "R_XTENSA_RTLD", false, 0, 0, false),
209 HOWTO (R_XTENSA_GLOB_DAT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
210 bfd_elf_generic_reloc
, "R_XTENSA_GLOB_DAT",
211 false, 0, 0xffffffff, false),
212 HOWTO (R_XTENSA_JMP_SLOT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
213 bfd_elf_generic_reloc
, "R_XTENSA_JMP_SLOT",
214 false, 0, 0xffffffff, false),
215 HOWTO (R_XTENSA_RELATIVE
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
216 bfd_elf_generic_reloc
, "R_XTENSA_RELATIVE",
217 false, 0, 0xffffffff, false),
218 HOWTO (R_XTENSA_PLT
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
219 bfd_elf_xtensa_reloc
, "R_XTENSA_PLT",
220 false, 0, 0xffffffff, false),
224 /* Old relocations for backward compatibility. */
225 HOWTO (R_XTENSA_OP0
, 0, 0, 0, true, 0, complain_overflow_dont
,
226 bfd_elf_xtensa_reloc
, "R_XTENSA_OP0", false, 0, 0, true),
227 HOWTO (R_XTENSA_OP1
, 0, 0, 0, true, 0, complain_overflow_dont
,
228 bfd_elf_xtensa_reloc
, "R_XTENSA_OP1", false, 0, 0, true),
229 HOWTO (R_XTENSA_OP2
, 0, 0, 0, true, 0, complain_overflow_dont
,
230 bfd_elf_xtensa_reloc
, "R_XTENSA_OP2", false, 0, 0, true),
232 /* Assembly auto-expansion. */
233 HOWTO (R_XTENSA_ASM_EXPAND
, 0, 0, 0, true, 0, complain_overflow_dont
,
234 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_EXPAND", false, 0, 0, true),
235 /* Relax assembly auto-expansion. */
236 HOWTO (R_XTENSA_ASM_SIMPLIFY
, 0, 0, 0, true, 0, complain_overflow_dont
,
237 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_SIMPLIFY", false, 0, 0, true),
241 HOWTO (R_XTENSA_32_PCREL
, 0, 2, 32, true, 0, complain_overflow_bitfield
,
242 bfd_elf_xtensa_reloc
, "R_XTENSA_32_PCREL",
243 false, 0, 0xffffffff, true),
245 /* GNU extension to record C++ vtable hierarchy. */
246 HOWTO (R_XTENSA_GNU_VTINHERIT
, 0, 2, 0, false, 0, complain_overflow_dont
,
247 NULL
, "R_XTENSA_GNU_VTINHERIT",
249 /* GNU extension to record C++ vtable member usage. */
250 HOWTO (R_XTENSA_GNU_VTENTRY
, 0, 2, 0, false, 0, complain_overflow_dont
,
251 _bfd_elf_rel_vtable_reloc_fn
, "R_XTENSA_GNU_VTENTRY",
254 /* Relocations for supporting difference of symbols. */
255 HOWTO (R_XTENSA_DIFF8
, 0, 0, 8, false, 0, complain_overflow_signed
,
256 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF8", false, 0, 0xff, false),
257 HOWTO (R_XTENSA_DIFF16
, 0, 1, 16, false, 0, complain_overflow_signed
,
258 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF16", false, 0, 0xffff, false),
259 HOWTO (R_XTENSA_DIFF32
, 0, 2, 32, false, 0, complain_overflow_signed
,
260 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF32", false, 0, 0xffffffff, false),
262 /* General immediate operand relocations. */
263 HOWTO (R_XTENSA_SLOT0_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
264 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_OP", false, 0, 0, true),
265 HOWTO (R_XTENSA_SLOT1_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
266 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_OP", false, 0, 0, true),
267 HOWTO (R_XTENSA_SLOT2_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
268 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_OP", false, 0, 0, true),
269 HOWTO (R_XTENSA_SLOT3_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
270 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_OP", false, 0, 0, true),
271 HOWTO (R_XTENSA_SLOT4_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
272 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_OP", false, 0, 0, true),
273 HOWTO (R_XTENSA_SLOT5_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
274 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_OP", false, 0, 0, true),
275 HOWTO (R_XTENSA_SLOT6_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
276 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_OP", false, 0, 0, true),
277 HOWTO (R_XTENSA_SLOT7_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
278 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_OP", false, 0, 0, true),
279 HOWTO (R_XTENSA_SLOT8_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
280 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_OP", false, 0, 0, true),
281 HOWTO (R_XTENSA_SLOT9_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
282 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_OP", false, 0, 0, true),
283 HOWTO (R_XTENSA_SLOT10_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
284 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_OP", false, 0, 0, true),
285 HOWTO (R_XTENSA_SLOT11_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
286 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_OP", false, 0, 0, true),
287 HOWTO (R_XTENSA_SLOT12_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
288 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_OP", false, 0, 0, true),
289 HOWTO (R_XTENSA_SLOT13_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
290 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_OP", false, 0, 0, true),
291 HOWTO (R_XTENSA_SLOT14_OP
, 0, 0, 0, true, 0, complain_overflow_dont
,
292 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_OP", false, 0, 0, true),
294 /* "Alternate" relocations. The meaning of these is opcode-specific. */
295 HOWTO (R_XTENSA_SLOT0_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
296 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_ALT", false, 0, 0, true),
297 HOWTO (R_XTENSA_SLOT1_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
298 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_ALT", false, 0, 0, true),
299 HOWTO (R_XTENSA_SLOT2_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
300 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_ALT", false, 0, 0, true),
301 HOWTO (R_XTENSA_SLOT3_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
302 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_ALT", false, 0, 0, true),
303 HOWTO (R_XTENSA_SLOT4_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
304 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_ALT", false, 0, 0, true),
305 HOWTO (R_XTENSA_SLOT5_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
306 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_ALT", false, 0, 0, true),
307 HOWTO (R_XTENSA_SLOT6_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
308 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_ALT", false, 0, 0, true),
309 HOWTO (R_XTENSA_SLOT7_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
310 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_ALT", false, 0, 0, true),
311 HOWTO (R_XTENSA_SLOT8_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
312 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_ALT", false, 0, 0, true),
313 HOWTO (R_XTENSA_SLOT9_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
314 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_ALT", false, 0, 0, true),
315 HOWTO (R_XTENSA_SLOT10_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
316 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_ALT", false, 0, 0, true),
317 HOWTO (R_XTENSA_SLOT11_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
318 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_ALT", false, 0, 0, true),
319 HOWTO (R_XTENSA_SLOT12_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
320 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_ALT", false, 0, 0, true),
321 HOWTO (R_XTENSA_SLOT13_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
322 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_ALT", false, 0, 0, true),
323 HOWTO (R_XTENSA_SLOT14_ALT
, 0, 0, 0, true, 0, complain_overflow_dont
,
324 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_ALT", false, 0, 0, true),
326 /* TLS relocations. */
327 HOWTO (R_XTENSA_TLSDESC_FN
, 0, 2, 32, false, 0, complain_overflow_dont
,
328 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_FN",
329 false, 0, 0xffffffff, false),
330 HOWTO (R_XTENSA_TLSDESC_ARG
, 0, 2, 32, false, 0, complain_overflow_dont
,
331 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_ARG",
332 false, 0, 0xffffffff, false),
333 HOWTO (R_XTENSA_TLS_DTPOFF
, 0, 2, 32, false, 0, complain_overflow_dont
,
334 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_DTPOFF",
335 false, 0, 0xffffffff, false),
336 HOWTO (R_XTENSA_TLS_TPOFF
, 0, 2, 32, false, 0, complain_overflow_dont
,
337 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_TPOFF",
338 false, 0, 0xffffffff, false),
339 HOWTO (R_XTENSA_TLS_FUNC
, 0, 0, 0, false, 0, complain_overflow_dont
,
340 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_FUNC",
342 HOWTO (R_XTENSA_TLS_ARG
, 0, 0, 0, false, 0, complain_overflow_dont
,
343 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_ARG",
345 HOWTO (R_XTENSA_TLS_CALL
, 0, 0, 0, false, 0, complain_overflow_dont
,
346 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_CALL",
349 HOWTO (R_XTENSA_PDIFF8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,
350 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF8", false, 0, 0xff, false),
351 HOWTO (R_XTENSA_PDIFF16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,
352 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF16", false, 0, 0xffff, false),
353 HOWTO (R_XTENSA_PDIFF32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
354 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF32", false, 0, 0xffffffff, false),
356 HOWTO (R_XTENSA_NDIFF8
, 0, 0, 8, false, 0, complain_overflow_bitfield
,
357 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF8", false, 0, 0xff, false),
358 HOWTO (R_XTENSA_NDIFF16
, 0, 1, 16, false, 0, complain_overflow_bitfield
,
359 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF16", false, 0, 0xffff, false),
360 HOWTO (R_XTENSA_NDIFF32
, 0, 2, 32, false, 0, complain_overflow_bitfield
,
361 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF32", false, 0, 0xffffffff, false),
366 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
371 static reloc_howto_type
*
372 elf_xtensa_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
373 bfd_reloc_code_real_type code
)
378 TRACE ("BFD_RELOC_NONE");
379 return &elf_howto_table
[(unsigned) R_XTENSA_NONE
];
382 TRACE ("BFD_RELOC_32");
383 return &elf_howto_table
[(unsigned) R_XTENSA_32
];
385 case BFD_RELOC_32_PCREL
:
386 TRACE ("BFD_RELOC_32_PCREL");
387 return &elf_howto_table
[(unsigned) R_XTENSA_32_PCREL
];
389 case BFD_RELOC_XTENSA_DIFF8
:
390 TRACE ("BFD_RELOC_XTENSA_DIFF8");
391 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF8
];
393 case BFD_RELOC_XTENSA_DIFF16
:
394 TRACE ("BFD_RELOC_XTENSA_DIFF16");
395 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF16
];
397 case BFD_RELOC_XTENSA_DIFF32
:
398 TRACE ("BFD_RELOC_XTENSA_DIFF32");
399 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF32
];
401 case BFD_RELOC_XTENSA_PDIFF8
:
402 TRACE ("BFD_RELOC_XTENSA_PDIFF8");
403 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF8
];
405 case BFD_RELOC_XTENSA_PDIFF16
:
406 TRACE ("BFD_RELOC_XTENSA_PDIFF16");
407 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF16
];
409 case BFD_RELOC_XTENSA_PDIFF32
:
410 TRACE ("BFD_RELOC_XTENSA_PDIFF32");
411 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF32
];
413 case BFD_RELOC_XTENSA_NDIFF8
:
414 TRACE ("BFD_RELOC_XTENSA_NDIFF8");
415 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF8
];
417 case BFD_RELOC_XTENSA_NDIFF16
:
418 TRACE ("BFD_RELOC_XTENSA_NDIFF16");
419 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF16
];
421 case BFD_RELOC_XTENSA_NDIFF32
:
422 TRACE ("BFD_RELOC_XTENSA_NDIFF32");
423 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF32
];
425 case BFD_RELOC_XTENSA_RTLD
:
426 TRACE ("BFD_RELOC_XTENSA_RTLD");
427 return &elf_howto_table
[(unsigned) R_XTENSA_RTLD
];
429 case BFD_RELOC_XTENSA_GLOB_DAT
:
430 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
431 return &elf_howto_table
[(unsigned) R_XTENSA_GLOB_DAT
];
433 case BFD_RELOC_XTENSA_JMP_SLOT
:
434 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
435 return &elf_howto_table
[(unsigned) R_XTENSA_JMP_SLOT
];
437 case BFD_RELOC_XTENSA_RELATIVE
:
438 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
439 return &elf_howto_table
[(unsigned) R_XTENSA_RELATIVE
];
441 case BFD_RELOC_XTENSA_PLT
:
442 TRACE ("BFD_RELOC_XTENSA_PLT");
443 return &elf_howto_table
[(unsigned) R_XTENSA_PLT
];
445 case BFD_RELOC_XTENSA_OP0
:
446 TRACE ("BFD_RELOC_XTENSA_OP0");
447 return &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
449 case BFD_RELOC_XTENSA_OP1
:
450 TRACE ("BFD_RELOC_XTENSA_OP1");
451 return &elf_howto_table
[(unsigned) R_XTENSA_OP1
];
453 case BFD_RELOC_XTENSA_OP2
:
454 TRACE ("BFD_RELOC_XTENSA_OP2");
455 return &elf_howto_table
[(unsigned) R_XTENSA_OP2
];
457 case BFD_RELOC_XTENSA_ASM_EXPAND
:
458 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
459 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_EXPAND
];
461 case BFD_RELOC_XTENSA_ASM_SIMPLIFY
:
462 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
463 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_SIMPLIFY
];
465 case BFD_RELOC_VTABLE_INHERIT
:
466 TRACE ("BFD_RELOC_VTABLE_INHERIT");
467 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTINHERIT
];
469 case BFD_RELOC_VTABLE_ENTRY
:
470 TRACE ("BFD_RELOC_VTABLE_ENTRY");
471 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTENTRY
];
473 case BFD_RELOC_XTENSA_TLSDESC_FN
:
474 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
475 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_FN
];
477 case BFD_RELOC_XTENSA_TLSDESC_ARG
:
478 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
479 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_ARG
];
481 case BFD_RELOC_XTENSA_TLS_DTPOFF
:
482 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
483 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_DTPOFF
];
485 case BFD_RELOC_XTENSA_TLS_TPOFF
:
486 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
487 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_TPOFF
];
489 case BFD_RELOC_XTENSA_TLS_FUNC
:
490 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
491 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_FUNC
];
493 case BFD_RELOC_XTENSA_TLS_ARG
:
494 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
495 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_ARG
];
497 case BFD_RELOC_XTENSA_TLS_CALL
:
498 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
499 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_CALL
];
502 if (code
>= BFD_RELOC_XTENSA_SLOT0_OP
503 && code
<= BFD_RELOC_XTENSA_SLOT14_OP
)
505 unsigned n
= (R_XTENSA_SLOT0_OP
+
506 (code
- BFD_RELOC_XTENSA_SLOT0_OP
));
507 return &elf_howto_table
[n
];
510 if (code
>= BFD_RELOC_XTENSA_SLOT0_ALT
511 && code
<= BFD_RELOC_XTENSA_SLOT14_ALT
)
513 unsigned n
= (R_XTENSA_SLOT0_ALT
+
514 (code
- BFD_RELOC_XTENSA_SLOT0_ALT
));
515 return &elf_howto_table
[n
];
521 /* xgettext:c-format */
522 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
, (int) code
);
523 bfd_set_error (bfd_error_bad_value
);
528 static reloc_howto_type
*
529 elf_xtensa_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
534 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
535 if (elf_howto_table
[i
].name
!= NULL
536 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
537 return &elf_howto_table
[i
];
543 /* Given an ELF "rela" relocation, find the corresponding howto and record
544 it in the BFD internal arelent representation of the relocation. */
547 elf_xtensa_info_to_howto_rela (bfd
*abfd
,
549 Elf_Internal_Rela
*dst
)
551 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
553 if (r_type
>= (unsigned int) R_XTENSA_max
)
555 /* xgettext:c-format */
556 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
558 bfd_set_error (bfd_error_bad_value
);
561 cache_ptr
->howto
= &elf_howto_table
[r_type
];
566 /* Functions for the Xtensa ELF linker. */
568 /* The name of the dynamic interpreter. This is put in the .interp
571 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
573 /* The size in bytes of an entry in the procedure linkage table.
574 (This does _not_ include the space for the literals associated with
577 #define PLT_ENTRY_SIZE 16
579 /* For _really_ large PLTs, we may need to alternate between literals
580 and code to keep the literals within the 256K range of the L32R
581 instructions in the code. It's unlikely that anyone would ever need
582 such a big PLT, but an arbitrary limit on the PLT size would be bad.
583 Thus, we split the PLT into chunks. Since there's very little
584 overhead (2 extra literals) for each chunk, the chunk size is kept
585 small so that the code for handling multiple chunks get used and
586 tested regularly. With 254 entries, there are 1K of literals for
587 each chunk, and that seems like a nice round number. */
589 #define PLT_ENTRIES_PER_CHUNK 254
591 /* PLT entries are actually used as stub functions for lazy symbol
592 resolution. Once the symbol is resolved, the stub function is never
593 invoked. Note: the 32-byte frame size used here cannot be changed
594 without a corresponding change in the runtime linker. */
596 static const bfd_byte elf_xtensa_be_plt_entry
[][PLT_ENTRY_SIZE
] =
599 0x6c, 0x10, 0x04, /* entry sp, 32 */
600 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
601 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
602 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
603 0x0a, 0x80, 0x00, /* jx a8 */
607 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
608 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
609 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
610 0x0a, 0x80, 0x00, /* jx a8 */
615 static const bfd_byte elf_xtensa_le_plt_entry
[][PLT_ENTRY_SIZE
] =
618 0x36, 0x41, 0x00, /* entry sp, 32 */
619 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
620 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
621 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
622 0xa0, 0x08, 0x00, /* jx a8 */
626 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
627 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
628 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
629 0xa0, 0x08, 0x00, /* jx a8 */
634 /* The size of the thread control block. */
637 struct elf_xtensa_link_hash_entry
639 struct elf_link_hash_entry elf
;
641 bfd_signed_vma tlsfunc_refcount
;
643 #define GOT_UNKNOWN 0
645 #define GOT_TLS_GD 2 /* global or local dynamic */
646 #define GOT_TLS_IE 4 /* initial or local exec */
647 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
648 unsigned char tls_type
;
651 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
653 struct elf_xtensa_obj_tdata
655 struct elf_obj_tdata root
;
657 /* tls_type for each local got entry. */
658 char *local_got_tls_type
;
660 bfd_signed_vma
*local_tlsfunc_refcounts
;
663 #define elf_xtensa_tdata(abfd) \
664 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
666 #define elf_xtensa_local_got_tls_type(abfd) \
667 (elf_xtensa_tdata (abfd)->local_got_tls_type)
669 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
670 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
672 #define is_xtensa_elf(bfd) \
673 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
674 && elf_tdata (bfd) != NULL \
675 && elf_object_id (bfd) == XTENSA_ELF_DATA)
678 elf_xtensa_mkobject (bfd
*abfd
)
680 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_xtensa_obj_tdata
),
684 /* Xtensa ELF linker hash table. */
686 struct elf_xtensa_link_hash_table
688 struct elf_link_hash_table elf
;
690 /* Short-cuts to get to dynamic linker sections. */
692 asection
*spltlittbl
;
694 /* Total count of PLT relocations seen during check_relocs.
695 The actual PLT code must be split into multiple sections and all
696 the sections have to be created before size_dynamic_sections,
697 where we figure out the exact number of PLT entries that will be
698 needed. It is OK if this count is an overestimate, e.g., some
699 relocations may be removed by GC. */
702 struct elf_xtensa_link_hash_entry
*tlsbase
;
705 /* Get the Xtensa ELF linker hash table from a link_info structure. */
707 #define elf_xtensa_hash_table(p) \
708 ((is_elf_hash_table ((p)->hash) \
709 && elf_hash_table_id (elf_hash_table (p)) == XTENSA_ELF_DATA) \
710 ? (struct elf_xtensa_link_hash_table *) (p)->hash : NULL)
712 /* Create an entry in an Xtensa ELF linker hash table. */
714 static struct bfd_hash_entry
*
715 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
716 struct bfd_hash_table
*table
,
719 /* Allocate the structure if it has not already been allocated by a
723 entry
= bfd_hash_allocate (table
,
724 sizeof (struct elf_xtensa_link_hash_entry
));
729 /* Call the allocation method of the superclass. */
730 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
733 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (entry
);
734 eh
->tlsfunc_refcount
= 0;
735 eh
->tls_type
= GOT_UNKNOWN
;
741 /* Create an Xtensa ELF linker hash table. */
743 static struct bfd_link_hash_table
*
744 elf_xtensa_link_hash_table_create (bfd
*abfd
)
746 struct elf_link_hash_entry
*tlsbase
;
747 struct elf_xtensa_link_hash_table
*ret
;
748 size_t amt
= sizeof (struct elf_xtensa_link_hash_table
);
750 ret
= bfd_zmalloc (amt
);
754 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
755 elf_xtensa_link_hash_newfunc
,
756 sizeof (struct elf_xtensa_link_hash_entry
),
763 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
765 tlsbase
= elf_link_hash_lookup (&ret
->elf
, "_TLS_MODULE_BASE_",
767 tlsbase
->root
.type
= bfd_link_hash_new
;
768 tlsbase
->root
.u
.undef
.abfd
= NULL
;
769 tlsbase
->non_elf
= 0;
770 ret
->elf
.dt_pltgot_required
= true;
771 ret
->tlsbase
= elf_xtensa_hash_entry (tlsbase
);
772 ret
->tlsbase
->tls_type
= GOT_UNKNOWN
;
774 return &ret
->elf
.root
;
777 /* Copy the extra info we tack onto an elf_link_hash_entry. */
780 elf_xtensa_copy_indirect_symbol (struct bfd_link_info
*info
,
781 struct elf_link_hash_entry
*dir
,
782 struct elf_link_hash_entry
*ind
)
784 struct elf_xtensa_link_hash_entry
*edir
, *eind
;
786 edir
= elf_xtensa_hash_entry (dir
);
787 eind
= elf_xtensa_hash_entry (ind
);
789 if (ind
->root
.type
== bfd_link_hash_indirect
)
791 edir
->tlsfunc_refcount
+= eind
->tlsfunc_refcount
;
792 eind
->tlsfunc_refcount
= 0;
794 if (dir
->got
.refcount
<= 0)
796 edir
->tls_type
= eind
->tls_type
;
797 eind
->tls_type
= GOT_UNKNOWN
;
801 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
805 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
806 struct bfd_link_info
*info
)
808 /* Check if we should do dynamic things to this symbol. The
809 "ignore_protected" argument need not be set, because Xtensa code
810 does not require special handling of STV_PROTECTED to make function
811 pointer comparisons work properly. The PLT addresses are never
812 used for function pointers. */
814 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
819 property_table_compare (const void *ap
, const void *bp
)
821 const property_table_entry
*a
= (const property_table_entry
*) ap
;
822 const property_table_entry
*b
= (const property_table_entry
*) bp
;
824 if (a
->address
== b
->address
)
826 if (a
->size
!= b
->size
)
827 return (a
->size
- b
->size
);
829 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
830 return ((b
->flags
& XTENSA_PROP_ALIGN
)
831 - (a
->flags
& XTENSA_PROP_ALIGN
));
833 if ((a
->flags
& XTENSA_PROP_ALIGN
)
834 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
835 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
836 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
837 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
839 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
840 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
841 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
842 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
844 return (a
->flags
- b
->flags
);
847 return (a
->address
- b
->address
);
852 property_table_matches (const void *ap
, const void *bp
)
854 const property_table_entry
*a
= (const property_table_entry
*) ap
;
855 const property_table_entry
*b
= (const property_table_entry
*) bp
;
857 /* Check if one entry overlaps with the other. */
858 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
859 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
862 return (a
->address
- b
->address
);
866 /* Get the literal table or property table entries for the given
867 section. Sets TABLE_P and returns the number of entries. On
868 error, returns a negative value. */
871 xtensa_read_table_entries (bfd
*abfd
,
873 property_table_entry
**table_p
,
874 const char *sec_name
,
877 asection
*table_section
;
878 bfd_size_type table_size
= 0;
879 bfd_byte
*table_data
;
880 property_table_entry
*blocks
;
881 int blk
, block_count
;
882 bfd_size_type num_records
;
883 Elf_Internal_Rela
*internal_relocs
, *irel
, *rel_end
;
884 bfd_vma section_addr
, off
;
885 flagword predef_flags
;
886 bfd_size_type table_entry_size
, section_limit
;
888 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
890 || !(section
->flags
& SEC_ALLOC
)
891 || (section
->flags
& SEC_DEBUGGING
))
897 table_section
= xtensa_get_property_section (section
, sec_name
);
899 table_size
= table_section
->size
;
907 predef_flags
= xtensa_get_property_predef_flags (table_section
);
908 table_entry_size
= 12;
910 table_entry_size
-= 4;
912 num_records
= table_size
/ table_entry_size
;
913 table_data
= retrieve_contents (abfd
, table_section
, true);
914 blocks
= (property_table_entry
*)
915 bfd_malloc (num_records
* sizeof (property_table_entry
));
919 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
921 section_addr
= section
->vma
;
923 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, true);
924 if (internal_relocs
&& !table_section
->reloc_done
)
926 qsort (internal_relocs
, table_section
->reloc_count
,
927 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
928 irel
= internal_relocs
;
933 section_limit
= bfd_get_section_limit (abfd
, section
);
934 rel_end
= internal_relocs
+ table_section
->reloc_count
;
936 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
938 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
940 /* Skip any relocations before the current offset. This should help
941 avoid confusion caused by unexpected relocations for the preceding
944 (irel
->r_offset
< off
945 || (irel
->r_offset
== off
946 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
953 if (irel
&& irel
->r_offset
== off
)
956 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
957 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
959 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
962 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
963 BFD_ASSERT (sym_off
== 0);
964 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
968 if (address
< section_addr
969 || address
>= section_addr
+ section_limit
)
973 blocks
[block_count
].address
= address
;
974 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
976 blocks
[block_count
].flags
= predef_flags
;
978 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
982 release_contents (table_section
, table_data
);
983 release_internal_relocs (table_section
, internal_relocs
);
987 /* Now sort them into address order for easy reference. */
988 qsort (blocks
, block_count
, sizeof (property_table_entry
),
989 property_table_compare
);
991 /* Check that the table contents are valid. Problems may occur,
992 for example, if an unrelocated object file is stripped. */
993 for (blk
= 1; blk
< block_count
; blk
++)
995 /* The only circumstance where two entries may legitimately
996 have the same address is when one of them is a zero-size
997 placeholder to mark a place where fill can be inserted.
998 The zero-size entry should come first. */
999 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
1000 blocks
[blk
- 1].size
!= 0)
1002 /* xgettext:c-format */
1003 _bfd_error_handler (_("%pB(%pA): invalid property table"),
1005 bfd_set_error (bfd_error_bad_value
);
1017 static property_table_entry
*
1018 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
1019 int property_table_size
,
1022 property_table_entry entry
;
1023 property_table_entry
*rv
;
1025 if (property_table_size
== 0)
1028 entry
.address
= addr
;
1032 rv
= bsearch (&entry
, property_table
, property_table_size
,
1033 sizeof (property_table_entry
), property_table_matches
);
1039 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
1043 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
1050 /* Look through the relocs for a section during the first phase, and
1051 calculate needed space in the dynamic reloc sections. */
1054 elf_xtensa_check_relocs (bfd
*abfd
,
1055 struct bfd_link_info
*info
,
1057 const Elf_Internal_Rela
*relocs
)
1059 struct elf_xtensa_link_hash_table
*htab
;
1060 Elf_Internal_Shdr
*symtab_hdr
;
1061 struct elf_link_hash_entry
**sym_hashes
;
1062 const Elf_Internal_Rela
*rel
;
1063 const Elf_Internal_Rela
*rel_end
;
1065 if (bfd_link_relocatable (info
))
1068 BFD_ASSERT (is_xtensa_elf (abfd
));
1070 htab
= elf_xtensa_hash_table (info
);
1074 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1075 sym_hashes
= elf_sym_hashes (abfd
);
1077 rel_end
= relocs
+ sec
->reloc_count
;
1078 for (rel
= relocs
; rel
< rel_end
; rel
++)
1080 unsigned int r_type
;
1082 struct elf_link_hash_entry
*h
= NULL
;
1083 struct elf_xtensa_link_hash_entry
*eh
;
1084 int tls_type
, old_tls_type
;
1085 bool is_got
= false;
1086 bool is_plt
= false;
1087 bool is_tlsfunc
= false;
1089 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1090 r_type
= ELF32_R_TYPE (rel
->r_info
);
1092 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1094 /* xgettext:c-format */
1095 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1100 if (r_symndx
>= symtab_hdr
->sh_info
)
1102 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1103 while (h
->root
.type
== bfd_link_hash_indirect
1104 || h
->root
.type
== bfd_link_hash_warning
)
1105 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1107 eh
= elf_xtensa_hash_entry (h
);
1111 case R_XTENSA_TLSDESC_FN
:
1112 if (bfd_link_pic (info
))
1114 tls_type
= GOT_TLS_GD
;
1119 tls_type
= GOT_TLS_IE
;
1122 case R_XTENSA_TLSDESC_ARG
:
1123 if (bfd_link_pic (info
))
1125 tls_type
= GOT_TLS_GD
;
1130 tls_type
= GOT_TLS_IE
;
1131 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1136 case R_XTENSA_TLS_DTPOFF
:
1137 if (bfd_link_pic (info
))
1138 tls_type
= GOT_TLS_GD
;
1140 tls_type
= GOT_TLS_IE
;
1143 case R_XTENSA_TLS_TPOFF
:
1144 tls_type
= GOT_TLS_IE
;
1145 if (bfd_link_pic (info
))
1146 info
->flags
|= DF_STATIC_TLS
;
1147 if (bfd_link_pic (info
) || h
)
1152 tls_type
= GOT_NORMAL
;
1157 tls_type
= GOT_NORMAL
;
1161 case R_XTENSA_GNU_VTINHERIT
:
1162 /* This relocation describes the C++ object vtable hierarchy.
1163 Reconstruct it for later use during GC. */
1164 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1168 case R_XTENSA_GNU_VTENTRY
:
1169 /* This relocation describes which C++ vtable entries are actually
1170 used. Record for later use during GC. */
1171 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1176 /* Nothing to do for any other relocations. */
1184 if (h
->plt
.refcount
<= 0)
1187 h
->plt
.refcount
= 1;
1190 h
->plt
.refcount
+= 1;
1192 /* Keep track of the total PLT relocation count even if we
1193 don't yet know whether the dynamic sections will be
1195 htab
->plt_reloc_count
+= 1;
1197 if (elf_hash_table (info
)->dynamic_sections_created
)
1199 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1205 if (h
->got
.refcount
<= 0)
1206 h
->got
.refcount
= 1;
1208 h
->got
.refcount
+= 1;
1212 eh
->tlsfunc_refcount
+= 1;
1214 old_tls_type
= eh
->tls_type
;
1218 /* Allocate storage the first time. */
1219 if (elf_local_got_refcounts (abfd
) == NULL
)
1221 bfd_size_type size
= symtab_hdr
->sh_info
;
1224 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1227 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1229 mem
= bfd_zalloc (abfd
, size
);
1232 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1234 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1237 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1238 = (bfd_signed_vma
*) mem
;
1241 /* This is a global offset table entry for a local symbol. */
1242 if (is_got
|| is_plt
)
1243 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1246 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1248 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1251 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1252 tls_type
|= old_tls_type
;
1253 /* If a TLS symbol is accessed using IE at least once,
1254 there is no point to use a dynamic model for it. */
1255 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1256 && ((old_tls_type
& GOT_TLS_GD
) == 0
1257 || (tls_type
& GOT_TLS_IE
) == 0))
1259 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1260 tls_type
= old_tls_type
;
1261 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1262 tls_type
|= old_tls_type
;
1266 /* xgettext:c-format */
1267 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1269 h
? h
->root
.root
.string
: "<local>");
1274 if (old_tls_type
!= tls_type
)
1277 eh
->tls_type
= tls_type
;
1279 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1288 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1289 struct elf_link_hash_entry
*h
)
1291 if (bfd_link_pic (info
))
1293 if (h
->plt
.refcount
> 0)
1295 /* For shared objects, there's no need for PLT entries for local
1296 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1297 if (h
->got
.refcount
< 0)
1298 h
->got
.refcount
= 0;
1299 h
->got
.refcount
+= h
->plt
.refcount
;
1300 h
->plt
.refcount
= 0;
1305 /* Don't need any dynamic relocations at all. */
1306 h
->plt
.refcount
= 0;
1307 h
->got
.refcount
= 0;
1313 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1314 struct elf_link_hash_entry
*h
,
1317 /* For a shared link, move the plt refcount to the got refcount to leave
1318 space for RELATIVE relocs. */
1319 elf_xtensa_make_sym_local (info
, h
);
1321 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1325 /* Return the section that should be marked against GC for a given
1329 elf_xtensa_gc_mark_hook (asection
*sec
,
1330 struct bfd_link_info
*info
,
1331 Elf_Internal_Rela
*rel
,
1332 struct elf_link_hash_entry
*h
,
1333 Elf_Internal_Sym
*sym
)
1335 /* Property sections are marked "KEEP" in the linker scripts, but they
1336 should not cause other sections to be marked. (This approach relies
1337 on elf_xtensa_discard_info to remove property table entries that
1338 describe discarded sections. Alternatively, it might be more
1339 efficient to avoid using "KEEP" in the linker scripts and instead use
1340 the gc_mark_extra_sections hook to mark only the property sections
1341 that describe marked sections. That alternative does not work well
1342 with the current property table sections, which do not correspond
1343 one-to-one with the sections they describe, but that should be fixed
1345 if (xtensa_is_property_section (sec
))
1349 switch (ELF32_R_TYPE (rel
->r_info
))
1351 case R_XTENSA_GNU_VTINHERIT
:
1352 case R_XTENSA_GNU_VTENTRY
:
1356 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1360 /* Create all the dynamic sections. */
1363 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1365 struct elf_xtensa_link_hash_table
*htab
;
1366 flagword flags
, noalloc_flags
;
1368 htab
= elf_xtensa_hash_table (info
);
1372 /* First do all the standard stuff. */
1373 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1376 /* Create any extra PLT sections in case check_relocs has already
1377 been called on all the non-dynamic input files. */
1378 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1381 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1382 | SEC_LINKER_CREATED
| SEC_READONLY
);
1383 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1385 /* Mark the ".got.plt" section READONLY. */
1386 if (htab
->elf
.sgotplt
== NULL
1387 || !bfd_set_section_flags (htab
->elf
.sgotplt
, flags
))
1390 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1391 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1393 if (htab
->sgotloc
== NULL
1394 || !bfd_set_section_alignment (htab
->sgotloc
, 2))
1397 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1398 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1400 if (htab
->spltlittbl
== NULL
1401 || !bfd_set_section_alignment (htab
->spltlittbl
, 2))
1409 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1411 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1414 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1415 ".got.plt" sections. */
1416 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1422 /* Stop when we find a section has already been created. */
1423 if (elf_xtensa_get_plt_section (info
, chunk
))
1426 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1427 | SEC_LINKER_CREATED
| SEC_READONLY
);
1429 sname
= (char *) bfd_malloc (10);
1430 sprintf (sname
, ".plt.%u", chunk
);
1431 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1433 || !bfd_set_section_alignment (s
, 2))
1436 sname
= (char *) bfd_malloc (14);
1437 sprintf (sname
, ".got.plt.%u", chunk
);
1438 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1440 || !bfd_set_section_alignment (s
, 2))
1448 /* Adjust a symbol defined by a dynamic object and referenced by a
1449 regular object. The current definition is in some section of the
1450 dynamic object, but we're not including those sections. We have to
1451 change the definition to something the rest of the link can
1455 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1456 struct elf_link_hash_entry
*h
)
1458 /* If this is a weak symbol, and there is a real definition, the
1459 processor independent code will have arranged for us to see the
1460 real definition first, and we can just use the same value. */
1461 if (h
->is_weakalias
)
1463 struct elf_link_hash_entry
*def
= weakdef (h
);
1464 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1465 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1466 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1470 /* This is a reference to a symbol defined by a dynamic object. The
1471 reference must go through the GOT, so there's no need for COPY relocs,
1479 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1481 struct bfd_link_info
*info
;
1482 struct elf_xtensa_link_hash_table
*htab
;
1483 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1485 if (h
->root
.type
== bfd_link_hash_indirect
)
1488 info
= (struct bfd_link_info
*) arg
;
1489 htab
= elf_xtensa_hash_table (info
);
1493 /* If we saw any use of an IE model for this symbol, we can then optimize
1494 away GOT entries for any TLSDESC_FN relocs. */
1495 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1497 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1498 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1501 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1502 elf_xtensa_make_sym_local (info
, h
);
1504 if (! elf_xtensa_dynamic_symbol_p (h
, info
)
1505 && h
->root
.type
== bfd_link_hash_undefweak
)
1508 if (h
->plt
.refcount
> 0)
1509 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1511 if (h
->got
.refcount
> 0)
1512 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1519 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1521 struct elf_xtensa_link_hash_table
*htab
;
1524 htab
= elf_xtensa_hash_table (info
);
1528 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1530 bfd_signed_vma
*local_got_refcounts
;
1531 bfd_size_type j
, cnt
;
1532 Elf_Internal_Shdr
*symtab_hdr
;
1534 local_got_refcounts
= elf_local_got_refcounts (i
);
1535 if (!local_got_refcounts
)
1538 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1539 cnt
= symtab_hdr
->sh_info
;
1541 for (j
= 0; j
< cnt
; ++j
)
1543 /* If we saw any use of an IE model for this symbol, we can
1544 then optimize away GOT entries for any TLSDESC_FN relocs. */
1545 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1547 bfd_signed_vma
*tlsfunc_refcount
1548 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1549 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1550 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1553 if (local_got_refcounts
[j
] > 0)
1554 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1555 * sizeof (Elf32_External_Rela
));
1561 /* Set the sizes of the dynamic sections. */
1564 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1565 struct bfd_link_info
*info
)
1567 struct elf_xtensa_link_hash_table
*htab
;
1569 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1570 bool relplt
, relgot
;
1571 int plt_entries
, plt_chunks
, chunk
;
1576 htab
= elf_xtensa_hash_table (info
);
1580 dynobj
= elf_hash_table (info
)->dynobj
;
1583 srelgot
= htab
->elf
.srelgot
;
1584 srelplt
= htab
->elf
.srelplt
;
1586 if (elf_hash_table (info
)->dynamic_sections_created
)
1588 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1589 && htab
->elf
.srelplt
!= NULL
1590 && htab
->elf
.sgot
!= NULL
1591 && htab
->spltlittbl
!= NULL
1592 && htab
->sgotloc
!= NULL
);
1594 /* Set the contents of the .interp section to the interpreter. */
1595 if (bfd_link_executable (info
) && !info
->nointerp
)
1597 s
= bfd_get_linker_section (dynobj
, ".interp");
1600 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1601 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1604 /* Allocate room for one word in ".got". */
1605 htab
->elf
.sgot
->size
= 4;
1607 /* Allocate space in ".rela.got" for literals that reference global
1608 symbols and space in ".rela.plt" for literals that have PLT
1610 elf_link_hash_traverse (elf_hash_table (info
),
1611 elf_xtensa_allocate_dynrelocs
,
1614 /* If we are generating a shared object, we also need space in
1615 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1616 reference local symbols. */
1617 if (bfd_link_pic (info
))
1618 elf_xtensa_allocate_local_got_size (info
);
1620 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1621 each PLT entry, we need the PLT code plus a 4-byte literal.
1622 For each chunk of ".plt", we also need two more 4-byte
1623 literals, two corresponding entries in ".rela.got", and an
1624 8-byte entry in ".xt.lit.plt". */
1625 spltlittbl
= htab
->spltlittbl
;
1626 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1628 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1630 /* Iterate over all the PLT chunks, including any extra sections
1631 created earlier because the initial count of PLT relocations
1632 was an overestimate. */
1634 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1639 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1640 BFD_ASSERT (sgotplt
!= NULL
);
1642 if (chunk
< plt_chunks
- 1)
1643 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1644 else if (chunk
== plt_chunks
- 1)
1645 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1649 if (chunk_entries
!= 0)
1651 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1652 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1653 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1654 spltlittbl
->size
+= 8;
1663 /* Allocate space in ".got.loc" to match the total size of all the
1665 sgotloc
= htab
->sgotloc
;
1666 sgotloc
->size
= spltlittbl
->size
;
1667 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1669 if (abfd
->flags
& DYNAMIC
)
1671 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1673 if (! discarded_section (s
)
1674 && xtensa_is_littable_section (s
)
1676 sgotloc
->size
+= s
->size
;
1681 /* Allocate memory for dynamic sections. */
1684 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1688 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1691 /* It's OK to base decisions on the section name, because none
1692 of the dynobj section names depend upon the input files. */
1693 name
= bfd_section_name (s
);
1695 if (startswith (name
, ".rela"))
1699 if (strcmp (name
, ".rela.plt") == 0)
1701 else if (strcmp (name
, ".rela.got") == 0)
1704 /* We use the reloc_count field as a counter if we need
1705 to copy relocs into the output file. */
1709 else if (! startswith (name
, ".plt.")
1710 && ! startswith (name
, ".got.plt.")
1711 && strcmp (name
, ".got") != 0
1712 && strcmp (name
, ".plt") != 0
1713 && strcmp (name
, ".got.plt") != 0
1714 && strcmp (name
, ".xt.lit.plt") != 0
1715 && strcmp (name
, ".got.loc") != 0)
1717 /* It's not one of our sections, so don't allocate space. */
1723 /* If we don't need this section, strip it from the output
1724 file. We must create the ".plt*" and ".got.plt*"
1725 sections in create_dynamic_sections and/or check_relocs
1726 based on a conservative estimate of the PLT relocation
1727 count, because the sections must be created before the
1728 linker maps input sections to output sections. The
1729 linker does that before size_dynamic_sections, where we
1730 compute the exact size of the PLT, so there may be more
1731 of these sections than are actually needed. */
1732 s
->flags
|= SEC_EXCLUDE
;
1734 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1736 /* Allocate memory for the section contents. */
1737 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1738 if (s
->contents
== NULL
)
1743 if (elf_hash_table (info
)->dynamic_sections_created
)
1745 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1746 known until finish_dynamic_sections, but we need to get the relocs
1747 in place before they are sorted. */
1748 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1750 Elf_Internal_Rela irela
;
1754 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1757 loc
= (srelgot
->contents
1758 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1759 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1760 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1761 loc
+ sizeof (Elf32_External_Rela
));
1762 srelgot
->reloc_count
+= 2;
1765 /* Add some entries to the .dynamic section. We fill in the
1766 values later, in elf_xtensa_finish_dynamic_sections, but we
1767 must add the entries now so that we get the correct size for
1768 the .dynamic section. The DT_DEBUG entry is filled in by the
1769 dynamic linker and used by the debugger. */
1770 #define add_dynamic_entry(TAG, VAL) \
1771 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1773 if (!_bfd_elf_add_dynamic_tags (output_bfd
, info
,
1777 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1778 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1781 #undef add_dynamic_entry
1787 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1788 struct bfd_link_info
*info
)
1790 struct elf_xtensa_link_hash_table
*htab
;
1793 htab
= elf_xtensa_hash_table (info
);
1797 tls_sec
= htab
->elf
.tls_sec
;
1799 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1801 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1802 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1803 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1805 tlsbase
->type
= STT_TLS
;
1806 if (!(_bfd_generic_link_add_one_symbol
1807 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1808 tls_sec
, 0, NULL
, false,
1809 bed
->collect
, &bh
)))
1811 tlsbase
->def_regular
= 1;
1812 tlsbase
->other
= STV_HIDDEN
;
1813 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, true);
1820 /* Return the base VMA address which should be subtracted from real addresses
1821 when resolving @dtpoff relocation.
1822 This is PT_TLS segment p_vaddr. */
1825 dtpoff_base (struct bfd_link_info
*info
)
1827 /* If tls_sec is NULL, we should have signalled an error already. */
1828 if (elf_hash_table (info
)->tls_sec
== NULL
)
1830 return elf_hash_table (info
)->tls_sec
->vma
;
1833 /* Return the relocation value for @tpoff relocation
1834 if STT_TLS virtual address is ADDRESS. */
1837 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1839 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1842 /* If tls_sec is NULL, we should have signalled an error already. */
1843 if (htab
->tls_sec
== NULL
)
1845 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1846 return address
- htab
->tls_sec
->vma
+ base
;
1849 /* Perform the specified relocation. The instruction at (contents + address)
1850 is modified to set one operand to represent the value in "relocation". The
1851 operand position is determined by the relocation type recorded in the
1854 #define CALL_SEGMENT_BITS (30)
1855 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1857 static bfd_reloc_status_type
1858 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1860 asection
*input_section
,
1865 char **error_message
)
1868 xtensa_opcode opcode
;
1869 xtensa_isa isa
= xtensa_default_isa
;
1870 static xtensa_insnbuf ibuff
= NULL
;
1871 static xtensa_insnbuf sbuff
= NULL
;
1872 bfd_vma self_address
;
1873 bfd_size_type input_size
;
1879 ibuff
= xtensa_insnbuf_alloc (isa
);
1880 sbuff
= xtensa_insnbuf_alloc (isa
);
1883 input_size
= bfd_get_section_limit (abfd
, input_section
);
1885 /* Calculate the PC address for this instruction. */
1886 self_address
= (input_section
->output_section
->vma
1887 + input_section
->output_offset
1890 switch (howto
->type
)
1893 case R_XTENSA_DIFF8
:
1894 case R_XTENSA_DIFF16
:
1895 case R_XTENSA_DIFF32
:
1896 case R_XTENSA_PDIFF8
:
1897 case R_XTENSA_PDIFF16
:
1898 case R_XTENSA_PDIFF32
:
1899 case R_XTENSA_NDIFF8
:
1900 case R_XTENSA_NDIFF16
:
1901 case R_XTENSA_NDIFF32
:
1902 case R_XTENSA_TLS_FUNC
:
1903 case R_XTENSA_TLS_ARG
:
1904 case R_XTENSA_TLS_CALL
:
1905 return bfd_reloc_ok
;
1907 case R_XTENSA_ASM_EXPAND
:
1910 /* Check for windowed CALL across a 1GB boundary. */
1911 opcode
= get_expanded_call_opcode (contents
+ address
,
1912 input_size
- address
, 0);
1913 if (is_windowed_call_opcode (opcode
))
1915 if ((self_address
>> CALL_SEGMENT_BITS
)
1916 != (relocation
>> CALL_SEGMENT_BITS
))
1918 *error_message
= "windowed longcall crosses 1GB boundary; "
1920 return bfd_reloc_dangerous
;
1924 return bfd_reloc_ok
;
1926 case R_XTENSA_ASM_SIMPLIFY
:
1928 /* Convert the L32R/CALLX to CALL. */
1929 bfd_reloc_status_type retval
=
1930 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1932 if (retval
!= bfd_reloc_ok
)
1933 return bfd_reloc_dangerous
;
1935 /* The CALL needs to be relocated. Continue below for that part. */
1938 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1945 x
= bfd_get_32 (abfd
, contents
+ address
);
1947 bfd_put_32 (abfd
, x
, contents
+ address
);
1949 return bfd_reloc_ok
;
1951 case R_XTENSA_32_PCREL
:
1952 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1953 return bfd_reloc_ok
;
1956 case R_XTENSA_TLSDESC_FN
:
1957 case R_XTENSA_TLSDESC_ARG
:
1958 case R_XTENSA_TLS_DTPOFF
:
1959 case R_XTENSA_TLS_TPOFF
:
1960 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1961 return bfd_reloc_ok
;
1964 /* Only instruction slot-specific relocations handled below.... */
1965 slot
= get_relocation_slot (howto
->type
);
1966 if (slot
== XTENSA_UNDEFINED
)
1968 *error_message
= "unexpected relocation";
1969 return bfd_reloc_dangerous
;
1972 if (input_size
<= address
)
1973 return bfd_reloc_outofrange
;
1974 /* Read the instruction into a buffer and decode the opcode. */
1975 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1976 input_size
- address
);
1977 fmt
= xtensa_format_decode (isa
, ibuff
);
1978 if (fmt
== XTENSA_UNDEFINED
)
1980 *error_message
= "cannot decode instruction format";
1981 return bfd_reloc_dangerous
;
1984 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1986 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1987 if (opcode
== XTENSA_UNDEFINED
)
1989 *error_message
= "cannot decode instruction opcode";
1990 return bfd_reloc_dangerous
;
1993 /* Check for opcode-specific "alternate" relocations. */
1994 if (is_alt_relocation (howto
->type
))
1996 if (opcode
== get_l32r_opcode ())
1998 /* Handle the special-case of non-PC-relative L32R instructions. */
1999 bfd
*output_bfd
= input_section
->output_section
->owner
;
2000 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
2003 *error_message
= "relocation references missing .lit4 section";
2004 return bfd_reloc_dangerous
;
2006 self_address
= ((lit4_sec
->vma
& ~0xfff)
2007 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2008 newval
= relocation
;
2011 else if (opcode
== get_const16_opcode ())
2013 /* ALT used for high 16 bits.
2014 Ignore 32-bit overflow. */
2015 newval
= (relocation
>> 16) & 0xffff;
2020 /* No other "alternate" relocations currently defined. */
2021 *error_message
= "unexpected relocation";
2022 return bfd_reloc_dangerous
;
2025 else /* Not an "alternate" relocation.... */
2027 if (opcode
== get_const16_opcode ())
2029 newval
= relocation
& 0xffff;
2034 /* ...normal PC-relative relocation.... */
2036 /* Determine which operand is being relocated. */
2037 opnd
= get_relocation_opnd (opcode
, howto
->type
);
2038 if (opnd
== XTENSA_UNDEFINED
)
2040 *error_message
= "unexpected relocation";
2041 return bfd_reloc_dangerous
;
2044 if (!howto
->pc_relative
)
2046 *error_message
= "expected PC-relative relocation";
2047 return bfd_reloc_dangerous
;
2050 newval
= relocation
;
2054 /* Apply the relocation. */
2055 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
2056 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
2057 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2060 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2063 msg
= "cannot encode";
2064 if (is_direct_call_opcode (opcode
))
2066 if ((relocation
& 0x3) != 0)
2067 msg
= "misaligned call target";
2069 msg
= "call target out of range";
2071 else if (opcode
== get_l32r_opcode ())
2073 if ((relocation
& 0x3) != 0)
2074 msg
= "misaligned literal target";
2075 else if (is_alt_relocation (howto
->type
))
2076 msg
= "literal target out of range (too many literals)";
2077 else if (self_address
> relocation
)
2078 msg
= "literal target out of range (try using text-section-literals)";
2080 msg
= "literal placed after use";
2083 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2084 return bfd_reloc_dangerous
;
2087 /* Check for calls across 1GB boundaries. */
2088 if (is_direct_call_opcode (opcode
)
2089 && is_windowed_call_opcode (opcode
))
2091 if ((self_address
>> CALL_SEGMENT_BITS
)
2092 != (relocation
>> CALL_SEGMENT_BITS
))
2095 "windowed call crosses 1GB boundary; return may fail";
2096 return bfd_reloc_dangerous
;
2100 /* Write the modified instruction back out of the buffer. */
2101 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2102 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2103 input_size
- address
);
2104 return bfd_reloc_ok
;
2109 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2111 /* To reduce the size of the memory leak,
2112 we only use a single message buffer. */
2113 static bfd_size_type alloc_size
= 0;
2114 static char *message
= NULL
;
2115 bfd_size_type orig_len
, len
= 0;
2119 va_start (ap
, arglen
);
2121 is_append
= (origmsg
== message
);
2123 orig_len
= strlen (origmsg
);
2124 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2125 if (len
> alloc_size
)
2127 message
= (char *) bfd_realloc_or_free (message
, len
);
2130 if (message
!= NULL
)
2133 memcpy (message
, origmsg
, orig_len
);
2134 vsprintf (message
+ orig_len
, fmt
, ap
);
2141 /* This function is registered as the "special_function" in the
2142 Xtensa howto for handling simplify operations.
2143 bfd_perform_relocation / bfd_install_relocation use it to
2144 perform (install) the specified relocation. Since this replaces the code
2145 in bfd_perform_relocation, it is basically an Xtensa-specific,
2146 stripped-down version of bfd_perform_relocation. */
2148 static bfd_reloc_status_type
2149 bfd_elf_xtensa_reloc (bfd
*abfd
,
2150 arelent
*reloc_entry
,
2153 asection
*input_section
,
2155 char **error_message
)
2158 bfd_reloc_status_type flag
;
2159 bfd_size_type octets
= (reloc_entry
->address
2160 * OCTETS_PER_BYTE (abfd
, input_section
));
2161 bfd_vma output_base
= 0;
2162 reloc_howto_type
*howto
= reloc_entry
->howto
;
2163 asection
*reloc_target_output_section
;
2166 if (!xtensa_default_isa
)
2167 xtensa_default_isa
= xtensa_isa_init (0, 0);
2169 /* ELF relocs are against symbols. If we are producing relocatable
2170 output, and the reloc is against an external symbol, the resulting
2171 reloc will also be against the same symbol. In such a case, we
2172 don't want to change anything about the way the reloc is handled,
2173 since it will all be done at final link time. This test is similar
2174 to what bfd_elf_generic_reloc does except that it lets relocs with
2175 howto->partial_inplace go through even if the addend is non-zero.
2176 (The real problem is that partial_inplace is set for XTENSA_32
2177 relocs to begin with, but that's a long story and there's little we
2178 can do about it now....) */
2180 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2182 reloc_entry
->address
+= input_section
->output_offset
;
2183 return bfd_reloc_ok
;
2186 /* Is the address of the relocation really within the section? */
2187 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2188 return bfd_reloc_outofrange
;
2190 /* Work out which section the relocation is targeted at and the
2191 initial relocation command value. */
2193 /* Get symbol value. (Common symbols are special.) */
2194 if (bfd_is_com_section (symbol
->section
))
2197 relocation
= symbol
->value
;
2199 reloc_target_output_section
= symbol
->section
->output_section
;
2201 /* Convert input-section-relative symbol value to absolute. */
2202 if ((output_bfd
&& !howto
->partial_inplace
)
2203 || reloc_target_output_section
== NULL
)
2206 output_base
= reloc_target_output_section
->vma
;
2208 relocation
+= output_base
+ symbol
->section
->output_offset
;
2210 /* Add in supplied addend. */
2211 relocation
+= reloc_entry
->addend
;
2213 /* Here the variable relocation holds the final address of the
2214 symbol we are relocating against, plus any addend. */
2217 if (!howto
->partial_inplace
)
2219 /* This is a partial relocation, and we want to apply the relocation
2220 to the reloc entry rather than the raw data. Everything except
2221 relocations against section symbols has already been handled
2224 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2225 reloc_entry
->addend
= relocation
;
2226 reloc_entry
->address
+= input_section
->output_offset
;
2227 return bfd_reloc_ok
;
2231 reloc_entry
->address
+= input_section
->output_offset
;
2232 reloc_entry
->addend
= 0;
2236 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2237 && (symbol
->flags
& BSF_WEAK
) != 0);
2238 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2239 (bfd_byte
*) data
, (bfd_vma
) octets
,
2240 is_weak_undef
, error_message
);
2242 if (flag
== bfd_reloc_dangerous
)
2244 /* Add the symbol name to the error message. */
2245 if (! *error_message
)
2246 *error_message
= "";
2247 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2248 strlen (symbol
->name
) + 17,
2250 (unsigned long) reloc_entry
->addend
);
2256 int xtensa_abi_choice (void)
2258 if (elf32xtensa_abi
== XTHAL_ABI_UNDEFINED
)
2261 return elf32xtensa_abi
;
2264 /* Set up an entry in the procedure linkage table. */
2267 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2269 unsigned reloc_index
)
2271 asection
*splt
, *sgotplt
;
2272 bfd_vma plt_base
, got_base
;
2273 bfd_vma code_offset
, lit_offset
, abi_offset
;
2275 int abi
= xtensa_abi_choice ();
2277 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2278 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2279 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2280 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2282 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2283 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2285 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2286 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2288 /* Fill in the literal entry. This is the offset of the dynamic
2289 relocation entry. */
2290 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2291 sgotplt
->contents
+ lit_offset
);
2293 /* Fill in the entry in the procedure linkage table. */
2294 memcpy (splt
->contents
+ code_offset
,
2295 (bfd_big_endian (output_bfd
)
2296 ? elf_xtensa_be_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]
2297 : elf_xtensa_le_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]),
2299 abi_offset
= abi
== XTHAL_ABI_WINDOWED
? 3 : 0;
2300 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2301 plt_base
+ code_offset
+ abi_offset
),
2302 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2303 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2304 plt_base
+ code_offset
+ abi_offset
+ 3),
2305 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2306 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2307 plt_base
+ code_offset
+ abi_offset
+ 6),
2308 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2310 return plt_base
+ code_offset
;
2314 static bool get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2317 replace_tls_insn (Elf_Internal_Rela
*rel
,
2319 asection
*input_section
,
2322 char **error_message
)
2324 static xtensa_insnbuf ibuff
= NULL
;
2325 static xtensa_insnbuf sbuff
= NULL
;
2326 xtensa_isa isa
= xtensa_default_isa
;
2328 xtensa_opcode old_op
, new_op
;
2329 bfd_size_type input_size
;
2331 unsigned dest_reg
, src_reg
;
2335 ibuff
= xtensa_insnbuf_alloc (isa
);
2336 sbuff
= xtensa_insnbuf_alloc (isa
);
2339 input_size
= bfd_get_section_limit (abfd
, input_section
);
2341 /* Read the instruction into a buffer and decode the opcode. */
2342 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2343 input_size
- rel
->r_offset
);
2344 fmt
= xtensa_format_decode (isa
, ibuff
);
2345 if (fmt
== XTENSA_UNDEFINED
)
2347 *error_message
= "cannot decode instruction format";
2351 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2352 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2354 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2355 if (old_op
== XTENSA_UNDEFINED
)
2357 *error_message
= "cannot decode instruction opcode";
2361 r_type
= ELF32_R_TYPE (rel
->r_info
);
2364 case R_XTENSA_TLS_FUNC
:
2365 case R_XTENSA_TLS_ARG
:
2366 if (old_op
!= get_l32r_opcode ()
2367 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2368 sbuff
, &dest_reg
) != 0)
2370 *error_message
= "cannot extract L32R destination for TLS access";
2375 case R_XTENSA_TLS_CALL
:
2376 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2377 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2378 sbuff
, &src_reg
) != 0)
2380 *error_message
= "cannot extract CALLXn operands for TLS access";
2393 case R_XTENSA_TLS_FUNC
:
2394 case R_XTENSA_TLS_ARG
:
2395 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2396 versions of Xtensa). */
2397 new_op
= xtensa_opcode_lookup (isa
, "nop");
2398 if (new_op
== XTENSA_UNDEFINED
)
2400 new_op
= xtensa_opcode_lookup (isa
, "or");
2401 if (new_op
== XTENSA_UNDEFINED
2402 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2403 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2405 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2407 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2410 *error_message
= "cannot encode OR for TLS access";
2416 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2418 *error_message
= "cannot encode NOP for TLS access";
2424 case R_XTENSA_TLS_CALL
:
2425 /* Read THREADPTR into the CALLX's return value register. */
2426 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2427 if (new_op
== XTENSA_UNDEFINED
2428 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2429 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2430 sbuff
, dest_reg
+ 2) != 0)
2432 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2442 case R_XTENSA_TLS_FUNC
:
2443 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2444 if (new_op
== XTENSA_UNDEFINED
2445 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2446 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2447 sbuff
, dest_reg
) != 0)
2449 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2454 case R_XTENSA_TLS_ARG
:
2455 /* Nothing to do. Keep the original L32R instruction. */
2458 case R_XTENSA_TLS_CALL
:
2459 /* Add the CALLX's src register (holding the THREADPTR value)
2460 to the first argument register (holding the offset) and put
2461 the result in the CALLX's return value register. */
2462 new_op
= xtensa_opcode_lookup (isa
, "add");
2463 if (new_op
== XTENSA_UNDEFINED
2464 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2465 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2466 sbuff
, dest_reg
+ 2) != 0
2467 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2468 sbuff
, dest_reg
+ 2) != 0
2469 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2470 sbuff
, src_reg
) != 0)
2472 *error_message
= "cannot encode ADD for TLS access";
2479 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2480 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2481 input_size
- rel
->r_offset
);
2487 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2488 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2489 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2490 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2491 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2492 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2493 || (R_TYPE) == R_XTENSA_TLS_ARG \
2494 || (R_TYPE) == R_XTENSA_TLS_CALL)
2496 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2497 both relocatable and final links. */
2500 elf_xtensa_relocate_section (bfd
*output_bfd
,
2501 struct bfd_link_info
*info
,
2503 asection
*input_section
,
2505 Elf_Internal_Rela
*relocs
,
2506 Elf_Internal_Sym
*local_syms
,
2507 asection
**local_sections
)
2509 struct elf_xtensa_link_hash_table
*htab
;
2510 Elf_Internal_Shdr
*symtab_hdr
;
2511 Elf_Internal_Rela
*rel
;
2512 Elf_Internal_Rela
*relend
;
2513 struct elf_link_hash_entry
**sym_hashes
;
2514 property_table_entry
*lit_table
= 0;
2516 char *local_got_tls_types
;
2517 char *error_message
= NULL
;
2518 bfd_size_type input_size
;
2521 if (!xtensa_default_isa
)
2522 xtensa_default_isa
= xtensa_isa_init (0, 0);
2524 if (!is_xtensa_elf (input_bfd
))
2526 bfd_set_error (bfd_error_wrong_format
);
2530 htab
= elf_xtensa_hash_table (info
);
2534 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2535 sym_hashes
= elf_sym_hashes (input_bfd
);
2536 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2538 if (elf_hash_table (info
)->dynamic_sections_created
)
2540 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2541 &lit_table
, XTENSA_LIT_SEC_NAME
,
2547 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2550 relend
= relocs
+ input_section
->reloc_count
;
2551 for (; rel
< relend
; rel
++)
2554 reloc_howto_type
*howto
;
2555 unsigned long r_symndx
;
2556 struct elf_link_hash_entry
*h
;
2557 Elf_Internal_Sym
*sym
;
2562 bfd_reloc_status_type r
;
2564 bool unresolved_reloc
;
2566 bool dynamic_symbol
;
2568 r_type
= ELF32_R_TYPE (rel
->r_info
);
2569 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2570 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2573 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2575 bfd_set_error (bfd_error_bad_value
);
2578 howto
= &elf_howto_table
[r_type
];
2580 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2585 is_weak_undef
= false;
2586 unresolved_reloc
= false;
2589 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2591 /* Because R_XTENSA_32 was made partial_inplace to fix some
2592 problems with DWARF info in partial links, there may be
2593 an addend stored in the contents. Take it out of there
2594 and move it back into the addend field of the reloc. */
2595 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2596 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2599 if (r_symndx
< symtab_hdr
->sh_info
)
2601 sym
= local_syms
+ r_symndx
;
2602 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2603 sec
= local_sections
[r_symndx
];
2604 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2610 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2611 r_symndx
, symtab_hdr
, sym_hashes
,
2613 unresolved_reloc
, warned
, ignored
);
2616 && !unresolved_reloc
2617 && h
->root
.type
== bfd_link_hash_undefweak
)
2618 is_weak_undef
= true;
2623 if (sec
!= NULL
&& discarded_section (sec
))
2624 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2625 rel
, 1, relend
, howto
, 0, contents
);
2627 if (bfd_link_relocatable (info
))
2630 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2632 /* This is a relocatable link.
2633 1) If the reloc is against a section symbol, adjust
2634 according to the output section.
2635 2) If there is a new target for this relocation,
2636 the new target will be in the same output section.
2637 We adjust the relocation by the output section
2640 if (relaxing_section
)
2642 /* Check if this references a section in another input file. */
2643 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2648 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2649 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2651 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2653 error_message
= NULL
;
2654 /* Convert ASM_SIMPLIFY into the simpler relocation
2655 so that they never escape a relaxing link. */
2656 r
= contract_asm_expansion (contents
, input_size
, rel
,
2658 if (r
!= bfd_reloc_ok
)
2659 (*info
->callbacks
->reloc_dangerous
)
2660 (info
, error_message
,
2661 input_bfd
, input_section
, rel
->r_offset
);
2663 r_type
= ELF32_R_TYPE (rel
->r_info
);
2666 /* This is a relocatable link, so we don't have to change
2667 anything unless the reloc is against a section symbol,
2668 in which case we have to adjust according to where the
2669 section symbol winds up in the output section. */
2670 if (r_symndx
< symtab_hdr
->sh_info
)
2672 sym
= local_syms
+ r_symndx
;
2673 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2675 sec
= local_sections
[r_symndx
];
2676 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2680 /* If there is an addend with a partial_inplace howto,
2681 then move the addend to the contents. This is a hack
2682 to work around problems with DWARF in relocatable links
2683 with some previous version of BFD. Now we can't easily get
2684 rid of the hack without breaking backward compatibility.... */
2686 howto
= &elf_howto_table
[r_type
];
2687 if (howto
->partial_inplace
&& rel
->r_addend
)
2689 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2690 rel
->r_addend
, contents
,
2691 rel
->r_offset
, false,
2697 /* Put the correct bits in the target instruction, even
2698 though the relocation will still be present in the output
2699 file. This makes disassembly clearer, as well as
2700 allowing loadable kernel modules to work without needing
2701 relocations on anything other than calls and l32r's. */
2703 /* If it is not in the same section, there is nothing we can do. */
2704 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2705 sym_sec
->output_section
== input_section
->output_section
)
2707 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2708 dest_addr
, contents
,
2709 rel
->r_offset
, false,
2713 if (r
!= bfd_reloc_ok
)
2714 (*info
->callbacks
->reloc_dangerous
)
2715 (info
, error_message
,
2716 input_bfd
, input_section
, rel
->r_offset
);
2718 /* Done with work for relocatable link; continue with next reloc. */
2722 /* This is a final link. */
2724 if (relaxing_section
)
2726 /* Check if this references a section in another input file. */
2727 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2731 /* Sanity check the address. */
2732 if (rel
->r_offset
>= input_size
2733 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2736 /* xgettext:c-format */
2737 (_("%pB(%pA+%#" PRIx64
"): "
2738 "relocation offset out of range (size=%#" PRIx64
")"),
2739 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2740 (uint64_t) input_size
);
2741 bfd_set_error (bfd_error_bad_value
);
2746 name
= h
->root
.root
.string
;
2749 name
= (bfd_elf_string_from_elf_section
2750 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2751 if (name
== NULL
|| *name
== '\0')
2752 name
= bfd_section_name (sec
);
2755 if (r_symndx
!= STN_UNDEF
2756 && r_type
!= R_XTENSA_NONE
2758 || h
->root
.type
== bfd_link_hash_defined
2759 || h
->root
.type
== bfd_link_hash_defweak
)
2760 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2763 ((sym_type
== STT_TLS
2764 /* xgettext:c-format */
2765 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2766 /* xgettext:c-format */
2767 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2770 (uint64_t) rel
->r_offset
,
2775 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2777 tls_type
= GOT_UNKNOWN
;
2779 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2780 else if (local_got_tls_types
)
2781 tls_type
= local_got_tls_types
[r_symndx
];
2787 if (elf_hash_table (info
)->dynamic_sections_created
2788 && (input_section
->flags
& SEC_ALLOC
) != 0
2789 && (dynamic_symbol
|| bfd_link_pic (info
)))
2791 Elf_Internal_Rela outrel
;
2795 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2796 srel
= htab
->elf
.srelplt
;
2798 srel
= htab
->elf
.srelgot
;
2800 BFD_ASSERT (srel
!= NULL
);
2803 _bfd_elf_section_offset (output_bfd
, info
,
2804 input_section
, rel
->r_offset
);
2806 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2807 memset (&outrel
, 0, sizeof outrel
);
2810 outrel
.r_offset
+= (input_section
->output_section
->vma
2811 + input_section
->output_offset
);
2813 /* Complain if the relocation is in a read-only section
2814 and not in a literal pool. */
2815 if ((input_section
->flags
& SEC_READONLY
) != 0
2816 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2820 _("dynamic relocation in read-only section");
2821 (*info
->callbacks
->reloc_dangerous
)
2822 (info
, error_message
,
2823 input_bfd
, input_section
, rel
->r_offset
);
2828 outrel
.r_addend
= rel
->r_addend
;
2831 if (r_type
== R_XTENSA_32
)
2834 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2837 else /* r_type == R_XTENSA_PLT */
2840 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2842 /* Create the PLT entry and set the initial
2843 contents of the literal entry to the address of
2846 elf_xtensa_create_plt_entry (info
, output_bfd
,
2849 unresolved_reloc
= false;
2851 else if (!is_weak_undef
)
2853 /* Generate a RELATIVE relocation. */
2854 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2855 outrel
.r_addend
= 0;
2863 loc
= (srel
->contents
2864 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2865 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2866 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2869 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2871 /* This should only happen for non-PIC code, which is not
2872 supposed to be used on systems with dynamic linking.
2873 Just ignore these relocations. */
2878 case R_XTENSA_TLS_TPOFF
:
2879 /* Switch to LE model for local symbols in an executable. */
2880 if (! bfd_link_pic (info
) && ! dynamic_symbol
)
2882 relocation
= tpoff (info
, relocation
);
2887 case R_XTENSA_TLSDESC_FN
:
2888 case R_XTENSA_TLSDESC_ARG
:
2890 if (r_type
== R_XTENSA_TLSDESC_FN
)
2892 if (! bfd_link_pic (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2893 r_type
= R_XTENSA_NONE
;
2895 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2897 if (bfd_link_pic (info
))
2899 if ((tls_type
& GOT_TLS_IE
) != 0)
2900 r_type
= R_XTENSA_TLS_TPOFF
;
2904 r_type
= R_XTENSA_TLS_TPOFF
;
2905 if (! dynamic_symbol
)
2907 relocation
= tpoff (info
, relocation
);
2913 if (r_type
== R_XTENSA_NONE
)
2914 /* Nothing to do here; skip to the next reloc. */
2917 if (! elf_hash_table (info
)->dynamic_sections_created
)
2920 _("TLS relocation invalid without dynamic sections");
2921 (*info
->callbacks
->reloc_dangerous
)
2922 (info
, error_message
,
2923 input_bfd
, input_section
, rel
->r_offset
);
2927 Elf_Internal_Rela outrel
;
2929 asection
*srel
= htab
->elf
.srelgot
;
2932 outrel
.r_offset
= (input_section
->output_section
->vma
2933 + input_section
->output_offset
2936 /* Complain if the relocation is in a read-only section
2937 and not in a literal pool. */
2938 if ((input_section
->flags
& SEC_READONLY
) != 0
2939 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2943 _("dynamic relocation in read-only section");
2944 (*info
->callbacks
->reloc_dangerous
)
2945 (info
, error_message
,
2946 input_bfd
, input_section
, rel
->r_offset
);
2949 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2951 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2953 outrel
.r_addend
= 0;
2956 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2958 unresolved_reloc
= false;
2961 loc
= (srel
->contents
2962 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2963 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2964 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2970 case R_XTENSA_TLS_DTPOFF
:
2971 if (! bfd_link_pic (info
))
2972 /* Switch from LD model to LE model. */
2973 relocation
= tpoff (info
, relocation
);
2975 relocation
-= dtpoff_base (info
);
2978 case R_XTENSA_TLS_FUNC
:
2979 case R_XTENSA_TLS_ARG
:
2980 case R_XTENSA_TLS_CALL
:
2981 /* Check if optimizing to IE or LE model. */
2982 if ((tls_type
& GOT_TLS_IE
) != 0)
2985 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
2986 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
2987 is_ld_model
, &error_message
))
2988 (*info
->callbacks
->reloc_dangerous
)
2989 (info
, error_message
,
2990 input_bfd
, input_section
, rel
->r_offset
);
2992 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
2994 /* Skip subsequent relocations on the same instruction. */
2995 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
3002 if (elf_hash_table (info
)->dynamic_sections_created
3003 && dynamic_symbol
&& (is_operand_relocation (r_type
)
3004 || r_type
== R_XTENSA_32_PCREL
))
3007 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3008 strlen (name
) + 2, name
);
3009 (*info
->callbacks
->reloc_dangerous
)
3010 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3016 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3017 because such sections are not SEC_ALLOC and thus ld.so will
3018 not process them. */
3019 if (unresolved_reloc
3020 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3022 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3023 rel
->r_offset
) != (bfd_vma
) -1)
3026 /* xgettext:c-format */
3027 (_("%pB(%pA+%#" PRIx64
"): "
3028 "unresolvable %s relocation against symbol `%s'"),
3031 (uint64_t) rel
->r_offset
,
3037 /* TLS optimizations may have changed r_type; update "howto". */
3038 howto
= &elf_howto_table
[r_type
];
3040 /* There's no point in calling bfd_perform_relocation here.
3041 Just go directly to our "special function". */
3042 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
3043 relocation
+ rel
->r_addend
,
3044 contents
, rel
->r_offset
, is_weak_undef
,
3047 if (r
!= bfd_reloc_ok
&& !warned
)
3049 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
3050 BFD_ASSERT (error_message
!= NULL
);
3052 if (rel
->r_addend
== 0)
3053 error_message
= vsprint_msg (error_message
, ": %s",
3054 strlen (name
) + 2, name
);
3056 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
3058 name
, (int) rel
->r_addend
);
3060 (*info
->callbacks
->reloc_dangerous
)
3061 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3066 input_section
->reloc_done
= true;
3072 /* Finish up dynamic symbol handling. There's not much to do here since
3073 the PLT and GOT entries are all set up by relocate_section. */
3076 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3077 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3078 struct elf_link_hash_entry
*h
,
3079 Elf_Internal_Sym
*sym
)
3081 if (h
->needs_plt
&& !h
->def_regular
)
3083 /* Mark the symbol as undefined, rather than as defined in
3084 the .plt section. Leave the value alone. */
3085 sym
->st_shndx
= SHN_UNDEF
;
3086 /* If the symbol is weak, we do need to clear the value.
3087 Otherwise, the PLT entry would provide a definition for
3088 the symbol even if the symbol wasn't defined anywhere,
3089 and so the symbol would never be NULL. */
3090 if (!h
->ref_regular_nonweak
)
3094 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3095 if (h
== elf_hash_table (info
)->hdynamic
3096 || h
== elf_hash_table (info
)->hgot
)
3097 sym
->st_shndx
= SHN_ABS
;
3103 /* Combine adjacent literal table entries in the output. Adjacent
3104 entries within each input section may have been removed during
3105 relaxation, but we repeat the process here, even though it's too late
3106 to shrink the output section, because it's important to minimize the
3107 number of literal table entries to reduce the start-up work for the
3108 runtime linker. Returns the number of remaining table entries or -1
3112 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3117 property_table_entry
*table
;
3118 bfd_size_type section_size
, sgotloc_size
;
3122 section_size
= sxtlit
->size
;
3123 if (section_size
== 0)
3126 BFD_ASSERT (section_size
% 8 == 0);
3127 num
= section_size
/ 8;
3129 sgotloc_size
= sgotloc
->size
;
3130 if (sgotloc_size
!= section_size
)
3133 (_("internal inconsistency in size of .got.loc section"));
3137 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3141 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3142 propagates to the output section, where it doesn't really apply and
3143 where it breaks the following call to bfd_malloc_and_get_section. */
3144 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3146 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3153 /* There should never be any relocations left at this point, so this
3154 is quite a bit easier than what is done during relaxation. */
3156 /* Copy the raw contents into a property table array and sort it. */
3158 for (n
= 0; n
< num
; n
++)
3160 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3161 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3164 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3166 for (n
= 0; n
< num
; n
++)
3168 bool remove_entry
= false;
3170 if (table
[n
].size
== 0)
3171 remove_entry
= true;
3173 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3175 table
[n
-1].size
+= table
[n
].size
;
3176 remove_entry
= true;
3181 for (m
= n
; m
< num
- 1; m
++)
3183 table
[m
].address
= table
[m
+1].address
;
3184 table
[m
].size
= table
[m
+1].size
;
3192 /* Copy the data back to the raw contents. */
3194 for (n
= 0; n
< num
; n
++)
3196 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3197 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3201 /* Clear the removed bytes. */
3202 if ((bfd_size_type
) (num
* 8) < section_size
)
3203 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3205 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3209 /* Copy the contents to ".got.loc". */
3210 memcpy (sgotloc
->contents
, contents
, section_size
);
3218 /* Finish up the dynamic sections. */
3221 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3222 struct bfd_link_info
*info
)
3224 struct elf_xtensa_link_hash_table
*htab
;
3226 asection
*sdyn
, *srelplt
, *srelgot
, *sgot
, *sxtlit
, *sgotloc
;
3227 Elf32_External_Dyn
*dyncon
, *dynconend
;
3228 int num_xtlit_entries
= 0;
3230 if (! elf_hash_table (info
)->dynamic_sections_created
)
3233 htab
= elf_xtensa_hash_table (info
);
3237 dynobj
= elf_hash_table (info
)->dynobj
;
3238 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3239 BFD_ASSERT (sdyn
!= NULL
);
3241 /* Set the first entry in the global offset table to the address of
3242 the dynamic section. */
3243 sgot
= htab
->elf
.sgot
;
3246 BFD_ASSERT (sgot
->size
== 4);
3248 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3250 bfd_put_32 (output_bfd
,
3251 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3255 srelplt
= htab
->elf
.srelplt
;
3256 srelgot
= htab
->elf
.srelgot
;
3257 if (srelplt
&& srelplt
->size
!= 0)
3259 asection
*sgotplt
, *spltlittbl
;
3260 int chunk
, plt_chunks
, plt_entries
;
3261 Elf_Internal_Rela irela
;
3263 unsigned rtld_reloc
;
3265 spltlittbl
= htab
->spltlittbl
;
3266 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3268 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3269 of them follow immediately after.... */
3270 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3272 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3273 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3274 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3277 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3279 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3281 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3283 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3285 int chunk_entries
= 0;
3287 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3288 BFD_ASSERT (sgotplt
!= NULL
);
3290 /* Emit special RTLD relocations for the first two entries in
3291 each chunk of the .got.plt section. */
3293 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3294 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3295 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3296 irela
.r_offset
= (sgotplt
->output_section
->vma
3297 + sgotplt
->output_offset
);
3298 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3299 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3301 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3303 /* Next literal immediately follows the first. */
3304 loc
+= sizeof (Elf32_External_Rela
);
3305 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3306 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3307 irela
.r_offset
= (sgotplt
->output_section
->vma
3308 + sgotplt
->output_offset
+ 4);
3309 /* Tell rtld to set value to object's link map. */
3311 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3313 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3315 /* Fill in the literal table. */
3316 if (chunk
< plt_chunks
- 1)
3317 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3319 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3321 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3322 bfd_put_32 (output_bfd
,
3323 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3324 spltlittbl
->contents
+ (chunk
* 8) + 0);
3325 bfd_put_32 (output_bfd
,
3326 8 + (chunk_entries
* 4),
3327 spltlittbl
->contents
+ (chunk
* 8) + 4);
3330 /* The .xt.lit.plt section has just been modified. This must
3331 happen before the code below which combines adjacent literal
3332 table entries, and the .xt.lit.plt contents have to be forced to
3334 if (! bfd_set_section_contents (output_bfd
,
3335 spltlittbl
->output_section
,
3336 spltlittbl
->contents
,
3337 spltlittbl
->output_offset
,
3340 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3341 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3344 /* All the dynamic relocations have been emitted at this point.
3345 Make sure the relocation sections are the correct size. */
3346 if ((srelgot
&& srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3347 * srelgot
->reloc_count
))
3348 || (srelplt
&& srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3349 * srelplt
->reloc_count
)))
3352 /* Combine adjacent literal table entries. */
3353 BFD_ASSERT (! bfd_link_relocatable (info
));
3354 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3355 sgotloc
= htab
->sgotloc
;
3356 BFD_ASSERT (sgotloc
);
3360 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3361 if (num_xtlit_entries
< 0)
3365 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3366 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3367 for (; dyncon
< dynconend
; dyncon
++)
3369 Elf_Internal_Dyn dyn
;
3371 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3378 case DT_XTENSA_GOT_LOC_SZ
:
3379 dyn
.d_un
.d_val
= num_xtlit_entries
;
3382 case DT_XTENSA_GOT_LOC_OFF
:
3383 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3384 + htab
->sgotloc
->output_offset
);
3388 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3389 + htab
->elf
.sgot
->output_offset
);
3393 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3394 + htab
->elf
.srelplt
->output_offset
);
3398 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3402 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3409 /* Functions for dealing with the e_flags field. */
3411 /* Merge backend specific data from an object file to the output
3412 object file when linking. */
3415 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3417 bfd
*obfd
= info
->output_bfd
;
3418 unsigned out_mach
, in_mach
;
3419 flagword out_flag
, in_flag
;
3421 /* Check if we have the same endianness. */
3422 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3425 /* Don't even pretend to support mixed-format linking. */
3426 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3427 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3430 out_flag
= elf_elfheader (obfd
)->e_flags
;
3431 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3433 out_mach
= out_flag
& EF_XTENSA_MACH
;
3434 in_mach
= in_flag
& EF_XTENSA_MACH
;
3435 if (out_mach
!= in_mach
)
3438 /* xgettext:c-format */
3439 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3440 ibfd
, out_mach
, in_mach
);
3441 bfd_set_error (bfd_error_wrong_format
);
3445 if (! elf_flags_init (obfd
))
3447 elf_flags_init (obfd
) = true;
3448 elf_elfheader (obfd
)->e_flags
= in_flag
;
3450 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3451 && bfd_get_arch_info (obfd
)->the_default
)
3452 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3453 bfd_get_mach (ibfd
));
3458 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3459 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3461 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3462 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3469 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3471 BFD_ASSERT (!elf_flags_init (abfd
)
3472 || elf_elfheader (abfd
)->e_flags
== flags
);
3474 elf_elfheader (abfd
)->e_flags
|= flags
;
3475 elf_flags_init (abfd
) = true;
3482 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3484 FILE *f
= (FILE *) farg
;
3485 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3487 fprintf (f
, "\nXtensa header:\n");
3488 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3489 fprintf (f
, "\nMachine = Base\n");
3491 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3493 fprintf (f
, "Insn tables = %s\n",
3494 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3496 fprintf (f
, "Literal tables = %s\n",
3497 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3499 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3503 /* Set the right machine number for an Xtensa ELF file. */
3506 elf_xtensa_object_p (bfd
*abfd
)
3509 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3514 mach
= bfd_mach_xtensa
;
3520 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3525 /* The final processing done just before writing out an Xtensa ELF object
3526 file. This gets the Xtensa architecture right based on the machine
3530 elf_xtensa_final_write_processing (bfd
*abfd
)
3533 unsigned long val
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3535 switch (mach
= bfd_get_mach (abfd
))
3537 case bfd_mach_xtensa
:
3538 val
= E_XTENSA_MACH
;
3544 elf_elfheader (abfd
)->e_flags
&= ~EF_XTENSA_MACH
;
3545 elf_elfheader (abfd
)->e_flags
|= val
;
3546 return _bfd_elf_final_write_processing (abfd
);
3550 static enum elf_reloc_type_class
3551 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3552 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3553 const Elf_Internal_Rela
*rela
)
3555 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3557 case R_XTENSA_RELATIVE
:
3558 return reloc_class_relative
;
3559 case R_XTENSA_JMP_SLOT
:
3560 return reloc_class_plt
;
3562 return reloc_class_normal
;
3568 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3569 struct elf_reloc_cookie
*cookie
,
3570 struct bfd_link_info
*info
,
3574 bfd_vma offset
, actual_offset
;
3575 bfd_size_type removed_bytes
= 0;
3576 bfd_size_type entry_size
;
3578 if (sec
->output_section
3579 && bfd_is_abs_section (sec
->output_section
))
3582 if (xtensa_is_proptable_section (sec
))
3587 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3590 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3594 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3597 release_contents (sec
, contents
);
3601 /* Sort the relocations. They should already be in order when
3602 relaxation is enabled, but it might not be. */
3603 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3604 internal_reloc_compare
);
3606 cookie
->rel
= cookie
->rels
;
3607 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3609 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3611 actual_offset
= offset
- removed_bytes
;
3613 /* The ...symbol_deleted_p function will skip over relocs but it
3614 won't adjust their offsets, so do that here. */
3615 while (cookie
->rel
< cookie
->relend
3616 && cookie
->rel
->r_offset
< offset
)
3618 cookie
->rel
->r_offset
-= removed_bytes
;
3622 while (cookie
->rel
< cookie
->relend
3623 && cookie
->rel
->r_offset
== offset
)
3625 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3627 /* Remove the table entry. (If the reloc type is NONE, then
3628 the entry has already been merged with another and deleted
3629 during relaxation.) */
3630 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3632 /* Shift the contents up. */
3633 if (offset
+ entry_size
< sec
->size
)
3634 memmove (&contents
[actual_offset
],
3635 &contents
[actual_offset
+ entry_size
],
3636 sec
->size
- offset
- entry_size
);
3637 removed_bytes
+= entry_size
;
3640 /* Remove this relocation. */
3641 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3644 /* Adjust the relocation offset for previous removals. This
3645 should not be done before calling ...symbol_deleted_p
3646 because it might mess up the offset comparisons there.
3647 Make sure the offset doesn't underflow in the case where
3648 the first entry is removed. */
3649 if (cookie
->rel
->r_offset
>= removed_bytes
)
3650 cookie
->rel
->r_offset
-= removed_bytes
;
3652 cookie
->rel
->r_offset
= 0;
3658 if (removed_bytes
!= 0)
3660 /* Adjust any remaining relocs (shouldn't be any). */
3661 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3663 if (cookie
->rel
->r_offset
>= removed_bytes
)
3664 cookie
->rel
->r_offset
-= removed_bytes
;
3666 cookie
->rel
->r_offset
= 0;
3669 /* Clear the removed bytes. */
3670 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3672 pin_contents (sec
, contents
);
3673 pin_internal_relocs (sec
, cookie
->rels
);
3676 if (sec
->rawsize
== 0)
3677 sec
->rawsize
= sec
->size
;
3678 sec
->size
-= removed_bytes
;
3680 if (xtensa_is_littable_section (sec
))
3682 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3684 sgotloc
->size
-= removed_bytes
;
3689 release_contents (sec
, contents
);
3690 release_internal_relocs (sec
, cookie
->rels
);
3693 return (removed_bytes
!= 0);
3698 elf_xtensa_discard_info (bfd
*abfd
,
3699 struct elf_reloc_cookie
*cookie
,
3700 struct bfd_link_info
*info
)
3703 bool changed
= false;
3705 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3707 if (xtensa_is_property_section (sec
))
3709 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3719 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3721 return xtensa_is_property_section (sec
);
3726 elf_xtensa_action_discarded (asection
*sec
)
3728 if (strcmp (".xt_except_table", sec
->name
) == 0)
3731 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3734 return _bfd_elf_default_action_discarded (sec
);
3738 /* Support for core dump NOTE sections. */
3741 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3746 if (elf_tdata (abfd
) == NULL
3747 || elf_tdata (abfd
)->core
== NULL
)
3750 /* The size for Xtensa is variable, so don't try to recognize the format
3751 based on the size. Just assume this is GNU/Linux. */
3752 if (note
== NULL
|| note
->descsz
< 28)
3756 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3759 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3763 size
= note
->descsz
- offset
- 4;
3765 /* Make a ".reg/999" section. */
3766 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3767 size
, note
->descpos
+ offset
);
3771 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3773 switch (note
->descsz
)
3778 case 128: /* GNU/Linux elf_prpsinfo */
3779 elf_tdata (abfd
)->core
->program
3780 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3781 elf_tdata (abfd
)->core
->command
3782 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3785 /* Note that for some reason, a spurious space is tacked
3786 onto the end of the args in some (at least one anyway)
3787 implementations, so strip it off if it exists. */
3790 char *command
= elf_tdata (abfd
)->core
->command
;
3791 int n
= strlen (command
);
3793 if (0 < n
&& command
[n
- 1] == ' ')
3794 command
[n
- 1] = '\0';
3801 /* Generic Xtensa configurability stuff. */
3803 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3804 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3805 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3806 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3807 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3808 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3809 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3810 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3813 init_call_opcodes (void)
3815 if (callx0_op
== XTENSA_UNDEFINED
)
3817 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3818 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3819 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3820 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3821 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3822 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3823 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3824 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3830 is_indirect_call_opcode (xtensa_opcode opcode
)
3832 init_call_opcodes ();
3833 return (opcode
== callx0_op
3834 || opcode
== callx4_op
3835 || opcode
== callx8_op
3836 || opcode
== callx12_op
);
3841 is_direct_call_opcode (xtensa_opcode opcode
)
3843 init_call_opcodes ();
3844 return (opcode
== call0_op
3845 || opcode
== call4_op
3846 || opcode
== call8_op
3847 || opcode
== call12_op
);
3852 is_windowed_call_opcode (xtensa_opcode opcode
)
3854 init_call_opcodes ();
3855 return (opcode
== call4_op
3856 || opcode
== call8_op
3857 || opcode
== call12_op
3858 || opcode
== callx4_op
3859 || opcode
== callx8_op
3860 || opcode
== callx12_op
);
3865 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3867 unsigned dst
= (unsigned) -1;
3869 init_call_opcodes ();
3870 if (opcode
== callx0_op
)
3872 else if (opcode
== callx4_op
)
3874 else if (opcode
== callx8_op
)
3876 else if (opcode
== callx12_op
)
3879 if (dst
== (unsigned) -1)
3887 static xtensa_opcode
3888 get_const16_opcode (void)
3890 static bool done_lookup
= false;
3891 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3894 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3897 return const16_opcode
;
3901 static xtensa_opcode
3902 get_l32r_opcode (void)
3904 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3905 static bool done_lookup
= false;
3909 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3917 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3921 offset
= addr
- ((pc
+3) & -4);
3922 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3923 offset
= (signed int) offset
>> 2;
3924 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3929 static xtensa_opcode
3930 get_rsr_lend_opcode (void)
3932 static xtensa_opcode rsr_lend_opcode
= XTENSA_UNDEFINED
;
3933 static bool done_lookup
= false;
3936 rsr_lend_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "rsr.lend");
3939 return rsr_lend_opcode
;
3942 static xtensa_opcode
3943 get_wsr_lbeg_opcode (void)
3945 static xtensa_opcode wsr_lbeg_opcode
= XTENSA_UNDEFINED
;
3946 static bool done_lookup
= false;
3949 wsr_lbeg_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "wsr.lbeg");
3952 return wsr_lbeg_opcode
;
3957 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3959 xtensa_isa isa
= xtensa_default_isa
;
3960 int last_immed
, last_opnd
, opi
;
3962 if (opcode
== XTENSA_UNDEFINED
)
3963 return XTENSA_UNDEFINED
;
3965 /* Find the last visible PC-relative immediate operand for the opcode.
3966 If there are no PC-relative immediates, then choose the last visible
3967 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3968 last_immed
= XTENSA_UNDEFINED
;
3969 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3970 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3972 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3974 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3979 if (last_immed
== XTENSA_UNDEFINED
3980 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3984 return XTENSA_UNDEFINED
;
3986 /* If the operand number was specified in an old-style relocation,
3987 check for consistency with the operand computed above. */
3988 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3990 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3991 if (reloc_opnd
!= last_immed
)
3992 return XTENSA_UNDEFINED
;
4000 get_relocation_slot (int r_type
)
4010 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4011 return r_type
- R_XTENSA_SLOT0_OP
;
4012 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4013 return r_type
- R_XTENSA_SLOT0_ALT
;
4017 return XTENSA_UNDEFINED
;
4021 /* Get the opcode for a relocation. */
4023 static xtensa_opcode
4024 get_relocation_opcode (bfd
*abfd
,
4027 Elf_Internal_Rela
*irel
)
4029 static xtensa_insnbuf ibuff
= NULL
;
4030 static xtensa_insnbuf sbuff
= NULL
;
4031 xtensa_isa isa
= xtensa_default_isa
;
4035 if (contents
== NULL
)
4036 return XTENSA_UNDEFINED
;
4038 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
4039 return XTENSA_UNDEFINED
;
4043 ibuff
= xtensa_insnbuf_alloc (isa
);
4044 sbuff
= xtensa_insnbuf_alloc (isa
);
4047 /* Decode the instruction. */
4048 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
4049 sec
->size
- irel
->r_offset
);
4050 fmt
= xtensa_format_decode (isa
, ibuff
);
4051 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
4052 if (slot
== XTENSA_UNDEFINED
)
4053 return XTENSA_UNDEFINED
;
4054 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
4055 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
4060 is_l32r_relocation (bfd
*abfd
,
4063 Elf_Internal_Rela
*irel
)
4065 xtensa_opcode opcode
;
4066 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
4068 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
4069 return (opcode
== get_l32r_opcode ());
4073 static bfd_size_type
4074 get_asm_simplify_size (bfd_byte
*contents
,
4075 bfd_size_type content_len
,
4076 bfd_size_type offset
)
4078 bfd_size_type insnlen
, size
= 0;
4080 /* Decode the size of the next two instructions. */
4081 insnlen
= insn_decode_len (contents
, content_len
, offset
);
4087 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
4097 is_alt_relocation (int r_type
)
4099 return (r_type
>= R_XTENSA_SLOT0_ALT
4100 && r_type
<= R_XTENSA_SLOT14_ALT
);
4105 is_operand_relocation (int r_type
)
4115 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4117 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4126 #define MIN_INSN_LENGTH 2
4128 /* Return 0 if it fails to decode. */
4131 insn_decode_len (bfd_byte
*contents
,
4132 bfd_size_type content_len
,
4133 bfd_size_type offset
)
4136 xtensa_isa isa
= xtensa_default_isa
;
4138 static xtensa_insnbuf ibuff
= NULL
;
4140 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4144 ibuff
= xtensa_insnbuf_alloc (isa
);
4145 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4146 content_len
- offset
);
4147 fmt
= xtensa_format_decode (isa
, ibuff
);
4148 if (fmt
== XTENSA_UNDEFINED
)
4150 insn_len
= xtensa_format_length (isa
, fmt
);
4151 if (insn_len
== XTENSA_UNDEFINED
)
4157 insn_num_slots (bfd_byte
*contents
,
4158 bfd_size_type content_len
,
4159 bfd_size_type offset
)
4161 xtensa_isa isa
= xtensa_default_isa
;
4163 static xtensa_insnbuf ibuff
= NULL
;
4165 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4166 return XTENSA_UNDEFINED
;
4169 ibuff
= xtensa_insnbuf_alloc (isa
);
4170 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4171 content_len
- offset
);
4172 fmt
= xtensa_format_decode (isa
, ibuff
);
4173 if (fmt
== XTENSA_UNDEFINED
)
4174 return XTENSA_UNDEFINED
;
4175 return xtensa_format_num_slots (isa
, fmt
);
4179 /* Decode the opcode for a single slot instruction.
4180 Return 0 if it fails to decode or the instruction is multi-slot. */
4183 insn_decode_opcode (bfd_byte
*contents
,
4184 bfd_size_type content_len
,
4185 bfd_size_type offset
,
4188 xtensa_isa isa
= xtensa_default_isa
;
4190 static xtensa_insnbuf insnbuf
= NULL
;
4191 static xtensa_insnbuf slotbuf
= NULL
;
4193 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4194 return XTENSA_UNDEFINED
;
4196 if (insnbuf
== NULL
)
4198 insnbuf
= xtensa_insnbuf_alloc (isa
);
4199 slotbuf
= xtensa_insnbuf_alloc (isa
);
4202 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4203 content_len
- offset
);
4204 fmt
= xtensa_format_decode (isa
, insnbuf
);
4205 if (fmt
== XTENSA_UNDEFINED
)
4206 return XTENSA_UNDEFINED
;
4208 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4209 return XTENSA_UNDEFINED
;
4211 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4212 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4216 /* The offset is the offset in the contents.
4217 The address is the address of that offset. */
4220 check_branch_target_aligned (bfd_byte
*contents
,
4221 bfd_size_type content_length
,
4225 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4228 return check_branch_target_aligned_address (address
, insn_len
);
4233 check_loop_aligned (bfd_byte
*contents
,
4234 bfd_size_type content_length
,
4238 bfd_size_type loop_len
, insn_len
;
4239 xtensa_opcode opcode
;
4241 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4242 if (opcode
== XTENSA_UNDEFINED
4243 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4249 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4250 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4251 if (loop_len
== 0 || insn_len
== 0)
4257 /* If this is relaxed loop, analyze first instruction of the actual loop
4258 body. It must be at offset 27 from the loop instruction address. */
4260 && insn_num_slots (contents
, content_length
, offset
+ loop_len
) == 1
4261 && insn_decode_opcode (contents
, content_length
,
4262 offset
+ loop_len
, 0) == get_rsr_lend_opcode()
4263 && insn_decode_len (contents
, content_length
, offset
+ loop_len
+ 3) == 3
4264 && insn_num_slots (contents
, content_length
, offset
+ loop_len
+ 3) == 1
4265 && insn_decode_opcode (contents
, content_length
,
4266 offset
+ loop_len
+ 3, 0) == get_wsr_lbeg_opcode())
4269 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4271 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4276 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4279 return (addr
% 8 == 0);
4280 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4284 /* Instruction widening and narrowing. */
4286 /* When FLIX is available we need to access certain instructions only
4287 when they are 16-bit or 24-bit instructions. This table caches
4288 information about such instructions by walking through all the
4289 opcodes and finding the smallest single-slot format into which each
4292 static xtensa_format
*op_single_fmt_table
= NULL
;
4296 init_op_single_format_table (void)
4298 xtensa_isa isa
= xtensa_default_isa
;
4299 xtensa_insnbuf ibuf
;
4300 xtensa_opcode opcode
;
4304 if (op_single_fmt_table
)
4307 ibuf
= xtensa_insnbuf_alloc (isa
);
4308 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4310 op_single_fmt_table
= (xtensa_format
*)
4311 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4312 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4314 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4315 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4317 if (xtensa_format_num_slots (isa
, fmt
) == 1
4318 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4320 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4321 int fmt_length
= xtensa_format_length (isa
, fmt
);
4322 if (old_fmt
== XTENSA_UNDEFINED
4323 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4324 op_single_fmt_table
[opcode
] = fmt
;
4328 xtensa_insnbuf_free (isa
, ibuf
);
4332 static xtensa_format
4333 get_single_format (xtensa_opcode opcode
)
4335 init_op_single_format_table ();
4336 return op_single_fmt_table
[opcode
];
4340 /* For the set of narrowable instructions we do NOT include the
4341 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4342 involved during linker relaxation that may require these to
4343 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4344 requires special case code to ensure it only works when op1 == op2. */
4352 const struct string_pair narrowable
[] =
4355 { "addi", "addi.n" },
4356 { "addmi", "addi.n" },
4357 { "l32i", "l32i.n" },
4358 { "movi", "movi.n" },
4360 { "retw", "retw.n" },
4361 { "s32i", "s32i.n" },
4362 { "or", "mov.n" } /* special case only when op1 == op2 */
4365 const struct string_pair widenable
[] =
4368 { "addi", "addi.n" },
4369 { "addmi", "addi.n" },
4370 { "beqz", "beqz.n" },
4371 { "bnez", "bnez.n" },
4372 { "l32i", "l32i.n" },
4373 { "movi", "movi.n" },
4375 { "retw", "retw.n" },
4376 { "s32i", "s32i.n" },
4377 { "or", "mov.n" } /* special case only when op1 == op2 */
4381 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4382 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4383 return the instruction buffer holding the narrow instruction. Otherwise,
4384 return 0. The set of valid narrowing are specified by a string table
4385 but require some special case operand checks in some cases. */
4387 static xtensa_insnbuf
4388 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4390 xtensa_opcode opcode
)
4392 xtensa_isa isa
= xtensa_default_isa
;
4393 xtensa_format o_fmt
;
4396 static xtensa_insnbuf o_insnbuf
= NULL
;
4397 static xtensa_insnbuf o_slotbuf
= NULL
;
4399 if (o_insnbuf
== NULL
)
4401 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4402 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4405 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4407 bool is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4409 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4411 uint32 value
, newval
;
4412 int i
, operand_count
, o_operand_count
;
4413 xtensa_opcode o_opcode
;
4415 /* Address does not matter in this case. We might need to
4416 fix it to handle branches/jumps. */
4417 bfd_vma self_address
= 0;
4419 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4420 if (o_opcode
== XTENSA_UNDEFINED
)
4422 o_fmt
= get_single_format (o_opcode
);
4423 if (o_fmt
== XTENSA_UNDEFINED
)
4426 if (xtensa_format_length (isa
, fmt
) != 3
4427 || xtensa_format_length (isa
, o_fmt
) != 2)
4430 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4431 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4432 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4434 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4439 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4444 uint32 rawval0
, rawval1
, rawval2
;
4446 if (o_operand_count
+ 1 != operand_count
4447 || xtensa_operand_get_field (isa
, opcode
, 0,
4448 fmt
, 0, slotbuf
, &rawval0
) != 0
4449 || xtensa_operand_get_field (isa
, opcode
, 1,
4450 fmt
, 0, slotbuf
, &rawval1
) != 0
4451 || xtensa_operand_get_field (isa
, opcode
, 2,
4452 fmt
, 0, slotbuf
, &rawval2
) != 0
4453 || rawval1
!= rawval2
4454 || rawval0
== rawval1
/* it is a nop */)
4458 for (i
= 0; i
< o_operand_count
; ++i
)
4460 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4462 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4465 /* PC-relative branches need adjustment, but
4466 the PC-rel operand will always have a relocation. */
4468 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4470 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4471 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4476 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4486 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4487 the action in-place directly into the contents and return TRUE. Otherwise,
4488 the return value is FALSE and the contents are not modified. */
4491 narrow_instruction (bfd_byte
*contents
,
4492 bfd_size_type content_length
,
4493 bfd_size_type offset
)
4495 xtensa_opcode opcode
;
4496 bfd_size_type insn_len
;
4497 xtensa_isa isa
= xtensa_default_isa
;
4499 xtensa_insnbuf o_insnbuf
;
4501 static xtensa_insnbuf insnbuf
= NULL
;
4502 static xtensa_insnbuf slotbuf
= NULL
;
4504 if (insnbuf
== NULL
)
4506 insnbuf
= xtensa_insnbuf_alloc (isa
);
4507 slotbuf
= xtensa_insnbuf_alloc (isa
);
4510 BFD_ASSERT (offset
< content_length
);
4512 if (content_length
< 2)
4515 /* We will hand-code a few of these for a little while.
4516 These have all been specified in the assembler aleady. */
4517 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4518 content_length
- offset
);
4519 fmt
= xtensa_format_decode (isa
, insnbuf
);
4520 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4523 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4526 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4527 if (opcode
== XTENSA_UNDEFINED
)
4529 insn_len
= xtensa_format_length (isa
, fmt
);
4530 if (insn_len
> content_length
)
4533 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4536 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4537 content_length
- offset
);
4545 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4546 "density" instruction to a standard 3-byte instruction. If it is valid,
4547 return the instruction buffer holding the wide instruction. Otherwise,
4548 return 0. The set of valid widenings are specified by a string table
4549 but require some special case operand checks in some cases. */
4551 static xtensa_insnbuf
4552 can_widen_instruction (xtensa_insnbuf slotbuf
,
4554 xtensa_opcode opcode
)
4556 xtensa_isa isa
= xtensa_default_isa
;
4557 xtensa_format o_fmt
;
4560 static xtensa_insnbuf o_insnbuf
= NULL
;
4561 static xtensa_insnbuf o_slotbuf
= NULL
;
4563 if (o_insnbuf
== NULL
)
4565 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4566 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4569 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4571 bool is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4572 bool is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4573 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4575 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4577 uint32 value
, newval
;
4578 int i
, operand_count
, o_operand_count
, check_operand_count
;
4579 xtensa_opcode o_opcode
;
4581 /* Address does not matter in this case. We might need to fix it
4582 to handle branches/jumps. */
4583 bfd_vma self_address
= 0;
4585 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4586 if (o_opcode
== XTENSA_UNDEFINED
)
4588 o_fmt
= get_single_format (o_opcode
);
4589 if (o_fmt
== XTENSA_UNDEFINED
)
4592 if (xtensa_format_length (isa
, fmt
) != 2
4593 || xtensa_format_length (isa
, o_fmt
) != 3)
4596 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4597 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4598 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4599 check_operand_count
= o_operand_count
;
4601 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4606 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4611 uint32 rawval0
, rawval1
;
4613 if (o_operand_count
!= operand_count
+ 1
4614 || xtensa_operand_get_field (isa
, opcode
, 0,
4615 fmt
, 0, slotbuf
, &rawval0
) != 0
4616 || xtensa_operand_get_field (isa
, opcode
, 1,
4617 fmt
, 0, slotbuf
, &rawval1
) != 0
4618 || rawval0
== rawval1
/* it is a nop */)
4622 check_operand_count
--;
4624 for (i
= 0; i
< check_operand_count
; i
++)
4627 if (is_or
&& i
== o_operand_count
- 1)
4629 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4631 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4634 /* PC-relative branches need adjustment, but
4635 the PC-rel operand will always have a relocation. */
4637 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4639 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4640 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4645 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4655 /* Attempt to widen an instruction. If the widening is valid, perform
4656 the action in-place directly into the contents and return TRUE. Otherwise,
4657 the return value is FALSE and the contents are not modified. */
4660 widen_instruction (bfd_byte
*contents
,
4661 bfd_size_type content_length
,
4662 bfd_size_type offset
)
4664 xtensa_opcode opcode
;
4665 bfd_size_type insn_len
;
4666 xtensa_isa isa
= xtensa_default_isa
;
4668 xtensa_insnbuf o_insnbuf
;
4670 static xtensa_insnbuf insnbuf
= NULL
;
4671 static xtensa_insnbuf slotbuf
= NULL
;
4673 if (insnbuf
== NULL
)
4675 insnbuf
= xtensa_insnbuf_alloc (isa
);
4676 slotbuf
= xtensa_insnbuf_alloc (isa
);
4679 BFD_ASSERT (offset
< content_length
);
4681 if (content_length
< 2)
4684 /* We will hand-code a few of these for a little while.
4685 These have all been specified in the assembler aleady. */
4686 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4687 content_length
- offset
);
4688 fmt
= xtensa_format_decode (isa
, insnbuf
);
4689 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4692 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4695 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4696 if (opcode
== XTENSA_UNDEFINED
)
4698 insn_len
= xtensa_format_length (isa
, fmt
);
4699 if (insn_len
> content_length
)
4702 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4705 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4706 content_length
- offset
);
4713 /* Code for transforming CALLs at link-time. */
4715 static bfd_reloc_status_type
4716 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4718 bfd_vma content_length
,
4719 char **error_message
)
4721 static xtensa_insnbuf insnbuf
= NULL
;
4722 static xtensa_insnbuf slotbuf
= NULL
;
4723 xtensa_format core_format
= XTENSA_UNDEFINED
;
4724 xtensa_opcode opcode
;
4725 xtensa_opcode direct_call_opcode
;
4726 xtensa_isa isa
= xtensa_default_isa
;
4727 bfd_byte
*chbuf
= contents
+ address
;
4730 if (insnbuf
== NULL
)
4732 insnbuf
= xtensa_insnbuf_alloc (isa
);
4733 slotbuf
= xtensa_insnbuf_alloc (isa
);
4736 if (content_length
< address
)
4738 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4739 return bfd_reloc_other
;
4742 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4743 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4744 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4746 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4747 return bfd_reloc_other
;
4750 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4751 core_format
= xtensa_format_lookup (isa
, "x24");
4752 opcode
= xtensa_opcode_lookup (isa
, "or");
4753 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4754 for (opn
= 0; opn
< 3; opn
++)
4757 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4758 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4761 xtensa_format_encode (isa
, core_format
, insnbuf
);
4762 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4763 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4765 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4766 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4767 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4769 xtensa_format_encode (isa
, core_format
, insnbuf
);
4770 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4771 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4772 content_length
- address
- 3);
4774 return bfd_reloc_ok
;
4778 static bfd_reloc_status_type
4779 contract_asm_expansion (bfd_byte
*contents
,
4780 bfd_vma content_length
,
4781 Elf_Internal_Rela
*irel
,
4782 char **error_message
)
4784 bfd_reloc_status_type retval
=
4785 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4788 if (retval
!= bfd_reloc_ok
)
4789 return bfd_reloc_dangerous
;
4791 /* Update the irel->r_offset field so that the right immediate and
4792 the right instruction are modified during the relocation. */
4793 irel
->r_offset
+= 3;
4794 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4795 return bfd_reloc_ok
;
4799 static xtensa_opcode
4800 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4802 init_call_opcodes ();
4804 if (opcode
== callx0_op
) return call0_op
;
4805 if (opcode
== callx4_op
) return call4_op
;
4806 if (opcode
== callx8_op
) return call8_op
;
4807 if (opcode
== callx12_op
) return call12_op
;
4809 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4810 return XTENSA_UNDEFINED
;
4814 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4815 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4816 If not, return XTENSA_UNDEFINED. */
4818 #define L32R_TARGET_REG_OPERAND 0
4819 #define CONST16_TARGET_REG_OPERAND 0
4820 #define CALLN_SOURCE_OPERAND 0
4822 static xtensa_opcode
4823 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bool *p_uses_l32r
)
4825 static xtensa_insnbuf insnbuf
= NULL
;
4826 static xtensa_insnbuf slotbuf
= NULL
;
4828 xtensa_opcode opcode
;
4829 xtensa_isa isa
= xtensa_default_isa
;
4830 uint32 regno
, const16_regno
, call_regno
;
4833 if (insnbuf
== NULL
)
4835 insnbuf
= xtensa_insnbuf_alloc (isa
);
4836 slotbuf
= xtensa_insnbuf_alloc (isa
);
4839 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4840 fmt
= xtensa_format_decode (isa
, insnbuf
);
4841 if (fmt
== XTENSA_UNDEFINED
4842 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4843 return XTENSA_UNDEFINED
;
4845 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4846 if (opcode
== XTENSA_UNDEFINED
)
4847 return XTENSA_UNDEFINED
;
4849 if (opcode
== get_l32r_opcode ())
4852 *p_uses_l32r
= true;
4853 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4854 fmt
, 0, slotbuf
, ®no
)
4855 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4857 return XTENSA_UNDEFINED
;
4859 else if (opcode
== get_const16_opcode ())
4862 *p_uses_l32r
= false;
4863 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4864 fmt
, 0, slotbuf
, ®no
)
4865 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4867 return XTENSA_UNDEFINED
;
4869 /* Check that the next instruction is also CONST16. */
4870 offset
+= xtensa_format_length (isa
, fmt
);
4871 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4872 fmt
= xtensa_format_decode (isa
, insnbuf
);
4873 if (fmt
== XTENSA_UNDEFINED
4874 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4875 return XTENSA_UNDEFINED
;
4876 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4877 if (opcode
!= get_const16_opcode ())
4878 return XTENSA_UNDEFINED
;
4880 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4881 fmt
, 0, slotbuf
, &const16_regno
)
4882 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4884 || const16_regno
!= regno
)
4885 return XTENSA_UNDEFINED
;
4888 return XTENSA_UNDEFINED
;
4890 /* Next instruction should be an CALLXn with operand 0 == regno. */
4891 offset
+= xtensa_format_length (isa
, fmt
);
4892 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4893 fmt
= xtensa_format_decode (isa
, insnbuf
);
4894 if (fmt
== XTENSA_UNDEFINED
4895 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4896 return XTENSA_UNDEFINED
;
4897 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4898 if (opcode
== XTENSA_UNDEFINED
4899 || !is_indirect_call_opcode (opcode
))
4900 return XTENSA_UNDEFINED
;
4902 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4903 fmt
, 0, slotbuf
, &call_regno
)
4904 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4906 return XTENSA_UNDEFINED
;
4908 if (call_regno
!= regno
)
4909 return XTENSA_UNDEFINED
;
4915 /* Data structures used during relaxation. */
4917 /* r_reloc: relocation values. */
4919 /* Through the relaxation process, we need to keep track of the values
4920 that will result from evaluating relocations. The standard ELF
4921 relocation structure is not sufficient for this purpose because we're
4922 operating on multiple input files at once, so we need to know which
4923 input file a relocation refers to. The r_reloc structure thus
4924 records both the input file (bfd) and ELF relocation.
4926 For efficiency, an r_reloc also contains a "target_offset" field to
4927 cache the target-section-relative offset value that is represented by
4930 The r_reloc also contains a virtual offset that allows multiple
4931 inserted literals to be placed at the same "address" with
4932 different offsets. */
4934 typedef struct r_reloc_struct r_reloc
;
4936 struct r_reloc_struct
4939 Elf_Internal_Rela rela
;
4940 bfd_vma target_offset
;
4941 bfd_vma virtual_offset
;
4945 /* The r_reloc structure is included by value in literal_value, but not
4946 every literal_value has an associated relocation -- some are simple
4947 constants. In such cases, we set all the fields in the r_reloc
4948 struct to zero. The r_reloc_is_const function should be used to
4949 detect this case. */
4952 r_reloc_is_const (const r_reloc
*r_rel
)
4954 return (r_rel
->abfd
== NULL
);
4959 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4961 bfd_vma target_offset
;
4962 unsigned long r_symndx
;
4964 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4965 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4966 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4967 return (target_offset
+ r_rel
->rela
.r_addend
);
4971 static struct elf_link_hash_entry
*
4972 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4974 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4975 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4980 r_reloc_get_section (const r_reloc
*r_rel
)
4982 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4983 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4988 r_reloc_is_defined (const r_reloc
*r_rel
)
4994 sec
= r_reloc_get_section (r_rel
);
4995 if (sec
== bfd_abs_section_ptr
4996 || sec
== bfd_com_section_ptr
4997 || sec
== bfd_und_section_ptr
)
5004 r_reloc_init (r_reloc
*r_rel
,
5006 Elf_Internal_Rela
*irel
,
5008 bfd_size_type content_length
)
5011 reloc_howto_type
*howto
;
5015 r_rel
->rela
= *irel
;
5017 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
5018 r_rel
->virtual_offset
= 0;
5019 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
5020 howto
= &elf_howto_table
[r_type
];
5021 if (howto
->partial_inplace
)
5023 bfd_vma inplace_val
;
5024 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
5026 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
5027 r_rel
->target_offset
+= inplace_val
;
5031 memset (r_rel
, 0, sizeof (r_reloc
));
5038 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
5040 if (r_reloc_is_defined (r_rel
))
5042 asection
*sec
= r_reloc_get_section (r_rel
);
5043 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
5045 else if (r_reloc_get_hash_entry (r_rel
))
5046 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
5048 fprintf (fp
, " ?? + ");
5050 fprintf_vma (fp
, r_rel
->target_offset
);
5051 if (r_rel
->virtual_offset
)
5053 fprintf (fp
, " + ");
5054 fprintf_vma (fp
, r_rel
->virtual_offset
);
5063 /* source_reloc: relocations that reference literals. */
5065 /* To determine whether literals can be coalesced, we need to first
5066 record all the relocations that reference the literals. The
5067 source_reloc structure below is used for this purpose. The
5068 source_reloc entries are kept in a per-literal-section array, sorted
5069 by offset within the literal section (i.e., target offset).
5071 The source_sec and r_rel.rela.r_offset fields identify the source of
5072 the relocation. The r_rel field records the relocation value, i.e.,
5073 the offset of the literal being referenced. The opnd field is needed
5074 to determine the range of the immediate field to which the relocation
5075 applies, so we can determine whether another literal with the same
5076 value is within range. The is_null field is true when the relocation
5077 is being removed (e.g., when an L32R is being removed due to a CALLX
5078 that is converted to a direct CALL). */
5080 typedef struct source_reloc_struct source_reloc
;
5082 struct source_reloc_struct
5084 asection
*source_sec
;
5086 xtensa_opcode opcode
;
5089 bool is_abs_literal
;
5094 init_source_reloc (source_reloc
*reloc
,
5095 asection
*source_sec
,
5096 const r_reloc
*r_rel
,
5097 xtensa_opcode opcode
,
5099 bool is_abs_literal
)
5101 reloc
->source_sec
= source_sec
;
5102 reloc
->r_rel
= *r_rel
;
5103 reloc
->opcode
= opcode
;
5105 reloc
->is_null
= false;
5106 reloc
->is_abs_literal
= is_abs_literal
;
5110 /* Find the source_reloc for a particular source offset and relocation
5111 type. Note that the array is sorted by _target_ offset, so this is
5112 just a linear search. */
5114 static source_reloc
*
5115 find_source_reloc (source_reloc
*src_relocs
,
5118 Elf_Internal_Rela
*irel
)
5122 for (i
= 0; i
< src_count
; i
++)
5124 if (src_relocs
[i
].source_sec
== sec
5125 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
5126 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
5127 == ELF32_R_TYPE (irel
->r_info
)))
5128 return &src_relocs
[i
];
5136 source_reloc_compare (const void *ap
, const void *bp
)
5138 const source_reloc
*a
= (const source_reloc
*) ap
;
5139 const source_reloc
*b
= (const source_reloc
*) bp
;
5141 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
5142 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5144 /* We don't need to sort on these criteria for correctness,
5145 but enforcing a more strict ordering prevents unstable qsort
5146 from behaving differently with different implementations.
5147 Without the code below we get correct but different results
5148 on Solaris 2.7 and 2.8. We would like to always produce the
5149 same results no matter the host. */
5151 if ((!a
->is_null
) - (!b
->is_null
))
5152 return ((!a
->is_null
) - (!b
->is_null
));
5153 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5157 /* Literal values and value hash tables. */
5159 /* Literals with the same value can be coalesced. The literal_value
5160 structure records the value of a literal: the "r_rel" field holds the
5161 information from the relocation on the literal (if there is one) and
5162 the "value" field holds the contents of the literal word itself.
5164 The value_map structure records a literal value along with the
5165 location of a literal holding that value. The value_map hash table
5166 is indexed by the literal value, so that we can quickly check if a
5167 particular literal value has been seen before and is thus a candidate
5170 typedef struct literal_value_struct literal_value
;
5171 typedef struct value_map_struct value_map
;
5172 typedef struct value_map_hash_table_struct value_map_hash_table
;
5174 struct literal_value_struct
5177 unsigned long value
;
5178 bool is_abs_literal
;
5181 struct value_map_struct
5183 literal_value val
; /* The literal value. */
5184 r_reloc loc
; /* Location of the literal. */
5188 struct value_map_hash_table_struct
5190 unsigned bucket_count
;
5191 value_map
**buckets
;
5199 init_literal_value (literal_value
*lit
,
5200 const r_reloc
*r_rel
,
5201 unsigned long value
,
5202 bool is_abs_literal
)
5204 lit
->r_rel
= *r_rel
;
5206 lit
->is_abs_literal
= is_abs_literal
;
5211 literal_value_equal (const literal_value
*src1
,
5212 const literal_value
*src2
,
5213 bool final_static_link
)
5215 struct elf_link_hash_entry
*h1
, *h2
;
5217 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5220 if (r_reloc_is_const (&src1
->r_rel
))
5221 return (src1
->value
== src2
->value
);
5223 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5224 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5227 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5230 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5233 if (src1
->value
!= src2
->value
)
5236 /* Now check for the same section (if defined) or the same elf_hash
5237 (if undefined or weak). */
5238 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5239 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5240 if (r_reloc_is_defined (&src1
->r_rel
)
5241 && (final_static_link
5242 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5243 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5245 if (r_reloc_get_section (&src1
->r_rel
)
5246 != r_reloc_get_section (&src2
->r_rel
))
5251 /* Require that the hash entries (i.e., symbols) be identical. */
5252 if (h1
!= h2
|| h1
== 0)
5256 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5263 /* Must be power of 2. */
5264 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5266 static value_map_hash_table
*
5267 value_map_hash_table_init (void)
5269 value_map_hash_table
*values
;
5271 values
= (value_map_hash_table
*)
5272 bfd_zmalloc (sizeof (value_map_hash_table
));
5273 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5275 values
->buckets
= (value_map
**)
5276 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5277 if (values
->buckets
== NULL
)
5282 values
->has_last_loc
= false;
5289 value_map_hash_table_delete (value_map_hash_table
*table
)
5291 free (table
->buckets
);
5297 hash_bfd_vma (bfd_vma val
)
5299 return (val
>> 2) + (val
>> 10);
5304 literal_value_hash (const literal_value
*src
)
5308 hash_val
= hash_bfd_vma (src
->value
);
5309 if (!r_reloc_is_const (&src
->r_rel
))
5313 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5314 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5315 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5317 /* Now check for the same section and the same elf_hash. */
5318 if (r_reloc_is_defined (&src
->r_rel
))
5319 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5321 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5322 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5328 /* Check if the specified literal_value has been seen before. */
5331 value_map_get_cached_value (value_map_hash_table
*map
,
5332 const literal_value
*val
,
5333 bool final_static_link
)
5339 idx
= literal_value_hash (val
);
5340 idx
= idx
& (map
->bucket_count
- 1);
5341 bucket
= map
->buckets
[idx
];
5342 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5344 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5351 /* Record a new literal value. It is illegal to call this if VALUE
5352 already has an entry here. */
5355 add_value_map (value_map_hash_table
*map
,
5356 const literal_value
*val
,
5358 bool final_static_link
)
5360 value_map
**bucket_p
;
5363 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5366 bfd_set_error (bfd_error_no_memory
);
5370 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5374 idx
= literal_value_hash (val
);
5375 idx
= idx
& (map
->bucket_count
- 1);
5376 bucket_p
= &map
->buckets
[idx
];
5378 val_e
->next
= *bucket_p
;
5381 /* FIXME: Consider resizing the hash table if we get too many entries. */
5387 /* Lists of text actions (ta_) for narrowing, widening, longcall
5388 conversion, space fill, code & literal removal, etc. */
5390 /* The following text actions are generated:
5392 "ta_remove_insn" remove an instruction or instructions
5393 "ta_remove_longcall" convert longcall to call
5394 "ta_convert_longcall" convert longcall to nop/call
5395 "ta_narrow_insn" narrow a wide instruction
5396 "ta_widen" widen a narrow instruction
5397 "ta_fill" add fill or remove fill
5398 removed < 0 is a fill; branches to the fill address will be
5399 changed to address + fill size (e.g., address - removed)
5400 removed >= 0 branches to the fill address will stay unchanged
5401 "ta_remove_literal" remove a literal; this action is
5402 indicated when a literal is removed
5404 "ta_add_literal" insert a new literal; this action is
5405 indicated when a literal has been moved.
5406 It may use a virtual_offset because
5407 multiple literals can be placed at the
5410 For each of these text actions, we also record the number of bytes
5411 removed by performing the text action. In the case of a "ta_widen"
5412 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5414 typedef struct text_action_struct text_action
;
5415 typedef struct text_action_list_struct text_action_list
;
5416 typedef enum text_action_enum_t text_action_t
;
5418 enum text_action_enum_t
5421 ta_remove_insn
, /* removed = -size */
5422 ta_remove_longcall
, /* removed = -size */
5423 ta_convert_longcall
, /* removed = 0 */
5424 ta_narrow_insn
, /* removed = -1 */
5425 ta_widen_insn
, /* removed = +1 */
5426 ta_fill
, /* removed = +size */
5432 /* Structure for a text action record. */
5433 struct text_action_struct
5435 text_action_t action
;
5436 asection
*sec
; /* Optional */
5438 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5440 literal_value value
; /* Only valid when adding literals. */
5443 struct removal_by_action_entry_struct
5448 int eq_removed_before_fill
;
5450 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5452 struct removal_by_action_map_struct
5455 removal_by_action_entry
*entry
;
5457 typedef struct removal_by_action_map_struct removal_by_action_map
;
5460 /* List of all of the actions taken on a text section. */
5461 struct text_action_list_struct
5465 removal_by_action_map map
;
5469 static text_action
*
5470 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5474 /* It is not necessary to fill at the end of a section. */
5475 if (sec
->size
== offset
)
5481 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5483 return (text_action
*)node
->value
;
5489 compute_removed_action_diff (const text_action
*ta
,
5493 int removable_space
)
5496 int current_removed
= 0;
5499 current_removed
= ta
->removed_bytes
;
5501 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5502 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5504 /* It is not necessary to fill at the end of a section. Clean this up. */
5505 if (sec
->size
== offset
)
5506 new_removed
= removable_space
- 0;
5510 int added
= -removed
- current_removed
;
5511 /* Ignore multiples of the section alignment. */
5512 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5513 new_removed
= (-added
);
5515 /* Modify for removable. */
5516 space
= removable_space
- new_removed
;
5517 new_removed
= (removable_space
5518 - (((1 << sec
->alignment_power
) - 1) & space
));
5520 return (new_removed
- current_removed
);
5525 adjust_fill_action (text_action
*ta
, int fill_diff
)
5527 ta
->removed_bytes
+= fill_diff
;
5532 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5534 text_action
*pa
= (text_action
*)a
;
5535 text_action
*pb
= (text_action
*)b
;
5536 static const int action_priority
[] =
5540 [ta_convert_longcall
] = 2,
5541 [ta_narrow_insn
] = 3,
5542 [ta_remove_insn
] = 4,
5543 [ta_remove_longcall
] = 5,
5544 [ta_remove_literal
] = 6,
5545 [ta_widen_insn
] = 7,
5546 [ta_add_literal
] = 8,
5549 if (pa
->offset
== pb
->offset
)
5551 if (pa
->action
== pb
->action
)
5553 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5556 return pa
->offset
< pb
->offset
? -1 : 1;
5559 static text_action
*
5560 action_first (text_action_list
*action_list
)
5562 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5563 return node
? (text_action
*)node
->value
: NULL
;
5566 static text_action
*
5567 action_next (text_action_list
*action_list
, text_action
*action
)
5569 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5570 (splay_tree_key
)action
);
5571 return node
? (text_action
*)node
->value
: NULL
;
5574 /* Add a modification action to the text. For the case of adding or
5575 removing space, modify any current fill and assume that
5576 "unreachable_space" bytes can be freely contracted. Note that a
5577 negative removed value is a fill. */
5580 text_action_add (text_action_list
*l
,
5581 text_action_t action
,
5589 /* It is not necessary to fill at the end of a section. */
5590 if (action
== ta_fill
&& sec
->size
== offset
)
5593 /* It is not necessary to fill 0 bytes. */
5594 if (action
== ta_fill
&& removed
== 0)
5600 if (action
== ta_fill
)
5602 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5606 ta
= (text_action
*)node
->value
;
5607 ta
->removed_bytes
+= removed
;
5612 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5614 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5615 ta
->action
= action
;
5617 ta
->offset
= offset
;
5618 ta
->removed_bytes
= removed
;
5619 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5625 text_action_add_literal (text_action_list
*l
,
5626 text_action_t action
,
5628 const literal_value
*value
,
5632 asection
*sec
= r_reloc_get_section (loc
);
5633 bfd_vma offset
= loc
->target_offset
;
5634 bfd_vma virtual_offset
= loc
->virtual_offset
;
5636 BFD_ASSERT (action
== ta_add_literal
);
5638 /* Create a new record and fill it up. */
5639 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5640 ta
->action
= action
;
5642 ta
->offset
= offset
;
5643 ta
->virtual_offset
= virtual_offset
;
5645 ta
->removed_bytes
= removed
;
5647 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5648 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5653 /* Find the total offset adjustment for the relaxations specified by
5654 text_actions, beginning from a particular starting action. This is
5655 typically used from offset_with_removed_text to search an entire list of
5656 actions, but it may also be called directly when adjusting adjacent offsets
5657 so that each search may begin where the previous one left off. */
5660 removed_by_actions (text_action_list
*action_list
,
5661 text_action
**p_start_action
,
5668 r
= *p_start_action
;
5671 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5673 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5678 if (r
->offset
> offset
)
5681 if (r
->offset
== offset
5682 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5685 removed
+= r
->removed_bytes
;
5687 r
= action_next (action_list
, r
);
5690 *p_start_action
= r
;
5696 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5698 text_action
*r
= action_first (action_list
);
5700 return offset
- removed_by_actions (action_list
, &r
, offset
, false);
5705 action_list_count (text_action_list
*action_list
)
5707 return action_list
->count
;
5710 typedef struct map_action_fn_context_struct map_action_fn_context
;
5711 struct map_action_fn_context_struct
5714 removal_by_action_map map
;
5719 map_action_fn (splay_tree_node node
, void *p
)
5721 map_action_fn_context
*ctx
= p
;
5722 text_action
*r
= (text_action
*)node
->value
;
5723 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5725 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5731 ++ctx
->map
.n_entries
;
5732 ctx
->eq_complete
= false;
5733 ientry
->offset
= r
->offset
;
5734 ientry
->eq_removed_before_fill
= ctx
->removed
;
5737 if (!ctx
->eq_complete
)
5739 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5741 ientry
->eq_removed
= ctx
->removed
;
5742 ctx
->eq_complete
= true;
5745 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5748 ctx
->removed
+= r
->removed_bytes
;
5749 ientry
->removed
= ctx
->removed
;
5754 map_removal_by_action (text_action_list
*action_list
)
5756 map_action_fn_context ctx
;
5759 ctx
.map
.n_entries
= 0;
5760 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5761 sizeof (removal_by_action_entry
));
5762 ctx
.eq_complete
= false;
5764 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5765 action_list
->map
= ctx
.map
;
5769 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5774 if (!action_list
->map
.entry
)
5775 map_removal_by_action (action_list
);
5777 if (!action_list
->map
.n_entries
)
5781 b
= action_list
->map
.n_entries
;
5785 unsigned c
= (a
+ b
) / 2;
5787 if (action_list
->map
.entry
[c
].offset
<= offset
)
5793 if (action_list
->map
.entry
[a
].offset
< offset
)
5795 return action_list
->map
.entry
[a
].removed
;
5797 else if (action_list
->map
.entry
[a
].offset
== offset
)
5799 return before_fill
?
5800 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5801 action_list
->map
.entry
[a
].eq_removed
;
5810 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5812 int removed
= removed_by_actions_map (action_list
, offset
, false);
5813 return offset
- removed
;
5817 /* The find_insn_action routine will only find non-fill actions. */
5819 static text_action
*
5820 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5822 static const text_action_t action
[] =
5824 ta_convert_longcall
,
5834 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5836 splay_tree_node node
;
5838 a
.action
= action
[i
];
5839 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5841 return (text_action
*)node
->value
;
5850 print_action (FILE *fp
, text_action
*r
)
5852 const char *t
= "unknown";
5855 case ta_remove_insn
:
5856 t
= "remove_insn"; break;
5857 case ta_remove_longcall
:
5858 t
= "remove_longcall"; break;
5859 case ta_convert_longcall
:
5860 t
= "convert_longcall"; break;
5861 case ta_narrow_insn
:
5862 t
= "narrow_insn"; break;
5864 t
= "widen_insn"; break;
5869 case ta_remove_literal
:
5870 t
= "remove_literal"; break;
5871 case ta_add_literal
:
5872 t
= "add_literal"; break;
5875 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5876 r
->sec
->owner
->filename
,
5877 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5881 print_action_list_fn (splay_tree_node node
, void *p
)
5883 text_action
*r
= (text_action
*)node
->value
;
5885 print_action (p
, r
);
5890 print_action_list (FILE *fp
, text_action_list
*action_list
)
5892 fprintf (fp
, "Text Action\n");
5893 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5899 /* Lists of literals being coalesced or removed. */
5901 /* In the usual case, the literal identified by "from" is being
5902 coalesced with another literal identified by "to". If the literal is
5903 unused and is being removed altogether, "to.abfd" will be NULL.
5904 The removed_literal entries are kept on a per-section list, sorted
5905 by the "from" offset field. */
5907 typedef struct removed_literal_struct removed_literal
;
5908 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5909 typedef struct removed_literal_list_struct removed_literal_list
;
5911 struct removed_literal_struct
5915 removed_literal
*next
;
5918 struct removed_literal_map_entry_struct
5921 removed_literal
*literal
;
5924 struct removed_literal_list_struct
5926 removed_literal
*head
;
5927 removed_literal
*tail
;
5930 removed_literal_map_entry
*map
;
5934 /* Record that the literal at "from" is being removed. If "to" is not
5935 NULL, the "from" literal is being coalesced with the "to" literal. */
5938 add_removed_literal (removed_literal_list
*removed_list
,
5939 const r_reloc
*from
,
5942 removed_literal
*r
, *new_r
, *next_r
;
5944 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5946 new_r
->from
= *from
;
5950 new_r
->to
.abfd
= NULL
;
5953 r
= removed_list
->head
;
5956 removed_list
->head
= new_r
;
5957 removed_list
->tail
= new_r
;
5959 /* Special check for common case of append. */
5960 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5962 removed_list
->tail
->next
= new_r
;
5963 removed_list
->tail
= new_r
;
5967 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5973 new_r
->next
= next_r
;
5975 removed_list
->tail
= new_r
;
5980 map_removed_literal (removed_literal_list
*removed_list
)
5984 removed_literal_map_entry
*map
= NULL
;
5985 removed_literal
*r
= removed_list
->head
;
5987 for (i
= 0; r
; ++i
, r
= r
->next
)
5991 n_map
= (n_map
* 2) + 2;
5992 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5994 map
[i
].addr
= r
->from
.target_offset
;
5997 removed_list
->map
= map
;
5998 removed_list
->n_map
= i
;
6002 removed_literal_compare (const void *a
, const void *b
)
6004 const bfd_vma
*key
= a
;
6005 const removed_literal_map_entry
*memb
= b
;
6007 if (*key
== memb
->addr
)
6010 return *key
< memb
->addr
? -1 : 1;
6013 /* Check if the list of removed literals contains an entry for the
6014 given address. Return the entry if found. */
6016 static removed_literal
*
6017 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
6019 removed_literal_map_entry
*p
;
6020 removed_literal
*r
= NULL
;
6022 if (removed_list
->map
== NULL
)
6023 map_removed_literal (removed_list
);
6025 if (removed_list
->map
!= NULL
)
6027 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
6028 sizeof (*removed_list
->map
), removed_literal_compare
);
6031 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
6043 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
6046 r
= removed_list
->head
;
6048 fprintf (fp
, "Removed Literals\n");
6049 for (; r
!= NULL
; r
= r
->next
)
6051 print_r_reloc (fp
, &r
->from
);
6052 fprintf (fp
, " => ");
6053 if (r
->to
.abfd
== NULL
)
6054 fprintf (fp
, "REMOVED");
6056 print_r_reloc (fp
, &r
->to
);
6064 /* Per-section data for relaxation. */
6066 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
6068 struct xtensa_relax_info_struct
6070 bool is_relaxable_literal_section
;
6071 bool is_relaxable_asm_section
;
6072 int visited
; /* Number of times visited. */
6074 source_reloc
*src_relocs
; /* Array[src_count]. */
6076 int src_next
; /* Next src_relocs entry to assign. */
6078 removed_literal_list removed_list
;
6079 text_action_list action_list
;
6081 reloc_bfd_fix
*fix_list
;
6082 reloc_bfd_fix
*fix_array
;
6083 unsigned fix_array_count
;
6085 /* Support for expanding the reloc array that is stored
6086 in the section structure. If the relocations have been
6087 reallocated, the newly allocated relocations will be referenced
6088 here along with the actual size allocated. The relocation
6089 count will always be found in the section structure. */
6090 Elf_Internal_Rela
*allocated_relocs
;
6091 unsigned relocs_count
;
6092 unsigned allocated_relocs_count
;
6095 struct elf_xtensa_section_data
6097 struct bfd_elf_section_data elf
;
6098 xtensa_relax_info relax_info
;
6103 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
6105 if (!sec
->used_by_bfd
)
6107 struct elf_xtensa_section_data
*sdata
;
6108 size_t amt
= sizeof (*sdata
);
6110 sdata
= bfd_zalloc (abfd
, amt
);
6113 sec
->used_by_bfd
= sdata
;
6116 return _bfd_elf_new_section_hook (abfd
, sec
);
6120 static xtensa_relax_info
*
6121 get_xtensa_relax_info (asection
*sec
)
6123 struct elf_xtensa_section_data
*section_data
;
6125 /* No info available if no section or if it is an output section. */
6126 if (!sec
|| sec
== sec
->output_section
)
6129 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
6130 return §ion_data
->relax_info
;
6135 init_xtensa_relax_info (asection
*sec
)
6137 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6139 relax_info
->is_relaxable_literal_section
= false;
6140 relax_info
->is_relaxable_asm_section
= false;
6141 relax_info
->visited
= 0;
6143 relax_info
->src_relocs
= NULL
;
6144 relax_info
->src_count
= 0;
6145 relax_info
->src_next
= 0;
6147 relax_info
->removed_list
.head
= NULL
;
6148 relax_info
->removed_list
.tail
= NULL
;
6150 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6152 relax_info
->action_list
.map
.n_entries
= 0;
6153 relax_info
->action_list
.map
.entry
= NULL
;
6155 relax_info
->fix_list
= NULL
;
6156 relax_info
->fix_array
= NULL
;
6157 relax_info
->fix_array_count
= 0;
6159 relax_info
->allocated_relocs
= NULL
;
6160 relax_info
->relocs_count
= 0;
6161 relax_info
->allocated_relocs_count
= 0;
6165 /* Coalescing literals may require a relocation to refer to a section in
6166 a different input file, but the standard relocation information
6167 cannot express that. Instead, the reloc_bfd_fix structures are used
6168 to "fix" the relocations that refer to sections in other input files.
6169 These structures are kept on per-section lists. The "src_type" field
6170 records the relocation type in case there are multiple relocations on
6171 the same location. FIXME: This is ugly; an alternative might be to
6172 add new symbols with the "owner" field to some other input file. */
6174 struct reloc_bfd_fix_struct
6178 unsigned src_type
; /* Relocation type. */
6180 asection
*target_sec
;
6181 bfd_vma target_offset
;
6184 reloc_bfd_fix
*next
;
6188 static reloc_bfd_fix
*
6189 reloc_bfd_fix_init (asection
*src_sec
,
6192 asection
*target_sec
,
6193 bfd_vma target_offset
,
6198 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6199 fix
->src_sec
= src_sec
;
6200 fix
->src_offset
= src_offset
;
6201 fix
->src_type
= src_type
;
6202 fix
->target_sec
= target_sec
;
6203 fix
->target_offset
= target_offset
;
6204 fix
->translated
= translated
;
6211 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6213 xtensa_relax_info
*relax_info
;
6215 relax_info
= get_xtensa_relax_info (src_sec
);
6216 fix
->next
= relax_info
->fix_list
;
6217 relax_info
->fix_list
= fix
;
6222 fix_compare (const void *ap
, const void *bp
)
6224 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6225 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6227 if (a
->src_offset
!= b
->src_offset
)
6228 return (a
->src_offset
- b
->src_offset
);
6229 return (a
->src_type
- b
->src_type
);
6234 cache_fix_array (asection
*sec
)
6236 unsigned i
, count
= 0;
6238 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6240 if (relax_info
== NULL
)
6242 if (relax_info
->fix_list
== NULL
)
6245 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6248 relax_info
->fix_array
=
6249 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6250 relax_info
->fix_array_count
= count
;
6252 r
= relax_info
->fix_list
;
6253 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6255 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6256 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6259 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6260 sizeof (reloc_bfd_fix
), fix_compare
);
6264 static reloc_bfd_fix
*
6265 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6267 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6271 if (relax_info
== NULL
)
6273 if (relax_info
->fix_list
== NULL
)
6276 if (relax_info
->fix_array
== NULL
)
6277 cache_fix_array (sec
);
6279 key
.src_offset
= offset
;
6280 key
.src_type
= type
;
6281 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6282 sizeof (reloc_bfd_fix
), fix_compare
);
6287 /* Section caching. */
6289 typedef struct section_cache_struct section_cache_t
;
6291 struct section_cache_struct
6295 bfd_byte
*contents
; /* Cache of the section contents. */
6296 bfd_size_type content_length
;
6298 property_table_entry
*ptbl
; /* Cache of the section property table. */
6301 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6302 unsigned reloc_count
;
6307 init_section_cache (section_cache_t
*sec_cache
)
6309 memset (sec_cache
, 0, sizeof (*sec_cache
));
6314 free_section_cache (section_cache_t
*sec_cache
)
6318 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6319 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6320 free (sec_cache
->ptbl
);
6326 section_cache_section (section_cache_t
*sec_cache
,
6328 struct bfd_link_info
*link_info
)
6331 property_table_entry
*prop_table
= NULL
;
6333 bfd_byte
*contents
= NULL
;
6334 Elf_Internal_Rela
*internal_relocs
= NULL
;
6335 bfd_size_type sec_size
;
6339 if (sec
== sec_cache
->sec
)
6343 sec_size
= bfd_get_section_limit (abfd
, sec
);
6345 /* Get the contents. */
6346 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6347 if (contents
== NULL
&& sec_size
!= 0)
6350 /* Get the relocations. */
6351 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6352 link_info
->keep_memory
);
6354 /* Get the entry table. */
6355 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6356 XTENSA_PROP_SEC_NAME
, false);
6360 /* Fill in the new section cache. */
6361 free_section_cache (sec_cache
);
6362 init_section_cache (sec_cache
);
6364 sec_cache
->sec
= sec
;
6365 sec_cache
->contents
= contents
;
6366 sec_cache
->content_length
= sec_size
;
6367 sec_cache
->relocs
= internal_relocs
;
6368 sec_cache
->reloc_count
= sec
->reloc_count
;
6369 sec_cache
->pte_count
= ptblsize
;
6370 sec_cache
->ptbl
= prop_table
;
6375 release_contents (sec
, contents
);
6376 release_internal_relocs (sec
, internal_relocs
);
6382 /* Extended basic blocks. */
6384 /* An ebb_struct represents an Extended Basic Block. Within this
6385 range, we guarantee that all instructions are decodable, the
6386 property table entries are contiguous, and no property table
6387 specifies a segment that cannot have instructions moved. This
6388 structure contains caches of the contents, property table and
6389 relocations for the specified section for easy use. The range is
6390 specified by ranges of indices for the byte offset, property table
6391 offsets and relocation offsets. These must be consistent. */
6393 typedef struct ebb_struct ebb_t
;
6399 bfd_byte
*contents
; /* Cache of the section contents. */
6400 bfd_size_type content_length
;
6402 property_table_entry
*ptbl
; /* Cache of the section property table. */
6405 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6406 unsigned reloc_count
;
6408 bfd_vma start_offset
; /* Offset in section. */
6409 unsigned start_ptbl_idx
; /* Offset in the property table. */
6410 unsigned start_reloc_idx
; /* Offset in the relocations. */
6413 unsigned end_ptbl_idx
;
6414 unsigned end_reloc_idx
;
6416 bool ends_section
; /* Is this the last ebb in a section? */
6418 /* The unreachable property table at the end of this set of blocks;
6419 NULL if the end is not an unreachable block. */
6420 property_table_entry
*ends_unreachable
;
6424 enum ebb_target_enum
6427 EBB_DESIRE_TGT_ALIGN
,
6428 EBB_REQUIRE_TGT_ALIGN
,
6429 EBB_REQUIRE_LOOP_ALIGN
,
6434 /* proposed_action_struct is similar to the text_action_struct except
6435 that is represents a potential transformation, not one that will
6436 occur. We build a list of these for an extended basic block
6437 and use them to compute the actual actions desired. We must be
6438 careful that the entire set of actual actions we perform do not
6439 break any relocations that would fit if the actions were not
6442 typedef struct proposed_action_struct proposed_action
;
6444 struct proposed_action_struct
6446 enum ebb_target_enum align_type
; /* for the target alignment */
6447 bfd_vma alignment_pow
;
6448 text_action_t action
;
6451 bool do_action
; /* If false, then we will not perform the action. */
6455 /* The ebb_constraint_struct keeps a set of proposed actions for an
6456 extended basic block. */
6458 typedef struct ebb_constraint_struct ebb_constraint
;
6460 struct ebb_constraint_struct
6465 /* Bytes of extra space at the beginning if movable. */
6466 int start_extra_space
;
6468 enum ebb_target_enum start_align
;
6472 /* Bytes of extra space at the end if movable. */
6473 int end_extra_space
;
6475 unsigned action_count
;
6476 unsigned action_allocated
;
6478 /* Array of proposed actions. */
6479 proposed_action
*actions
;
6481 /* Action alignments -- one for each proposed action. */
6482 enum ebb_target_enum
*action_aligns
;
6487 init_ebb_constraint (ebb_constraint
*c
)
6489 memset (c
, 0, sizeof (ebb_constraint
));
6494 free_ebb_constraint (ebb_constraint
*c
)
6501 init_ebb (ebb_t
*ebb
,
6504 bfd_size_type content_length
,
6505 property_table_entry
*prop_table
,
6507 Elf_Internal_Rela
*internal_relocs
,
6508 unsigned reloc_count
)
6510 memset (ebb
, 0, sizeof (ebb_t
));
6512 ebb
->contents
= contents
;
6513 ebb
->content_length
= content_length
;
6514 ebb
->ptbl
= prop_table
;
6515 ebb
->pte_count
= ptblsize
;
6516 ebb
->relocs
= internal_relocs
;
6517 ebb
->reloc_count
= reloc_count
;
6518 ebb
->start_offset
= 0;
6519 ebb
->end_offset
= ebb
->content_length
- 1;
6520 ebb
->start_ptbl_idx
= 0;
6521 ebb
->end_ptbl_idx
= ptblsize
;
6522 ebb
->start_reloc_idx
= 0;
6523 ebb
->end_reloc_idx
= reloc_count
;
6527 /* Extend the ebb to all decodable contiguous sections. The algorithm
6528 for building a basic block around an instruction is to push it
6529 forward until we hit the end of a section, an unreachable block or
6530 a block that cannot be transformed. Then we push it backwards
6531 searching for similar conditions. */
6533 static bool extend_ebb_bounds_forward (ebb_t
*);
6534 static bool extend_ebb_bounds_backward (ebb_t
*);
6535 static bfd_size_type insn_block_decodable_len
6536 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6539 extend_ebb_bounds (ebb_t
*ebb
)
6541 if (!extend_ebb_bounds_forward (ebb
))
6543 if (!extend_ebb_bounds_backward (ebb
))
6550 extend_ebb_bounds_forward (ebb_t
*ebb
)
6552 property_table_entry
*the_entry
, *new_entry
;
6554 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6556 /* Stop when (1) we cannot decode an instruction, (2) we are at
6557 the end of the property tables, (3) we hit a non-contiguous property
6558 table entry, (4) we hit a NO_TRANSFORM region. */
6563 bfd_size_type insn_block_len
;
6565 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6567 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6569 entry_end
- ebb
->end_offset
);
6570 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6573 /* xgettext:c-format */
6574 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6575 "possible configuration mismatch"),
6576 ebb
->sec
->owner
, ebb
->sec
,
6577 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6580 ebb
->end_offset
+= insn_block_len
;
6582 if (ebb
->end_offset
== ebb
->sec
->size
)
6583 ebb
->ends_section
= true;
6585 /* Update the reloc counter. */
6586 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6587 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6590 ebb
->end_reloc_idx
++;
6593 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6596 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6597 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6598 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6599 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6602 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6605 the_entry
= new_entry
;
6606 ebb
->end_ptbl_idx
++;
6609 /* Quick check for an unreachable or end of file just at the end. */
6610 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6612 if (ebb
->end_offset
== ebb
->content_length
)
6613 ebb
->ends_section
= true;
6617 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6618 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6619 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6620 ebb
->ends_unreachable
= new_entry
;
6623 /* Any other ending requires exact alignment. */
6629 extend_ebb_bounds_backward (ebb_t
*ebb
)
6631 property_table_entry
*the_entry
, *new_entry
;
6633 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6635 /* Stop when (1) we cannot decode the instructions in the current entry.
6636 (2) we are at the beginning of the property tables, (3) we hit a
6637 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6641 bfd_vma block_begin
;
6642 bfd_size_type insn_block_len
;
6644 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6646 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6648 ebb
->start_offset
- block_begin
);
6649 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6652 /* xgettext:c-format */
6653 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6654 "possible configuration mismatch"),
6655 ebb
->sec
->owner
, ebb
->sec
,
6656 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6659 ebb
->start_offset
-= insn_block_len
;
6661 /* Update the reloc counter. */
6662 while (ebb
->start_reloc_idx
> 0
6663 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6664 >= ebb
->start_offset
))
6666 ebb
->start_reloc_idx
--;
6669 if (ebb
->start_ptbl_idx
== 0)
6672 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6673 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6674 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6675 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6677 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6680 the_entry
= new_entry
;
6681 ebb
->start_ptbl_idx
--;
6687 static bfd_size_type
6688 insn_block_decodable_len (bfd_byte
*contents
,
6689 bfd_size_type content_len
,
6690 bfd_vma block_offset
,
6691 bfd_size_type block_len
)
6693 bfd_vma offset
= block_offset
;
6695 while (offset
< block_offset
+ block_len
)
6697 bfd_size_type insn_len
= 0;
6699 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6701 return (offset
- block_offset
);
6704 return (offset
- block_offset
);
6709 ebb_propose_action (ebb_constraint
*c
,
6710 enum ebb_target_enum align_type
,
6711 bfd_vma alignment_pow
,
6712 text_action_t action
,
6717 proposed_action
*act
;
6719 if (c
->action_allocated
<= c
->action_count
)
6721 unsigned new_allocated
, i
;
6722 proposed_action
*new_actions
;
6724 new_allocated
= (c
->action_count
+ 2) * 2;
6725 new_actions
= (proposed_action
*)
6726 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6728 for (i
= 0; i
< c
->action_count
; i
++)
6729 new_actions
[i
] = c
->actions
[i
];
6731 c
->actions
= new_actions
;
6732 c
->action_allocated
= new_allocated
;
6735 act
= &c
->actions
[c
->action_count
];
6736 act
->align_type
= align_type
;
6737 act
->alignment_pow
= alignment_pow
;
6738 act
->action
= action
;
6739 act
->offset
= offset
;
6740 act
->removed_bytes
= removed_bytes
;
6741 act
->do_action
= do_action
;
6747 /* Access to internal relocations, section contents and symbols. */
6749 /* During relaxation, we need to modify relocations, section contents,
6750 and symbol definitions, and we need to keep the original values from
6751 being reloaded from the input files, i.e., we need to "pin" the
6752 modified values in memory. We also want to continue to observe the
6753 setting of the "keep-memory" flag. The following functions wrap the
6754 standard BFD functions to take care of this for us. */
6756 static Elf_Internal_Rela
*
6757 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bool keep_memory
)
6759 Elf_Internal_Rela
*internal_relocs
;
6761 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6764 internal_relocs
= elf_section_data (sec
)->relocs
;
6765 if (internal_relocs
== NULL
)
6766 internal_relocs
= (_bfd_elf_link_read_relocs
6767 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6768 return internal_relocs
;
6773 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6775 elf_section_data (sec
)->relocs
= internal_relocs
;
6780 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6782 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
6783 free (internal_relocs
);
6788 retrieve_contents (bfd
*abfd
, asection
*sec
, bool keep_memory
)
6791 bfd_size_type sec_size
;
6793 sec_size
= bfd_get_section_limit (abfd
, sec
);
6794 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6796 if (contents
== NULL
&& sec_size
!= 0)
6798 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6804 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6811 pin_contents (asection
*sec
, bfd_byte
*contents
)
6813 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6818 release_contents (asection
*sec
, bfd_byte
*contents
)
6820 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6825 static Elf_Internal_Sym
*
6826 retrieve_local_syms (bfd
*input_bfd
)
6828 Elf_Internal_Shdr
*symtab_hdr
;
6829 Elf_Internal_Sym
*isymbuf
;
6832 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6833 locsymcount
= symtab_hdr
->sh_info
;
6835 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6836 if (isymbuf
== NULL
&& locsymcount
!= 0)
6837 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6840 /* Save the symbols for this input file so they won't be read again. */
6841 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6842 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6848 /* Code for link-time relaxation. */
6850 /* Initialization for relaxation: */
6851 static bool analyze_relocations (struct bfd_link_info
*);
6852 static bool find_relaxable_sections
6853 (bfd
*, asection
*, struct bfd_link_info
*, bool *);
6854 static bool collect_source_relocs
6855 (bfd
*, asection
*, struct bfd_link_info
*);
6856 static bool is_resolvable_asm_expansion
6857 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6859 static Elf_Internal_Rela
*find_associated_l32r_irel
6860 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6861 static bool compute_text_actions
6862 (bfd
*, asection
*, struct bfd_link_info
*);
6863 static bool compute_ebb_proposed_actions (ebb_constraint
*);
6864 static bool compute_ebb_actions (ebb_constraint
*);
6865 typedef struct reloc_range_list_struct reloc_range_list
;
6866 static bool check_section_ebb_pcrels_fit
6867 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6868 reloc_range_list
*, const ebb_constraint
*,
6869 const xtensa_opcode
*);
6870 static bool check_section_ebb_reduces (const ebb_constraint
*);
6871 static void text_action_add_proposed
6872 (text_action_list
*, const ebb_constraint
*, asection
*);
6875 static bool compute_removed_literals
6876 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6877 static Elf_Internal_Rela
*get_irel_at_offset
6878 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6879 static bool is_removable_literal
6880 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6881 property_table_entry
*, int);
6882 static bool remove_dead_literal
6883 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6884 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6885 static bool identify_literal_placement
6886 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6887 value_map_hash_table
*, bool *, Elf_Internal_Rela
*, int,
6888 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6890 static bool relocations_reach (source_reloc
*, int, const r_reloc
*);
6891 static bool coalesce_shared_literal
6892 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6893 static bool move_shared_literal
6894 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6895 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6898 static bool relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6899 static bool translate_section_fixes (asection
*);
6900 static bool translate_reloc_bfd_fix (reloc_bfd_fix
*);
6901 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6902 static void shrink_dynamic_reloc_sections
6903 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6904 static bool move_literal
6905 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6906 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6907 static bool relax_property_section
6908 (bfd
*, asection
*, struct bfd_link_info
*);
6911 static bool relax_section_symbols (bfd
*, asection
*);
6915 elf_xtensa_relax_section (bfd
*abfd
,
6917 struct bfd_link_info
*link_info
,
6920 static value_map_hash_table
*values
= NULL
;
6921 static bool relocations_analyzed
= false;
6922 xtensa_relax_info
*relax_info
;
6924 if (!relocations_analyzed
)
6926 /* Do some overall initialization for relaxation. */
6927 values
= value_map_hash_table_init ();
6930 relaxing_section
= true;
6931 if (!analyze_relocations (link_info
))
6933 relocations_analyzed
= true;
6937 /* Don't mess with linker-created sections. */
6938 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6941 relax_info
= get_xtensa_relax_info (sec
);
6942 BFD_ASSERT (relax_info
!= NULL
);
6944 switch (relax_info
->visited
)
6947 /* Note: It would be nice to fold this pass into
6948 analyze_relocations, but it is important for this step that the
6949 sections be examined in link order. */
6950 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6957 value_map_hash_table_delete (values
);
6959 if (!relax_section (abfd
, sec
, link_info
))
6965 if (!relax_section_symbols (abfd
, sec
))
6970 relax_info
->visited
++;
6975 /* Initialization for relaxation. */
6977 /* This function is called once at the start of relaxation. It scans
6978 all the input sections and marks the ones that are relaxable (i.e.,
6979 literal sections with L32R relocations against them), and then
6980 collects source_reloc information for all the relocations against
6981 those relaxable sections. During this process, it also detects
6982 longcalls, i.e., calls relaxed by the assembler into indirect
6983 calls, that can be optimized back into direct calls. Within each
6984 extended basic block (ebb) containing an optimized longcall, it
6985 computes a set of "text actions" that can be performed to remove
6986 the L32R associated with the longcall while optionally preserving
6987 branch target alignments. */
6990 analyze_relocations (struct bfd_link_info
*link_info
)
6994 bool is_relaxable
= false;
6996 /* Initialize the per-section relaxation info. */
6997 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6998 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7000 init_xtensa_relax_info (sec
);
7003 /* Mark relaxable sections (and count relocations against each one). */
7004 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7005 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7007 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
7011 /* Bail out if there are no relaxable sections. */
7015 /* Allocate space for source_relocs. */
7016 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7017 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7019 xtensa_relax_info
*relax_info
;
7021 relax_info
= get_xtensa_relax_info (sec
);
7022 if (relax_info
->is_relaxable_literal_section
7023 || relax_info
->is_relaxable_asm_section
)
7025 relax_info
->src_relocs
= (source_reloc
*)
7026 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
7029 relax_info
->src_count
= 0;
7032 /* Collect info on relocations against each relaxable section. */
7033 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7034 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7036 if (!collect_source_relocs (abfd
, sec
, link_info
))
7040 /* Compute the text actions. */
7041 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7042 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7044 if (!compute_text_actions (abfd
, sec
, link_info
))
7052 /* Find all the sections that might be relaxed. The motivation for
7053 this pass is that collect_source_relocs() needs to record _all_ the
7054 relocations that target each relaxable section. That is expensive
7055 and unnecessary unless the target section is actually going to be
7056 relaxed. This pass identifies all such sections by checking if
7057 they have L32Rs pointing to them. In the process, the total number
7058 of relocations targeting each section is also counted so that we
7059 know how much space to allocate for source_relocs against each
7060 relaxable literal section. */
7063 find_relaxable_sections (bfd
*abfd
,
7065 struct bfd_link_info
*link_info
,
7066 bool *is_relaxable_p
)
7068 Elf_Internal_Rela
*internal_relocs
;
7072 xtensa_relax_info
*source_relax_info
;
7075 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7076 link_info
->keep_memory
);
7077 if (internal_relocs
== NULL
)
7080 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7081 if (contents
== NULL
&& sec
->size
!= 0)
7087 source_relax_info
= get_xtensa_relax_info (sec
);
7088 for (i
= 0; i
< sec
->reloc_count
; i
++)
7090 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7092 asection
*target_sec
;
7093 xtensa_relax_info
*target_relax_info
;
7095 /* If this section has not already been marked as "relaxable", and
7096 if it contains any ASM_EXPAND relocations (marking expanded
7097 longcalls) that can be optimized into direct calls, then mark
7098 the section as "relaxable". */
7099 if (source_relax_info
7100 && !source_relax_info
->is_relaxable_asm_section
7101 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
7103 bool is_reachable
= false;
7104 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
7105 link_info
, &is_reachable
)
7108 source_relax_info
->is_relaxable_asm_section
= true;
7109 *is_relaxable_p
= true;
7113 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7114 bfd_get_section_limit (abfd
, sec
));
7116 target_sec
= r_reloc_get_section (&r_rel
);
7117 target_relax_info
= get_xtensa_relax_info (target_sec
);
7118 if (!target_relax_info
)
7121 /* Count PC-relative operand relocations against the target section.
7122 Note: The conditions tested here must match the conditions under
7123 which init_source_reloc is called in collect_source_relocs(). */
7124 is_l32r_reloc
= false;
7125 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7127 xtensa_opcode opcode
=
7128 get_relocation_opcode (abfd
, sec
, contents
, irel
);
7129 if (opcode
!= XTENSA_UNDEFINED
)
7131 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
7132 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
7134 target_relax_info
->src_count
++;
7138 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7140 /* Mark the target section as relaxable. */
7141 target_relax_info
->is_relaxable_literal_section
= true;
7142 *is_relaxable_p
= true;
7147 release_contents (sec
, contents
);
7148 release_internal_relocs (sec
, internal_relocs
);
7153 /* Record _all_ the relocations that point to relaxable sections, and
7154 get rid of ASM_EXPAND relocs by either converting them to
7155 ASM_SIMPLIFY or by removing them. */
7158 collect_source_relocs (bfd
*abfd
,
7160 struct bfd_link_info
*link_info
)
7162 Elf_Internal_Rela
*internal_relocs
;
7166 bfd_size_type sec_size
;
7168 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7169 link_info
->keep_memory
);
7170 if (internal_relocs
== NULL
)
7173 sec_size
= bfd_get_section_limit (abfd
, sec
);
7174 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7175 if (contents
== NULL
&& sec_size
!= 0)
7181 /* Record relocations against relaxable literal sections. */
7182 for (i
= 0; i
< sec
->reloc_count
; i
++)
7184 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7186 asection
*target_sec
;
7187 xtensa_relax_info
*target_relax_info
;
7189 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7191 target_sec
= r_reloc_get_section (&r_rel
);
7192 target_relax_info
= get_xtensa_relax_info (target_sec
);
7194 if (target_relax_info
7195 && (target_relax_info
->is_relaxable_literal_section
7196 || target_relax_info
->is_relaxable_asm_section
))
7198 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7200 bool is_abs_literal
= false;
7202 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7204 /* None of the current alternate relocs are PC-relative,
7205 and only PC-relative relocs matter here. However, we
7206 still need to record the opcode for literal
7208 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7209 if (opcode
== get_l32r_opcode ())
7211 is_abs_literal
= true;
7215 opcode
= XTENSA_UNDEFINED
;
7217 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7219 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7220 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7223 if (opcode
!= XTENSA_UNDEFINED
)
7225 int src_next
= target_relax_info
->src_next
++;
7226 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7228 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7234 /* Now get rid of ASM_EXPAND relocations. At this point, the
7235 src_relocs array for the target literal section may still be
7236 incomplete, but it must at least contain the entries for the L32R
7237 relocations associated with ASM_EXPANDs because they were just
7238 added in the preceding loop over the relocations. */
7240 for (i
= 0; i
< sec
->reloc_count
; i
++)
7242 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7245 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7251 Elf_Internal_Rela
*l32r_irel
;
7253 asection
*target_sec
;
7254 xtensa_relax_info
*target_relax_info
;
7256 /* Mark the source_reloc for the L32R so that it will be
7257 removed in compute_removed_literals(), along with the
7258 associated literal. */
7259 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7260 irel
, internal_relocs
);
7261 if (l32r_irel
== NULL
)
7264 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7266 target_sec
= r_reloc_get_section (&r_rel
);
7267 target_relax_info
= get_xtensa_relax_info (target_sec
);
7269 if (target_relax_info
7270 && (target_relax_info
->is_relaxable_literal_section
7271 || target_relax_info
->is_relaxable_asm_section
))
7273 source_reloc
*s_reloc
;
7275 /* Search the source_relocs for the entry corresponding to
7276 the l32r_irel. Note: The src_relocs array is not yet
7277 sorted, but it wouldn't matter anyway because we're
7278 searching by source offset instead of target offset. */
7279 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7280 target_relax_info
->src_next
,
7282 BFD_ASSERT (s_reloc
);
7283 s_reloc
->is_null
= true;
7286 /* Convert this reloc to ASM_SIMPLIFY. */
7287 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7288 R_XTENSA_ASM_SIMPLIFY
);
7289 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7291 pin_internal_relocs (sec
, internal_relocs
);
7295 /* It is resolvable but doesn't reach. We resolve now
7296 by eliminating the relocation -- the call will remain
7297 expanded into L32R/CALLX. */
7298 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7299 pin_internal_relocs (sec
, internal_relocs
);
7304 release_contents (sec
, contents
);
7305 release_internal_relocs (sec
, internal_relocs
);
7310 /* Return TRUE if the asm expansion can be resolved. Generally it can
7311 be resolved on a final link or when a partial link locates it in the
7312 same section as the target. Set "is_reachable" flag if the target of
7313 the call is within the range of a direct call, given the current VMA
7314 for this section and the target section. */
7317 is_resolvable_asm_expansion (bfd
*abfd
,
7320 Elf_Internal_Rela
*irel
,
7321 struct bfd_link_info
*link_info
,
7322 bool *is_reachable_p
)
7324 asection
*target_sec
;
7328 unsigned int first_align
;
7329 unsigned int adjust
;
7330 bfd_vma target_offset
;
7332 xtensa_opcode opcode
, direct_call_opcode
;
7333 bfd_vma self_address
;
7334 bfd_vma dest_address
;
7336 bfd_size_type sec_size
;
7338 *is_reachable_p
= false;
7340 if (contents
== NULL
)
7343 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7346 sec_size
= bfd_get_section_limit (abfd
, sec
);
7347 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7348 sec_size
- irel
->r_offset
, &uses_l32r
);
7349 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7353 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7354 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7357 /* Check and see that the target resolves. */
7358 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7359 if (!r_reloc_is_defined (&r_rel
))
7362 target_sec
= r_reloc_get_section (&r_rel
);
7363 target_offset
= r_rel
.target_offset
;
7365 /* If the target is in a shared library, then it doesn't reach. This
7366 isn't supposed to come up because the compiler should never generate
7367 non-PIC calls on systems that use shared libraries, but the linker
7368 shouldn't crash regardless. */
7369 if (!target_sec
->output_section
)
7372 /* For relocatable sections, we can only simplify when the output
7373 section of the target is the same as the output section of the
7375 if (bfd_link_relocatable (link_info
)
7376 && (target_sec
->output_section
!= sec
->output_section
7377 || is_reloc_sym_weak (abfd
, irel
)))
7380 if (target_sec
->output_section
!= sec
->output_section
)
7382 /* If the two sections are sufficiently far away that relaxation
7383 might take the call out of range, we can't simplify. For
7384 example, a positive displacement call into another memory
7385 could get moved to a lower address due to literal removal,
7386 but the destination won't move, and so the displacment might
7389 If the displacement is negative, assume the destination could
7390 move as far back as the start of the output section. The
7391 self_address will be at least as far into the output section
7392 as it is prior to relaxation.
7394 If the displacement is postive, assume the destination will be in
7395 it's pre-relaxed location (because relaxation only makes sections
7396 smaller). The self_address could go all the way to the beginning
7397 of the output section. */
7399 dest_address
= target_sec
->output_section
->vma
;
7400 self_address
= sec
->output_section
->vma
;
7402 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7403 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7405 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7406 /* Call targets should be four-byte aligned. */
7407 dest_address
= (dest_address
+ 3) & ~3;
7412 self_address
= (sec
->output_section
->vma
7413 + sec
->output_offset
+ irel
->r_offset
+ 3);
7414 dest_address
= (target_sec
->output_section
->vma
7415 + target_sec
->output_offset
+ target_offset
);
7418 /* Adjust addresses with alignments for the worst case to see if call insn
7419 can fit. Don't relax l32r + callx to call if the target can be out of
7420 range due to alignment.
7421 Caller and target addresses are highest and lowest address.
7422 Search all sections between caller and target, looking for max alignment.
7423 The adjustment is max alignment bytes. If the alignment at the lowest
7424 address is less than the adjustment, apply the adjustment to highest
7427 /* Start from lowest address.
7428 Lowest address aligmnet is from input section.
7429 Initial alignment (adjust) is from input section. */
7430 if (dest_address
> self_address
)
7432 s
= sec
->output_section
;
7433 last_vma
= dest_address
;
7434 first_align
= sec
->alignment_power
;
7435 adjust
= target_sec
->alignment_power
;
7439 s
= target_sec
->output_section
;
7440 last_vma
= self_address
;
7441 first_align
= target_sec
->alignment_power
;
7442 adjust
= sec
->alignment_power
;
7447 /* Find the largest alignment in output section list. */
7448 for (; s
&& s
->vma
>= first_vma
&& s
->vma
<= last_vma
; s
= s
->next
)
7450 if (s
->alignment_power
> adjust
)
7451 adjust
= s
->alignment_power
;
7454 if (adjust
> first_align
)
7456 /* Alignment may enlarge the range, adjust highest address. */
7457 adjust
= 1 << adjust
;
7458 if (dest_address
> self_address
)
7460 dest_address
+= adjust
;
7464 self_address
+= adjust
;
7468 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7469 self_address
, dest_address
);
7471 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7472 (dest_address
>> CALL_SEGMENT_BITS
))
7479 static Elf_Internal_Rela
*
7480 find_associated_l32r_irel (bfd
*abfd
,
7483 Elf_Internal_Rela
*other_irel
,
7484 Elf_Internal_Rela
*internal_relocs
)
7488 for (i
= 0; i
< sec
->reloc_count
; i
++)
7490 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7492 if (irel
== other_irel
)
7494 if (irel
->r_offset
!= other_irel
->r_offset
)
7496 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7504 static xtensa_opcode
*
7505 build_reloc_opcodes (bfd
*abfd
,
7508 Elf_Internal_Rela
*internal_relocs
)
7511 xtensa_opcode
*reloc_opcodes
=
7512 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7513 for (i
= 0; i
< sec
->reloc_count
; i
++)
7515 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7516 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7518 return reloc_opcodes
;
7521 struct reloc_range_struct
7524 bool add
; /* TRUE if start of a range, FALSE otherwise. */
7525 /* Original irel index in the array of relocations for a section. */
7526 unsigned irel_index
;
7528 typedef struct reloc_range_struct reloc_range
;
7530 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7531 struct reloc_range_list_entry_struct
7533 reloc_range_list_entry
*next
;
7534 reloc_range_list_entry
*prev
;
7535 Elf_Internal_Rela
*irel
;
7536 xtensa_opcode opcode
;
7540 struct reloc_range_list_struct
7542 /* The rest of the structure is only meaningful when ok is TRUE. */
7545 unsigned n_range
; /* Number of range markers. */
7546 reloc_range
*range
; /* Sorted range markers. */
7548 unsigned first
; /* Index of a first range element in the list. */
7549 unsigned last
; /* One past index of a last range element in the list. */
7551 unsigned n_list
; /* Number of list elements. */
7552 reloc_range_list_entry
*reloc
; /* */
7553 reloc_range_list_entry list_root
;
7557 reloc_range_compare (const void *a
, const void *b
)
7559 const reloc_range
*ra
= a
;
7560 const reloc_range
*rb
= b
;
7562 if (ra
->addr
!= rb
->addr
)
7563 return ra
->addr
< rb
->addr
? -1 : 1;
7564 if (ra
->add
!= rb
->add
)
7565 return ra
->add
? -1 : 1;
7570 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7572 Elf_Internal_Rela
*internal_relocs
,
7573 xtensa_opcode
*reloc_opcodes
,
7574 reloc_range_list
*list
)
7579 reloc_range
*ranges
= NULL
;
7580 reloc_range_list_entry
*reloc
=
7581 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7583 memset (list
, 0, sizeof (*list
));
7586 for (i
= 0; i
< sec
->reloc_count
; i
++)
7588 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7589 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7590 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7593 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7594 || r_type
== R_XTENSA_32_PCREL
7595 || !howto
->pc_relative
)
7598 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7599 bfd_get_section_limit (abfd
, sec
));
7601 if (r_reloc_get_section (&r_rel
) != sec
)
7606 max_n
= (max_n
+ 2) * 2;
7607 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7610 ranges
[n
].addr
= irel
->r_offset
;
7611 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7613 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7614 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7616 ranges
[n
].irel_index
= i
;
7617 ranges
[n
+ 1].irel_index
= i
;
7621 reloc
[i
].irel
= irel
;
7623 /* Every relocation won't possibly be checked in the optimized version of
7624 check_section_ebb_pcrels_fit, so this needs to be done here. */
7625 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7627 /* None of the current alternate relocs are PC-relative,
7628 and only PC-relative relocs matter here. */
7632 xtensa_opcode opcode
;
7636 opcode
= reloc_opcodes
[i
];
7638 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7640 if (opcode
== XTENSA_UNDEFINED
)
7646 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7647 if (opnum
== XTENSA_UNDEFINED
)
7653 /* Record relocation opcode and opnum as we've calculated them
7654 anyway and they won't change. */
7655 reloc
[i
].opcode
= opcode
;
7656 reloc
[i
].opnum
= opnum
;
7662 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7663 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7666 list
->range
= ranges
;
7667 list
->reloc
= reloc
;
7668 list
->list_root
.prev
= &list
->list_root
;
7669 list
->list_root
.next
= &list
->list_root
;
7678 static void reloc_range_list_append (reloc_range_list
*list
,
7679 unsigned irel_index
)
7681 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7683 entry
->prev
= list
->list_root
.prev
;
7684 entry
->next
= &list
->list_root
;
7685 entry
->prev
->next
= entry
;
7686 entry
->next
->prev
= entry
;
7690 static void reloc_range_list_remove (reloc_range_list
*list
,
7691 unsigned irel_index
)
7693 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7695 entry
->next
->prev
= entry
->prev
;
7696 entry
->prev
->next
= entry
->next
;
7700 /* Update relocation list object so that it lists all relocations that cross
7701 [first; last] range. Range bounds should not decrease with successive
7703 static void reloc_range_list_update_range (reloc_range_list
*list
,
7704 bfd_vma first
, bfd_vma last
)
7706 /* This should not happen: EBBs are iterated from lower addresses to higher.
7707 But even if that happens there's no need to break: just flush current list
7708 and start from scratch. */
7709 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7710 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7715 list
->list_root
.next
= &list
->list_root
;
7716 list
->list_root
.prev
= &list
->list_root
;
7717 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7720 for (; list
->last
< list
->n_range
&&
7721 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7722 if (list
->range
[list
->last
].add
)
7723 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7725 for (; list
->first
< list
->n_range
&&
7726 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7727 if (!list
->range
[list
->first
].add
)
7728 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7731 static void free_reloc_range_list (reloc_range_list
*list
)
7737 /* The compute_text_actions function will build a list of potential
7738 transformation actions for code in the extended basic block of each
7739 longcall that is optimized to a direct call. From this list we
7740 generate a set of actions to actually perform that optimizes for
7741 space and, if not using size_opt, maintains branch target
7744 These actions to be performed are placed on a per-section list.
7745 The actual changes are performed by relax_section() in the second
7749 compute_text_actions (bfd
*abfd
,
7751 struct bfd_link_info
*link_info
)
7753 xtensa_opcode
*reloc_opcodes
= NULL
;
7754 xtensa_relax_info
*relax_info
;
7756 Elf_Internal_Rela
*internal_relocs
;
7759 property_table_entry
*prop_table
= 0;
7761 bfd_size_type sec_size
;
7762 reloc_range_list relevant_relocs
;
7764 relax_info
= get_xtensa_relax_info (sec
);
7765 BFD_ASSERT (relax_info
);
7766 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7768 /* Do nothing if the section contains no optimized longcalls. */
7769 if (!relax_info
->is_relaxable_asm_section
)
7772 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7773 link_info
->keep_memory
);
7775 if (internal_relocs
)
7776 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7777 internal_reloc_compare
);
7779 sec_size
= bfd_get_section_limit (abfd
, sec
);
7780 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7781 if (contents
== NULL
&& sec_size
!= 0)
7787 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7788 XTENSA_PROP_SEC_NAME
, false);
7795 /* Precompute the opcode for each relocation. */
7796 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7798 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7801 for (i
= 0; i
< sec
->reloc_count
; i
++)
7803 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7805 property_table_entry
*the_entry
;
7808 ebb_constraint ebb_table
;
7809 bfd_size_type simplify_size
;
7811 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7813 r_offset
= irel
->r_offset
;
7815 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7816 if (simplify_size
== 0)
7819 /* xgettext:c-format */
7820 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7821 "XTENSA_ASM_SIMPLIFY relocation; "
7822 "possible configuration mismatch"),
7823 sec
->owner
, sec
, (uint64_t) r_offset
);
7827 /* If the instruction table is not around, then don't do this
7829 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7830 sec
->vma
+ irel
->r_offset
);
7831 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7833 text_action_add (&relax_info
->action_list
,
7834 ta_convert_longcall
, sec
, r_offset
,
7839 /* If the next longcall happens to be at the same address as an
7840 unreachable section of size 0, then skip forward. */
7841 ptbl_idx
= the_entry
- prop_table
;
7842 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7843 && the_entry
->size
== 0
7844 && ptbl_idx
+ 1 < ptblsize
7845 && (prop_table
[ptbl_idx
+ 1].address
7846 == prop_table
[ptbl_idx
].address
))
7852 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7853 /* NO_REORDER is OK */
7856 init_ebb_constraint (&ebb_table
);
7857 ebb
= &ebb_table
.ebb
;
7858 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7859 internal_relocs
, sec
->reloc_count
);
7860 ebb
->start_offset
= r_offset
+ simplify_size
;
7861 ebb
->end_offset
= r_offset
+ simplify_size
;
7862 ebb
->start_ptbl_idx
= ptbl_idx
;
7863 ebb
->end_ptbl_idx
= ptbl_idx
;
7864 ebb
->start_reloc_idx
= i
;
7865 ebb
->end_reloc_idx
= i
;
7867 if (!extend_ebb_bounds (ebb
)
7868 || !compute_ebb_proposed_actions (&ebb_table
)
7869 || !compute_ebb_actions (&ebb_table
)
7870 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7873 &ebb_table
, reloc_opcodes
)
7874 || !check_section_ebb_reduces (&ebb_table
))
7876 /* If anything goes wrong or we get unlucky and something does
7877 not fit, with our plan because of expansion between
7878 critical branches, just convert to a NOP. */
7880 text_action_add (&relax_info
->action_list
,
7881 ta_convert_longcall
, sec
, r_offset
, 0);
7882 i
= ebb_table
.ebb
.end_reloc_idx
;
7883 free_ebb_constraint (&ebb_table
);
7887 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7889 /* Update the index so we do not go looking at the relocations
7890 we have already processed. */
7891 i
= ebb_table
.ebb
.end_reloc_idx
;
7892 free_ebb_constraint (&ebb_table
);
7895 free_reloc_range_list (&relevant_relocs
);
7898 if (action_list_count (&relax_info
->action_list
))
7899 print_action_list (stderr
, &relax_info
->action_list
);
7903 release_contents (sec
, contents
);
7904 release_internal_relocs (sec
, internal_relocs
);
7906 free (reloc_opcodes
);
7912 /* Do not widen an instruction if it is preceeded by a
7913 loop opcode. It might cause misalignment. */
7916 prev_instr_is_a_loop (bfd_byte
*contents
,
7917 bfd_size_type content_length
,
7918 bfd_size_type offset
)
7920 xtensa_opcode prev_opcode
;
7924 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7925 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7929 /* Find all of the possible actions for an extended basic block. */
7932 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7934 const ebb_t
*ebb
= &ebb_table
->ebb
;
7935 unsigned rel_idx
= ebb
->start_reloc_idx
;
7936 property_table_entry
*entry
, *start_entry
, *end_entry
;
7938 xtensa_isa isa
= xtensa_default_isa
;
7940 static xtensa_insnbuf insnbuf
= NULL
;
7941 static xtensa_insnbuf slotbuf
= NULL
;
7943 if (insnbuf
== NULL
)
7945 insnbuf
= xtensa_insnbuf_alloc (isa
);
7946 slotbuf
= xtensa_insnbuf_alloc (isa
);
7949 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7950 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7952 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7954 bfd_vma start_offset
, end_offset
;
7955 bfd_size_type insn_len
;
7957 start_offset
= entry
->address
- ebb
->sec
->vma
;
7958 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7960 if (entry
== start_entry
)
7961 start_offset
= ebb
->start_offset
;
7962 if (entry
== end_entry
)
7963 end_offset
= ebb
->end_offset
;
7964 offset
= start_offset
;
7966 if (offset
== entry
->address
- ebb
->sec
->vma
7967 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7969 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7970 BFD_ASSERT (offset
!= end_offset
);
7971 if (offset
== end_offset
)
7974 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7979 if (check_branch_target_aligned_address (offset
, insn_len
))
7980 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7982 ebb_propose_action (ebb_table
, align_type
, 0,
7983 ta_none
, offset
, 0, true);
7986 while (offset
!= end_offset
)
7988 Elf_Internal_Rela
*irel
;
7989 xtensa_opcode opcode
;
7991 while (rel_idx
< ebb
->end_reloc_idx
7992 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7993 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7994 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
7995 != R_XTENSA_ASM_SIMPLIFY
))))
7998 /* Check for longcall. */
7999 irel
= &ebb
->relocs
[rel_idx
];
8000 if (irel
->r_offset
== offset
8001 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
8003 bfd_size_type simplify_size
;
8005 simplify_size
= get_asm_simplify_size (ebb
->contents
,
8006 ebb
->content_length
,
8008 if (simplify_size
== 0)
8011 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8012 ta_convert_longcall
, offset
, 0, true);
8014 offset
+= simplify_size
;
8018 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
8020 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
8021 ebb
->content_length
- offset
);
8022 fmt
= xtensa_format_decode (isa
, insnbuf
);
8023 if (fmt
== XTENSA_UNDEFINED
)
8025 insn_len
= xtensa_format_length (isa
, fmt
);
8026 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
8029 if (xtensa_format_num_slots (isa
, fmt
) != 1)
8035 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
8036 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
8037 if (opcode
== XTENSA_UNDEFINED
)
8040 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
8041 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8042 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
8044 /* Add an instruction narrow action. */
8045 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8046 ta_narrow_insn
, offset
, 0, false);
8048 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8049 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
8050 && ! prev_instr_is_a_loop (ebb
->contents
,
8051 ebb
->content_length
, offset
))
8053 /* Add an instruction widen action. */
8054 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8055 ta_widen_insn
, offset
, 0, false);
8057 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
8059 /* Check for branch targets. */
8060 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
8061 ta_none
, offset
, 0, true);
8068 if (ebb
->ends_unreachable
)
8070 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8071 ta_fill
, ebb
->end_offset
, 0, true);
8078 /* xgettext:c-format */
8079 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
8080 "possible configuration mismatch"),
8081 ebb
->sec
->owner
, ebb
->sec
, (uint64_t) offset
);
8086 /* After all of the information has collected about the
8087 transformations possible in an EBB, compute the appropriate actions
8088 here in compute_ebb_actions. We still must check later to make
8089 sure that the actions do not break any relocations. The algorithm
8090 used here is pretty greedy. Basically, it removes as many no-ops
8091 as possible so that the end of the EBB has the same alignment
8092 characteristics as the original. First, it uses narrowing, then
8093 fill space at the end of the EBB, and finally widenings. If that
8094 does not work, it tries again with one fewer no-op removed. The
8095 optimization will only be performed if all of the branch targets
8096 that were aligned before transformation are also aligned after the
8099 When the size_opt flag is set, ignore the branch target alignments,
8100 narrow all wide instructions, and remove all no-ops unless the end
8101 of the EBB prevents it. */
8104 compute_ebb_actions (ebb_constraint
*ebb_table
)
8108 int removed_bytes
= 0;
8109 ebb_t
*ebb
= &ebb_table
->ebb
;
8110 unsigned seg_idx_start
= 0;
8111 unsigned seg_idx_end
= 0;
8113 /* We perform this like the assembler relaxation algorithm: Start by
8114 assuming all instructions are narrow and all no-ops removed; then
8117 /* For each segment of this that has a solid constraint, check to
8118 see if there are any combinations that will keep the constraint.
8120 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
8122 bool requires_text_end_align
= false;
8123 unsigned longcall_count
= 0;
8124 unsigned longcall_convert_count
= 0;
8125 unsigned narrowable_count
= 0;
8126 unsigned narrowable_convert_count
= 0;
8127 unsigned widenable_count
= 0;
8128 unsigned widenable_convert_count
= 0;
8130 proposed_action
*action
= NULL
;
8131 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
8133 seg_idx_start
= seg_idx_end
;
8135 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
8137 action
= &ebb_table
->actions
[i
];
8138 if (action
->action
== ta_convert_longcall
)
8140 if (action
->action
== ta_narrow_insn
)
8142 if (action
->action
== ta_widen_insn
)
8144 if (action
->action
== ta_fill
)
8146 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8148 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
8149 && !elf32xtensa_size_opt
)
8154 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
8155 requires_text_end_align
= true;
8157 if (elf32xtensa_size_opt
&& !requires_text_end_align
8158 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
8159 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
8161 longcall_convert_count
= longcall_count
;
8162 narrowable_convert_count
= narrowable_count
;
8163 widenable_convert_count
= 0;
8167 /* There is a constraint. Convert the max number of longcalls. */
8168 narrowable_convert_count
= 0;
8169 longcall_convert_count
= 0;
8170 widenable_convert_count
= 0;
8172 for (j
= 0; j
< longcall_count
; j
++)
8174 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
8175 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
8176 unsigned desire_widen
= removed
;
8177 if (desire_narrow
<= narrowable_count
)
8179 narrowable_convert_count
= desire_narrow
;
8180 narrowable_convert_count
+=
8181 (align
* ((narrowable_count
- narrowable_convert_count
)
8183 longcall_convert_count
= (longcall_count
- j
);
8184 widenable_convert_count
= 0;
8187 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
8189 narrowable_convert_count
= 0;
8190 longcall_convert_count
= longcall_count
- j
;
8191 widenable_convert_count
= desire_widen
;
8197 /* Now the number of conversions are saved. Do them. */
8198 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
8200 action
= &ebb_table
->actions
[i
];
8201 switch (action
->action
)
8203 case ta_convert_longcall
:
8204 if (longcall_convert_count
!= 0)
8206 action
->action
= ta_remove_longcall
;
8207 action
->do_action
= true;
8208 action
->removed_bytes
+= 3;
8209 longcall_convert_count
--;
8212 case ta_narrow_insn
:
8213 if (narrowable_convert_count
!= 0)
8215 action
->do_action
= true;
8216 action
->removed_bytes
+= 1;
8217 narrowable_convert_count
--;
8221 if (widenable_convert_count
!= 0)
8223 action
->do_action
= true;
8224 action
->removed_bytes
-= 1;
8225 widenable_convert_count
--;
8234 /* Now we move on to some local opts. Try to remove each of the
8235 remaining longcalls. */
8237 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8240 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8242 int old_removed_bytes
= removed_bytes
;
8243 proposed_action
*action
= &ebb_table
->actions
[i
];
8245 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8247 bool bad_alignment
= false;
8249 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8251 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8252 bfd_vma offset
= new_action
->offset
;
8253 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8255 if (!check_branch_target_aligned
8256 (ebb_table
->ebb
.contents
,
8257 ebb_table
->ebb
.content_length
,
8258 offset
, offset
- removed_bytes
))
8260 bad_alignment
= true;
8264 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8266 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8267 ebb_table
->ebb
.content_length
,
8269 offset
- removed_bytes
))
8271 bad_alignment
= true;
8275 if (new_action
->action
== ta_narrow_insn
8276 && !new_action
->do_action
8277 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8279 /* Narrow an instruction and we are done. */
8280 new_action
->do_action
= true;
8281 new_action
->removed_bytes
+= 1;
8282 bad_alignment
= false;
8285 if (new_action
->action
== ta_widen_insn
8286 && new_action
->do_action
8287 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8289 /* Narrow an instruction and we are done. */
8290 new_action
->do_action
= false;
8291 new_action
->removed_bytes
+= 1;
8292 bad_alignment
= false;
8295 if (new_action
->do_action
)
8296 removed_bytes
+= new_action
->removed_bytes
;
8300 action
->removed_bytes
+= 3;
8301 action
->action
= ta_remove_longcall
;
8302 action
->do_action
= true;
8305 removed_bytes
= old_removed_bytes
;
8306 if (action
->do_action
)
8307 removed_bytes
+= action
->removed_bytes
;
8312 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8314 proposed_action
*action
= &ebb_table
->actions
[i
];
8315 if (action
->do_action
)
8316 removed_bytes
+= action
->removed_bytes
;
8319 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8320 && ebb
->ends_unreachable
)
8322 proposed_action
*action
;
8326 BFD_ASSERT (ebb_table
->action_count
!= 0);
8327 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8328 BFD_ASSERT (action
->action
== ta_fill
);
8329 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8331 extra_space
= xtensa_compute_fill_extra_space (ebb
->ends_unreachable
);
8332 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8333 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8335 action
->removed_bytes
= extra_space
- br
;
8341 /* The xlate_map is a sorted array of address mappings designed to
8342 answer the offset_with_removed_text() query with a binary search instead
8343 of a linear search through the section's action_list. */
8345 typedef struct xlate_map_entry xlate_map_entry_t
;
8346 typedef struct xlate_map xlate_map_t
;
8348 struct xlate_map_entry
8350 bfd_vma orig_address
;
8351 bfd_vma new_address
;
8357 unsigned entry_count
;
8358 xlate_map_entry_t
*entry
;
8363 xlate_compare (const void *a_v
, const void *b_v
)
8365 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8366 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8367 if (a
->orig_address
< b
->orig_address
)
8369 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8376 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8377 text_action_list
*action_list
,
8381 xlate_map_entry_t
*e
;
8382 struct xlate_map_entry se
;
8385 return offset_with_removed_text (action_list
, offset
);
8387 if (map
->entry_count
== 0)
8390 se
.orig_address
= offset
;
8391 r
= bsearch (&se
, map
->entry
, map
->entry_count
,
8392 sizeof (xlate_map_entry_t
), &xlate_compare
);
8393 e
= (xlate_map_entry_t
*) r
;
8395 /* There could be a jump past the end of the section,
8396 allow it using the last xlate map entry to translate its address. */
8399 e
= map
->entry
+ map
->entry_count
- 1;
8400 if (xlate_compare (&se
, e
) <= 0)
8403 BFD_ASSERT (e
!= NULL
);
8406 return e
->new_address
- e
->orig_address
+ offset
;
8409 typedef struct xlate_map_context_struct xlate_map_context
;
8410 struct xlate_map_context_struct
8413 xlate_map_entry_t
*current_entry
;
8418 xlate_map_fn (splay_tree_node node
, void *p
)
8420 text_action
*r
= (text_action
*)node
->value
;
8421 xlate_map_context
*ctx
= p
;
8422 unsigned orig_size
= 0;
8427 case ta_remove_insn
:
8428 case ta_convert_longcall
:
8429 case ta_remove_literal
:
8430 case ta_add_literal
:
8432 case ta_remove_longcall
:
8435 case ta_narrow_insn
:
8444 ctx
->current_entry
->size
=
8445 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8446 if (ctx
->current_entry
->size
!= 0)
8448 ctx
->current_entry
++;
8449 ctx
->map
->entry_count
++;
8451 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8452 ctx
->removed
+= r
->removed_bytes
;
8453 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8454 ctx
->current_entry
->size
= 0;
8458 /* Build a binary searchable offset translation map from a section's
8461 static xlate_map_t
*
8462 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8464 text_action_list
*action_list
= &relax_info
->action_list
;
8465 unsigned num_actions
= 0;
8466 xlate_map_context ctx
;
8468 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8470 if (ctx
.map
== NULL
)
8473 num_actions
= action_list_count (action_list
);
8474 ctx
.map
->entry
= (xlate_map_entry_t
*)
8475 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8476 if (ctx
.map
->entry
== NULL
)
8481 ctx
.map
->entry_count
= 0;
8484 ctx
.current_entry
= &ctx
.map
->entry
[0];
8486 ctx
.current_entry
->orig_address
= 0;
8487 ctx
.current_entry
->new_address
= 0;
8488 ctx
.current_entry
->size
= 0;
8490 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8492 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8493 - ctx
.current_entry
->orig_address
);
8494 if (ctx
.current_entry
->size
!= 0)
8495 ctx
.map
->entry_count
++;
8501 /* Free an offset translation map. */
8504 free_xlate_map (xlate_map_t
*map
)
8514 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8515 relocations in a section will fit if a proposed set of actions
8519 check_section_ebb_pcrels_fit (bfd
*abfd
,
8522 Elf_Internal_Rela
*internal_relocs
,
8523 reloc_range_list
*relevant_relocs
,
8524 const ebb_constraint
*constraint
,
8525 const xtensa_opcode
*reloc_opcodes
)
8528 unsigned n
= sec
->reloc_count
;
8529 Elf_Internal_Rela
*irel
;
8530 xlate_map_t
*xmap
= NULL
;
8532 xtensa_relax_info
*relax_info
;
8533 reloc_range_list_entry
*entry
= NULL
;
8535 relax_info
= get_xtensa_relax_info (sec
);
8537 if (relax_info
&& sec
->reloc_count
> 100)
8539 xmap
= build_xlate_map (sec
, relax_info
);
8540 /* NULL indicates out of memory, but the slow version
8541 can still be used. */
8544 if (relevant_relocs
&& constraint
->action_count
)
8546 if (!relevant_relocs
->ok
)
8553 bfd_vma min_offset
, max_offset
;
8554 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8556 for (i
= 1; i
< constraint
->action_count
; ++i
)
8558 proposed_action
*action
= &constraint
->actions
[i
];
8559 bfd_vma offset
= action
->offset
;
8561 if (offset
< min_offset
)
8562 min_offset
= offset
;
8563 if (offset
> max_offset
)
8564 max_offset
= offset
;
8566 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8568 n
= relevant_relocs
->n_list
;
8569 entry
= &relevant_relocs
->list_root
;
8574 relevant_relocs
= NULL
;
8577 for (i
= 0; i
< n
; i
++)
8580 bfd_vma orig_self_offset
, orig_target_offset
;
8581 bfd_vma self_offset
, target_offset
;
8583 reloc_howto_type
*howto
;
8584 int self_removed_bytes
, target_removed_bytes
;
8586 if (relevant_relocs
)
8588 entry
= entry
->next
;
8593 irel
= internal_relocs
+ i
;
8595 r_type
= ELF32_R_TYPE (irel
->r_info
);
8597 howto
= &elf_howto_table
[r_type
];
8598 /* We maintain the required invariant: PC-relative relocations
8599 that fit before linking must fit after linking. Thus we only
8600 need to deal with relocations to the same section that are
8602 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8603 || r_type
== R_XTENSA_32_PCREL
8604 || !howto
->pc_relative
)
8607 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8608 bfd_get_section_limit (abfd
, sec
));
8610 if (r_reloc_get_section (&r_rel
) != sec
)
8613 orig_self_offset
= irel
->r_offset
;
8614 orig_target_offset
= r_rel
.target_offset
;
8616 self_offset
= orig_self_offset
;
8617 target_offset
= orig_target_offset
;
8622 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8625 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8626 orig_target_offset
);
8629 self_removed_bytes
= 0;
8630 target_removed_bytes
= 0;
8632 for (j
= 0; j
< constraint
->action_count
; ++j
)
8634 proposed_action
*action
= &constraint
->actions
[j
];
8635 bfd_vma offset
= action
->offset
;
8636 int removed_bytes
= action
->removed_bytes
;
8637 if (offset
< orig_self_offset
8638 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8639 && action
->removed_bytes
< 0))
8640 self_removed_bytes
+= removed_bytes
;
8641 if (offset
< orig_target_offset
8642 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8643 && action
->removed_bytes
< 0))
8644 target_removed_bytes
+= removed_bytes
;
8646 self_offset
-= self_removed_bytes
;
8647 target_offset
-= target_removed_bytes
;
8649 /* Try to encode it. Get the operand and check. */
8650 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8652 /* None of the current alternate relocs are PC-relative,
8653 and only PC-relative relocs matter here. */
8657 xtensa_opcode opcode
;
8660 if (relevant_relocs
)
8662 opcode
= entry
->opcode
;
8663 opnum
= entry
->opnum
;
8668 opcode
= reloc_opcodes
[relevant_relocs
?
8669 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8671 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8672 if (opcode
== XTENSA_UNDEFINED
)
8678 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8679 if (opnum
== XTENSA_UNDEFINED
)
8686 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8694 free_xlate_map (xmap
);
8701 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8706 for (i
= 0; i
< constraint
->action_count
; i
++)
8708 const proposed_action
*action
= &constraint
->actions
[i
];
8709 if (action
->do_action
)
8710 removed
+= action
->removed_bytes
;
8720 text_action_add_proposed (text_action_list
*l
,
8721 const ebb_constraint
*ebb_table
,
8726 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8728 proposed_action
*action
= &ebb_table
->actions
[i
];
8730 if (!action
->do_action
)
8732 switch (action
->action
)
8734 case ta_remove_insn
:
8735 case ta_remove_longcall
:
8736 case ta_convert_longcall
:
8737 case ta_narrow_insn
:
8740 case ta_remove_literal
:
8741 text_action_add (l
, action
->action
, sec
, action
->offset
,
8742 action
->removed_bytes
);
8755 xtensa_compute_fill_extra_space (property_table_entry
*entry
)
8757 int fill_extra_space
;
8762 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8765 fill_extra_space
= entry
->size
;
8766 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8768 /* Fill bytes for alignment:
8769 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8770 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8771 int nsm
= (1 << pow
) - 1;
8772 bfd_vma addr
= entry
->address
+ entry
->size
;
8773 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8774 fill_extra_space
+= align_fill
;
8776 return fill_extra_space
;
8780 /* First relaxation pass. */
8782 /* If the section contains relaxable literals, check each literal to
8783 see if it has the same value as another literal that has already
8784 been seen, either in the current section or a previous one. If so,
8785 add an entry to the per-section list of removed literals. The
8786 actual changes are deferred until the next pass. */
8789 compute_removed_literals (bfd
*abfd
,
8791 struct bfd_link_info
*link_info
,
8792 value_map_hash_table
*values
)
8794 xtensa_relax_info
*relax_info
;
8796 Elf_Internal_Rela
*internal_relocs
;
8797 source_reloc
*src_relocs
, *rel
;
8799 property_table_entry
*prop_table
= NULL
;
8802 bool last_loc_is_prev
= false;
8803 bfd_vma last_target_offset
= 0;
8804 section_cache_t target_sec_cache
;
8805 bfd_size_type sec_size
;
8807 init_section_cache (&target_sec_cache
);
8809 /* Do nothing if it is not a relaxable literal section. */
8810 relax_info
= get_xtensa_relax_info (sec
);
8811 BFD_ASSERT (relax_info
);
8812 if (!relax_info
->is_relaxable_literal_section
)
8815 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8816 link_info
->keep_memory
);
8818 sec_size
= bfd_get_section_limit (abfd
, sec
);
8819 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8820 if (contents
== NULL
&& sec_size
!= 0)
8826 /* Sort the source_relocs by target offset. */
8827 src_relocs
= relax_info
->src_relocs
;
8828 qsort (src_relocs
, relax_info
->src_count
,
8829 sizeof (source_reloc
), source_reloc_compare
);
8830 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8831 internal_reloc_compare
);
8833 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8834 XTENSA_PROP_SEC_NAME
, false);
8842 for (i
= 0; i
< relax_info
->src_count
; i
++)
8844 Elf_Internal_Rela
*irel
= NULL
;
8846 rel
= &src_relocs
[i
];
8847 if (get_l32r_opcode () != rel
->opcode
)
8849 irel
= get_irel_at_offset (sec
, internal_relocs
,
8850 rel
->r_rel
.target_offset
);
8852 /* If the relocation on this is not a simple R_XTENSA_32 or
8853 R_XTENSA_PLT then do not consider it. This may happen when
8854 the difference of two symbols is used in a literal. */
8855 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8856 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8859 /* If the target_offset for this relocation is the same as the
8860 previous relocation, then we've already considered whether the
8861 literal can be coalesced. Skip to the next one.... */
8862 if (i
!= 0 && prev_i
!= -1
8863 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8867 if (last_loc_is_prev
&&
8868 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8869 last_loc_is_prev
= false;
8871 /* Check if the relocation was from an L32R that is being removed
8872 because a CALLX was converted to a direct CALL, and check if
8873 there are no other relocations to the literal. */
8874 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8875 sec
, prop_table
, ptblsize
))
8877 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8878 irel
, rel
, prop_table
, ptblsize
))
8883 last_target_offset
= rel
->r_rel
.target_offset
;
8887 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8889 &last_loc_is_prev
, irel
,
8890 relax_info
->src_count
- i
, rel
,
8891 prop_table
, ptblsize
,
8892 &target_sec_cache
, rel
->is_abs_literal
))
8897 last_target_offset
= rel
->r_rel
.target_offset
;
8901 print_removed_literals (stderr
, &relax_info
->removed_list
);
8902 print_action_list (stderr
, &relax_info
->action_list
);
8907 free_section_cache (&target_sec_cache
);
8909 release_contents (sec
, contents
);
8910 release_internal_relocs (sec
, internal_relocs
);
8915 static Elf_Internal_Rela
*
8916 get_irel_at_offset (asection
*sec
,
8917 Elf_Internal_Rela
*internal_relocs
,
8921 Elf_Internal_Rela
*irel
;
8923 Elf_Internal_Rela key
;
8925 if (!internal_relocs
)
8928 key
.r_offset
= offset
;
8929 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8930 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8934 /* bsearch does not guarantee which will be returned if there are
8935 multiple matches. We need the first that is not an alignment. */
8936 i
= irel
- internal_relocs
;
8939 if (internal_relocs
[i
-1].r_offset
!= offset
)
8943 for ( ; i
< sec
->reloc_count
; i
++)
8945 irel
= &internal_relocs
[i
];
8946 r_type
= ELF32_R_TYPE (irel
->r_info
);
8947 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8956 is_removable_literal (const source_reloc
*rel
,
8958 const source_reloc
*src_relocs
,
8961 property_table_entry
*prop_table
,
8964 const source_reloc
*curr_rel
;
8965 property_table_entry
*entry
;
8970 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8971 sec
->vma
+ rel
->r_rel
.target_offset
);
8972 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8975 for (++i
; i
< src_count
; ++i
)
8977 curr_rel
= &src_relocs
[i
];
8978 /* If all others have the same target offset.... */
8979 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8982 if (!curr_rel
->is_null
8983 && !xtensa_is_property_section (curr_rel
->source_sec
)
8984 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8992 remove_dead_literal (bfd
*abfd
,
8994 struct bfd_link_info
*link_info
,
8995 Elf_Internal_Rela
*internal_relocs
,
8996 Elf_Internal_Rela
*irel
,
8998 property_table_entry
*prop_table
,
9001 property_table_entry
*entry
;
9002 xtensa_relax_info
*relax_info
;
9004 relax_info
= get_xtensa_relax_info (sec
);
9008 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9009 sec
->vma
+ rel
->r_rel
.target_offset
);
9011 /* Mark the unused literal so that it will be removed. */
9012 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
9014 text_action_add (&relax_info
->action_list
,
9015 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9017 /* If the section is 4-byte aligned, do not add fill. */
9018 if (sec
->alignment_power
> 2)
9020 int fill_extra_space
;
9021 bfd_vma entry_sec_offset
;
9023 property_table_entry
*the_add_entry
;
9027 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9029 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9031 /* If the literal range is at the end of the section,
9033 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9035 fill_extra_space
= xtensa_compute_fill_extra_space (the_add_entry
);
9037 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9038 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9039 -4, fill_extra_space
);
9041 adjust_fill_action (fa
, removed_diff
);
9043 text_action_add (&relax_info
->action_list
,
9044 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9047 /* Zero out the relocation on this literal location. */
9050 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9051 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9053 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9054 pin_internal_relocs (sec
, internal_relocs
);
9057 /* Do not modify "last_loc_is_prev". */
9063 identify_literal_placement (bfd
*abfd
,
9066 struct bfd_link_info
*link_info
,
9067 value_map_hash_table
*values
,
9068 bool *last_loc_is_prev_p
,
9069 Elf_Internal_Rela
*irel
,
9070 int remaining_src_rels
,
9072 property_table_entry
*prop_table
,
9074 section_cache_t
*target_sec_cache
,
9075 bool is_abs_literal
)
9079 xtensa_relax_info
*relax_info
;
9080 bool literal_placed
= false;
9082 unsigned long value
;
9083 bool final_static_link
;
9084 bfd_size_type sec_size
;
9086 relax_info
= get_xtensa_relax_info (sec
);
9090 sec_size
= bfd_get_section_limit (abfd
, sec
);
9093 (!bfd_link_relocatable (link_info
)
9094 && !elf_hash_table (link_info
)->dynamic_sections_created
);
9096 /* The placement algorithm first checks to see if the literal is
9097 already in the value map. If so and the value map is reachable
9098 from all uses, then the literal is moved to that location. If
9099 not, then we identify the last location where a fresh literal was
9100 placed. If the literal can be safely moved there, then we do so.
9101 If not, then we assume that the literal is not to move and leave
9102 the literal where it is, marking it as the last literal
9105 /* Find the literal value. */
9107 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9110 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
9111 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
9113 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
9115 /* Check if we've seen another literal with the same value that
9116 is in the same output section. */
9117 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
9120 && (r_reloc_get_section (&val_map
->loc
)->output_section
9121 == sec
->output_section
)
9122 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
9123 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
9125 /* No change to last_loc_is_prev. */
9126 literal_placed
= true;
9129 /* For relocatable links, do not try to move literals. To do it
9130 correctly might increase the number of relocations in an input
9131 section making the default relocatable linking fail. */
9132 if (!bfd_link_relocatable (link_info
) && !literal_placed
9133 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
9135 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
9136 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
9138 /* Increment the virtual offset. */
9139 r_reloc try_loc
= values
->last_loc
;
9140 try_loc
.virtual_offset
+= 4;
9142 /* There is a last loc that was in the same output section. */
9143 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
9144 && move_shared_literal (sec
, link_info
, rel
,
9145 prop_table
, ptblsize
,
9146 &try_loc
, &val
, target_sec_cache
))
9148 values
->last_loc
.virtual_offset
+= 4;
9149 literal_placed
= true;
9151 val_map
= add_value_map (values
, &val
, &try_loc
,
9154 val_map
->loc
= try_loc
;
9159 if (!literal_placed
)
9161 /* Nothing worked, leave the literal alone but update the last loc. */
9162 values
->has_last_loc
= true;
9163 values
->last_loc
= rel
->r_rel
;
9165 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
9167 val_map
->loc
= rel
->r_rel
;
9168 *last_loc_is_prev_p
= true;
9175 /* Check if the original relocations (presumably on L32R instructions)
9176 identified by reloc[0..N] can be changed to reference the literal
9177 identified by r_rel. If r_rel is out of range for any of the
9178 original relocations, then we don't want to coalesce the original
9179 literal with the one at r_rel. We only check reloc[0..N], where the
9180 offsets are all the same as for reloc[0] (i.e., they're all
9181 referencing the same literal) and where N is also bounded by the
9182 number of remaining entries in the "reloc" array. The "reloc" array
9183 is sorted by target offset so we know all the entries for the same
9184 literal will be contiguous. */
9187 relocations_reach (source_reloc
*reloc
,
9188 int remaining_relocs
,
9189 const r_reloc
*r_rel
)
9191 bfd_vma from_offset
, source_address
, dest_address
;
9195 if (!r_reloc_is_defined (r_rel
))
9198 sec
= r_reloc_get_section (r_rel
);
9199 from_offset
= reloc
[0].r_rel
.target_offset
;
9201 for (i
= 0; i
< remaining_relocs
; i
++)
9203 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9206 /* Ignore relocations that have been removed. */
9207 if (reloc
[i
].is_null
)
9210 /* The original and new output section for these must be the same
9211 in order to coalesce. */
9212 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9213 != sec
->output_section
)
9216 /* Absolute literals in the same output section can always be
9218 if (reloc
[i
].is_abs_literal
)
9221 /* A literal with no PC-relative relocations can be moved anywhere. */
9222 if (reloc
[i
].opnd
!= -1)
9224 /* Otherwise, check to see that it fits. */
9225 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9226 + reloc
[i
].source_sec
->output_offset
9227 + reloc
[i
].r_rel
.rela
.r_offset
);
9228 dest_address
= (sec
->output_section
->vma
9229 + sec
->output_offset
9230 + r_rel
->target_offset
);
9232 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9233 source_address
, dest_address
))
9242 /* Move a literal to another literal location because it is
9243 the same as the other literal value. */
9246 coalesce_shared_literal (asection
*sec
,
9248 property_table_entry
*prop_table
,
9252 property_table_entry
*entry
;
9254 property_table_entry
*the_add_entry
;
9256 xtensa_relax_info
*relax_info
;
9258 relax_info
= get_xtensa_relax_info (sec
);
9262 entry
= elf_xtensa_find_property_entry
9263 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9264 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9267 /* Mark that the literal will be coalesced. */
9268 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9270 text_action_add (&relax_info
->action_list
,
9271 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9273 /* If the section is 4-byte aligned, do not add fill. */
9274 if (sec
->alignment_power
> 2)
9276 int fill_extra_space
;
9277 bfd_vma entry_sec_offset
;
9280 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9282 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9284 /* If the literal range is at the end of the section,
9286 fill_extra_space
= 0;
9287 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9289 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9290 fill_extra_space
= the_add_entry
->size
;
9292 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9293 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9294 -4, fill_extra_space
);
9296 adjust_fill_action (fa
, removed_diff
);
9298 text_action_add (&relax_info
->action_list
,
9299 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9306 /* Move a literal to another location. This may actually increase the
9307 total amount of space used because of alignments so we need to do
9308 this carefully. Also, it may make a branch go out of range. */
9311 move_shared_literal (asection
*sec
,
9312 struct bfd_link_info
*link_info
,
9314 property_table_entry
*prop_table
,
9316 const r_reloc
*target_loc
,
9317 const literal_value
*lit_value
,
9318 section_cache_t
*target_sec_cache
)
9320 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9321 text_action
*fa
, *target_fa
;
9323 xtensa_relax_info
*relax_info
, *target_relax_info
;
9324 asection
*target_sec
;
9326 ebb_constraint ebb_table
;
9329 /* If this routine always returns FALSE, the literals that cannot be
9330 coalesced will not be moved. */
9331 if (elf32xtensa_no_literal_movement
)
9334 relax_info
= get_xtensa_relax_info (sec
);
9338 target_sec
= r_reloc_get_section (target_loc
);
9339 target_relax_info
= get_xtensa_relax_info (target_sec
);
9341 /* Literals to undefined sections may not be moved because they
9342 must report an error. */
9343 if (bfd_is_und_section (target_sec
))
9346 src_entry
= elf_xtensa_find_property_entry
9347 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9349 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9352 target_entry
= elf_xtensa_find_property_entry
9353 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9354 target_sec
->vma
+ target_loc
->target_offset
);
9359 /* Make sure that we have not broken any branches. */
9362 init_ebb_constraint (&ebb_table
);
9363 ebb
= &ebb_table
.ebb
;
9364 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9365 target_sec_cache
->content_length
,
9366 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9367 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9369 /* Propose to add 4 bytes + worst-case alignment size increase to
9371 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9372 ta_fill
, target_loc
->target_offset
,
9373 -4 - (1 << target_sec
->alignment_power
), true);
9375 /* Check all of the PC-relative relocations to make sure they still fit. */
9376 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9377 target_sec_cache
->contents
,
9378 target_sec_cache
->relocs
, NULL
,
9384 text_action_add_literal (&target_relax_info
->action_list
,
9385 ta_add_literal
, target_loc
, lit_value
, -4);
9387 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9389 /* May need to add or remove some fill to maintain alignment. */
9390 int fill_extra_space
;
9391 bfd_vma entry_sec_offset
;
9394 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9396 /* If the literal range is at the end of the section,
9398 fill_extra_space
= 0;
9400 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9401 target_sec_cache
->pte_count
,
9403 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9404 fill_extra_space
= the_add_entry
->size
;
9406 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9407 target_sec
, entry_sec_offset
);
9408 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9409 entry_sec_offset
, 4,
9412 adjust_fill_action (target_fa
, removed_diff
);
9414 text_action_add (&target_relax_info
->action_list
,
9415 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9418 /* Mark that the literal will be moved to the new location. */
9419 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9421 /* Remove the literal. */
9422 text_action_add (&relax_info
->action_list
,
9423 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9425 /* If the section is 4-byte aligned, do not add fill. */
9426 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9428 int fill_extra_space
;
9429 bfd_vma entry_sec_offset
;
9432 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9434 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9436 /* If the literal range is at the end of the section,
9438 fill_extra_space
= 0;
9439 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9441 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9442 fill_extra_space
= the_add_entry
->size
;
9444 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9445 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9446 -4, fill_extra_space
);
9448 adjust_fill_action (fa
, removed_diff
);
9450 text_action_add (&relax_info
->action_list
,
9451 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9458 /* Second relaxation pass. */
9461 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9463 bfd_size_type
*final_size
= p
;
9464 text_action
*action
= (text_action
*)node
->value
;
9466 *final_size
-= action
->removed_bytes
;
9470 /* Modify all of the relocations to point to the right spot, and if this
9471 is a relaxable section, delete the unwanted literals and fix the
9475 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9477 Elf_Internal_Rela
*internal_relocs
;
9478 xtensa_relax_info
*relax_info
;
9483 bool virtual_action
;
9484 bfd_size_type sec_size
;
9486 sec_size
= bfd_get_section_limit (abfd
, sec
);
9487 relax_info
= get_xtensa_relax_info (sec
);
9488 BFD_ASSERT (relax_info
);
9490 /* First translate any of the fixes that have been added already. */
9491 translate_section_fixes (sec
);
9493 /* Handle property sections (e.g., literal tables) specially. */
9494 if (xtensa_is_property_section (sec
))
9496 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9497 return relax_property_section (abfd
, sec
, link_info
);
9500 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9501 link_info
->keep_memory
);
9502 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9505 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9506 if (contents
== NULL
&& sec_size
!= 0)
9512 if (internal_relocs
)
9514 for (i
= 0; i
< sec
->reloc_count
; i
++)
9516 Elf_Internal_Rela
*irel
;
9517 xtensa_relax_info
*target_relax_info
;
9518 bfd_vma source_offset
, old_source_offset
;
9521 asection
*target_sec
;
9523 /* Locally change the source address.
9524 Translate the target to the new target address.
9525 If it points to this section and has been removed,
9529 irel
= &internal_relocs
[i
];
9530 source_offset
= irel
->r_offset
;
9531 old_source_offset
= source_offset
;
9533 r_type
= ELF32_R_TYPE (irel
->r_info
);
9534 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9535 bfd_get_section_limit (abfd
, sec
));
9537 /* If this section could have changed then we may need to
9538 change the relocation's offset. */
9540 if (relax_info
->is_relaxable_literal_section
9541 || relax_info
->is_relaxable_asm_section
)
9543 pin_internal_relocs (sec
, internal_relocs
);
9545 if (r_type
!= R_XTENSA_NONE
9546 && find_removed_literal (&relax_info
->removed_list
,
9549 /* Remove this relocation. */
9550 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9551 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9552 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9553 irel
->r_offset
= offset_with_removed_text_map
9554 (&relax_info
->action_list
, irel
->r_offset
);
9558 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9560 text_action
*action
=
9561 find_insn_action (&relax_info
->action_list
,
9563 if (action
&& (action
->action
== ta_convert_longcall
9564 || action
->action
== ta_remove_longcall
))
9566 bfd_reloc_status_type retval
;
9567 char *error_message
= NULL
;
9569 retval
= contract_asm_expansion (contents
, sec_size
,
9570 irel
, &error_message
);
9571 if (retval
!= bfd_reloc_ok
)
9573 (*link_info
->callbacks
->reloc_dangerous
)
9574 (link_info
, error_message
, abfd
, sec
,
9578 /* Update the action so that the code that moves
9579 the contents will do the right thing. */
9580 /* ta_remove_longcall and ta_remove_insn actions are
9581 grouped together in the tree as well as
9582 ta_convert_longcall and ta_none, so that changes below
9583 can be done w/o removing and reinserting action into
9586 if (action
->action
== ta_remove_longcall
)
9587 action
->action
= ta_remove_insn
;
9589 action
->action
= ta_none
;
9590 /* Refresh the info in the r_rel. */
9591 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9592 r_type
= ELF32_R_TYPE (irel
->r_info
);
9596 source_offset
= offset_with_removed_text_map
9597 (&relax_info
->action_list
, irel
->r_offset
);
9598 irel
->r_offset
= source_offset
;
9601 /* If the target section could have changed then
9602 we may need to change the relocation's target offset. */
9604 target_sec
= r_reloc_get_section (&r_rel
);
9606 /* For a reference to a discarded section from a DWARF section,
9607 i.e., where action_discarded is PRETEND, the symbol will
9608 eventually be modified to refer to the kept section (at least if
9609 the kept and discarded sections are the same size). Anticipate
9610 that here and adjust things accordingly. */
9611 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9612 && elf_xtensa_action_discarded (sec
) == PRETEND
9613 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9614 && target_sec
!= NULL
9615 && discarded_section (target_sec
))
9617 /* It would be natural to call _bfd_elf_check_kept_section
9618 here, but it's not exported from elflink.c. It's also a
9619 fairly expensive check. Adjusting the relocations to the
9620 discarded section is fairly harmless; it will only adjust
9621 some addends and difference values. If it turns out that
9622 _bfd_elf_check_kept_section fails later, it won't matter,
9623 so just compare the section names to find the right group
9625 asection
*kept
= target_sec
->kept_section
;
9628 if ((kept
->flags
& SEC_GROUP
) != 0)
9630 asection
*first
= elf_next_in_group (kept
);
9631 asection
*s
= first
;
9636 if (strcmp (s
->name
, target_sec
->name
) == 0)
9641 s
= elf_next_in_group (s
);
9648 && ((target_sec
->rawsize
!= 0
9649 ? target_sec
->rawsize
: target_sec
->size
)
9650 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9654 target_relax_info
= get_xtensa_relax_info (target_sec
);
9655 if (target_relax_info
9656 && (target_relax_info
->is_relaxable_literal_section
9657 || target_relax_info
->is_relaxable_asm_section
))
9660 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9662 if (r_type
== R_XTENSA_DIFF8
9663 || r_type
== R_XTENSA_DIFF16
9664 || r_type
== R_XTENSA_DIFF32
9665 || r_type
== R_XTENSA_PDIFF8
9666 || r_type
== R_XTENSA_PDIFF16
9667 || r_type
== R_XTENSA_PDIFF32
9668 || r_type
== R_XTENSA_NDIFF8
9669 || r_type
== R_XTENSA_NDIFF16
9670 || r_type
== R_XTENSA_NDIFF32
)
9672 bfd_signed_vma diff_value
= 0;
9673 bfd_vma new_end_offset
, diff_mask
= 0;
9675 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9677 (*link_info
->callbacks
->reloc_dangerous
)
9678 (link_info
, _("invalid relocation address"),
9679 abfd
, sec
, old_source_offset
);
9685 case R_XTENSA_DIFF8
:
9688 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9690 case R_XTENSA_DIFF16
:
9693 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9695 case R_XTENSA_DIFF32
:
9696 diff_mask
= 0x7fffffff;
9698 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9700 case R_XTENSA_PDIFF8
:
9701 case R_XTENSA_NDIFF8
:
9704 bfd_get_8 (abfd
, &contents
[old_source_offset
]);
9706 case R_XTENSA_PDIFF16
:
9707 case R_XTENSA_NDIFF16
:
9710 bfd_get_16 (abfd
, &contents
[old_source_offset
]);
9712 case R_XTENSA_PDIFF32
:
9713 case R_XTENSA_NDIFF32
:
9714 diff_mask
= 0xffffffff;
9716 bfd_get_32 (abfd
, &contents
[old_source_offset
]);
9720 if (r_type
>= R_XTENSA_NDIFF8
9721 && r_type
<= R_XTENSA_NDIFF32
9723 diff_value
|= ~diff_mask
;
9725 new_end_offset
= offset_with_removed_text_map
9726 (&target_relax_info
->action_list
,
9727 r_rel
.target_offset
+ diff_value
);
9728 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9732 case R_XTENSA_DIFF8
:
9733 bfd_put_signed_8 (abfd
, diff_value
,
9734 &contents
[old_source_offset
]);
9736 case R_XTENSA_DIFF16
:
9737 bfd_put_signed_16 (abfd
, diff_value
,
9738 &contents
[old_source_offset
]);
9740 case R_XTENSA_DIFF32
:
9741 bfd_put_signed_32 (abfd
, diff_value
,
9742 &contents
[old_source_offset
]);
9744 case R_XTENSA_PDIFF8
:
9745 case R_XTENSA_NDIFF8
:
9746 bfd_put_8 (abfd
, diff_value
,
9747 &contents
[old_source_offset
]);
9749 case R_XTENSA_PDIFF16
:
9750 case R_XTENSA_NDIFF16
:
9751 bfd_put_16 (abfd
, diff_value
,
9752 &contents
[old_source_offset
]);
9754 case R_XTENSA_PDIFF32
:
9755 case R_XTENSA_NDIFF32
:
9756 bfd_put_32 (abfd
, diff_value
,
9757 &contents
[old_source_offset
]);
9761 /* Check for overflow. Sign bits must be all zeroes or
9762 all ones. When sign bits are all ones diff_value
9764 if (((diff_value
& ~diff_mask
) != 0
9765 && (diff_value
& ~diff_mask
) != ~diff_mask
)
9766 || (diff_value
&& (bfd_vma
) diff_value
== ~diff_mask
))
9768 (*link_info
->callbacks
->reloc_dangerous
)
9769 (link_info
, _("overflow after relaxation"),
9770 abfd
, sec
, old_source_offset
);
9774 pin_contents (sec
, contents
);
9777 /* If the relocation still references a section in the same
9778 input file, modify the relocation directly instead of
9779 adding a "fix" record. */
9780 if (target_sec
->owner
== abfd
)
9782 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9783 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9784 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9785 pin_internal_relocs (sec
, internal_relocs
);
9789 bfd_vma addend_displacement
;
9792 addend_displacement
=
9793 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9794 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9796 addend_displacement
, true);
9803 if ((relax_info
->is_relaxable_literal_section
9804 || relax_info
->is_relaxable_asm_section
)
9805 && action_list_count (&relax_info
->action_list
))
9807 /* Walk through the planned actions and build up a table
9808 of move, copy and fill records. Use the move, copy and
9809 fill records to perform the actions once. */
9811 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9812 bfd_byte
*scratch
= NULL
;
9813 bfd_byte
*dup_contents
= NULL
;
9814 bfd_size_type orig_size
= sec
->size
;
9815 bfd_vma orig_dot
= 0;
9816 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9817 orig dot in physical memory. */
9818 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9819 bfd_vma dup_dot
= 0;
9821 text_action
*action
;
9823 final_size
= sec
->size
;
9825 splay_tree_foreach (relax_info
->action_list
.tree
,
9826 action_remove_bytes_fn
, &final_size
);
9827 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9828 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9830 /* The dot is the current fill location. */
9832 print_action_list (stderr
, &relax_info
->action_list
);
9835 for (action
= action_first (&relax_info
->action_list
); action
;
9836 action
= action_next (&relax_info
->action_list
, action
))
9838 virtual_action
= false;
9839 if (action
->offset
> orig_dot
)
9841 orig_dot
+= orig_dot_copied
;
9842 orig_dot_copied
= 0;
9844 /* Out of the virtual world. */
9847 if (action
->offset
> orig_dot
)
9849 copy_size
= action
->offset
- orig_dot
;
9850 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9851 orig_dot
+= copy_size
;
9852 dup_dot
+= copy_size
;
9853 BFD_ASSERT (action
->offset
== orig_dot
);
9855 else if (action
->offset
< orig_dot
)
9857 if (action
->action
== ta_fill
9858 && action
->offset
- action
->removed_bytes
== orig_dot
)
9860 /* This is OK because the fill only effects the dup_dot. */
9862 else if (action
->action
== ta_add_literal
)
9864 /* TBD. Might need to handle this. */
9867 if (action
->offset
== orig_dot
)
9869 if (action
->virtual_offset
> orig_dot_vo
)
9871 if (orig_dot_vo
== 0)
9873 /* Need to copy virtual_offset bytes. Probably four. */
9874 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9875 memmove (&dup_contents
[dup_dot
],
9876 &contents
[orig_dot
], copy_size
);
9877 orig_dot_copied
= copy_size
;
9878 dup_dot
+= copy_size
;
9880 virtual_action
= true;
9883 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9885 switch (action
->action
)
9887 case ta_remove_literal
:
9888 case ta_remove_insn
:
9889 BFD_ASSERT (action
->removed_bytes
>= 0);
9890 orig_dot
+= action
->removed_bytes
;
9893 case ta_narrow_insn
:
9896 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9897 BFD_ASSERT (action
->removed_bytes
== 1);
9898 rv
= narrow_instruction (scratch
, final_size
, 0);
9900 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9901 orig_dot
+= orig_insn_size
;
9902 dup_dot
+= copy_size
;
9906 if (action
->removed_bytes
>= 0)
9907 orig_dot
+= action
->removed_bytes
;
9910 /* Already zeroed in dup_contents. Just bump the
9912 dup_dot
+= (-action
->removed_bytes
);
9917 BFD_ASSERT (action
->removed_bytes
== 0);
9920 case ta_convert_longcall
:
9921 case ta_remove_longcall
:
9922 /* These will be removed or converted before we get here. */
9929 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9930 BFD_ASSERT (action
->removed_bytes
== -1);
9931 rv
= widen_instruction (scratch
, final_size
, 0);
9933 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9934 orig_dot
+= orig_insn_size
;
9935 dup_dot
+= copy_size
;
9938 case ta_add_literal
:
9941 BFD_ASSERT (action
->removed_bytes
== -4);
9942 /* TBD -- place the literal value here and insert
9944 memset (&dup_contents
[dup_dot
], 0, 4);
9945 pin_internal_relocs (sec
, internal_relocs
);
9946 pin_contents (sec
, contents
);
9948 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9949 relax_info
, &internal_relocs
, &action
->value
))
9953 orig_dot_vo
+= copy_size
;
9955 orig_dot
+= orig_insn_size
;
9956 dup_dot
+= copy_size
;
9960 /* Not implemented yet. */
9965 BFD_ASSERT (dup_dot
<= final_size
);
9966 BFD_ASSERT (orig_dot
<= orig_size
);
9969 orig_dot
+= orig_dot_copied
;
9970 orig_dot_copied
= 0;
9972 if (orig_dot
!= orig_size
)
9974 copy_size
= orig_size
- orig_dot
;
9975 BFD_ASSERT (orig_size
> orig_dot
);
9976 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9977 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9978 orig_dot
+= copy_size
;
9979 dup_dot
+= copy_size
;
9981 BFD_ASSERT (orig_size
== orig_dot
);
9982 BFD_ASSERT (final_size
== dup_dot
);
9984 /* Move the dup_contents back. */
9985 if (final_size
> orig_size
)
9987 /* Contents need to be reallocated. Swap the dup_contents into
9989 sec
->contents
= dup_contents
;
9991 contents
= dup_contents
;
9992 pin_contents (sec
, contents
);
9996 BFD_ASSERT (final_size
<= orig_size
);
9997 memset (contents
, 0, orig_size
);
9998 memcpy (contents
, dup_contents
, final_size
);
9999 free (dup_contents
);
10002 pin_contents (sec
, contents
);
10004 if (sec
->rawsize
== 0)
10005 sec
->rawsize
= sec
->size
;
10006 sec
->size
= final_size
;
10010 release_internal_relocs (sec
, internal_relocs
);
10011 release_contents (sec
, contents
);
10017 translate_section_fixes (asection
*sec
)
10019 xtensa_relax_info
*relax_info
;
10022 relax_info
= get_xtensa_relax_info (sec
);
10026 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
10027 if (!translate_reloc_bfd_fix (r
))
10034 /* Translate a fix given the mapping in the relax info for the target
10035 section. If it has already been translated, no work is required. */
10038 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
10040 reloc_bfd_fix new_fix
;
10042 xtensa_relax_info
*relax_info
;
10043 removed_literal
*removed
;
10044 bfd_vma new_offset
, target_offset
;
10046 if (fix
->translated
)
10049 sec
= fix
->target_sec
;
10050 target_offset
= fix
->target_offset
;
10052 relax_info
= get_xtensa_relax_info (sec
);
10055 fix
->translated
= true;
10061 /* The fix does not need to be translated if the section cannot change. */
10062 if (!relax_info
->is_relaxable_literal_section
10063 && !relax_info
->is_relaxable_asm_section
)
10065 fix
->translated
= true;
10069 /* If the literal has been moved and this relocation was on an
10070 opcode, then the relocation should move to the new literal
10071 location. Otherwise, the relocation should move within the
10075 if (is_operand_relocation (fix
->src_type
))
10077 /* Check if the original relocation is against a literal being
10079 removed
= find_removed_literal (&relax_info
->removed_list
,
10087 /* The fact that there is still a relocation to this literal indicates
10088 that the literal is being coalesced, not simply removed. */
10089 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10091 /* This was moved to some other address (possibly another section). */
10092 new_sec
= r_reloc_get_section (&removed
->to
);
10093 if (new_sec
!= sec
)
10096 relax_info
= get_xtensa_relax_info (sec
);
10098 (!relax_info
->is_relaxable_literal_section
10099 && !relax_info
->is_relaxable_asm_section
))
10101 target_offset
= removed
->to
.target_offset
;
10102 new_fix
.target_sec
= new_sec
;
10103 new_fix
.target_offset
= target_offset
;
10104 new_fix
.translated
= true;
10109 target_offset
= removed
->to
.target_offset
;
10110 new_fix
.target_sec
= new_sec
;
10113 /* The target address may have been moved within its section. */
10114 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
10117 new_fix
.target_offset
= new_offset
;
10118 new_fix
.target_offset
= new_offset
;
10119 new_fix
.translated
= true;
10125 /* Fix up a relocation to take account of removed literals. */
10128 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
10130 xtensa_relax_info
*relax_info
;
10131 removed_literal
*removed
;
10132 bfd_vma target_offset
, base_offset
;
10134 *new_rel
= *orig_rel
;
10136 if (!r_reloc_is_defined (orig_rel
))
10139 relax_info
= get_xtensa_relax_info (sec
);
10140 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
10141 || relax_info
->is_relaxable_asm_section
));
10143 target_offset
= orig_rel
->target_offset
;
10146 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
10148 /* Check if the original relocation is against a literal being
10150 removed
= find_removed_literal (&relax_info
->removed_list
,
10153 if (removed
&& removed
->to
.abfd
)
10157 /* The fact that there is still a relocation to this literal indicates
10158 that the literal is being coalesced, not simply removed. */
10159 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10161 /* This was moved to some other address
10162 (possibly in another section). */
10163 *new_rel
= removed
->to
;
10164 new_sec
= r_reloc_get_section (new_rel
);
10165 if (new_sec
!= sec
)
10168 relax_info
= get_xtensa_relax_info (sec
);
10170 || (!relax_info
->is_relaxable_literal_section
10171 && !relax_info
->is_relaxable_asm_section
))
10174 target_offset
= new_rel
->target_offset
;
10177 /* Find the base offset of the reloc symbol, excluding any addend from the
10178 reloc or from the section contents (for a partial_inplace reloc). Then
10179 find the adjusted values of the offsets due to relaxation. The base
10180 offset is needed to determine the change to the reloc's addend; the reloc
10181 addend should not be adjusted due to relaxations located before the base
10184 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
10185 if (base_offset
<= target_offset
)
10187 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
10188 base_offset
, false);
10189 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10190 target_offset
, false) -
10193 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
10194 new_rel
->rela
.r_addend
-= addend_removed
;
10198 /* Handle a negative addend. The base offset comes first. */
10199 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
10200 target_offset
, false);
10201 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10202 base_offset
, false) -
10205 new_rel
->target_offset
= target_offset
- tgt_removed
;
10206 new_rel
->rela
.r_addend
+= addend_removed
;
10213 /* For dynamic links, there may be a dynamic relocation for each
10214 literal. The number of dynamic relocations must be computed in
10215 size_dynamic_sections, which occurs before relaxation. When a
10216 literal is removed, this function checks if there is a corresponding
10217 dynamic relocation and shrinks the size of the appropriate dynamic
10218 relocation section accordingly. At this point, the contents of the
10219 dynamic relocation sections have not yet been filled in, so there's
10220 nothing else that needs to be done. */
10223 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
10225 asection
*input_section
,
10226 Elf_Internal_Rela
*rel
)
10228 struct elf_xtensa_link_hash_table
*htab
;
10229 Elf_Internal_Shdr
*symtab_hdr
;
10230 struct elf_link_hash_entry
**sym_hashes
;
10231 unsigned long r_symndx
;
10233 struct elf_link_hash_entry
*h
;
10234 bool dynamic_symbol
;
10236 htab
= elf_xtensa_hash_table (info
);
10240 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10241 sym_hashes
= elf_sym_hashes (abfd
);
10243 r_type
= ELF32_R_TYPE (rel
->r_info
);
10244 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10246 if (r_symndx
< symtab_hdr
->sh_info
)
10249 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10251 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10253 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10254 && (input_section
->flags
& SEC_ALLOC
) != 0
10256 || (bfd_link_pic (info
)
10257 && (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
))))
10260 bool is_plt
= false;
10262 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10264 srel
= htab
->elf
.srelplt
;
10268 srel
= htab
->elf
.srelgot
;
10270 /* Reduce size of the .rela.* section by one reloc. */
10271 BFD_ASSERT (srel
!= NULL
);
10272 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10273 srel
->size
-= sizeof (Elf32_External_Rela
);
10277 asection
*splt
, *sgotplt
, *srelgot
;
10278 int reloc_index
, chunk
;
10280 /* Find the PLT reloc index of the entry being removed. This
10281 is computed from the size of ".rela.plt". It is needed to
10282 figure out which PLT chunk to resize. Usually "last index
10283 = size - 1" since the index starts at zero, but in this
10284 context, the size has just been decremented so there's no
10285 need to subtract one. */
10286 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10288 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10289 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10290 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10291 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10293 /* Check if an entire PLT chunk has just been eliminated. */
10294 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10296 /* The two magic GOT entries for that chunk can go away. */
10297 srelgot
= htab
->elf
.srelgot
;
10298 BFD_ASSERT (srelgot
!= NULL
);
10299 srelgot
->reloc_count
-= 2;
10300 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10301 sgotplt
->size
-= 8;
10303 /* There should be only one entry left (and it will be
10305 BFD_ASSERT (sgotplt
->size
== 4);
10306 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10309 BFD_ASSERT (sgotplt
->size
>= 4);
10310 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10312 sgotplt
->size
-= 4;
10313 splt
->size
-= PLT_ENTRY_SIZE
;
10319 /* Take an r_rel and move it to another section. This usually
10320 requires extending the interal_relocation array and pinning it. If
10321 the original r_rel is from the same BFD, we can complete this here.
10322 Otherwise, we add a fix record to let the final link fix the
10323 appropriate address. Contents and internal relocations for the
10324 section must be pinned after calling this routine. */
10327 move_literal (bfd
*abfd
,
10328 struct bfd_link_info
*link_info
,
10331 bfd_byte
*contents
,
10332 xtensa_relax_info
*relax_info
,
10333 Elf_Internal_Rela
**internal_relocs_p
,
10334 const literal_value
*lit
)
10336 Elf_Internal_Rela
*new_relocs
= NULL
;
10337 size_t new_relocs_count
= 0;
10338 Elf_Internal_Rela this_rela
;
10339 const r_reloc
*r_rel
;
10341 r_rel
= &lit
->r_rel
;
10342 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10344 if (r_reloc_is_const (r_rel
))
10345 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10350 reloc_bfd_fix
*fix
;
10351 unsigned insert_at
;
10353 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10355 /* This is the difficult case. We have to create a fix up. */
10356 this_rela
.r_offset
= offset
;
10357 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10358 this_rela
.r_addend
=
10359 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10360 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10362 /* Currently, we cannot move relocations during a relocatable link. */
10363 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10364 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10365 r_reloc_get_section (r_rel
),
10366 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10368 /* We also need to mark that relocations are needed here. */
10369 sec
->flags
|= SEC_RELOC
;
10371 translate_reloc_bfd_fix (fix
);
10372 /* This fix has not yet been translated. */
10373 add_fix (sec
, fix
);
10375 /* Add the relocation. If we have already allocated our own
10376 space for the relocations and we have room for more, then use
10377 it. Otherwise, allocate new space and move the literals. */
10378 insert_at
= sec
->reloc_count
;
10379 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10381 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10388 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10389 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10391 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10392 || sec
->reloc_count
== relax_info
->relocs_count
);
10394 if (relax_info
->allocated_relocs_count
== 0)
10395 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10397 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10399 new_relocs
= (Elf_Internal_Rela
*)
10400 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10404 /* We could handle this more quickly by finding the split point. */
10405 if (insert_at
!= 0)
10406 memcpy (new_relocs
, *internal_relocs_p
,
10407 insert_at
* sizeof (Elf_Internal_Rela
));
10409 new_relocs
[insert_at
] = this_rela
;
10411 if (insert_at
!= sec
->reloc_count
)
10412 memcpy (new_relocs
+ insert_at
+ 1,
10413 (*internal_relocs_p
) + insert_at
,
10414 (sec
->reloc_count
- insert_at
)
10415 * sizeof (Elf_Internal_Rela
));
10417 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10419 /* The first time we re-allocate, we can only free the
10420 old relocs if they were allocated with bfd_malloc.
10421 This is not true when keep_memory is in effect. */
10422 if (!link_info
->keep_memory
)
10423 free (*internal_relocs_p
);
10426 free (*internal_relocs_p
);
10427 relax_info
->allocated_relocs
= new_relocs
;
10428 relax_info
->allocated_relocs_count
= new_relocs_count
;
10429 elf_section_data (sec
)->relocs
= new_relocs
;
10430 sec
->reloc_count
++;
10431 relax_info
->relocs_count
= sec
->reloc_count
;
10432 *internal_relocs_p
= new_relocs
;
10436 if (insert_at
!= sec
->reloc_count
)
10439 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10440 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10442 (*internal_relocs_p
)[insert_at
] = this_rela
;
10443 sec
->reloc_count
++;
10444 if (relax_info
->allocated_relocs
)
10445 relax_info
->relocs_count
= sec
->reloc_count
;
10452 /* This is similar to relax_section except that when a target is moved,
10453 we shift addresses up. We also need to modify the size. This
10454 algorithm does NOT allow for relocations into the middle of the
10455 property sections. */
10458 relax_property_section (bfd
*abfd
,
10460 struct bfd_link_info
*link_info
)
10462 Elf_Internal_Rela
*internal_relocs
;
10463 bfd_byte
*contents
;
10466 bool is_full_prop_section
;
10467 size_t last_zfill_target_offset
= 0;
10468 asection
*last_zfill_target_sec
= NULL
;
10469 bfd_size_type sec_size
;
10470 bfd_size_type entry_size
;
10472 sec_size
= bfd_get_section_limit (abfd
, sec
);
10473 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10474 link_info
->keep_memory
);
10475 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10476 if (contents
== NULL
&& sec_size
!= 0)
10482 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10483 if (is_full_prop_section
)
10488 if (internal_relocs
)
10490 for (i
= 0; i
< sec
->reloc_count
; i
++)
10492 Elf_Internal_Rela
*irel
;
10493 xtensa_relax_info
*target_relax_info
;
10495 asection
*target_sec
;
10497 bfd_byte
*size_p
, *flags_p
;
10499 /* Locally change the source address.
10500 Translate the target to the new target address.
10501 If it points to this section and has been removed, MOVE IT.
10502 Also, don't forget to modify the associated SIZE at
10505 irel
= &internal_relocs
[i
];
10506 r_type
= ELF32_R_TYPE (irel
->r_info
);
10507 if (r_type
== R_XTENSA_NONE
)
10510 /* Find the literal value. */
10511 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10512 size_p
= &contents
[irel
->r_offset
+ 4];
10514 if (is_full_prop_section
)
10515 flags_p
= &contents
[irel
->r_offset
+ 8];
10516 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10518 target_sec
= r_reloc_get_section (&val
.r_rel
);
10519 target_relax_info
= get_xtensa_relax_info (target_sec
);
10521 if (target_relax_info
10522 && (target_relax_info
->is_relaxable_literal_section
10523 || target_relax_info
->is_relaxable_asm_section
))
10525 /* Translate the relocation's destination. */
10526 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10527 bfd_vma new_offset
;
10528 long old_size
, new_size
;
10529 int removed_by_old_offset
=
10530 removed_by_actions_map (&target_relax_info
->action_list
,
10531 old_offset
, false);
10532 new_offset
= old_offset
- removed_by_old_offset
;
10534 /* Assert that we are not out of bounds. */
10535 old_size
= bfd_get_32 (abfd
, size_p
);
10536 new_size
= old_size
;
10540 /* Only the first zero-sized unreachable entry is
10541 allowed to expand. In this case the new offset
10542 should be the offset before the fill and the new
10543 size is the expansion size. For other zero-sized
10544 entries the resulting size should be zero with an
10545 offset before or after the fill address depending
10546 on whether the expanding unreachable entry
10548 if (last_zfill_target_sec
== 0
10549 || last_zfill_target_sec
!= target_sec
10550 || last_zfill_target_offset
!= old_offset
)
10552 bfd_vma new_end_offset
= new_offset
;
10554 /* Recompute the new_offset, but this time don't
10555 include any fill inserted by relaxation. */
10556 removed_by_old_offset
=
10557 removed_by_actions_map (&target_relax_info
->action_list
,
10559 new_offset
= old_offset
- removed_by_old_offset
;
10561 /* If it is not unreachable and we have not yet
10562 seen an unreachable at this address, place it
10563 before the fill address. */
10564 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10565 & XTENSA_PROP_UNREACHABLE
) != 0)
10567 new_size
= new_end_offset
- new_offset
;
10569 last_zfill_target_sec
= target_sec
;
10570 last_zfill_target_offset
= old_offset
;
10576 int removed_by_old_offset_size
=
10577 removed_by_actions_map (&target_relax_info
->action_list
,
10578 old_offset
+ old_size
, true);
10579 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10582 if (new_size
!= old_size
)
10584 bfd_put_32 (abfd
, new_size
, size_p
);
10585 pin_contents (sec
, contents
);
10588 if (new_offset
!= old_offset
)
10590 bfd_vma diff
= new_offset
- old_offset
;
10591 irel
->r_addend
+= diff
;
10592 pin_internal_relocs (sec
, internal_relocs
);
10598 /* Combine adjacent property table entries. This is also done in
10599 finish_dynamic_sections() but at that point it's too late to
10600 reclaim the space in the output section, so we do this twice. */
10602 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10603 || xtensa_is_littable_section (sec
)))
10605 Elf_Internal_Rela
*last_irel
= NULL
;
10606 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10607 int removed_bytes
= 0;
10609 flagword predef_flags
;
10611 predef_flags
= xtensa_get_property_predef_flags (sec
);
10613 /* Walk over memory and relocations at the same time.
10614 This REQUIRES that the internal_relocs be sorted by offset. */
10615 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10616 internal_reloc_compare
);
10618 pin_internal_relocs (sec
, internal_relocs
);
10619 pin_contents (sec
, contents
);
10621 next_rel
= internal_relocs
;
10622 rel_end
= internal_relocs
+ sec
->reloc_count
;
10624 BFD_ASSERT (sec
->size
% entry_size
== 0);
10626 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10628 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10629 bfd_vma bytes_to_remove
, size
, actual_offset
;
10630 bool remove_this_rel
;
10633 /* Find the first relocation for the entry at the current offset.
10634 Adjust the offsets of any extra relocations for the previous
10639 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10641 if ((irel
->r_offset
== offset
10642 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10643 || irel
->r_offset
> offset
)
10648 irel
->r_offset
-= removed_bytes
;
10652 /* Find the next relocation (if there are any left). */
10656 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10658 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10666 /* Check if there are relocations on the current entry. There
10667 should usually be a relocation on the offset field. If there
10668 are relocations on the size or flags, then we can't optimize
10669 this entry. Also, find the next relocation to examine on the
10673 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10675 next_rel
= offset_rel
;
10676 /* There are no relocations on the current entry, but we
10677 might still be able to remove it if the size is zero. */
10680 else if (offset_rel
->r_offset
> offset
10682 && extra_rel
->r_offset
< offset
+ entry_size
))
10684 /* There is a relocation on the size or flags, so we can't
10685 do anything with this entry. Continue with the next. */
10686 next_rel
= offset_rel
;
10691 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10692 offset_rel
->r_offset
-= removed_bytes
;
10693 next_rel
= offset_rel
+ 1;
10699 remove_this_rel
= false;
10700 bytes_to_remove
= 0;
10701 actual_offset
= offset
- removed_bytes
;
10702 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10704 if (is_full_prop_section
)
10705 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10707 flags
= predef_flags
;
10710 && (flags
& XTENSA_PROP_ALIGN
) == 0
10711 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10713 /* Always remove entries with zero size and no alignment. */
10714 bytes_to_remove
= entry_size
;
10716 remove_this_rel
= true;
10718 else if (offset_rel
10719 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10723 flagword old_flags
;
10725 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10726 bfd_vma old_address
=
10727 (last_irel
->r_addend
10728 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10729 bfd_vma new_address
=
10730 (offset_rel
->r_addend
10731 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10732 if (is_full_prop_section
)
10733 old_flags
= bfd_get_32
10734 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10736 old_flags
= predef_flags
;
10738 if ((ELF32_R_SYM (offset_rel
->r_info
)
10739 == ELF32_R_SYM (last_irel
->r_info
))
10740 && old_address
+ old_size
== new_address
10741 && old_flags
== flags
10742 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10743 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10745 /* Fix the old size. */
10746 bfd_put_32 (abfd
, old_size
+ size
,
10747 &contents
[last_irel
->r_offset
+ 4]);
10748 bytes_to_remove
= entry_size
;
10749 remove_this_rel
= true;
10752 last_irel
= offset_rel
;
10755 last_irel
= offset_rel
;
10758 if (remove_this_rel
)
10760 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10761 offset_rel
->r_offset
= 0;
10764 if (bytes_to_remove
!= 0)
10766 removed_bytes
+= bytes_to_remove
;
10767 if (offset
+ bytes_to_remove
< sec
->size
)
10768 memmove (&contents
[actual_offset
],
10769 &contents
[actual_offset
+ bytes_to_remove
],
10770 sec
->size
- offset
- bytes_to_remove
);
10776 /* Fix up any extra relocations on the last entry. */
10777 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10778 irel
->r_offset
-= removed_bytes
;
10780 /* Clear the removed bytes. */
10781 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10783 if (sec
->rawsize
== 0)
10784 sec
->rawsize
= sec
->size
;
10785 sec
->size
-= removed_bytes
;
10787 if (xtensa_is_littable_section (sec
))
10789 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10791 sgotloc
->size
-= removed_bytes
;
10797 release_internal_relocs (sec
, internal_relocs
);
10798 release_contents (sec
, contents
);
10803 /* Third relaxation pass. */
10805 /* Change symbol values to account for removed literals. */
10808 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10810 xtensa_relax_info
*relax_info
;
10811 unsigned int sec_shndx
;
10812 Elf_Internal_Shdr
*symtab_hdr
;
10813 Elf_Internal_Sym
*isymbuf
;
10814 unsigned i
, num_syms
, num_locals
;
10816 relax_info
= get_xtensa_relax_info (sec
);
10817 BFD_ASSERT (relax_info
);
10819 if (!relax_info
->is_relaxable_literal_section
10820 && !relax_info
->is_relaxable_asm_section
)
10823 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10825 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10826 isymbuf
= retrieve_local_syms (abfd
);
10828 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10829 num_locals
= symtab_hdr
->sh_info
;
10831 /* Adjust the local symbols defined in this section. */
10832 for (i
= 0; i
< num_locals
; i
++)
10834 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10836 if (isym
->st_shndx
== sec_shndx
)
10838 bfd_vma orig_addr
= isym
->st_value
;
10839 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10842 isym
->st_value
-= removed
;
10843 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10845 removed_by_actions_map (&relax_info
->action_list
,
10846 orig_addr
+ isym
->st_size
, false) -
10851 /* Now adjust the global symbols defined in this section. */
10852 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10854 struct elf_link_hash_entry
*sym_hash
;
10856 sym_hash
= elf_sym_hashes (abfd
)[i
];
10858 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10859 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10861 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10862 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10863 && sym_hash
->root
.u
.def
.section
== sec
)
10865 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10866 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10869 sym_hash
->root
.u
.def
.value
-= removed
;
10871 if (sym_hash
->type
== STT_FUNC
)
10873 removed_by_actions_map (&relax_info
->action_list
,
10874 orig_addr
+ sym_hash
->size
, false) -
10883 /* "Fix" handling functions, called while performing relocations. */
10886 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10888 asection
*input_section
,
10889 bfd_byte
*contents
)
10892 asection
*sec
, *old_sec
;
10893 bfd_vma old_offset
;
10894 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10895 reloc_bfd_fix
*fix
;
10897 if (r_type
== R_XTENSA_NONE
)
10900 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10904 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10905 bfd_get_section_limit (input_bfd
, input_section
));
10906 old_sec
= r_reloc_get_section (&r_rel
);
10907 old_offset
= r_rel
.target_offset
;
10909 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10911 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10914 /* xgettext:c-format */
10915 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10916 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10917 elf_howto_table
[r_type
].name
);
10920 /* Leave it be. Resolution will happen in a later stage. */
10924 sec
= fix
->target_sec
;
10925 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10926 - (old_sec
->output_offset
+ old_offset
));
10933 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10935 asection
*input_section
,
10936 bfd_byte
*contents
,
10937 bfd_vma
*relocationp
)
10940 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10941 reloc_bfd_fix
*fix
;
10942 bfd_vma fixup_diff
;
10944 if (r_type
== R_XTENSA_NONE
)
10947 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10951 sec
= fix
->target_sec
;
10953 fixup_diff
= rel
->r_addend
;
10954 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10956 bfd_vma inplace_val
;
10957 BFD_ASSERT (fix
->src_offset
10958 < bfd_get_section_limit (input_bfd
, input_section
));
10959 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10960 fixup_diff
+= inplace_val
;
10963 *relocationp
= (sec
->output_section
->vma
10964 + sec
->output_offset
10965 + fix
->target_offset
- fixup_diff
);
10969 /* Miscellaneous utility functions.... */
10972 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10978 return elf_hash_table (info
)->splt
;
10980 dynobj
= elf_hash_table (info
)->dynobj
;
10981 sprintf (plt_name
, ".plt.%u", chunk
);
10982 return bfd_get_linker_section (dynobj
, plt_name
);
10987 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10993 return elf_hash_table (info
)->sgotplt
;
10995 dynobj
= elf_hash_table (info
)->dynobj
;
10996 sprintf (got_name
, ".got.plt.%u", chunk
);
10997 return bfd_get_linker_section (dynobj
, got_name
);
11001 /* Get the input section for a given symbol index.
11003 . a section symbol, return the section;
11004 . a common symbol, return the common section;
11005 . an undefined symbol, return the undefined section;
11006 . an indirect symbol, follow the links;
11007 . an absolute value, return the absolute section. */
11010 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
11012 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11013 asection
*target_sec
= NULL
;
11014 if (r_symndx
< symtab_hdr
->sh_info
)
11016 Elf_Internal_Sym
*isymbuf
;
11017 unsigned int section_index
;
11019 isymbuf
= retrieve_local_syms (abfd
);
11020 section_index
= isymbuf
[r_symndx
].st_shndx
;
11022 if (section_index
== SHN_UNDEF
)
11023 target_sec
= bfd_und_section_ptr
;
11024 else if (section_index
== SHN_ABS
)
11025 target_sec
= bfd_abs_section_ptr
;
11026 else if (section_index
== SHN_COMMON
)
11027 target_sec
= bfd_com_section_ptr
;
11029 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
11033 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11034 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
11036 while (h
->root
.type
== bfd_link_hash_indirect
11037 || h
->root
.type
== bfd_link_hash_warning
)
11038 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11040 switch (h
->root
.type
)
11042 case bfd_link_hash_defined
:
11043 case bfd_link_hash_defweak
:
11044 target_sec
= h
->root
.u
.def
.section
;
11046 case bfd_link_hash_common
:
11047 target_sec
= bfd_com_section_ptr
;
11049 case bfd_link_hash_undefined
:
11050 case bfd_link_hash_undefweak
:
11051 target_sec
= bfd_und_section_ptr
;
11053 default: /* New indirect warning. */
11054 target_sec
= bfd_und_section_ptr
;
11062 static struct elf_link_hash_entry
*
11063 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
11065 unsigned long indx
;
11066 struct elf_link_hash_entry
*h
;
11067 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11069 if (r_symndx
< symtab_hdr
->sh_info
)
11072 indx
= r_symndx
- symtab_hdr
->sh_info
;
11073 h
= elf_sym_hashes (abfd
)[indx
];
11074 while (h
->root
.type
== bfd_link_hash_indirect
11075 || h
->root
.type
== bfd_link_hash_warning
)
11076 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11081 /* Get the section-relative offset for a symbol number. */
11084 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
11086 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11087 bfd_vma offset
= 0;
11089 if (r_symndx
< symtab_hdr
->sh_info
)
11091 Elf_Internal_Sym
*isymbuf
;
11092 isymbuf
= retrieve_local_syms (abfd
);
11093 offset
= isymbuf
[r_symndx
].st_value
;
11097 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11098 struct elf_link_hash_entry
*h
=
11099 elf_sym_hashes (abfd
)[indx
];
11101 while (h
->root
.type
== bfd_link_hash_indirect
11102 || h
->root
.type
== bfd_link_hash_warning
)
11103 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11104 if (h
->root
.type
== bfd_link_hash_defined
11105 || h
->root
.type
== bfd_link_hash_defweak
)
11106 offset
= h
->root
.u
.def
.value
;
11113 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
11115 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
11116 struct elf_link_hash_entry
*h
;
11118 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
11119 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
11126 pcrel_reloc_fits (xtensa_opcode opc
,
11128 bfd_vma self_address
,
11129 bfd_vma dest_address
)
11131 xtensa_isa isa
= xtensa_default_isa
;
11132 uint32 valp
= dest_address
;
11133 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
11134 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
11141 xtensa_is_property_section (asection
*sec
)
11143 if (xtensa_is_insntable_section (sec
)
11144 || xtensa_is_littable_section (sec
)
11145 || xtensa_is_proptable_section (sec
))
11153 xtensa_is_insntable_section (asection
*sec
)
11155 if (startswith (sec
->name
, XTENSA_INSN_SEC_NAME
)
11156 || startswith (sec
->name
, ".gnu.linkonce.x."))
11164 xtensa_is_littable_section (asection
*sec
)
11166 if (startswith (sec
->name
, XTENSA_LIT_SEC_NAME
)
11167 || startswith (sec
->name
, ".gnu.linkonce.p."))
11175 xtensa_is_proptable_section (asection
*sec
)
11177 if (startswith (sec
->name
, XTENSA_PROP_SEC_NAME
)
11178 || startswith (sec
->name
, ".gnu.linkonce.prop."))
11186 internal_reloc_compare (const void *ap
, const void *bp
)
11188 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11189 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11191 if (a
->r_offset
!= b
->r_offset
)
11192 return (a
->r_offset
- b
->r_offset
);
11194 /* We don't need to sort on these criteria for correctness,
11195 but enforcing a more strict ordering prevents unstable qsort
11196 from behaving differently with different implementations.
11197 Without the code below we get correct but different results
11198 on Solaris 2.7 and 2.8. We would like to always produce the
11199 same results no matter the host. */
11201 if (a
->r_info
!= b
->r_info
)
11202 return (a
->r_info
- b
->r_info
);
11204 return (a
->r_addend
- b
->r_addend
);
11209 internal_reloc_matches (const void *ap
, const void *bp
)
11211 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11212 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11214 /* Check if one entry overlaps with the other; this shouldn't happen
11215 except when searching for a match. */
11216 return (a
->r_offset
- b
->r_offset
);
11220 /* Predicate function used to look up a section in a particular group. */
11223 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
11225 const char *gname
= inf
;
11226 const char *group_name
= elf_group_name (sec
);
11228 return (group_name
== gname
11229 || (group_name
!= NULL
11231 && strcmp (group_name
, gname
) == 0));
11236 xtensa_add_names (const char *base
, const char *suffix
)
11240 size_t base_len
= strlen (base
);
11241 size_t suffix_len
= strlen (suffix
);
11242 char *str
= bfd_malloc (base_len
+ suffix_len
+ 1);
11244 memcpy (str
, base
, base_len
);
11245 memcpy (str
+ base_len
, suffix
, suffix_len
+ 1);
11250 return strdup (base
);
11254 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11257 xtensa_property_section_name (asection
*sec
, const char *base_name
,
11258 bool separate_sections
)
11260 const char *suffix
, *group_name
;
11261 char *prop_sec_name
;
11263 group_name
= elf_group_name (sec
);
11266 suffix
= strrchr (sec
->name
, '.');
11267 if (suffix
== sec
->name
)
11269 prop_sec_name
= xtensa_add_names (base_name
, suffix
);
11271 else if (startswith (sec
->name
, ".gnu.linkonce."))
11273 char *linkonce_kind
= 0;
11275 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11276 linkonce_kind
= "x.";
11277 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11278 linkonce_kind
= "p.";
11279 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11280 linkonce_kind
= "prop.";
11284 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11285 + strlen (linkonce_kind
) + 1);
11286 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11287 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11289 suffix
= sec
->name
+ linkonce_len
;
11290 /* For backward compatibility, replace "t." instead of inserting
11291 the new linkonce_kind (but not for "prop" sections). */
11292 if (startswith (suffix
, "t.") && linkonce_kind
[1] == '.')
11294 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11298 prop_sec_name
= xtensa_add_names (base_name
,
11299 separate_sections
? sec
->name
: NULL
);
11302 return prop_sec_name
;
11307 xtensa_get_separate_property_section (asection
*sec
, const char *base_name
,
11308 bool separate_section
)
11310 char *prop_sec_name
;
11311 asection
*prop_sec
;
11313 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11315 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11316 match_section_group
,
11317 (void *) elf_group_name (sec
));
11318 free (prop_sec_name
);
11323 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11325 asection
*prop_sec
;
11327 /* Try individual property section first. */
11328 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, true);
11330 /* Refer to a common property section if individual is not present. */
11332 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, false);
11339 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11341 char *prop_sec_name
;
11342 asection
*prop_sec
;
11344 /* Check if the section already exists. */
11345 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11346 elf32xtensa_separate_props
);
11347 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11348 match_section_group
,
11349 (void *) elf_group_name (sec
));
11350 /* If not, create it. */
11353 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11354 flags
|= (bfd_section_flags (sec
)
11355 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11357 prop_sec
= bfd_make_section_anyway_with_flags
11358 (sec
->owner
, strdup (prop_sec_name
), flags
);
11362 elf_group_name (prop_sec
) = elf_group_name (sec
);
11365 free (prop_sec_name
);
11371 xtensa_get_property_predef_flags (asection
*sec
)
11373 if (xtensa_is_insntable_section (sec
))
11374 return (XTENSA_PROP_INSN
11375 | XTENSA_PROP_NO_TRANSFORM
11376 | XTENSA_PROP_INSN_NO_REORDER
);
11378 if (xtensa_is_littable_section (sec
))
11379 return (XTENSA_PROP_LITERAL
11380 | XTENSA_PROP_NO_TRANSFORM
11381 | XTENSA_PROP_INSN_NO_REORDER
);
11387 /* Other functions called directly by the linker. */
11390 xtensa_callback_required_dependence (bfd
*abfd
,
11392 struct bfd_link_info
*link_info
,
11393 deps_callback_t callback
,
11396 Elf_Internal_Rela
*internal_relocs
;
11397 bfd_byte
*contents
;
11400 bfd_size_type sec_size
;
11402 sec_size
= bfd_get_section_limit (abfd
, sec
);
11404 /* ".plt*" sections have no explicit relocations but they contain L32R
11405 instructions that reference the corresponding ".got.plt*" sections. */
11406 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11407 && startswith (sec
->name
, ".plt"))
11411 /* Find the corresponding ".got.plt*" section. */
11412 if (sec
->name
[4] == '\0')
11413 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11419 BFD_ASSERT (sec
->name
[4] == '.');
11420 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11422 sprintf (got_name
, ".got.plt.%u", chunk
);
11423 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11425 BFD_ASSERT (sgotplt
);
11427 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11428 section referencing a literal at the very beginning of
11429 ".got.plt". This is very close to the real dependence, anyway. */
11430 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11433 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11434 when building uclibc, which runs "ld -b binary /dev/null". */
11435 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11438 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11439 link_info
->keep_memory
);
11440 if (internal_relocs
== NULL
11441 || sec
->reloc_count
== 0)
11444 /* Cache the contents for the duration of this scan. */
11445 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11446 if (contents
== NULL
&& sec_size
!= 0)
11452 if (!xtensa_default_isa
)
11453 xtensa_default_isa
= xtensa_isa_init (0, 0);
11455 for (i
= 0; i
< sec
->reloc_count
; i
++)
11457 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11458 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11461 asection
*target_sec
;
11462 bfd_vma target_offset
;
11464 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11467 /* L32Rs must be local to the input file. */
11468 if (r_reloc_is_defined (&l32r_rel
))
11470 target_sec
= r_reloc_get_section (&l32r_rel
);
11471 target_offset
= l32r_rel
.target_offset
;
11473 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11479 release_internal_relocs (sec
, internal_relocs
);
11480 release_contents (sec
, contents
);
11484 /* The default literal sections should always be marked as "code" (i.e.,
11485 SHF_EXECINSTR). This is particularly important for the Linux kernel
11486 module loader so that the literals are not placed after the text. */
11487 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11489 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11490 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11491 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11492 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11493 { NULL
, 0, 0, 0, 0 }
11496 #define ELF_TARGET_ID XTENSA_ELF_DATA
11498 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11499 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11500 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11501 #define TARGET_BIG_NAME "elf32-xtensa-be"
11502 #define ELF_ARCH bfd_arch_xtensa
11504 #define ELF_MACHINE_CODE EM_XTENSA
11505 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11507 #define ELF_MAXPAGESIZE 0x1000
11508 #endif /* ELF_ARCH */
11510 #define elf_backend_can_gc_sections 1
11511 #define elf_backend_can_refcount 1
11512 #define elf_backend_plt_readonly 1
11513 #define elf_backend_got_header_size 4
11514 #define elf_backend_want_dynbss 0
11515 #define elf_backend_want_got_plt 1
11516 #define elf_backend_dtrel_excludes_plt 1
11518 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11520 #define bfd_elf32_mkobject elf_xtensa_mkobject
11522 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11523 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11524 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11525 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11526 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11527 #define bfd_elf32_bfd_reloc_name_lookup \
11528 elf_xtensa_reloc_name_lookup
11529 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11530 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11532 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11533 #define elf_backend_check_relocs elf_xtensa_check_relocs
11534 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11535 #define elf_backend_discard_info elf_xtensa_discard_info
11536 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11537 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11538 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11539 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11540 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11541 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11542 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11543 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11544 #define elf_backend_object_p elf_xtensa_object_p
11545 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11546 #define elf_backend_relocate_section elf_xtensa_relocate_section
11547 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11548 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11549 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11550 #define elf_backend_special_sections elf_xtensa_special_sections
11551 #define elf_backend_action_discarded elf_xtensa_action_discarded
11552 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11554 #include "elf32-target.h"