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
;
889 || !(section
->flags
& SEC_ALLOC
)
890 || (section
->flags
& SEC_DEBUGGING
))
896 table_section
= xtensa_get_property_section (section
, sec_name
);
898 table_size
= table_section
->size
;
906 predef_flags
= xtensa_get_property_predef_flags (table_section
);
907 table_entry_size
= 12;
909 table_entry_size
-= 4;
911 num_records
= table_size
/ table_entry_size
;
912 table_data
= retrieve_contents (abfd
, table_section
, true);
913 blocks
= (property_table_entry
*)
914 bfd_malloc (num_records
* sizeof (property_table_entry
));
918 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
920 section_addr
= section
->vma
;
922 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, true);
923 if (internal_relocs
&& !table_section
->reloc_done
)
925 qsort (internal_relocs
, table_section
->reloc_count
,
926 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
927 irel
= internal_relocs
;
932 section_limit
= bfd_get_section_limit (abfd
, section
);
933 rel_end
= internal_relocs
+ table_section
->reloc_count
;
935 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
937 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
939 /* Skip any relocations before the current offset. This should help
940 avoid confusion caused by unexpected relocations for the preceding
943 (irel
->r_offset
< off
944 || (irel
->r_offset
== off
945 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
952 if (irel
&& irel
->r_offset
== off
)
955 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
956 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
958 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
961 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
962 BFD_ASSERT (sym_off
== 0);
963 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
967 if (address
< section_addr
968 || address
>= section_addr
+ section_limit
)
972 blocks
[block_count
].address
= address
;
973 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
975 blocks
[block_count
].flags
= predef_flags
;
977 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
981 release_contents (table_section
, table_data
);
982 release_internal_relocs (table_section
, internal_relocs
);
986 /* Now sort them into address order for easy reference. */
987 qsort (blocks
, block_count
, sizeof (property_table_entry
),
988 property_table_compare
);
990 /* Check that the table contents are valid. Problems may occur,
991 for example, if an unrelocated object file is stripped. */
992 for (blk
= 1; blk
< block_count
; blk
++)
994 /* The only circumstance where two entries may legitimately
995 have the same address is when one of them is a zero-size
996 placeholder to mark a place where fill can be inserted.
997 The zero-size entry should come first. */
998 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
999 blocks
[blk
- 1].size
!= 0)
1001 /* xgettext:c-format */
1002 _bfd_error_handler (_("%pB(%pA): invalid property table"),
1004 bfd_set_error (bfd_error_bad_value
);
1016 static property_table_entry
*
1017 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
1018 int property_table_size
,
1021 property_table_entry entry
;
1022 property_table_entry
*rv
;
1024 if (property_table_size
== 0)
1027 entry
.address
= addr
;
1031 rv
= bsearch (&entry
, property_table
, property_table_size
,
1032 sizeof (property_table_entry
), property_table_matches
);
1038 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
1042 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
1049 /* Look through the relocs for a section during the first phase, and
1050 calculate needed space in the dynamic reloc sections. */
1053 elf_xtensa_check_relocs (bfd
*abfd
,
1054 struct bfd_link_info
*info
,
1056 const Elf_Internal_Rela
*relocs
)
1058 struct elf_xtensa_link_hash_table
*htab
;
1059 Elf_Internal_Shdr
*symtab_hdr
;
1060 struct elf_link_hash_entry
**sym_hashes
;
1061 const Elf_Internal_Rela
*rel
;
1062 const Elf_Internal_Rela
*rel_end
;
1064 if (bfd_link_relocatable (info
))
1067 BFD_ASSERT (is_xtensa_elf (abfd
));
1069 htab
= elf_xtensa_hash_table (info
);
1073 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1074 sym_hashes
= elf_sym_hashes (abfd
);
1076 rel_end
= relocs
+ sec
->reloc_count
;
1077 for (rel
= relocs
; rel
< rel_end
; rel
++)
1079 unsigned int r_type
;
1081 struct elf_link_hash_entry
*h
= NULL
;
1082 struct elf_xtensa_link_hash_entry
*eh
;
1083 int tls_type
, old_tls_type
;
1084 bool is_got
= false;
1085 bool is_plt
= false;
1086 bool is_tlsfunc
= false;
1088 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1089 r_type
= ELF32_R_TYPE (rel
->r_info
);
1091 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1093 /* xgettext:c-format */
1094 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1099 if (r_symndx
>= symtab_hdr
->sh_info
)
1101 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1102 while (h
->root
.type
== bfd_link_hash_indirect
1103 || h
->root
.type
== bfd_link_hash_warning
)
1104 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1106 eh
= elf_xtensa_hash_entry (h
);
1110 case R_XTENSA_TLSDESC_FN
:
1111 if (bfd_link_pic (info
))
1113 tls_type
= GOT_TLS_GD
;
1118 tls_type
= GOT_TLS_IE
;
1121 case R_XTENSA_TLSDESC_ARG
:
1122 if (bfd_link_pic (info
))
1124 tls_type
= GOT_TLS_GD
;
1129 tls_type
= GOT_TLS_IE
;
1130 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1135 case R_XTENSA_TLS_DTPOFF
:
1136 if (bfd_link_pic (info
))
1137 tls_type
= GOT_TLS_GD
;
1139 tls_type
= GOT_TLS_IE
;
1142 case R_XTENSA_TLS_TPOFF
:
1143 tls_type
= GOT_TLS_IE
;
1144 if (bfd_link_pic (info
))
1145 info
->flags
|= DF_STATIC_TLS
;
1146 if (bfd_link_pic (info
) || h
)
1151 tls_type
= GOT_NORMAL
;
1156 tls_type
= GOT_NORMAL
;
1160 case R_XTENSA_GNU_VTINHERIT
:
1161 /* This relocation describes the C++ object vtable hierarchy.
1162 Reconstruct it for later use during GC. */
1163 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1167 case R_XTENSA_GNU_VTENTRY
:
1168 /* This relocation describes which C++ vtable entries are actually
1169 used. Record for later use during GC. */
1170 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1175 /* Nothing to do for any other relocations. */
1183 if (h
->plt
.refcount
<= 0)
1186 h
->plt
.refcount
= 1;
1189 h
->plt
.refcount
+= 1;
1191 /* Keep track of the total PLT relocation count even if we
1192 don't yet know whether the dynamic sections will be
1194 htab
->plt_reloc_count
+= 1;
1196 if (elf_hash_table (info
)->dynamic_sections_created
)
1198 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1204 if (h
->got
.refcount
<= 0)
1205 h
->got
.refcount
= 1;
1207 h
->got
.refcount
+= 1;
1211 eh
->tlsfunc_refcount
+= 1;
1213 old_tls_type
= eh
->tls_type
;
1217 /* Allocate storage the first time. */
1218 if (elf_local_got_refcounts (abfd
) == NULL
)
1220 bfd_size_type size
= symtab_hdr
->sh_info
;
1223 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1226 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1228 mem
= bfd_zalloc (abfd
, size
);
1231 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1233 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1236 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1237 = (bfd_signed_vma
*) mem
;
1240 /* This is a global offset table entry for a local symbol. */
1241 if (is_got
|| is_plt
)
1242 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1245 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1247 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1250 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1251 tls_type
|= old_tls_type
;
1252 /* If a TLS symbol is accessed using IE at least once,
1253 there is no point to use a dynamic model for it. */
1254 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1255 && ((old_tls_type
& GOT_TLS_GD
) == 0
1256 || (tls_type
& GOT_TLS_IE
) == 0))
1258 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1259 tls_type
= old_tls_type
;
1260 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1261 tls_type
|= old_tls_type
;
1265 /* xgettext:c-format */
1266 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1268 h
? h
->root
.root
.string
: "<local>");
1273 if (old_tls_type
!= tls_type
)
1276 eh
->tls_type
= tls_type
;
1278 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1287 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1288 struct elf_link_hash_entry
*h
)
1290 if (bfd_link_pic (info
))
1292 if (h
->plt
.refcount
> 0)
1294 /* For shared objects, there's no need for PLT entries for local
1295 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1296 if (h
->got
.refcount
< 0)
1297 h
->got
.refcount
= 0;
1298 h
->got
.refcount
+= h
->plt
.refcount
;
1299 h
->plt
.refcount
= 0;
1304 /* Don't need any dynamic relocations at all. */
1305 h
->plt
.refcount
= 0;
1306 h
->got
.refcount
= 0;
1312 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1313 struct elf_link_hash_entry
*h
,
1316 /* For a shared link, move the plt refcount to the got refcount to leave
1317 space for RELATIVE relocs. */
1318 elf_xtensa_make_sym_local (info
, h
);
1320 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1324 /* Return the section that should be marked against GC for a given
1328 elf_xtensa_gc_mark_hook (asection
*sec
,
1329 struct bfd_link_info
*info
,
1330 Elf_Internal_Rela
*rel
,
1331 struct elf_link_hash_entry
*h
,
1332 Elf_Internal_Sym
*sym
)
1334 /* Property sections are marked "KEEP" in the linker scripts, but they
1335 should not cause other sections to be marked. (This approach relies
1336 on elf_xtensa_discard_info to remove property table entries that
1337 describe discarded sections. Alternatively, it might be more
1338 efficient to avoid using "KEEP" in the linker scripts and instead use
1339 the gc_mark_extra_sections hook to mark only the property sections
1340 that describe marked sections. That alternative does not work well
1341 with the current property table sections, which do not correspond
1342 one-to-one with the sections they describe, but that should be fixed
1344 if (xtensa_is_property_section (sec
))
1348 switch (ELF32_R_TYPE (rel
->r_info
))
1350 case R_XTENSA_GNU_VTINHERIT
:
1351 case R_XTENSA_GNU_VTENTRY
:
1355 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1359 /* Create all the dynamic sections. */
1362 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1364 struct elf_xtensa_link_hash_table
*htab
;
1365 flagword flags
, noalloc_flags
;
1367 htab
= elf_xtensa_hash_table (info
);
1371 /* First do all the standard stuff. */
1372 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1375 /* Create any extra PLT sections in case check_relocs has already
1376 been called on all the non-dynamic input files. */
1377 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1380 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1381 | SEC_LINKER_CREATED
| SEC_READONLY
);
1382 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1384 /* Mark the ".got.plt" section READONLY. */
1385 if (htab
->elf
.sgotplt
== NULL
1386 || !bfd_set_section_flags (htab
->elf
.sgotplt
, flags
))
1389 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1390 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1392 if (htab
->sgotloc
== NULL
1393 || !bfd_set_section_alignment (htab
->sgotloc
, 2))
1396 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1397 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1399 if (htab
->spltlittbl
== NULL
1400 || !bfd_set_section_alignment (htab
->spltlittbl
, 2))
1408 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1410 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1413 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1414 ".got.plt" sections. */
1415 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1421 /* Stop when we find a section has already been created. */
1422 if (elf_xtensa_get_plt_section (info
, chunk
))
1425 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1426 | SEC_LINKER_CREATED
| SEC_READONLY
);
1428 sname
= (char *) bfd_malloc (10);
1429 sprintf (sname
, ".plt.%u", chunk
);
1430 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1432 || !bfd_set_section_alignment (s
, 2))
1435 sname
= (char *) bfd_malloc (14);
1436 sprintf (sname
, ".got.plt.%u", chunk
);
1437 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1439 || !bfd_set_section_alignment (s
, 2))
1447 /* Adjust a symbol defined by a dynamic object and referenced by a
1448 regular object. The current definition is in some section of the
1449 dynamic object, but we're not including those sections. We have to
1450 change the definition to something the rest of the link can
1454 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1455 struct elf_link_hash_entry
*h
)
1457 /* If this is a weak symbol, and there is a real definition, the
1458 processor independent code will have arranged for us to see the
1459 real definition first, and we can just use the same value. */
1460 if (h
->is_weakalias
)
1462 struct elf_link_hash_entry
*def
= weakdef (h
);
1463 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1464 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1465 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1469 /* This is a reference to a symbol defined by a dynamic object. The
1470 reference must go through the GOT, so there's no need for COPY relocs,
1478 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1480 struct bfd_link_info
*info
;
1481 struct elf_xtensa_link_hash_table
*htab
;
1482 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1484 if (h
->root
.type
== bfd_link_hash_indirect
)
1487 info
= (struct bfd_link_info
*) arg
;
1488 htab
= elf_xtensa_hash_table (info
);
1492 /* If we saw any use of an IE model for this symbol, we can then optimize
1493 away GOT entries for any TLSDESC_FN relocs. */
1494 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1496 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1497 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1500 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1501 elf_xtensa_make_sym_local (info
, h
);
1503 if (! elf_xtensa_dynamic_symbol_p (h
, info
)
1504 && h
->root
.type
== bfd_link_hash_undefweak
)
1507 if (h
->plt
.refcount
> 0)
1508 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1510 if (h
->got
.refcount
> 0)
1511 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1518 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1520 struct elf_xtensa_link_hash_table
*htab
;
1523 htab
= elf_xtensa_hash_table (info
);
1527 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1529 bfd_signed_vma
*local_got_refcounts
;
1530 bfd_size_type j
, cnt
;
1531 Elf_Internal_Shdr
*symtab_hdr
;
1533 local_got_refcounts
= elf_local_got_refcounts (i
);
1534 if (!local_got_refcounts
)
1537 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1538 cnt
= symtab_hdr
->sh_info
;
1540 for (j
= 0; j
< cnt
; ++j
)
1542 /* If we saw any use of an IE model for this symbol, we can
1543 then optimize away GOT entries for any TLSDESC_FN relocs. */
1544 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1546 bfd_signed_vma
*tlsfunc_refcount
1547 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1548 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1549 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1552 if (local_got_refcounts
[j
] > 0)
1553 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1554 * sizeof (Elf32_External_Rela
));
1560 /* Set the sizes of the dynamic sections. */
1563 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1564 struct bfd_link_info
*info
)
1566 struct elf_xtensa_link_hash_table
*htab
;
1568 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1569 bool relplt
, relgot
;
1570 int plt_entries
, plt_chunks
, chunk
;
1575 htab
= elf_xtensa_hash_table (info
);
1579 dynobj
= elf_hash_table (info
)->dynobj
;
1582 srelgot
= htab
->elf
.srelgot
;
1583 srelplt
= htab
->elf
.srelplt
;
1585 if (elf_hash_table (info
)->dynamic_sections_created
)
1587 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1588 && htab
->elf
.srelplt
!= NULL
1589 && htab
->elf
.sgot
!= NULL
1590 && htab
->spltlittbl
!= NULL
1591 && htab
->sgotloc
!= NULL
);
1593 /* Set the contents of the .interp section to the interpreter. */
1594 if (bfd_link_executable (info
) && !info
->nointerp
)
1596 s
= bfd_get_linker_section (dynobj
, ".interp");
1599 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1600 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1603 /* Allocate room for one word in ".got". */
1604 htab
->elf
.sgot
->size
= 4;
1606 /* Allocate space in ".rela.got" for literals that reference global
1607 symbols and space in ".rela.plt" for literals that have PLT
1609 elf_link_hash_traverse (elf_hash_table (info
),
1610 elf_xtensa_allocate_dynrelocs
,
1613 /* If we are generating a shared object, we also need space in
1614 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1615 reference local symbols. */
1616 if (bfd_link_pic (info
))
1617 elf_xtensa_allocate_local_got_size (info
);
1619 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1620 each PLT entry, we need the PLT code plus a 4-byte literal.
1621 For each chunk of ".plt", we also need two more 4-byte
1622 literals, two corresponding entries in ".rela.got", and an
1623 8-byte entry in ".xt.lit.plt". */
1624 spltlittbl
= htab
->spltlittbl
;
1625 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1627 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1629 /* Iterate over all the PLT chunks, including any extra sections
1630 created earlier because the initial count of PLT relocations
1631 was an overestimate. */
1633 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1638 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1639 BFD_ASSERT (sgotplt
!= NULL
);
1641 if (chunk
< plt_chunks
- 1)
1642 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1643 else if (chunk
== plt_chunks
- 1)
1644 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1648 if (chunk_entries
!= 0)
1650 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1651 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1652 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1653 spltlittbl
->size
+= 8;
1662 /* Allocate space in ".got.loc" to match the total size of all the
1664 sgotloc
= htab
->sgotloc
;
1665 sgotloc
->size
= spltlittbl
->size
;
1666 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1668 if (abfd
->flags
& DYNAMIC
)
1670 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1672 if (! discarded_section (s
)
1673 && xtensa_is_littable_section (s
)
1675 sgotloc
->size
+= s
->size
;
1680 /* Allocate memory for dynamic sections. */
1683 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1687 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1690 /* It's OK to base decisions on the section name, because none
1691 of the dynobj section names depend upon the input files. */
1692 name
= bfd_section_name (s
);
1694 if (startswith (name
, ".rela"))
1698 if (strcmp (name
, ".rela.plt") == 0)
1700 else if (strcmp (name
, ".rela.got") == 0)
1703 /* We use the reloc_count field as a counter if we need
1704 to copy relocs into the output file. */
1708 else if (! startswith (name
, ".plt.")
1709 && ! startswith (name
, ".got.plt.")
1710 && strcmp (name
, ".got") != 0
1711 && strcmp (name
, ".plt") != 0
1712 && strcmp (name
, ".got.plt") != 0
1713 && strcmp (name
, ".xt.lit.plt") != 0
1714 && strcmp (name
, ".got.loc") != 0)
1716 /* It's not one of our sections, so don't allocate space. */
1722 /* If we don't need this section, strip it from the output
1723 file. We must create the ".plt*" and ".got.plt*"
1724 sections in create_dynamic_sections and/or check_relocs
1725 based on a conservative estimate of the PLT relocation
1726 count, because the sections must be created before the
1727 linker maps input sections to output sections. The
1728 linker does that before size_dynamic_sections, where we
1729 compute the exact size of the PLT, so there may be more
1730 of these sections than are actually needed. */
1731 s
->flags
|= SEC_EXCLUDE
;
1733 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1735 /* Allocate memory for the section contents. */
1736 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1737 if (s
->contents
== NULL
)
1742 if (elf_hash_table (info
)->dynamic_sections_created
)
1744 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1745 known until finish_dynamic_sections, but we need to get the relocs
1746 in place before they are sorted. */
1747 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1749 Elf_Internal_Rela irela
;
1753 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1756 loc
= (srelgot
->contents
1757 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1758 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1759 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1760 loc
+ sizeof (Elf32_External_Rela
));
1761 srelgot
->reloc_count
+= 2;
1764 /* Add some entries to the .dynamic section. We fill in the
1765 values later, in elf_xtensa_finish_dynamic_sections, but we
1766 must add the entries now so that we get the correct size for
1767 the .dynamic section. The DT_DEBUG entry is filled in by the
1768 dynamic linker and used by the debugger. */
1769 #define add_dynamic_entry(TAG, VAL) \
1770 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1772 if (!_bfd_elf_add_dynamic_tags (output_bfd
, info
,
1776 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1777 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1780 #undef add_dynamic_entry
1786 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1787 struct bfd_link_info
*info
)
1789 struct elf_xtensa_link_hash_table
*htab
;
1792 htab
= elf_xtensa_hash_table (info
);
1796 tls_sec
= htab
->elf
.tls_sec
;
1798 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1800 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1801 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1802 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1804 tlsbase
->type
= STT_TLS
;
1805 if (!(_bfd_generic_link_add_one_symbol
1806 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1807 tls_sec
, 0, NULL
, false,
1808 bed
->collect
, &bh
)))
1810 tlsbase
->def_regular
= 1;
1811 tlsbase
->other
= STV_HIDDEN
;
1812 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, true);
1819 /* Return the base VMA address which should be subtracted from real addresses
1820 when resolving @dtpoff relocation.
1821 This is PT_TLS segment p_vaddr. */
1824 dtpoff_base (struct bfd_link_info
*info
)
1826 /* If tls_sec is NULL, we should have signalled an error already. */
1827 if (elf_hash_table (info
)->tls_sec
== NULL
)
1829 return elf_hash_table (info
)->tls_sec
->vma
;
1832 /* Return the relocation value for @tpoff relocation
1833 if STT_TLS virtual address is ADDRESS. */
1836 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1838 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1841 /* If tls_sec is NULL, we should have signalled an error already. */
1842 if (htab
->tls_sec
== NULL
)
1844 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1845 return address
- htab
->tls_sec
->vma
+ base
;
1848 /* Perform the specified relocation. The instruction at (contents + address)
1849 is modified to set one operand to represent the value in "relocation". The
1850 operand position is determined by the relocation type recorded in the
1853 #define CALL_SEGMENT_BITS (30)
1854 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1856 static bfd_reloc_status_type
1857 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1859 asection
*input_section
,
1864 char **error_message
)
1867 xtensa_opcode opcode
;
1868 xtensa_isa isa
= xtensa_default_isa
;
1869 static xtensa_insnbuf ibuff
= NULL
;
1870 static xtensa_insnbuf sbuff
= NULL
;
1871 bfd_vma self_address
;
1872 bfd_size_type input_size
;
1878 ibuff
= xtensa_insnbuf_alloc (isa
);
1879 sbuff
= xtensa_insnbuf_alloc (isa
);
1882 input_size
= bfd_get_section_limit (abfd
, input_section
);
1884 /* Calculate the PC address for this instruction. */
1885 self_address
= (input_section
->output_section
->vma
1886 + input_section
->output_offset
1889 switch (howto
->type
)
1892 case R_XTENSA_DIFF8
:
1893 case R_XTENSA_DIFF16
:
1894 case R_XTENSA_DIFF32
:
1895 case R_XTENSA_PDIFF8
:
1896 case R_XTENSA_PDIFF16
:
1897 case R_XTENSA_PDIFF32
:
1898 case R_XTENSA_NDIFF8
:
1899 case R_XTENSA_NDIFF16
:
1900 case R_XTENSA_NDIFF32
:
1901 case R_XTENSA_TLS_FUNC
:
1902 case R_XTENSA_TLS_ARG
:
1903 case R_XTENSA_TLS_CALL
:
1904 return bfd_reloc_ok
;
1906 case R_XTENSA_ASM_EXPAND
:
1909 /* Check for windowed CALL across a 1GB boundary. */
1910 opcode
= get_expanded_call_opcode (contents
+ address
,
1911 input_size
- address
, 0);
1912 if (is_windowed_call_opcode (opcode
))
1914 if ((self_address
>> CALL_SEGMENT_BITS
)
1915 != (relocation
>> CALL_SEGMENT_BITS
))
1917 *error_message
= "windowed longcall crosses 1GB boundary; "
1919 return bfd_reloc_dangerous
;
1923 return bfd_reloc_ok
;
1925 case R_XTENSA_ASM_SIMPLIFY
:
1927 /* Convert the L32R/CALLX to CALL. */
1928 bfd_reloc_status_type retval
=
1929 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1931 if (retval
!= bfd_reloc_ok
)
1932 return bfd_reloc_dangerous
;
1934 /* The CALL needs to be relocated. Continue below for that part. */
1937 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1944 x
= bfd_get_32 (abfd
, contents
+ address
);
1946 bfd_put_32 (abfd
, x
, contents
+ address
);
1948 return bfd_reloc_ok
;
1950 case R_XTENSA_32_PCREL
:
1951 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1952 return bfd_reloc_ok
;
1955 case R_XTENSA_TLSDESC_FN
:
1956 case R_XTENSA_TLSDESC_ARG
:
1957 case R_XTENSA_TLS_DTPOFF
:
1958 case R_XTENSA_TLS_TPOFF
:
1959 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1960 return bfd_reloc_ok
;
1963 /* Only instruction slot-specific relocations handled below.... */
1964 slot
= get_relocation_slot (howto
->type
);
1965 if (slot
== XTENSA_UNDEFINED
)
1967 *error_message
= "unexpected relocation";
1968 return bfd_reloc_dangerous
;
1971 if (input_size
<= address
)
1972 return bfd_reloc_outofrange
;
1973 /* Read the instruction into a buffer and decode the opcode. */
1974 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1975 input_size
- address
);
1976 fmt
= xtensa_format_decode (isa
, ibuff
);
1977 if (fmt
== XTENSA_UNDEFINED
)
1979 *error_message
= "cannot decode instruction format";
1980 return bfd_reloc_dangerous
;
1983 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1985 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1986 if (opcode
== XTENSA_UNDEFINED
)
1988 *error_message
= "cannot decode instruction opcode";
1989 return bfd_reloc_dangerous
;
1992 /* Check for opcode-specific "alternate" relocations. */
1993 if (is_alt_relocation (howto
->type
))
1995 if (opcode
== get_l32r_opcode ())
1997 /* Handle the special-case of non-PC-relative L32R instructions. */
1998 bfd
*output_bfd
= input_section
->output_section
->owner
;
1999 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
2002 *error_message
= "relocation references missing .lit4 section";
2003 return bfd_reloc_dangerous
;
2005 self_address
= ((lit4_sec
->vma
& ~0xfff)
2006 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2007 newval
= relocation
;
2010 else if (opcode
== get_const16_opcode ())
2012 /* ALT used for high 16 bits.
2013 Ignore 32-bit overflow. */
2014 newval
= (relocation
>> 16) & 0xffff;
2019 /* No other "alternate" relocations currently defined. */
2020 *error_message
= "unexpected relocation";
2021 return bfd_reloc_dangerous
;
2024 else /* Not an "alternate" relocation.... */
2026 if (opcode
== get_const16_opcode ())
2028 newval
= relocation
& 0xffff;
2033 /* ...normal PC-relative relocation.... */
2035 /* Determine which operand is being relocated. */
2036 opnd
= get_relocation_opnd (opcode
, howto
->type
);
2037 if (opnd
== XTENSA_UNDEFINED
)
2039 *error_message
= "unexpected relocation";
2040 return bfd_reloc_dangerous
;
2043 if (!howto
->pc_relative
)
2045 *error_message
= "expected PC-relative relocation";
2046 return bfd_reloc_dangerous
;
2049 newval
= relocation
;
2053 /* Apply the relocation. */
2054 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
2055 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
2056 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2059 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2062 msg
= "cannot encode";
2063 if (is_direct_call_opcode (opcode
))
2065 if ((relocation
& 0x3) != 0)
2066 msg
= "misaligned call target";
2068 msg
= "call target out of range";
2070 else if (opcode
== get_l32r_opcode ())
2072 if ((relocation
& 0x3) != 0)
2073 msg
= "misaligned literal target";
2074 else if (is_alt_relocation (howto
->type
))
2075 msg
= "literal target out of range (too many literals)";
2076 else if (self_address
> relocation
)
2077 msg
= "literal target out of range (try using text-section-literals)";
2079 msg
= "literal placed after use";
2082 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2083 return bfd_reloc_dangerous
;
2086 /* Check for calls across 1GB boundaries. */
2087 if (is_direct_call_opcode (opcode
)
2088 && is_windowed_call_opcode (opcode
))
2090 if ((self_address
>> CALL_SEGMENT_BITS
)
2091 != (relocation
>> CALL_SEGMENT_BITS
))
2094 "windowed call crosses 1GB boundary; return may fail";
2095 return bfd_reloc_dangerous
;
2099 /* Write the modified instruction back out of the buffer. */
2100 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2101 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2102 input_size
- address
);
2103 return bfd_reloc_ok
;
2108 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2110 /* To reduce the size of the memory leak,
2111 we only use a single message buffer. */
2112 static bfd_size_type alloc_size
= 0;
2113 static char *message
= NULL
;
2114 bfd_size_type orig_len
, len
= 0;
2118 va_start (ap
, arglen
);
2120 is_append
= (origmsg
== message
);
2122 orig_len
= strlen (origmsg
);
2123 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2124 if (len
> alloc_size
)
2126 message
= (char *) bfd_realloc_or_free (message
, len
);
2129 if (message
!= NULL
)
2132 memcpy (message
, origmsg
, orig_len
);
2133 vsprintf (message
+ orig_len
, fmt
, ap
);
2140 /* This function is registered as the "special_function" in the
2141 Xtensa howto for handling simplify operations.
2142 bfd_perform_relocation / bfd_install_relocation use it to
2143 perform (install) the specified relocation. Since this replaces the code
2144 in bfd_perform_relocation, it is basically an Xtensa-specific,
2145 stripped-down version of bfd_perform_relocation. */
2147 static bfd_reloc_status_type
2148 bfd_elf_xtensa_reloc (bfd
*abfd
,
2149 arelent
*reloc_entry
,
2152 asection
*input_section
,
2154 char **error_message
)
2157 bfd_reloc_status_type flag
;
2158 bfd_size_type octets
= (reloc_entry
->address
2159 * OCTETS_PER_BYTE (abfd
, input_section
));
2160 bfd_vma output_base
= 0;
2161 reloc_howto_type
*howto
= reloc_entry
->howto
;
2162 asection
*reloc_target_output_section
;
2165 if (!xtensa_default_isa
)
2166 xtensa_default_isa
= xtensa_isa_init (0, 0);
2168 /* ELF relocs are against symbols. If we are producing relocatable
2169 output, and the reloc is against an external symbol, the resulting
2170 reloc will also be against the same symbol. In such a case, we
2171 don't want to change anything about the way the reloc is handled,
2172 since it will all be done at final link time. This test is similar
2173 to what bfd_elf_generic_reloc does except that it lets relocs with
2174 howto->partial_inplace go through even if the addend is non-zero.
2175 (The real problem is that partial_inplace is set for XTENSA_32
2176 relocs to begin with, but that's a long story and there's little we
2177 can do about it now....) */
2179 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2181 reloc_entry
->address
+= input_section
->output_offset
;
2182 return bfd_reloc_ok
;
2185 /* Is the address of the relocation really within the section? */
2186 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2187 return bfd_reloc_outofrange
;
2189 /* Work out which section the relocation is targeted at and the
2190 initial relocation command value. */
2192 /* Get symbol value. (Common symbols are special.) */
2193 if (bfd_is_com_section (symbol
->section
))
2196 relocation
= symbol
->value
;
2198 reloc_target_output_section
= symbol
->section
->output_section
;
2200 /* Convert input-section-relative symbol value to absolute. */
2201 if ((output_bfd
&& !howto
->partial_inplace
)
2202 || reloc_target_output_section
== NULL
)
2205 output_base
= reloc_target_output_section
->vma
;
2207 relocation
+= output_base
+ symbol
->section
->output_offset
;
2209 /* Add in supplied addend. */
2210 relocation
+= reloc_entry
->addend
;
2212 /* Here the variable relocation holds the final address of the
2213 symbol we are relocating against, plus any addend. */
2216 if (!howto
->partial_inplace
)
2218 /* This is a partial relocation, and we want to apply the relocation
2219 to the reloc entry rather than the raw data. Everything except
2220 relocations against section symbols has already been handled
2223 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2224 reloc_entry
->addend
= relocation
;
2225 reloc_entry
->address
+= input_section
->output_offset
;
2226 return bfd_reloc_ok
;
2230 reloc_entry
->address
+= input_section
->output_offset
;
2231 reloc_entry
->addend
= 0;
2235 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2236 && (symbol
->flags
& BSF_WEAK
) != 0);
2237 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2238 (bfd_byte
*) data
, (bfd_vma
) octets
,
2239 is_weak_undef
, error_message
);
2241 if (flag
== bfd_reloc_dangerous
)
2243 /* Add the symbol name to the error message. */
2244 if (! *error_message
)
2245 *error_message
= "";
2246 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2247 strlen (symbol
->name
) + 17,
2249 (unsigned long) reloc_entry
->addend
);
2255 int xtensa_abi_choice (void)
2257 if (elf32xtensa_abi
== XTHAL_ABI_UNDEFINED
)
2260 return elf32xtensa_abi
;
2263 /* Set up an entry in the procedure linkage table. */
2266 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2268 unsigned reloc_index
)
2270 asection
*splt
, *sgotplt
;
2271 bfd_vma plt_base
, got_base
;
2272 bfd_vma code_offset
, lit_offset
, abi_offset
;
2274 int abi
= xtensa_abi_choice ();
2276 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2277 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2278 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2279 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2281 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2282 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2284 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2285 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2287 /* Fill in the literal entry. This is the offset of the dynamic
2288 relocation entry. */
2289 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2290 sgotplt
->contents
+ lit_offset
);
2292 /* Fill in the entry in the procedure linkage table. */
2293 memcpy (splt
->contents
+ code_offset
,
2294 (bfd_big_endian (output_bfd
)
2295 ? elf_xtensa_be_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]
2296 : elf_xtensa_le_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]),
2298 abi_offset
= abi
== XTHAL_ABI_WINDOWED
? 3 : 0;
2299 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2300 plt_base
+ code_offset
+ abi_offset
),
2301 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2302 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2303 plt_base
+ code_offset
+ abi_offset
+ 3),
2304 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2305 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2306 plt_base
+ code_offset
+ abi_offset
+ 6),
2307 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2309 return plt_base
+ code_offset
;
2313 static bool get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2316 replace_tls_insn (Elf_Internal_Rela
*rel
,
2318 asection
*input_section
,
2321 char **error_message
)
2323 static xtensa_insnbuf ibuff
= NULL
;
2324 static xtensa_insnbuf sbuff
= NULL
;
2325 xtensa_isa isa
= xtensa_default_isa
;
2327 xtensa_opcode old_op
, new_op
;
2328 bfd_size_type input_size
;
2330 unsigned dest_reg
, src_reg
;
2334 ibuff
= xtensa_insnbuf_alloc (isa
);
2335 sbuff
= xtensa_insnbuf_alloc (isa
);
2338 input_size
= bfd_get_section_limit (abfd
, input_section
);
2340 /* Read the instruction into a buffer and decode the opcode. */
2341 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2342 input_size
- rel
->r_offset
);
2343 fmt
= xtensa_format_decode (isa
, ibuff
);
2344 if (fmt
== XTENSA_UNDEFINED
)
2346 *error_message
= "cannot decode instruction format";
2350 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2351 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2353 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2354 if (old_op
== XTENSA_UNDEFINED
)
2356 *error_message
= "cannot decode instruction opcode";
2360 r_type
= ELF32_R_TYPE (rel
->r_info
);
2363 case R_XTENSA_TLS_FUNC
:
2364 case R_XTENSA_TLS_ARG
:
2365 if (old_op
!= get_l32r_opcode ()
2366 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2367 sbuff
, &dest_reg
) != 0)
2369 *error_message
= "cannot extract L32R destination for TLS access";
2374 case R_XTENSA_TLS_CALL
:
2375 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2376 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2377 sbuff
, &src_reg
) != 0)
2379 *error_message
= "cannot extract CALLXn operands for TLS access";
2392 case R_XTENSA_TLS_FUNC
:
2393 case R_XTENSA_TLS_ARG
:
2394 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2395 versions of Xtensa). */
2396 new_op
= xtensa_opcode_lookup (isa
, "nop");
2397 if (new_op
== XTENSA_UNDEFINED
)
2399 new_op
= xtensa_opcode_lookup (isa
, "or");
2400 if (new_op
== XTENSA_UNDEFINED
2401 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2402 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2404 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2406 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2409 *error_message
= "cannot encode OR for TLS access";
2415 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2417 *error_message
= "cannot encode NOP for TLS access";
2423 case R_XTENSA_TLS_CALL
:
2424 /* Read THREADPTR into the CALLX's return value register. */
2425 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2426 if (new_op
== XTENSA_UNDEFINED
2427 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2428 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2429 sbuff
, dest_reg
+ 2) != 0)
2431 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2441 case R_XTENSA_TLS_FUNC
:
2442 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2443 if (new_op
== XTENSA_UNDEFINED
2444 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2445 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2446 sbuff
, dest_reg
) != 0)
2448 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2453 case R_XTENSA_TLS_ARG
:
2454 /* Nothing to do. Keep the original L32R instruction. */
2457 case R_XTENSA_TLS_CALL
:
2458 /* Add the CALLX's src register (holding the THREADPTR value)
2459 to the first argument register (holding the offset) and put
2460 the result in the CALLX's return value register. */
2461 new_op
= xtensa_opcode_lookup (isa
, "add");
2462 if (new_op
== XTENSA_UNDEFINED
2463 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2464 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2465 sbuff
, dest_reg
+ 2) != 0
2466 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2467 sbuff
, dest_reg
+ 2) != 0
2468 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2469 sbuff
, src_reg
) != 0)
2471 *error_message
= "cannot encode ADD for TLS access";
2478 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2479 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2480 input_size
- rel
->r_offset
);
2486 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2487 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2488 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2489 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2490 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2491 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2492 || (R_TYPE) == R_XTENSA_TLS_ARG \
2493 || (R_TYPE) == R_XTENSA_TLS_CALL)
2495 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2496 both relocatable and final links. */
2499 elf_xtensa_relocate_section (bfd
*output_bfd
,
2500 struct bfd_link_info
*info
,
2502 asection
*input_section
,
2504 Elf_Internal_Rela
*relocs
,
2505 Elf_Internal_Sym
*local_syms
,
2506 asection
**local_sections
)
2508 struct elf_xtensa_link_hash_table
*htab
;
2509 Elf_Internal_Shdr
*symtab_hdr
;
2510 Elf_Internal_Rela
*rel
;
2511 Elf_Internal_Rela
*relend
;
2512 struct elf_link_hash_entry
**sym_hashes
;
2513 property_table_entry
*lit_table
= 0;
2515 char *local_got_tls_types
;
2516 char *error_message
= NULL
;
2517 bfd_size_type input_size
;
2520 if (!xtensa_default_isa
)
2521 xtensa_default_isa
= xtensa_isa_init (0, 0);
2523 if (!is_xtensa_elf (input_bfd
))
2525 bfd_set_error (bfd_error_wrong_format
);
2529 htab
= elf_xtensa_hash_table (info
);
2533 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2534 sym_hashes
= elf_sym_hashes (input_bfd
);
2535 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2537 if (elf_hash_table (info
)->dynamic_sections_created
)
2539 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2540 &lit_table
, XTENSA_LIT_SEC_NAME
,
2546 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2549 relend
= relocs
+ input_section
->reloc_count
;
2550 for (; rel
< relend
; rel
++)
2553 reloc_howto_type
*howto
;
2554 unsigned long r_symndx
;
2555 struct elf_link_hash_entry
*h
;
2556 Elf_Internal_Sym
*sym
;
2561 bfd_reloc_status_type r
;
2563 bool unresolved_reloc
;
2565 bool dynamic_symbol
;
2567 r_type
= ELF32_R_TYPE (rel
->r_info
);
2568 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2569 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2572 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2574 bfd_set_error (bfd_error_bad_value
);
2577 howto
= &elf_howto_table
[r_type
];
2579 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2584 is_weak_undef
= false;
2585 unresolved_reloc
= false;
2588 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2590 /* Because R_XTENSA_32 was made partial_inplace to fix some
2591 problems with DWARF info in partial links, there may be
2592 an addend stored in the contents. Take it out of there
2593 and move it back into the addend field of the reloc. */
2594 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2595 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2598 if (r_symndx
< symtab_hdr
->sh_info
)
2600 sym
= local_syms
+ r_symndx
;
2601 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2602 sec
= local_sections
[r_symndx
];
2603 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2609 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2610 r_symndx
, symtab_hdr
, sym_hashes
,
2612 unresolved_reloc
, warned
, ignored
);
2615 && !unresolved_reloc
2616 && h
->root
.type
== bfd_link_hash_undefweak
)
2617 is_weak_undef
= true;
2622 if (sec
!= NULL
&& discarded_section (sec
))
2623 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2624 rel
, 1, relend
, howto
, 0, contents
);
2626 if (bfd_link_relocatable (info
))
2629 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2631 /* This is a relocatable link.
2632 1) If the reloc is against a section symbol, adjust
2633 according to the output section.
2634 2) If there is a new target for this relocation,
2635 the new target will be in the same output section.
2636 We adjust the relocation by the output section
2639 if (relaxing_section
)
2641 /* Check if this references a section in another input file. */
2642 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2647 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2648 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2650 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2652 error_message
= NULL
;
2653 /* Convert ASM_SIMPLIFY into the simpler relocation
2654 so that they never escape a relaxing link. */
2655 r
= contract_asm_expansion (contents
, input_size
, rel
,
2657 if (r
!= bfd_reloc_ok
)
2658 (*info
->callbacks
->reloc_dangerous
)
2659 (info
, error_message
,
2660 input_bfd
, input_section
, rel
->r_offset
);
2662 r_type
= ELF32_R_TYPE (rel
->r_info
);
2665 /* This is a relocatable link, so we don't have to change
2666 anything unless the reloc is against a section symbol,
2667 in which case we have to adjust according to where the
2668 section symbol winds up in the output section. */
2669 if (r_symndx
< symtab_hdr
->sh_info
)
2671 sym
= local_syms
+ r_symndx
;
2672 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2674 sec
= local_sections
[r_symndx
];
2675 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2679 /* If there is an addend with a partial_inplace howto,
2680 then move the addend to the contents. This is a hack
2681 to work around problems with DWARF in relocatable links
2682 with some previous version of BFD. Now we can't easily get
2683 rid of the hack without breaking backward compatibility.... */
2685 howto
= &elf_howto_table
[r_type
];
2686 if (howto
->partial_inplace
&& rel
->r_addend
)
2688 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2689 rel
->r_addend
, contents
,
2690 rel
->r_offset
, false,
2696 /* Put the correct bits in the target instruction, even
2697 though the relocation will still be present in the output
2698 file. This makes disassembly clearer, as well as
2699 allowing loadable kernel modules to work without needing
2700 relocations on anything other than calls and l32r's. */
2702 /* If it is not in the same section, there is nothing we can do. */
2703 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2704 sym_sec
->output_section
== input_section
->output_section
)
2706 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2707 dest_addr
, contents
,
2708 rel
->r_offset
, false,
2712 if (r
!= bfd_reloc_ok
)
2713 (*info
->callbacks
->reloc_dangerous
)
2714 (info
, error_message
,
2715 input_bfd
, input_section
, rel
->r_offset
);
2717 /* Done with work for relocatable link; continue with next reloc. */
2721 /* This is a final link. */
2723 if (relaxing_section
)
2725 /* Check if this references a section in another input file. */
2726 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2730 /* Sanity check the address. */
2731 if (rel
->r_offset
>= input_size
2732 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2735 /* xgettext:c-format */
2736 (_("%pB(%pA+%#" PRIx64
"): "
2737 "relocation offset out of range (size=%#" PRIx64
")"),
2738 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2739 (uint64_t) input_size
);
2740 bfd_set_error (bfd_error_bad_value
);
2745 name
= h
->root
.root
.string
;
2748 name
= (bfd_elf_string_from_elf_section
2749 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2750 if (name
== NULL
|| *name
== '\0')
2751 name
= bfd_section_name (sec
);
2754 if (r_symndx
!= STN_UNDEF
2755 && r_type
!= R_XTENSA_NONE
2757 || h
->root
.type
== bfd_link_hash_defined
2758 || h
->root
.type
== bfd_link_hash_defweak
)
2759 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2762 ((sym_type
== STT_TLS
2763 /* xgettext:c-format */
2764 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2765 /* xgettext:c-format */
2766 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2769 (uint64_t) rel
->r_offset
,
2774 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2776 tls_type
= GOT_UNKNOWN
;
2778 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2779 else if (local_got_tls_types
)
2780 tls_type
= local_got_tls_types
[r_symndx
];
2786 if (elf_hash_table (info
)->dynamic_sections_created
2787 && (input_section
->flags
& SEC_ALLOC
) != 0
2788 && (dynamic_symbol
|| bfd_link_pic (info
)))
2790 Elf_Internal_Rela outrel
;
2794 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2795 srel
= htab
->elf
.srelplt
;
2797 srel
= htab
->elf
.srelgot
;
2799 BFD_ASSERT (srel
!= NULL
);
2802 _bfd_elf_section_offset (output_bfd
, info
,
2803 input_section
, rel
->r_offset
);
2805 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2806 memset (&outrel
, 0, sizeof outrel
);
2809 outrel
.r_offset
+= (input_section
->output_section
->vma
2810 + input_section
->output_offset
);
2812 /* Complain if the relocation is in a read-only section
2813 and not in a literal pool. */
2814 if ((input_section
->flags
& SEC_READONLY
) != 0
2815 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2819 _("dynamic relocation in read-only section");
2820 (*info
->callbacks
->reloc_dangerous
)
2821 (info
, error_message
,
2822 input_bfd
, input_section
, rel
->r_offset
);
2827 outrel
.r_addend
= rel
->r_addend
;
2830 if (r_type
== R_XTENSA_32
)
2833 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2836 else /* r_type == R_XTENSA_PLT */
2839 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2841 /* Create the PLT entry and set the initial
2842 contents of the literal entry to the address of
2845 elf_xtensa_create_plt_entry (info
, output_bfd
,
2848 unresolved_reloc
= false;
2850 else if (!is_weak_undef
)
2852 /* Generate a RELATIVE relocation. */
2853 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2854 outrel
.r_addend
= 0;
2862 loc
= (srel
->contents
2863 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2864 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2865 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2868 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2870 /* This should only happen for non-PIC code, which is not
2871 supposed to be used on systems with dynamic linking.
2872 Just ignore these relocations. */
2877 case R_XTENSA_TLS_TPOFF
:
2878 /* Switch to LE model for local symbols in an executable. */
2879 if (! bfd_link_pic (info
) && ! dynamic_symbol
)
2881 relocation
= tpoff (info
, relocation
);
2886 case R_XTENSA_TLSDESC_FN
:
2887 case R_XTENSA_TLSDESC_ARG
:
2889 if (r_type
== R_XTENSA_TLSDESC_FN
)
2891 if (! bfd_link_pic (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2892 r_type
= R_XTENSA_NONE
;
2894 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2896 if (bfd_link_pic (info
))
2898 if ((tls_type
& GOT_TLS_IE
) != 0)
2899 r_type
= R_XTENSA_TLS_TPOFF
;
2903 r_type
= R_XTENSA_TLS_TPOFF
;
2904 if (! dynamic_symbol
)
2906 relocation
= tpoff (info
, relocation
);
2912 if (r_type
== R_XTENSA_NONE
)
2913 /* Nothing to do here; skip to the next reloc. */
2916 if (! elf_hash_table (info
)->dynamic_sections_created
)
2919 _("TLS relocation invalid without dynamic sections");
2920 (*info
->callbacks
->reloc_dangerous
)
2921 (info
, error_message
,
2922 input_bfd
, input_section
, rel
->r_offset
);
2926 Elf_Internal_Rela outrel
;
2928 asection
*srel
= htab
->elf
.srelgot
;
2931 outrel
.r_offset
= (input_section
->output_section
->vma
2932 + input_section
->output_offset
2935 /* Complain if the relocation is in a read-only section
2936 and not in a literal pool. */
2937 if ((input_section
->flags
& SEC_READONLY
) != 0
2938 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2942 _("dynamic relocation in read-only section");
2943 (*info
->callbacks
->reloc_dangerous
)
2944 (info
, error_message
,
2945 input_bfd
, input_section
, rel
->r_offset
);
2948 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2950 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2952 outrel
.r_addend
= 0;
2955 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2957 unresolved_reloc
= false;
2960 loc
= (srel
->contents
2961 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2962 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2963 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2969 case R_XTENSA_TLS_DTPOFF
:
2970 if (! bfd_link_pic (info
))
2971 /* Switch from LD model to LE model. */
2972 relocation
= tpoff (info
, relocation
);
2974 relocation
-= dtpoff_base (info
);
2977 case R_XTENSA_TLS_FUNC
:
2978 case R_XTENSA_TLS_ARG
:
2979 case R_XTENSA_TLS_CALL
:
2980 /* Check if optimizing to IE or LE model. */
2981 if ((tls_type
& GOT_TLS_IE
) != 0)
2984 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
2985 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
2986 is_ld_model
, &error_message
))
2987 (*info
->callbacks
->reloc_dangerous
)
2988 (info
, error_message
,
2989 input_bfd
, input_section
, rel
->r_offset
);
2991 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
2993 /* Skip subsequent relocations on the same instruction. */
2994 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
3001 if (elf_hash_table (info
)->dynamic_sections_created
3002 && dynamic_symbol
&& (is_operand_relocation (r_type
)
3003 || r_type
== R_XTENSA_32_PCREL
))
3006 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3007 strlen (name
) + 2, name
);
3008 (*info
->callbacks
->reloc_dangerous
)
3009 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3015 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3016 because such sections are not SEC_ALLOC and thus ld.so will
3017 not process them. */
3018 if (unresolved_reloc
3019 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3021 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3022 rel
->r_offset
) != (bfd_vma
) -1)
3025 /* xgettext:c-format */
3026 (_("%pB(%pA+%#" PRIx64
"): "
3027 "unresolvable %s relocation against symbol `%s'"),
3030 (uint64_t) rel
->r_offset
,
3036 /* TLS optimizations may have changed r_type; update "howto". */
3037 howto
= &elf_howto_table
[r_type
];
3039 /* There's no point in calling bfd_perform_relocation here.
3040 Just go directly to our "special function". */
3041 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
3042 relocation
+ rel
->r_addend
,
3043 contents
, rel
->r_offset
, is_weak_undef
,
3046 if (r
!= bfd_reloc_ok
&& !warned
)
3048 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
3049 BFD_ASSERT (error_message
!= NULL
);
3051 if (rel
->r_addend
== 0)
3052 error_message
= vsprint_msg (error_message
, ": %s",
3053 strlen (name
) + 2, name
);
3055 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
3057 name
, (int) rel
->r_addend
);
3059 (*info
->callbacks
->reloc_dangerous
)
3060 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3065 input_section
->reloc_done
= true;
3071 /* Finish up dynamic symbol handling. There's not much to do here since
3072 the PLT and GOT entries are all set up by relocate_section. */
3075 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3076 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3077 struct elf_link_hash_entry
*h
,
3078 Elf_Internal_Sym
*sym
)
3080 if (h
->needs_plt
&& !h
->def_regular
)
3082 /* Mark the symbol as undefined, rather than as defined in
3083 the .plt section. Leave the value alone. */
3084 sym
->st_shndx
= SHN_UNDEF
;
3085 /* If the symbol is weak, we do need to clear the value.
3086 Otherwise, the PLT entry would provide a definition for
3087 the symbol even if the symbol wasn't defined anywhere,
3088 and so the symbol would never be NULL. */
3089 if (!h
->ref_regular_nonweak
)
3093 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3094 if (h
== elf_hash_table (info
)->hdynamic
3095 || h
== elf_hash_table (info
)->hgot
)
3096 sym
->st_shndx
= SHN_ABS
;
3102 /* Combine adjacent literal table entries in the output. Adjacent
3103 entries within each input section may have been removed during
3104 relaxation, but we repeat the process here, even though it's too late
3105 to shrink the output section, because it's important to minimize the
3106 number of literal table entries to reduce the start-up work for the
3107 runtime linker. Returns the number of remaining table entries or -1
3111 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3116 property_table_entry
*table
;
3117 bfd_size_type section_size
, sgotloc_size
;
3121 section_size
= sxtlit
->size
;
3122 if (section_size
== 0)
3125 BFD_ASSERT (section_size
% 8 == 0);
3126 num
= section_size
/ 8;
3128 sgotloc_size
= sgotloc
->size
;
3129 if (sgotloc_size
!= section_size
)
3132 (_("internal inconsistency in size of .got.loc section"));
3136 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3140 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3141 propagates to the output section, where it doesn't really apply and
3142 where it breaks the following call to bfd_malloc_and_get_section. */
3143 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3145 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3152 /* There should never be any relocations left at this point, so this
3153 is quite a bit easier than what is done during relaxation. */
3155 /* Copy the raw contents into a property table array and sort it. */
3157 for (n
= 0; n
< num
; n
++)
3159 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3160 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3163 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3165 for (n
= 0; n
< num
; n
++)
3167 bool remove_entry
= false;
3169 if (table
[n
].size
== 0)
3170 remove_entry
= true;
3172 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3174 table
[n
-1].size
+= table
[n
].size
;
3175 remove_entry
= true;
3180 for (m
= n
; m
< num
- 1; m
++)
3182 table
[m
].address
= table
[m
+1].address
;
3183 table
[m
].size
= table
[m
+1].size
;
3191 /* Copy the data back to the raw contents. */
3193 for (n
= 0; n
< num
; n
++)
3195 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3196 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3200 /* Clear the removed bytes. */
3201 if ((bfd_size_type
) (num
* 8) < section_size
)
3202 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3204 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3208 /* Copy the contents to ".got.loc". */
3209 memcpy (sgotloc
->contents
, contents
, section_size
);
3217 /* Finish up the dynamic sections. */
3220 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3221 struct bfd_link_info
*info
)
3223 struct elf_xtensa_link_hash_table
*htab
;
3225 asection
*sdyn
, *srelplt
, *srelgot
, *sgot
, *sxtlit
, *sgotloc
;
3226 Elf32_External_Dyn
*dyncon
, *dynconend
;
3227 int num_xtlit_entries
= 0;
3229 if (! elf_hash_table (info
)->dynamic_sections_created
)
3232 htab
= elf_xtensa_hash_table (info
);
3236 dynobj
= elf_hash_table (info
)->dynobj
;
3237 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3238 BFD_ASSERT (sdyn
!= NULL
);
3240 /* Set the first entry in the global offset table to the address of
3241 the dynamic section. */
3242 sgot
= htab
->elf
.sgot
;
3245 BFD_ASSERT (sgot
->size
== 4);
3247 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3249 bfd_put_32 (output_bfd
,
3250 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3254 srelplt
= htab
->elf
.srelplt
;
3255 srelgot
= htab
->elf
.srelgot
;
3256 if (srelplt
&& srelplt
->size
!= 0)
3258 asection
*sgotplt
, *spltlittbl
;
3259 int chunk
, plt_chunks
, plt_entries
;
3260 Elf_Internal_Rela irela
;
3262 unsigned rtld_reloc
;
3264 spltlittbl
= htab
->spltlittbl
;
3265 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3267 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3268 of them follow immediately after.... */
3269 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3271 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3272 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3273 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3276 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3278 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3280 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3282 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3284 int chunk_entries
= 0;
3286 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3287 BFD_ASSERT (sgotplt
!= NULL
);
3289 /* Emit special RTLD relocations for the first two entries in
3290 each chunk of the .got.plt section. */
3292 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3293 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3294 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3295 irela
.r_offset
= (sgotplt
->output_section
->vma
3296 + sgotplt
->output_offset
);
3297 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3298 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3300 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3302 /* Next literal immediately follows the first. */
3303 loc
+= sizeof (Elf32_External_Rela
);
3304 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3305 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3306 irela
.r_offset
= (sgotplt
->output_section
->vma
3307 + sgotplt
->output_offset
+ 4);
3308 /* Tell rtld to set value to object's link map. */
3310 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3312 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3314 /* Fill in the literal table. */
3315 if (chunk
< plt_chunks
- 1)
3316 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3318 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3320 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3321 bfd_put_32 (output_bfd
,
3322 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3323 spltlittbl
->contents
+ (chunk
* 8) + 0);
3324 bfd_put_32 (output_bfd
,
3325 8 + (chunk_entries
* 4),
3326 spltlittbl
->contents
+ (chunk
* 8) + 4);
3329 /* The .xt.lit.plt section has just been modified. This must
3330 happen before the code below which combines adjacent literal
3331 table entries, and the .xt.lit.plt contents have to be forced to
3333 if (! bfd_set_section_contents (output_bfd
,
3334 spltlittbl
->output_section
,
3335 spltlittbl
->contents
,
3336 spltlittbl
->output_offset
,
3339 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3340 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3343 /* All the dynamic relocations have been emitted at this point.
3344 Make sure the relocation sections are the correct size. */
3345 if ((srelgot
&& srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3346 * srelgot
->reloc_count
))
3347 || (srelplt
&& srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3348 * srelplt
->reloc_count
)))
3351 /* Combine adjacent literal table entries. */
3352 BFD_ASSERT (! bfd_link_relocatable (info
));
3353 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3354 sgotloc
= htab
->sgotloc
;
3355 BFD_ASSERT (sgotloc
);
3359 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3360 if (num_xtlit_entries
< 0)
3364 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3365 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3366 for (; dyncon
< dynconend
; dyncon
++)
3368 Elf_Internal_Dyn dyn
;
3370 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3377 case DT_XTENSA_GOT_LOC_SZ
:
3378 dyn
.d_un
.d_val
= num_xtlit_entries
;
3381 case DT_XTENSA_GOT_LOC_OFF
:
3382 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3383 + htab
->sgotloc
->output_offset
);
3387 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3388 + htab
->elf
.sgot
->output_offset
);
3392 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3393 + htab
->elf
.srelplt
->output_offset
);
3397 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3401 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3408 /* Functions for dealing with the e_flags field. */
3410 /* Merge backend specific data from an object file to the output
3411 object file when linking. */
3414 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3416 bfd
*obfd
= info
->output_bfd
;
3417 unsigned out_mach
, in_mach
;
3418 flagword out_flag
, in_flag
;
3420 /* Check if we have the same endianness. */
3421 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3424 /* Don't even pretend to support mixed-format linking. */
3425 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3426 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3429 out_flag
= elf_elfheader (obfd
)->e_flags
;
3430 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3432 out_mach
= out_flag
& EF_XTENSA_MACH
;
3433 in_mach
= in_flag
& EF_XTENSA_MACH
;
3434 if (out_mach
!= in_mach
)
3437 /* xgettext:c-format */
3438 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3439 ibfd
, out_mach
, in_mach
);
3440 bfd_set_error (bfd_error_wrong_format
);
3444 if (! elf_flags_init (obfd
))
3446 elf_flags_init (obfd
) = true;
3447 elf_elfheader (obfd
)->e_flags
= in_flag
;
3449 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3450 && bfd_get_arch_info (obfd
)->the_default
)
3451 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3452 bfd_get_mach (ibfd
));
3457 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3458 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3460 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3461 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3468 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3470 BFD_ASSERT (!elf_flags_init (abfd
)
3471 || elf_elfheader (abfd
)->e_flags
== flags
);
3473 elf_elfheader (abfd
)->e_flags
|= flags
;
3474 elf_flags_init (abfd
) = true;
3481 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3483 FILE *f
= (FILE *) farg
;
3484 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3486 fprintf (f
, "\nXtensa header:\n");
3487 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3488 fprintf (f
, "\nMachine = Base\n");
3490 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3492 fprintf (f
, "Insn tables = %s\n",
3493 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3495 fprintf (f
, "Literal tables = %s\n",
3496 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3498 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3502 /* Set the right machine number for an Xtensa ELF file. */
3505 elf_xtensa_object_p (bfd
*abfd
)
3508 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3513 mach
= bfd_mach_xtensa
;
3519 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3524 /* The final processing done just before writing out an Xtensa ELF object
3525 file. This gets the Xtensa architecture right based on the machine
3529 elf_xtensa_final_write_processing (bfd
*abfd
)
3532 unsigned long val
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3534 switch (mach
= bfd_get_mach (abfd
))
3536 case bfd_mach_xtensa
:
3537 val
= E_XTENSA_MACH
;
3543 elf_elfheader (abfd
)->e_flags
&= ~EF_XTENSA_MACH
;
3544 elf_elfheader (abfd
)->e_flags
|= val
;
3545 return _bfd_elf_final_write_processing (abfd
);
3549 static enum elf_reloc_type_class
3550 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3551 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3552 const Elf_Internal_Rela
*rela
)
3554 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3556 case R_XTENSA_RELATIVE
:
3557 return reloc_class_relative
;
3558 case R_XTENSA_JMP_SLOT
:
3559 return reloc_class_plt
;
3561 return reloc_class_normal
;
3567 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3568 struct elf_reloc_cookie
*cookie
,
3569 struct bfd_link_info
*info
,
3573 bfd_vma offset
, actual_offset
;
3574 bfd_size_type removed_bytes
= 0;
3575 bfd_size_type entry_size
;
3577 if (sec
->output_section
3578 && bfd_is_abs_section (sec
->output_section
))
3581 if (xtensa_is_proptable_section (sec
))
3586 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3589 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3593 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3596 release_contents (sec
, contents
);
3600 /* Sort the relocations. They should already be in order when
3601 relaxation is enabled, but it might not be. */
3602 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3603 internal_reloc_compare
);
3605 cookie
->rel
= cookie
->rels
;
3606 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3608 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3610 actual_offset
= offset
- removed_bytes
;
3612 /* The ...symbol_deleted_p function will skip over relocs but it
3613 won't adjust their offsets, so do that here. */
3614 while (cookie
->rel
< cookie
->relend
3615 && cookie
->rel
->r_offset
< offset
)
3617 cookie
->rel
->r_offset
-= removed_bytes
;
3621 while (cookie
->rel
< cookie
->relend
3622 && cookie
->rel
->r_offset
== offset
)
3624 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3626 /* Remove the table entry. (If the reloc type is NONE, then
3627 the entry has already been merged with another and deleted
3628 during relaxation.) */
3629 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3631 /* Shift the contents up. */
3632 if (offset
+ entry_size
< sec
->size
)
3633 memmove (&contents
[actual_offset
],
3634 &contents
[actual_offset
+ entry_size
],
3635 sec
->size
- offset
- entry_size
);
3636 removed_bytes
+= entry_size
;
3639 /* Remove this relocation. */
3640 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3643 /* Adjust the relocation offset for previous removals. This
3644 should not be done before calling ...symbol_deleted_p
3645 because it might mess up the offset comparisons there.
3646 Make sure the offset doesn't underflow in the case where
3647 the first entry is removed. */
3648 if (cookie
->rel
->r_offset
>= removed_bytes
)
3649 cookie
->rel
->r_offset
-= removed_bytes
;
3651 cookie
->rel
->r_offset
= 0;
3657 if (removed_bytes
!= 0)
3659 /* Adjust any remaining relocs (shouldn't be any). */
3660 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3662 if (cookie
->rel
->r_offset
>= removed_bytes
)
3663 cookie
->rel
->r_offset
-= removed_bytes
;
3665 cookie
->rel
->r_offset
= 0;
3668 /* Clear the removed bytes. */
3669 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3671 pin_contents (sec
, contents
);
3672 pin_internal_relocs (sec
, cookie
->rels
);
3675 if (sec
->rawsize
== 0)
3676 sec
->rawsize
= sec
->size
;
3677 sec
->size
-= removed_bytes
;
3679 if (xtensa_is_littable_section (sec
))
3681 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3683 sgotloc
->size
-= removed_bytes
;
3688 release_contents (sec
, contents
);
3689 release_internal_relocs (sec
, cookie
->rels
);
3692 return (removed_bytes
!= 0);
3697 elf_xtensa_discard_info (bfd
*abfd
,
3698 struct elf_reloc_cookie
*cookie
,
3699 struct bfd_link_info
*info
)
3702 bool changed
= false;
3704 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3706 if (xtensa_is_property_section (sec
))
3708 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3718 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3720 return xtensa_is_property_section (sec
);
3725 elf_xtensa_action_discarded (asection
*sec
)
3727 if (strcmp (".xt_except_table", sec
->name
) == 0)
3730 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3733 return _bfd_elf_default_action_discarded (sec
);
3737 /* Support for core dump NOTE sections. */
3740 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3745 if (elf_tdata (abfd
) == NULL
3746 || elf_tdata (abfd
)->core
== NULL
)
3749 /* The size for Xtensa is variable, so don't try to recognize the format
3750 based on the size. Just assume this is GNU/Linux. */
3751 if (note
== NULL
|| note
->descsz
< 28)
3755 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3758 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3762 size
= note
->descsz
- offset
- 4;
3764 /* Make a ".reg/999" section. */
3765 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3766 size
, note
->descpos
+ offset
);
3770 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3772 switch (note
->descsz
)
3777 case 128: /* GNU/Linux elf_prpsinfo */
3778 elf_tdata (abfd
)->core
->program
3779 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3780 elf_tdata (abfd
)->core
->command
3781 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3784 /* Note that for some reason, a spurious space is tacked
3785 onto the end of the args in some (at least one anyway)
3786 implementations, so strip it off if it exists. */
3789 char *command
= elf_tdata (abfd
)->core
->command
;
3790 int n
= strlen (command
);
3792 if (0 < n
&& command
[n
- 1] == ' ')
3793 command
[n
- 1] = '\0';
3800 /* Generic Xtensa configurability stuff. */
3802 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3803 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3804 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3805 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3806 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3807 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3808 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3809 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3812 init_call_opcodes (void)
3814 if (callx0_op
== XTENSA_UNDEFINED
)
3816 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3817 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3818 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3819 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3820 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3821 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3822 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3823 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3829 is_indirect_call_opcode (xtensa_opcode opcode
)
3831 init_call_opcodes ();
3832 return (opcode
== callx0_op
3833 || opcode
== callx4_op
3834 || opcode
== callx8_op
3835 || opcode
== callx12_op
);
3840 is_direct_call_opcode (xtensa_opcode opcode
)
3842 init_call_opcodes ();
3843 return (opcode
== call0_op
3844 || opcode
== call4_op
3845 || opcode
== call8_op
3846 || opcode
== call12_op
);
3851 is_windowed_call_opcode (xtensa_opcode opcode
)
3853 init_call_opcodes ();
3854 return (opcode
== call4_op
3855 || opcode
== call8_op
3856 || opcode
== call12_op
3857 || opcode
== callx4_op
3858 || opcode
== callx8_op
3859 || opcode
== callx12_op
);
3864 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3866 unsigned dst
= (unsigned) -1;
3868 init_call_opcodes ();
3869 if (opcode
== callx0_op
)
3871 else if (opcode
== callx4_op
)
3873 else if (opcode
== callx8_op
)
3875 else if (opcode
== callx12_op
)
3878 if (dst
== (unsigned) -1)
3886 static xtensa_opcode
3887 get_const16_opcode (void)
3889 static bool done_lookup
= false;
3890 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3893 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3896 return const16_opcode
;
3900 static xtensa_opcode
3901 get_l32r_opcode (void)
3903 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3904 static bool done_lookup
= false;
3908 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3916 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3920 offset
= addr
- ((pc
+3) & -4);
3921 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3922 offset
= (signed int) offset
>> 2;
3923 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3928 static xtensa_opcode
3929 get_rsr_lend_opcode (void)
3931 static xtensa_opcode rsr_lend_opcode
= XTENSA_UNDEFINED
;
3932 static bool done_lookup
= false;
3935 rsr_lend_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "rsr.lend");
3938 return rsr_lend_opcode
;
3941 static xtensa_opcode
3942 get_wsr_lbeg_opcode (void)
3944 static xtensa_opcode wsr_lbeg_opcode
= XTENSA_UNDEFINED
;
3945 static bool done_lookup
= false;
3948 wsr_lbeg_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "wsr.lbeg");
3951 return wsr_lbeg_opcode
;
3956 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3958 xtensa_isa isa
= xtensa_default_isa
;
3959 int last_immed
, last_opnd
, opi
;
3961 if (opcode
== XTENSA_UNDEFINED
)
3962 return XTENSA_UNDEFINED
;
3964 /* Find the last visible PC-relative immediate operand for the opcode.
3965 If there are no PC-relative immediates, then choose the last visible
3966 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3967 last_immed
= XTENSA_UNDEFINED
;
3968 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3969 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3971 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3973 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3978 if (last_immed
== XTENSA_UNDEFINED
3979 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3983 return XTENSA_UNDEFINED
;
3985 /* If the operand number was specified in an old-style relocation,
3986 check for consistency with the operand computed above. */
3987 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3989 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3990 if (reloc_opnd
!= last_immed
)
3991 return XTENSA_UNDEFINED
;
3999 get_relocation_slot (int r_type
)
4009 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4010 return r_type
- R_XTENSA_SLOT0_OP
;
4011 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4012 return r_type
- R_XTENSA_SLOT0_ALT
;
4016 return XTENSA_UNDEFINED
;
4020 /* Get the opcode for a relocation. */
4022 static xtensa_opcode
4023 get_relocation_opcode (bfd
*abfd
,
4026 Elf_Internal_Rela
*irel
)
4028 static xtensa_insnbuf ibuff
= NULL
;
4029 static xtensa_insnbuf sbuff
= NULL
;
4030 xtensa_isa isa
= xtensa_default_isa
;
4034 if (contents
== NULL
)
4035 return XTENSA_UNDEFINED
;
4037 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
4038 return XTENSA_UNDEFINED
;
4042 ibuff
= xtensa_insnbuf_alloc (isa
);
4043 sbuff
= xtensa_insnbuf_alloc (isa
);
4046 /* Decode the instruction. */
4047 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
4048 sec
->size
- irel
->r_offset
);
4049 fmt
= xtensa_format_decode (isa
, ibuff
);
4050 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
4051 if (slot
== XTENSA_UNDEFINED
)
4052 return XTENSA_UNDEFINED
;
4053 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
4054 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
4059 is_l32r_relocation (bfd
*abfd
,
4062 Elf_Internal_Rela
*irel
)
4064 xtensa_opcode opcode
;
4065 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
4067 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
4068 return (opcode
== get_l32r_opcode ());
4072 static bfd_size_type
4073 get_asm_simplify_size (bfd_byte
*contents
,
4074 bfd_size_type content_len
,
4075 bfd_size_type offset
)
4077 bfd_size_type insnlen
, size
= 0;
4079 /* Decode the size of the next two instructions. */
4080 insnlen
= insn_decode_len (contents
, content_len
, offset
);
4086 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
4096 is_alt_relocation (int r_type
)
4098 return (r_type
>= R_XTENSA_SLOT0_ALT
4099 && r_type
<= R_XTENSA_SLOT14_ALT
);
4104 is_operand_relocation (int r_type
)
4114 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4116 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4125 #define MIN_INSN_LENGTH 2
4127 /* Return 0 if it fails to decode. */
4130 insn_decode_len (bfd_byte
*contents
,
4131 bfd_size_type content_len
,
4132 bfd_size_type offset
)
4135 xtensa_isa isa
= xtensa_default_isa
;
4137 static xtensa_insnbuf ibuff
= NULL
;
4139 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4143 ibuff
= xtensa_insnbuf_alloc (isa
);
4144 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4145 content_len
- offset
);
4146 fmt
= xtensa_format_decode (isa
, ibuff
);
4147 if (fmt
== XTENSA_UNDEFINED
)
4149 insn_len
= xtensa_format_length (isa
, fmt
);
4150 if (insn_len
== XTENSA_UNDEFINED
)
4156 insn_num_slots (bfd_byte
*contents
,
4157 bfd_size_type content_len
,
4158 bfd_size_type offset
)
4160 xtensa_isa isa
= xtensa_default_isa
;
4162 static xtensa_insnbuf ibuff
= NULL
;
4164 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4165 return XTENSA_UNDEFINED
;
4168 ibuff
= xtensa_insnbuf_alloc (isa
);
4169 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4170 content_len
- offset
);
4171 fmt
= xtensa_format_decode (isa
, ibuff
);
4172 if (fmt
== XTENSA_UNDEFINED
)
4173 return XTENSA_UNDEFINED
;
4174 return xtensa_format_num_slots (isa
, fmt
);
4178 /* Decode the opcode for a single slot instruction.
4179 Return 0 if it fails to decode or the instruction is multi-slot. */
4182 insn_decode_opcode (bfd_byte
*contents
,
4183 bfd_size_type content_len
,
4184 bfd_size_type offset
,
4187 xtensa_isa isa
= xtensa_default_isa
;
4189 static xtensa_insnbuf insnbuf
= NULL
;
4190 static xtensa_insnbuf slotbuf
= NULL
;
4192 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4193 return XTENSA_UNDEFINED
;
4195 if (insnbuf
== NULL
)
4197 insnbuf
= xtensa_insnbuf_alloc (isa
);
4198 slotbuf
= xtensa_insnbuf_alloc (isa
);
4201 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4202 content_len
- offset
);
4203 fmt
= xtensa_format_decode (isa
, insnbuf
);
4204 if (fmt
== XTENSA_UNDEFINED
)
4205 return XTENSA_UNDEFINED
;
4207 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4208 return XTENSA_UNDEFINED
;
4210 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4211 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4215 /* The offset is the offset in the contents.
4216 The address is the address of that offset. */
4219 check_branch_target_aligned (bfd_byte
*contents
,
4220 bfd_size_type content_length
,
4224 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4227 return check_branch_target_aligned_address (address
, insn_len
);
4232 check_loop_aligned (bfd_byte
*contents
,
4233 bfd_size_type content_length
,
4237 bfd_size_type loop_len
, insn_len
;
4238 xtensa_opcode opcode
;
4240 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4241 if (opcode
== XTENSA_UNDEFINED
4242 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4248 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4249 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4250 if (loop_len
== 0 || insn_len
== 0)
4256 /* If this is relaxed loop, analyze first instruction of the actual loop
4257 body. It must be at offset 27 from the loop instruction address. */
4259 && insn_num_slots (contents
, content_length
, offset
+ loop_len
) == 1
4260 && insn_decode_opcode (contents
, content_length
,
4261 offset
+ loop_len
, 0) == get_rsr_lend_opcode()
4262 && insn_decode_len (contents
, content_length
, offset
+ loop_len
+ 3) == 3
4263 && insn_num_slots (contents
, content_length
, offset
+ loop_len
+ 3) == 1
4264 && insn_decode_opcode (contents
, content_length
,
4265 offset
+ loop_len
+ 3, 0) == get_wsr_lbeg_opcode())
4268 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4270 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4275 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4278 return (addr
% 8 == 0);
4279 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4283 /* Instruction widening and narrowing. */
4285 /* When FLIX is available we need to access certain instructions only
4286 when they are 16-bit or 24-bit instructions. This table caches
4287 information about such instructions by walking through all the
4288 opcodes and finding the smallest single-slot format into which each
4291 static xtensa_format
*op_single_fmt_table
= NULL
;
4295 init_op_single_format_table (void)
4297 xtensa_isa isa
= xtensa_default_isa
;
4298 xtensa_insnbuf ibuf
;
4299 xtensa_opcode opcode
;
4303 if (op_single_fmt_table
)
4306 ibuf
= xtensa_insnbuf_alloc (isa
);
4307 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4309 op_single_fmt_table
= (xtensa_format
*)
4310 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4311 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4313 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4314 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4316 if (xtensa_format_num_slots (isa
, fmt
) == 1
4317 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4319 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4320 int fmt_length
= xtensa_format_length (isa
, fmt
);
4321 if (old_fmt
== XTENSA_UNDEFINED
4322 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4323 op_single_fmt_table
[opcode
] = fmt
;
4327 xtensa_insnbuf_free (isa
, ibuf
);
4331 static xtensa_format
4332 get_single_format (xtensa_opcode opcode
)
4334 init_op_single_format_table ();
4335 return op_single_fmt_table
[opcode
];
4339 /* For the set of narrowable instructions we do NOT include the
4340 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4341 involved during linker relaxation that may require these to
4342 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4343 requires special case code to ensure it only works when op1 == op2. */
4351 const struct string_pair narrowable
[] =
4354 { "addi", "addi.n" },
4355 { "addmi", "addi.n" },
4356 { "l32i", "l32i.n" },
4357 { "movi", "movi.n" },
4359 { "retw", "retw.n" },
4360 { "s32i", "s32i.n" },
4361 { "or", "mov.n" } /* special case only when op1 == op2 */
4364 const struct string_pair widenable
[] =
4367 { "addi", "addi.n" },
4368 { "addmi", "addi.n" },
4369 { "beqz", "beqz.n" },
4370 { "bnez", "bnez.n" },
4371 { "l32i", "l32i.n" },
4372 { "movi", "movi.n" },
4374 { "retw", "retw.n" },
4375 { "s32i", "s32i.n" },
4376 { "or", "mov.n" } /* special case only when op1 == op2 */
4380 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4381 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4382 return the instruction buffer holding the narrow instruction. Otherwise,
4383 return 0. The set of valid narrowing are specified by a string table
4384 but require some special case operand checks in some cases. */
4386 static xtensa_insnbuf
4387 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4389 xtensa_opcode opcode
)
4391 xtensa_isa isa
= xtensa_default_isa
;
4392 xtensa_format o_fmt
;
4395 static xtensa_insnbuf o_insnbuf
= NULL
;
4396 static xtensa_insnbuf o_slotbuf
= NULL
;
4398 if (o_insnbuf
== NULL
)
4400 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4401 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4404 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4406 bool is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4408 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4410 uint32 value
, newval
;
4411 int i
, operand_count
, o_operand_count
;
4412 xtensa_opcode o_opcode
;
4414 /* Address does not matter in this case. We might need to
4415 fix it to handle branches/jumps. */
4416 bfd_vma self_address
= 0;
4418 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4419 if (o_opcode
== XTENSA_UNDEFINED
)
4421 o_fmt
= get_single_format (o_opcode
);
4422 if (o_fmt
== XTENSA_UNDEFINED
)
4425 if (xtensa_format_length (isa
, fmt
) != 3
4426 || xtensa_format_length (isa
, o_fmt
) != 2)
4429 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4430 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4431 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4433 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4438 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4443 uint32 rawval0
, rawval1
, rawval2
;
4445 if (o_operand_count
+ 1 != operand_count
4446 || xtensa_operand_get_field (isa
, opcode
, 0,
4447 fmt
, 0, slotbuf
, &rawval0
) != 0
4448 || xtensa_operand_get_field (isa
, opcode
, 1,
4449 fmt
, 0, slotbuf
, &rawval1
) != 0
4450 || xtensa_operand_get_field (isa
, opcode
, 2,
4451 fmt
, 0, slotbuf
, &rawval2
) != 0
4452 || rawval1
!= rawval2
4453 || rawval0
== rawval1
/* it is a nop */)
4457 for (i
= 0; i
< o_operand_count
; ++i
)
4459 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4461 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4464 /* PC-relative branches need adjustment, but
4465 the PC-rel operand will always have a relocation. */
4467 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4469 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4470 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4475 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4485 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4486 the action in-place directly into the contents and return TRUE. Otherwise,
4487 the return value is FALSE and the contents are not modified. */
4490 narrow_instruction (bfd_byte
*contents
,
4491 bfd_size_type content_length
,
4492 bfd_size_type offset
)
4494 xtensa_opcode opcode
;
4495 bfd_size_type insn_len
;
4496 xtensa_isa isa
= xtensa_default_isa
;
4498 xtensa_insnbuf o_insnbuf
;
4500 static xtensa_insnbuf insnbuf
= NULL
;
4501 static xtensa_insnbuf slotbuf
= NULL
;
4503 if (insnbuf
== NULL
)
4505 insnbuf
= xtensa_insnbuf_alloc (isa
);
4506 slotbuf
= xtensa_insnbuf_alloc (isa
);
4509 BFD_ASSERT (offset
< content_length
);
4511 if (content_length
< 2)
4514 /* We will hand-code a few of these for a little while.
4515 These have all been specified in the assembler aleady. */
4516 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4517 content_length
- offset
);
4518 fmt
= xtensa_format_decode (isa
, insnbuf
);
4519 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4522 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4525 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4526 if (opcode
== XTENSA_UNDEFINED
)
4528 insn_len
= xtensa_format_length (isa
, fmt
);
4529 if (insn_len
> content_length
)
4532 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4535 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4536 content_length
- offset
);
4544 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4545 "density" instruction to a standard 3-byte instruction. If it is valid,
4546 return the instruction buffer holding the wide instruction. Otherwise,
4547 return 0. The set of valid widenings are specified by a string table
4548 but require some special case operand checks in some cases. */
4550 static xtensa_insnbuf
4551 can_widen_instruction (xtensa_insnbuf slotbuf
,
4553 xtensa_opcode opcode
)
4555 xtensa_isa isa
= xtensa_default_isa
;
4556 xtensa_format o_fmt
;
4559 static xtensa_insnbuf o_insnbuf
= NULL
;
4560 static xtensa_insnbuf o_slotbuf
= NULL
;
4562 if (o_insnbuf
== NULL
)
4564 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4565 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4568 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4570 bool is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4571 bool is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4572 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4574 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4576 uint32 value
, newval
;
4577 int i
, operand_count
, o_operand_count
, check_operand_count
;
4578 xtensa_opcode o_opcode
;
4580 /* Address does not matter in this case. We might need to fix it
4581 to handle branches/jumps. */
4582 bfd_vma self_address
= 0;
4584 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4585 if (o_opcode
== XTENSA_UNDEFINED
)
4587 o_fmt
= get_single_format (o_opcode
);
4588 if (o_fmt
== XTENSA_UNDEFINED
)
4591 if (xtensa_format_length (isa
, fmt
) != 2
4592 || xtensa_format_length (isa
, o_fmt
) != 3)
4595 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4596 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4597 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4598 check_operand_count
= o_operand_count
;
4600 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4605 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4610 uint32 rawval0
, rawval1
;
4612 if (o_operand_count
!= operand_count
+ 1
4613 || xtensa_operand_get_field (isa
, opcode
, 0,
4614 fmt
, 0, slotbuf
, &rawval0
) != 0
4615 || xtensa_operand_get_field (isa
, opcode
, 1,
4616 fmt
, 0, slotbuf
, &rawval1
) != 0
4617 || rawval0
== rawval1
/* it is a nop */)
4621 check_operand_count
--;
4623 for (i
= 0; i
< check_operand_count
; i
++)
4626 if (is_or
&& i
== o_operand_count
- 1)
4628 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4630 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4633 /* PC-relative branches need adjustment, but
4634 the PC-rel operand will always have a relocation. */
4636 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4638 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4639 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4644 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4654 /* Attempt to widen an instruction. If the widening is valid, perform
4655 the action in-place directly into the contents and return TRUE. Otherwise,
4656 the return value is FALSE and the contents are not modified. */
4659 widen_instruction (bfd_byte
*contents
,
4660 bfd_size_type content_length
,
4661 bfd_size_type offset
)
4663 xtensa_opcode opcode
;
4664 bfd_size_type insn_len
;
4665 xtensa_isa isa
= xtensa_default_isa
;
4667 xtensa_insnbuf o_insnbuf
;
4669 static xtensa_insnbuf insnbuf
= NULL
;
4670 static xtensa_insnbuf slotbuf
= NULL
;
4672 if (insnbuf
== NULL
)
4674 insnbuf
= xtensa_insnbuf_alloc (isa
);
4675 slotbuf
= xtensa_insnbuf_alloc (isa
);
4678 BFD_ASSERT (offset
< content_length
);
4680 if (content_length
< 2)
4683 /* We will hand-code a few of these for a little while.
4684 These have all been specified in the assembler aleady. */
4685 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4686 content_length
- offset
);
4687 fmt
= xtensa_format_decode (isa
, insnbuf
);
4688 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4691 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4694 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4695 if (opcode
== XTENSA_UNDEFINED
)
4697 insn_len
= xtensa_format_length (isa
, fmt
);
4698 if (insn_len
> content_length
)
4701 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4704 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4705 content_length
- offset
);
4712 /* Code for transforming CALLs at link-time. */
4714 static bfd_reloc_status_type
4715 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4717 bfd_vma content_length
,
4718 char **error_message
)
4720 static xtensa_insnbuf insnbuf
= NULL
;
4721 static xtensa_insnbuf slotbuf
= NULL
;
4722 xtensa_format core_format
= XTENSA_UNDEFINED
;
4723 xtensa_opcode opcode
;
4724 xtensa_opcode direct_call_opcode
;
4725 xtensa_isa isa
= xtensa_default_isa
;
4726 bfd_byte
*chbuf
= contents
+ address
;
4729 if (insnbuf
== NULL
)
4731 insnbuf
= xtensa_insnbuf_alloc (isa
);
4732 slotbuf
= xtensa_insnbuf_alloc (isa
);
4735 if (content_length
< address
)
4737 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4738 return bfd_reloc_other
;
4741 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4742 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4743 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4745 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4746 return bfd_reloc_other
;
4749 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4750 core_format
= xtensa_format_lookup (isa
, "x24");
4751 opcode
= xtensa_opcode_lookup (isa
, "or");
4752 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4753 for (opn
= 0; opn
< 3; opn
++)
4756 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4757 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4760 xtensa_format_encode (isa
, core_format
, insnbuf
);
4761 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4762 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4764 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4765 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4766 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4768 xtensa_format_encode (isa
, core_format
, insnbuf
);
4769 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4770 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4771 content_length
- address
- 3);
4773 return bfd_reloc_ok
;
4777 static bfd_reloc_status_type
4778 contract_asm_expansion (bfd_byte
*contents
,
4779 bfd_vma content_length
,
4780 Elf_Internal_Rela
*irel
,
4781 char **error_message
)
4783 bfd_reloc_status_type retval
=
4784 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4787 if (retval
!= bfd_reloc_ok
)
4788 return bfd_reloc_dangerous
;
4790 /* Update the irel->r_offset field so that the right immediate and
4791 the right instruction are modified during the relocation. */
4792 irel
->r_offset
+= 3;
4793 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4794 return bfd_reloc_ok
;
4798 static xtensa_opcode
4799 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4801 init_call_opcodes ();
4803 if (opcode
== callx0_op
) return call0_op
;
4804 if (opcode
== callx4_op
) return call4_op
;
4805 if (opcode
== callx8_op
) return call8_op
;
4806 if (opcode
== callx12_op
) return call12_op
;
4808 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4809 return XTENSA_UNDEFINED
;
4813 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4814 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4815 If not, return XTENSA_UNDEFINED. */
4817 #define L32R_TARGET_REG_OPERAND 0
4818 #define CONST16_TARGET_REG_OPERAND 0
4819 #define CALLN_SOURCE_OPERAND 0
4821 static xtensa_opcode
4822 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bool *p_uses_l32r
)
4824 static xtensa_insnbuf insnbuf
= NULL
;
4825 static xtensa_insnbuf slotbuf
= NULL
;
4827 xtensa_opcode opcode
;
4828 xtensa_isa isa
= xtensa_default_isa
;
4829 uint32 regno
, const16_regno
, call_regno
;
4832 if (insnbuf
== NULL
)
4834 insnbuf
= xtensa_insnbuf_alloc (isa
);
4835 slotbuf
= xtensa_insnbuf_alloc (isa
);
4838 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4839 fmt
= xtensa_format_decode (isa
, insnbuf
);
4840 if (fmt
== XTENSA_UNDEFINED
4841 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4842 return XTENSA_UNDEFINED
;
4844 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4845 if (opcode
== XTENSA_UNDEFINED
)
4846 return XTENSA_UNDEFINED
;
4848 if (opcode
== get_l32r_opcode ())
4851 *p_uses_l32r
= true;
4852 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4853 fmt
, 0, slotbuf
, ®no
)
4854 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4856 return XTENSA_UNDEFINED
;
4858 else if (opcode
== get_const16_opcode ())
4861 *p_uses_l32r
= false;
4862 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4863 fmt
, 0, slotbuf
, ®no
)
4864 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4866 return XTENSA_UNDEFINED
;
4868 /* Check that the next instruction is also CONST16. */
4869 offset
+= xtensa_format_length (isa
, fmt
);
4870 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4871 fmt
= xtensa_format_decode (isa
, insnbuf
);
4872 if (fmt
== XTENSA_UNDEFINED
4873 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4874 return XTENSA_UNDEFINED
;
4875 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4876 if (opcode
!= get_const16_opcode ())
4877 return XTENSA_UNDEFINED
;
4879 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4880 fmt
, 0, slotbuf
, &const16_regno
)
4881 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4883 || const16_regno
!= regno
)
4884 return XTENSA_UNDEFINED
;
4887 return XTENSA_UNDEFINED
;
4889 /* Next instruction should be an CALLXn with operand 0 == regno. */
4890 offset
+= xtensa_format_length (isa
, fmt
);
4891 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4892 fmt
= xtensa_format_decode (isa
, insnbuf
);
4893 if (fmt
== XTENSA_UNDEFINED
4894 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4895 return XTENSA_UNDEFINED
;
4896 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4897 if (opcode
== XTENSA_UNDEFINED
4898 || !is_indirect_call_opcode (opcode
))
4899 return XTENSA_UNDEFINED
;
4901 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4902 fmt
, 0, slotbuf
, &call_regno
)
4903 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4905 return XTENSA_UNDEFINED
;
4907 if (call_regno
!= regno
)
4908 return XTENSA_UNDEFINED
;
4914 /* Data structures used during relaxation. */
4916 /* r_reloc: relocation values. */
4918 /* Through the relaxation process, we need to keep track of the values
4919 that will result from evaluating relocations. The standard ELF
4920 relocation structure is not sufficient for this purpose because we're
4921 operating on multiple input files at once, so we need to know which
4922 input file a relocation refers to. The r_reloc structure thus
4923 records both the input file (bfd) and ELF relocation.
4925 For efficiency, an r_reloc also contains a "target_offset" field to
4926 cache the target-section-relative offset value that is represented by
4929 The r_reloc also contains a virtual offset that allows multiple
4930 inserted literals to be placed at the same "address" with
4931 different offsets. */
4933 typedef struct r_reloc_struct r_reloc
;
4935 struct r_reloc_struct
4938 Elf_Internal_Rela rela
;
4939 bfd_vma target_offset
;
4940 bfd_vma virtual_offset
;
4944 /* The r_reloc structure is included by value in literal_value, but not
4945 every literal_value has an associated relocation -- some are simple
4946 constants. In such cases, we set all the fields in the r_reloc
4947 struct to zero. The r_reloc_is_const function should be used to
4948 detect this case. */
4951 r_reloc_is_const (const r_reloc
*r_rel
)
4953 return (r_rel
->abfd
== NULL
);
4958 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4960 bfd_vma target_offset
;
4961 unsigned long r_symndx
;
4963 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4964 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4965 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4966 return (target_offset
+ r_rel
->rela
.r_addend
);
4970 static struct elf_link_hash_entry
*
4971 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4973 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4974 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4979 r_reloc_get_section (const r_reloc
*r_rel
)
4981 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4982 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4987 r_reloc_is_defined (const r_reloc
*r_rel
)
4993 sec
= r_reloc_get_section (r_rel
);
4994 if (sec
== bfd_abs_section_ptr
4995 || sec
== bfd_com_section_ptr
4996 || sec
== bfd_und_section_ptr
)
5003 r_reloc_init (r_reloc
*r_rel
,
5005 Elf_Internal_Rela
*irel
,
5007 bfd_size_type content_length
)
5010 reloc_howto_type
*howto
;
5014 r_rel
->rela
= *irel
;
5016 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
5017 r_rel
->virtual_offset
= 0;
5018 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
5019 howto
= &elf_howto_table
[r_type
];
5020 if (howto
->partial_inplace
)
5022 bfd_vma inplace_val
;
5023 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
5025 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
5026 r_rel
->target_offset
+= inplace_val
;
5030 memset (r_rel
, 0, sizeof (r_reloc
));
5037 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
5039 if (r_reloc_is_defined (r_rel
))
5041 asection
*sec
= r_reloc_get_section (r_rel
);
5042 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
5044 else if (r_reloc_get_hash_entry (r_rel
))
5045 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
5047 fprintf (fp
, " ?? + ");
5049 fprintf_vma (fp
, r_rel
->target_offset
);
5050 if (r_rel
->virtual_offset
)
5052 fprintf (fp
, " + ");
5053 fprintf_vma (fp
, r_rel
->virtual_offset
);
5062 /* source_reloc: relocations that reference literals. */
5064 /* To determine whether literals can be coalesced, we need to first
5065 record all the relocations that reference the literals. The
5066 source_reloc structure below is used for this purpose. The
5067 source_reloc entries are kept in a per-literal-section array, sorted
5068 by offset within the literal section (i.e., target offset).
5070 The source_sec and r_rel.rela.r_offset fields identify the source of
5071 the relocation. The r_rel field records the relocation value, i.e.,
5072 the offset of the literal being referenced. The opnd field is needed
5073 to determine the range of the immediate field to which the relocation
5074 applies, so we can determine whether another literal with the same
5075 value is within range. The is_null field is true when the relocation
5076 is being removed (e.g., when an L32R is being removed due to a CALLX
5077 that is converted to a direct CALL). */
5079 typedef struct source_reloc_struct source_reloc
;
5081 struct source_reloc_struct
5083 asection
*source_sec
;
5085 xtensa_opcode opcode
;
5088 bool is_abs_literal
;
5093 init_source_reloc (source_reloc
*reloc
,
5094 asection
*source_sec
,
5095 const r_reloc
*r_rel
,
5096 xtensa_opcode opcode
,
5098 bool is_abs_literal
)
5100 reloc
->source_sec
= source_sec
;
5101 reloc
->r_rel
= *r_rel
;
5102 reloc
->opcode
= opcode
;
5104 reloc
->is_null
= false;
5105 reloc
->is_abs_literal
= is_abs_literal
;
5109 /* Find the source_reloc for a particular source offset and relocation
5110 type. Note that the array is sorted by _target_ offset, so this is
5111 just a linear search. */
5113 static source_reloc
*
5114 find_source_reloc (source_reloc
*src_relocs
,
5117 Elf_Internal_Rela
*irel
)
5121 for (i
= 0; i
< src_count
; i
++)
5123 if (src_relocs
[i
].source_sec
== sec
5124 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
5125 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
5126 == ELF32_R_TYPE (irel
->r_info
)))
5127 return &src_relocs
[i
];
5135 source_reloc_compare (const void *ap
, const void *bp
)
5137 const source_reloc
*a
= (const source_reloc
*) ap
;
5138 const source_reloc
*b
= (const source_reloc
*) bp
;
5140 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
5141 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5143 /* We don't need to sort on these criteria for correctness,
5144 but enforcing a more strict ordering prevents unstable qsort
5145 from behaving differently with different implementations.
5146 Without the code below we get correct but different results
5147 on Solaris 2.7 and 2.8. We would like to always produce the
5148 same results no matter the host. */
5150 if ((!a
->is_null
) - (!b
->is_null
))
5151 return ((!a
->is_null
) - (!b
->is_null
));
5152 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5156 /* Literal values and value hash tables. */
5158 /* Literals with the same value can be coalesced. The literal_value
5159 structure records the value of a literal: the "r_rel" field holds the
5160 information from the relocation on the literal (if there is one) and
5161 the "value" field holds the contents of the literal word itself.
5163 The value_map structure records a literal value along with the
5164 location of a literal holding that value. The value_map hash table
5165 is indexed by the literal value, so that we can quickly check if a
5166 particular literal value has been seen before and is thus a candidate
5169 typedef struct literal_value_struct literal_value
;
5170 typedef struct value_map_struct value_map
;
5171 typedef struct value_map_hash_table_struct value_map_hash_table
;
5173 struct literal_value_struct
5176 unsigned long value
;
5177 bool is_abs_literal
;
5180 struct value_map_struct
5182 literal_value val
; /* The literal value. */
5183 r_reloc loc
; /* Location of the literal. */
5187 struct value_map_hash_table_struct
5189 unsigned bucket_count
;
5190 value_map
**buckets
;
5198 init_literal_value (literal_value
*lit
,
5199 const r_reloc
*r_rel
,
5200 unsigned long value
,
5201 bool is_abs_literal
)
5203 lit
->r_rel
= *r_rel
;
5205 lit
->is_abs_literal
= is_abs_literal
;
5210 literal_value_equal (const literal_value
*src1
,
5211 const literal_value
*src2
,
5212 bool final_static_link
)
5214 struct elf_link_hash_entry
*h1
, *h2
;
5216 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5219 if (r_reloc_is_const (&src1
->r_rel
))
5220 return (src1
->value
== src2
->value
);
5222 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5223 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5226 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5229 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5232 if (src1
->value
!= src2
->value
)
5235 /* Now check for the same section (if defined) or the same elf_hash
5236 (if undefined or weak). */
5237 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5238 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5239 if (r_reloc_is_defined (&src1
->r_rel
)
5240 && (final_static_link
5241 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5242 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5244 if (r_reloc_get_section (&src1
->r_rel
)
5245 != r_reloc_get_section (&src2
->r_rel
))
5250 /* Require that the hash entries (i.e., symbols) be identical. */
5251 if (h1
!= h2
|| h1
== 0)
5255 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5262 /* Must be power of 2. */
5263 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5265 static value_map_hash_table
*
5266 value_map_hash_table_init (void)
5268 value_map_hash_table
*values
;
5270 values
= (value_map_hash_table
*)
5271 bfd_zmalloc (sizeof (value_map_hash_table
));
5272 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5274 values
->buckets
= (value_map
**)
5275 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5276 if (values
->buckets
== NULL
)
5281 values
->has_last_loc
= false;
5288 value_map_hash_table_delete (value_map_hash_table
*table
)
5290 free (table
->buckets
);
5296 hash_bfd_vma (bfd_vma val
)
5298 return (val
>> 2) + (val
>> 10);
5303 literal_value_hash (const literal_value
*src
)
5307 hash_val
= hash_bfd_vma (src
->value
);
5308 if (!r_reloc_is_const (&src
->r_rel
))
5312 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5313 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5314 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5316 /* Now check for the same section and the same elf_hash. */
5317 if (r_reloc_is_defined (&src
->r_rel
))
5318 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5320 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5321 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5327 /* Check if the specified literal_value has been seen before. */
5330 value_map_get_cached_value (value_map_hash_table
*map
,
5331 const literal_value
*val
,
5332 bool final_static_link
)
5338 idx
= literal_value_hash (val
);
5339 idx
= idx
& (map
->bucket_count
- 1);
5340 bucket
= map
->buckets
[idx
];
5341 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5343 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5350 /* Record a new literal value. It is illegal to call this if VALUE
5351 already has an entry here. */
5354 add_value_map (value_map_hash_table
*map
,
5355 const literal_value
*val
,
5357 bool final_static_link
)
5359 value_map
**bucket_p
;
5362 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5365 bfd_set_error (bfd_error_no_memory
);
5369 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5373 idx
= literal_value_hash (val
);
5374 idx
= idx
& (map
->bucket_count
- 1);
5375 bucket_p
= &map
->buckets
[idx
];
5377 val_e
->next
= *bucket_p
;
5380 /* FIXME: Consider resizing the hash table if we get too many entries. */
5386 /* Lists of text actions (ta_) for narrowing, widening, longcall
5387 conversion, space fill, code & literal removal, etc. */
5389 /* The following text actions are generated:
5391 "ta_remove_insn" remove an instruction or instructions
5392 "ta_remove_longcall" convert longcall to call
5393 "ta_convert_longcall" convert longcall to nop/call
5394 "ta_narrow_insn" narrow a wide instruction
5395 "ta_widen" widen a narrow instruction
5396 "ta_fill" add fill or remove fill
5397 removed < 0 is a fill; branches to the fill address will be
5398 changed to address + fill size (e.g., address - removed)
5399 removed >= 0 branches to the fill address will stay unchanged
5400 "ta_remove_literal" remove a literal; this action is
5401 indicated when a literal is removed
5403 "ta_add_literal" insert a new literal; this action is
5404 indicated when a literal has been moved.
5405 It may use a virtual_offset because
5406 multiple literals can be placed at the
5409 For each of these text actions, we also record the number of bytes
5410 removed by performing the text action. In the case of a "ta_widen"
5411 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5413 typedef struct text_action_struct text_action
;
5414 typedef struct text_action_list_struct text_action_list
;
5415 typedef enum text_action_enum_t text_action_t
;
5417 enum text_action_enum_t
5420 ta_remove_insn
, /* removed = -size */
5421 ta_remove_longcall
, /* removed = -size */
5422 ta_convert_longcall
, /* removed = 0 */
5423 ta_narrow_insn
, /* removed = -1 */
5424 ta_widen_insn
, /* removed = +1 */
5425 ta_fill
, /* removed = +size */
5431 /* Structure for a text action record. */
5432 struct text_action_struct
5434 text_action_t action
;
5435 asection
*sec
; /* Optional */
5437 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5439 literal_value value
; /* Only valid when adding literals. */
5442 struct removal_by_action_entry_struct
5447 int eq_removed_before_fill
;
5449 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5451 struct removal_by_action_map_struct
5454 removal_by_action_entry
*entry
;
5456 typedef struct removal_by_action_map_struct removal_by_action_map
;
5459 /* List of all of the actions taken on a text section. */
5460 struct text_action_list_struct
5464 removal_by_action_map map
;
5468 static text_action
*
5469 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5473 /* It is not necessary to fill at the end of a section. */
5474 if (sec
->size
== offset
)
5480 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5482 return (text_action
*)node
->value
;
5488 compute_removed_action_diff (const text_action
*ta
,
5492 int removable_space
)
5495 int current_removed
= 0;
5498 current_removed
= ta
->removed_bytes
;
5500 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5501 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5503 /* It is not necessary to fill at the end of a section. Clean this up. */
5504 if (sec
->size
== offset
)
5505 new_removed
= removable_space
- 0;
5509 int added
= -removed
- current_removed
;
5510 /* Ignore multiples of the section alignment. */
5511 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5512 new_removed
= (-added
);
5514 /* Modify for removable. */
5515 space
= removable_space
- new_removed
;
5516 new_removed
= (removable_space
5517 - (((1 << sec
->alignment_power
) - 1) & space
));
5519 return (new_removed
- current_removed
);
5524 adjust_fill_action (text_action
*ta
, int fill_diff
)
5526 ta
->removed_bytes
+= fill_diff
;
5531 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5533 text_action
*pa
= (text_action
*)a
;
5534 text_action
*pb
= (text_action
*)b
;
5535 static const int action_priority
[] =
5539 [ta_convert_longcall
] = 2,
5540 [ta_narrow_insn
] = 3,
5541 [ta_remove_insn
] = 4,
5542 [ta_remove_longcall
] = 5,
5543 [ta_remove_literal
] = 6,
5544 [ta_widen_insn
] = 7,
5545 [ta_add_literal
] = 8,
5548 if (pa
->offset
== pb
->offset
)
5550 if (pa
->action
== pb
->action
)
5552 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5555 return pa
->offset
< pb
->offset
? -1 : 1;
5558 static text_action
*
5559 action_first (text_action_list
*action_list
)
5561 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5562 return node
? (text_action
*)node
->value
: NULL
;
5565 static text_action
*
5566 action_next (text_action_list
*action_list
, text_action
*action
)
5568 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5569 (splay_tree_key
)action
);
5570 return node
? (text_action
*)node
->value
: NULL
;
5573 /* Add a modification action to the text. For the case of adding or
5574 removing space, modify any current fill and assume that
5575 "unreachable_space" bytes can be freely contracted. Note that a
5576 negative removed value is a fill. */
5579 text_action_add (text_action_list
*l
,
5580 text_action_t action
,
5588 /* It is not necessary to fill at the end of a section. */
5589 if (action
== ta_fill
&& sec
->size
== offset
)
5592 /* It is not necessary to fill 0 bytes. */
5593 if (action
== ta_fill
&& removed
== 0)
5599 if (action
== ta_fill
)
5601 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5605 ta
= (text_action
*)node
->value
;
5606 ta
->removed_bytes
+= removed
;
5611 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5613 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5614 ta
->action
= action
;
5616 ta
->offset
= offset
;
5617 ta
->removed_bytes
= removed
;
5618 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5624 text_action_add_literal (text_action_list
*l
,
5625 text_action_t action
,
5627 const literal_value
*value
,
5631 asection
*sec
= r_reloc_get_section (loc
);
5632 bfd_vma offset
= loc
->target_offset
;
5633 bfd_vma virtual_offset
= loc
->virtual_offset
;
5635 BFD_ASSERT (action
== ta_add_literal
);
5637 /* Create a new record and fill it up. */
5638 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5639 ta
->action
= action
;
5641 ta
->offset
= offset
;
5642 ta
->virtual_offset
= virtual_offset
;
5644 ta
->removed_bytes
= removed
;
5646 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5647 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5652 /* Find the total offset adjustment for the relaxations specified by
5653 text_actions, beginning from a particular starting action. This is
5654 typically used from offset_with_removed_text to search an entire list of
5655 actions, but it may also be called directly when adjusting adjacent offsets
5656 so that each search may begin where the previous one left off. */
5659 removed_by_actions (text_action_list
*action_list
,
5660 text_action
**p_start_action
,
5667 r
= *p_start_action
;
5670 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5672 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5677 if (r
->offset
> offset
)
5680 if (r
->offset
== offset
5681 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5684 removed
+= r
->removed_bytes
;
5686 r
= action_next (action_list
, r
);
5689 *p_start_action
= r
;
5695 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5697 text_action
*r
= action_first (action_list
);
5699 return offset
- removed_by_actions (action_list
, &r
, offset
, false);
5704 action_list_count (text_action_list
*action_list
)
5706 return action_list
->count
;
5709 typedef struct map_action_fn_context_struct map_action_fn_context
;
5710 struct map_action_fn_context_struct
5713 removal_by_action_map map
;
5718 map_action_fn (splay_tree_node node
, void *p
)
5720 map_action_fn_context
*ctx
= p
;
5721 text_action
*r
= (text_action
*)node
->value
;
5722 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5724 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5730 ++ctx
->map
.n_entries
;
5731 ctx
->eq_complete
= false;
5732 ientry
->offset
= r
->offset
;
5733 ientry
->eq_removed_before_fill
= ctx
->removed
;
5736 if (!ctx
->eq_complete
)
5738 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5740 ientry
->eq_removed
= ctx
->removed
;
5741 ctx
->eq_complete
= true;
5744 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5747 ctx
->removed
+= r
->removed_bytes
;
5748 ientry
->removed
= ctx
->removed
;
5753 map_removal_by_action (text_action_list
*action_list
)
5755 map_action_fn_context ctx
;
5758 ctx
.map
.n_entries
= 0;
5759 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5760 sizeof (removal_by_action_entry
));
5761 ctx
.eq_complete
= false;
5763 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5764 action_list
->map
= ctx
.map
;
5768 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5773 if (!action_list
->map
.entry
)
5774 map_removal_by_action (action_list
);
5776 if (!action_list
->map
.n_entries
)
5780 b
= action_list
->map
.n_entries
;
5784 unsigned c
= (a
+ b
) / 2;
5786 if (action_list
->map
.entry
[c
].offset
<= offset
)
5792 if (action_list
->map
.entry
[a
].offset
< offset
)
5794 return action_list
->map
.entry
[a
].removed
;
5796 else if (action_list
->map
.entry
[a
].offset
== offset
)
5798 return before_fill
?
5799 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5800 action_list
->map
.entry
[a
].eq_removed
;
5809 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5811 int removed
= removed_by_actions_map (action_list
, offset
, false);
5812 return offset
- removed
;
5816 /* The find_insn_action routine will only find non-fill actions. */
5818 static text_action
*
5819 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5821 static const text_action_t action
[] =
5823 ta_convert_longcall
,
5833 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5835 splay_tree_node node
;
5837 a
.action
= action
[i
];
5838 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5840 return (text_action
*)node
->value
;
5849 print_action (FILE *fp
, text_action
*r
)
5851 const char *t
= "unknown";
5854 case ta_remove_insn
:
5855 t
= "remove_insn"; break;
5856 case ta_remove_longcall
:
5857 t
= "remove_longcall"; break;
5858 case ta_convert_longcall
:
5859 t
= "convert_longcall"; break;
5860 case ta_narrow_insn
:
5861 t
= "narrow_insn"; break;
5863 t
= "widen_insn"; break;
5868 case ta_remove_literal
:
5869 t
= "remove_literal"; break;
5870 case ta_add_literal
:
5871 t
= "add_literal"; break;
5874 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5875 r
->sec
->owner
->filename
,
5876 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5880 print_action_list_fn (splay_tree_node node
, void *p
)
5882 text_action
*r
= (text_action
*)node
->value
;
5884 print_action (p
, r
);
5889 print_action_list (FILE *fp
, text_action_list
*action_list
)
5891 fprintf (fp
, "Text Action\n");
5892 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5898 /* Lists of literals being coalesced or removed. */
5900 /* In the usual case, the literal identified by "from" is being
5901 coalesced with another literal identified by "to". If the literal is
5902 unused and is being removed altogether, "to.abfd" will be NULL.
5903 The removed_literal entries are kept on a per-section list, sorted
5904 by the "from" offset field. */
5906 typedef struct removed_literal_struct removed_literal
;
5907 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5908 typedef struct removed_literal_list_struct removed_literal_list
;
5910 struct removed_literal_struct
5914 removed_literal
*next
;
5917 struct removed_literal_map_entry_struct
5920 removed_literal
*literal
;
5923 struct removed_literal_list_struct
5925 removed_literal
*head
;
5926 removed_literal
*tail
;
5929 removed_literal_map_entry
*map
;
5933 /* Record that the literal at "from" is being removed. If "to" is not
5934 NULL, the "from" literal is being coalesced with the "to" literal. */
5937 add_removed_literal (removed_literal_list
*removed_list
,
5938 const r_reloc
*from
,
5941 removed_literal
*r
, *new_r
, *next_r
;
5943 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5945 new_r
->from
= *from
;
5949 new_r
->to
.abfd
= NULL
;
5952 r
= removed_list
->head
;
5955 removed_list
->head
= new_r
;
5956 removed_list
->tail
= new_r
;
5958 /* Special check for common case of append. */
5959 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5961 removed_list
->tail
->next
= new_r
;
5962 removed_list
->tail
= new_r
;
5966 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5972 new_r
->next
= next_r
;
5974 removed_list
->tail
= new_r
;
5979 map_removed_literal (removed_literal_list
*removed_list
)
5983 removed_literal_map_entry
*map
= NULL
;
5984 removed_literal
*r
= removed_list
->head
;
5986 for (i
= 0; r
; ++i
, r
= r
->next
)
5990 n_map
= (n_map
* 2) + 2;
5991 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5993 map
[i
].addr
= r
->from
.target_offset
;
5996 removed_list
->map
= map
;
5997 removed_list
->n_map
= i
;
6001 removed_literal_compare (const void *a
, const void *b
)
6003 const bfd_vma
*key
= a
;
6004 const removed_literal_map_entry
*memb
= b
;
6006 if (*key
== memb
->addr
)
6009 return *key
< memb
->addr
? -1 : 1;
6012 /* Check if the list of removed literals contains an entry for the
6013 given address. Return the entry if found. */
6015 static removed_literal
*
6016 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
6018 removed_literal_map_entry
*p
;
6019 removed_literal
*r
= NULL
;
6021 if (removed_list
->map
== NULL
)
6022 map_removed_literal (removed_list
);
6024 if (removed_list
->map
!= NULL
)
6026 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
6027 sizeof (*removed_list
->map
), removed_literal_compare
);
6030 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
6042 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
6045 r
= removed_list
->head
;
6047 fprintf (fp
, "Removed Literals\n");
6048 for (; r
!= NULL
; r
= r
->next
)
6050 print_r_reloc (fp
, &r
->from
);
6051 fprintf (fp
, " => ");
6052 if (r
->to
.abfd
== NULL
)
6053 fprintf (fp
, "REMOVED");
6055 print_r_reloc (fp
, &r
->to
);
6063 /* Per-section data for relaxation. */
6065 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
6067 struct xtensa_relax_info_struct
6069 bool is_relaxable_literal_section
;
6070 bool is_relaxable_asm_section
;
6071 int visited
; /* Number of times visited. */
6073 source_reloc
*src_relocs
; /* Array[src_count]. */
6075 int src_next
; /* Next src_relocs entry to assign. */
6077 removed_literal_list removed_list
;
6078 text_action_list action_list
;
6080 reloc_bfd_fix
*fix_list
;
6081 reloc_bfd_fix
*fix_array
;
6082 unsigned fix_array_count
;
6084 /* Support for expanding the reloc array that is stored
6085 in the section structure. If the relocations have been
6086 reallocated, the newly allocated relocations will be referenced
6087 here along with the actual size allocated. The relocation
6088 count will always be found in the section structure. */
6089 Elf_Internal_Rela
*allocated_relocs
;
6090 unsigned relocs_count
;
6091 unsigned allocated_relocs_count
;
6094 struct elf_xtensa_section_data
6096 struct bfd_elf_section_data elf
;
6097 xtensa_relax_info relax_info
;
6102 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
6104 if (!sec
->used_by_bfd
)
6106 struct elf_xtensa_section_data
*sdata
;
6107 size_t amt
= sizeof (*sdata
);
6109 sdata
= bfd_zalloc (abfd
, amt
);
6112 sec
->used_by_bfd
= sdata
;
6115 return _bfd_elf_new_section_hook (abfd
, sec
);
6119 static xtensa_relax_info
*
6120 get_xtensa_relax_info (asection
*sec
)
6122 struct elf_xtensa_section_data
*section_data
;
6124 /* No info available if no section or if it is an output section. */
6125 if (!sec
|| sec
== sec
->output_section
)
6128 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
6129 return §ion_data
->relax_info
;
6134 init_xtensa_relax_info (asection
*sec
)
6136 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6138 relax_info
->is_relaxable_literal_section
= false;
6139 relax_info
->is_relaxable_asm_section
= false;
6140 relax_info
->visited
= 0;
6142 relax_info
->src_relocs
= NULL
;
6143 relax_info
->src_count
= 0;
6144 relax_info
->src_next
= 0;
6146 relax_info
->removed_list
.head
= NULL
;
6147 relax_info
->removed_list
.tail
= NULL
;
6149 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6151 relax_info
->action_list
.map
.n_entries
= 0;
6152 relax_info
->action_list
.map
.entry
= NULL
;
6154 relax_info
->fix_list
= NULL
;
6155 relax_info
->fix_array
= NULL
;
6156 relax_info
->fix_array_count
= 0;
6158 relax_info
->allocated_relocs
= NULL
;
6159 relax_info
->relocs_count
= 0;
6160 relax_info
->allocated_relocs_count
= 0;
6164 /* Coalescing literals may require a relocation to refer to a section in
6165 a different input file, but the standard relocation information
6166 cannot express that. Instead, the reloc_bfd_fix structures are used
6167 to "fix" the relocations that refer to sections in other input files.
6168 These structures are kept on per-section lists. The "src_type" field
6169 records the relocation type in case there are multiple relocations on
6170 the same location. FIXME: This is ugly; an alternative might be to
6171 add new symbols with the "owner" field to some other input file. */
6173 struct reloc_bfd_fix_struct
6177 unsigned src_type
; /* Relocation type. */
6179 asection
*target_sec
;
6180 bfd_vma target_offset
;
6183 reloc_bfd_fix
*next
;
6187 static reloc_bfd_fix
*
6188 reloc_bfd_fix_init (asection
*src_sec
,
6191 asection
*target_sec
,
6192 bfd_vma target_offset
,
6197 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6198 fix
->src_sec
= src_sec
;
6199 fix
->src_offset
= src_offset
;
6200 fix
->src_type
= src_type
;
6201 fix
->target_sec
= target_sec
;
6202 fix
->target_offset
= target_offset
;
6203 fix
->translated
= translated
;
6210 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6212 xtensa_relax_info
*relax_info
;
6214 relax_info
= get_xtensa_relax_info (src_sec
);
6215 fix
->next
= relax_info
->fix_list
;
6216 relax_info
->fix_list
= fix
;
6221 fix_compare (const void *ap
, const void *bp
)
6223 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6224 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6226 if (a
->src_offset
!= b
->src_offset
)
6227 return (a
->src_offset
- b
->src_offset
);
6228 return (a
->src_type
- b
->src_type
);
6233 cache_fix_array (asection
*sec
)
6235 unsigned i
, count
= 0;
6237 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6239 if (relax_info
== NULL
)
6241 if (relax_info
->fix_list
== NULL
)
6244 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6247 relax_info
->fix_array
=
6248 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6249 relax_info
->fix_array_count
= count
;
6251 r
= relax_info
->fix_list
;
6252 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6254 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6255 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6258 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6259 sizeof (reloc_bfd_fix
), fix_compare
);
6263 static reloc_bfd_fix
*
6264 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6266 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6270 if (relax_info
== NULL
)
6272 if (relax_info
->fix_list
== NULL
)
6275 if (relax_info
->fix_array
== NULL
)
6276 cache_fix_array (sec
);
6278 key
.src_offset
= offset
;
6279 key
.src_type
= type
;
6280 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6281 sizeof (reloc_bfd_fix
), fix_compare
);
6286 /* Section caching. */
6288 typedef struct section_cache_struct section_cache_t
;
6290 struct section_cache_struct
6294 bfd_byte
*contents
; /* Cache of the section contents. */
6295 bfd_size_type content_length
;
6297 property_table_entry
*ptbl
; /* Cache of the section property table. */
6300 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6301 unsigned reloc_count
;
6306 init_section_cache (section_cache_t
*sec_cache
)
6308 memset (sec_cache
, 0, sizeof (*sec_cache
));
6313 free_section_cache (section_cache_t
*sec_cache
)
6317 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6318 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6319 free (sec_cache
->ptbl
);
6325 section_cache_section (section_cache_t
*sec_cache
,
6327 struct bfd_link_info
*link_info
)
6330 property_table_entry
*prop_table
= NULL
;
6332 bfd_byte
*contents
= NULL
;
6333 Elf_Internal_Rela
*internal_relocs
= NULL
;
6334 bfd_size_type sec_size
;
6338 if (sec
== sec_cache
->sec
)
6342 sec_size
= bfd_get_section_limit (abfd
, sec
);
6344 /* Get the contents. */
6345 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6346 if (contents
== NULL
&& sec_size
!= 0)
6349 /* Get the relocations. */
6350 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6351 link_info
->keep_memory
);
6353 /* Get the entry table. */
6354 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6355 XTENSA_PROP_SEC_NAME
, false);
6359 /* Fill in the new section cache. */
6360 free_section_cache (sec_cache
);
6361 init_section_cache (sec_cache
);
6363 sec_cache
->sec
= sec
;
6364 sec_cache
->contents
= contents
;
6365 sec_cache
->content_length
= sec_size
;
6366 sec_cache
->relocs
= internal_relocs
;
6367 sec_cache
->reloc_count
= sec
->reloc_count
;
6368 sec_cache
->pte_count
= ptblsize
;
6369 sec_cache
->ptbl
= prop_table
;
6374 release_contents (sec
, contents
);
6375 release_internal_relocs (sec
, internal_relocs
);
6381 /* Extended basic blocks. */
6383 /* An ebb_struct represents an Extended Basic Block. Within this
6384 range, we guarantee that all instructions are decodable, the
6385 property table entries are contiguous, and no property table
6386 specifies a segment that cannot have instructions moved. This
6387 structure contains caches of the contents, property table and
6388 relocations for the specified section for easy use. The range is
6389 specified by ranges of indices for the byte offset, property table
6390 offsets and relocation offsets. These must be consistent. */
6392 typedef struct ebb_struct ebb_t
;
6398 bfd_byte
*contents
; /* Cache of the section contents. */
6399 bfd_size_type content_length
;
6401 property_table_entry
*ptbl
; /* Cache of the section property table. */
6404 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6405 unsigned reloc_count
;
6407 bfd_vma start_offset
; /* Offset in section. */
6408 unsigned start_ptbl_idx
; /* Offset in the property table. */
6409 unsigned start_reloc_idx
; /* Offset in the relocations. */
6412 unsigned end_ptbl_idx
;
6413 unsigned end_reloc_idx
;
6415 bool ends_section
; /* Is this the last ebb in a section? */
6417 /* The unreachable property table at the end of this set of blocks;
6418 NULL if the end is not an unreachable block. */
6419 property_table_entry
*ends_unreachable
;
6423 enum ebb_target_enum
6426 EBB_DESIRE_TGT_ALIGN
,
6427 EBB_REQUIRE_TGT_ALIGN
,
6428 EBB_REQUIRE_LOOP_ALIGN
,
6433 /* proposed_action_struct is similar to the text_action_struct except
6434 that is represents a potential transformation, not one that will
6435 occur. We build a list of these for an extended basic block
6436 and use them to compute the actual actions desired. We must be
6437 careful that the entire set of actual actions we perform do not
6438 break any relocations that would fit if the actions were not
6441 typedef struct proposed_action_struct proposed_action
;
6443 struct proposed_action_struct
6445 enum ebb_target_enum align_type
; /* for the target alignment */
6446 bfd_vma alignment_pow
;
6447 text_action_t action
;
6450 bool do_action
; /* If false, then we will not perform the action. */
6454 /* The ebb_constraint_struct keeps a set of proposed actions for an
6455 extended basic block. */
6457 typedef struct ebb_constraint_struct ebb_constraint
;
6459 struct ebb_constraint_struct
6464 /* Bytes of extra space at the beginning if movable. */
6465 int start_extra_space
;
6467 enum ebb_target_enum start_align
;
6471 /* Bytes of extra space at the end if movable. */
6472 int end_extra_space
;
6474 unsigned action_count
;
6475 unsigned action_allocated
;
6477 /* Array of proposed actions. */
6478 proposed_action
*actions
;
6480 /* Action alignments -- one for each proposed action. */
6481 enum ebb_target_enum
*action_aligns
;
6486 init_ebb_constraint (ebb_constraint
*c
)
6488 memset (c
, 0, sizeof (ebb_constraint
));
6493 free_ebb_constraint (ebb_constraint
*c
)
6500 init_ebb (ebb_t
*ebb
,
6503 bfd_size_type content_length
,
6504 property_table_entry
*prop_table
,
6506 Elf_Internal_Rela
*internal_relocs
,
6507 unsigned reloc_count
)
6509 memset (ebb
, 0, sizeof (ebb_t
));
6511 ebb
->contents
= contents
;
6512 ebb
->content_length
= content_length
;
6513 ebb
->ptbl
= prop_table
;
6514 ebb
->pte_count
= ptblsize
;
6515 ebb
->relocs
= internal_relocs
;
6516 ebb
->reloc_count
= reloc_count
;
6517 ebb
->start_offset
= 0;
6518 ebb
->end_offset
= ebb
->content_length
- 1;
6519 ebb
->start_ptbl_idx
= 0;
6520 ebb
->end_ptbl_idx
= ptblsize
;
6521 ebb
->start_reloc_idx
= 0;
6522 ebb
->end_reloc_idx
= reloc_count
;
6526 /* Extend the ebb to all decodable contiguous sections. The algorithm
6527 for building a basic block around an instruction is to push it
6528 forward until we hit the end of a section, an unreachable block or
6529 a block that cannot be transformed. Then we push it backwards
6530 searching for similar conditions. */
6532 static bool extend_ebb_bounds_forward (ebb_t
*);
6533 static bool extend_ebb_bounds_backward (ebb_t
*);
6534 static bfd_size_type insn_block_decodable_len
6535 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6538 extend_ebb_bounds (ebb_t
*ebb
)
6540 if (!extend_ebb_bounds_forward (ebb
))
6542 if (!extend_ebb_bounds_backward (ebb
))
6549 extend_ebb_bounds_forward (ebb_t
*ebb
)
6551 property_table_entry
*the_entry
, *new_entry
;
6553 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6555 /* Stop when (1) we cannot decode an instruction, (2) we are at
6556 the end of the property tables, (3) we hit a non-contiguous property
6557 table entry, (4) we hit a NO_TRANSFORM region. */
6562 bfd_size_type insn_block_len
;
6564 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6566 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6568 entry_end
- ebb
->end_offset
);
6569 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6572 /* xgettext:c-format */
6573 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6574 "possible configuration mismatch"),
6575 ebb
->sec
->owner
, ebb
->sec
,
6576 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6579 ebb
->end_offset
+= insn_block_len
;
6581 if (ebb
->end_offset
== ebb
->sec
->size
)
6582 ebb
->ends_section
= true;
6584 /* Update the reloc counter. */
6585 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6586 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6589 ebb
->end_reloc_idx
++;
6592 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6595 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6596 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6597 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6598 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6601 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6604 the_entry
= new_entry
;
6605 ebb
->end_ptbl_idx
++;
6608 /* Quick check for an unreachable or end of file just at the end. */
6609 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6611 if (ebb
->end_offset
== ebb
->content_length
)
6612 ebb
->ends_section
= true;
6616 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6617 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6618 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6619 ebb
->ends_unreachable
= new_entry
;
6622 /* Any other ending requires exact alignment. */
6628 extend_ebb_bounds_backward (ebb_t
*ebb
)
6630 property_table_entry
*the_entry
, *new_entry
;
6632 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6634 /* Stop when (1) we cannot decode the instructions in the current entry.
6635 (2) we are at the beginning of the property tables, (3) we hit a
6636 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6640 bfd_vma block_begin
;
6641 bfd_size_type insn_block_len
;
6643 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6645 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6647 ebb
->start_offset
- block_begin
);
6648 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6651 /* xgettext:c-format */
6652 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6653 "possible configuration mismatch"),
6654 ebb
->sec
->owner
, ebb
->sec
,
6655 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6658 ebb
->start_offset
-= insn_block_len
;
6660 /* Update the reloc counter. */
6661 while (ebb
->start_reloc_idx
> 0
6662 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6663 >= ebb
->start_offset
))
6665 ebb
->start_reloc_idx
--;
6668 if (ebb
->start_ptbl_idx
== 0)
6671 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6672 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6673 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6674 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6676 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6679 the_entry
= new_entry
;
6680 ebb
->start_ptbl_idx
--;
6686 static bfd_size_type
6687 insn_block_decodable_len (bfd_byte
*contents
,
6688 bfd_size_type content_len
,
6689 bfd_vma block_offset
,
6690 bfd_size_type block_len
)
6692 bfd_vma offset
= block_offset
;
6694 while (offset
< block_offset
+ block_len
)
6696 bfd_size_type insn_len
= 0;
6698 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6700 return (offset
- block_offset
);
6703 return (offset
- block_offset
);
6708 ebb_propose_action (ebb_constraint
*c
,
6709 enum ebb_target_enum align_type
,
6710 bfd_vma alignment_pow
,
6711 text_action_t action
,
6716 proposed_action
*act
;
6718 if (c
->action_allocated
<= c
->action_count
)
6720 unsigned new_allocated
, i
;
6721 proposed_action
*new_actions
;
6723 new_allocated
= (c
->action_count
+ 2) * 2;
6724 new_actions
= (proposed_action
*)
6725 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6727 for (i
= 0; i
< c
->action_count
; i
++)
6728 new_actions
[i
] = c
->actions
[i
];
6730 c
->actions
= new_actions
;
6731 c
->action_allocated
= new_allocated
;
6734 act
= &c
->actions
[c
->action_count
];
6735 act
->align_type
= align_type
;
6736 act
->alignment_pow
= alignment_pow
;
6737 act
->action
= action
;
6738 act
->offset
= offset
;
6739 act
->removed_bytes
= removed_bytes
;
6740 act
->do_action
= do_action
;
6746 /* Access to internal relocations, section contents and symbols. */
6748 /* During relaxation, we need to modify relocations, section contents,
6749 and symbol definitions, and we need to keep the original values from
6750 being reloaded from the input files, i.e., we need to "pin" the
6751 modified values in memory. We also want to continue to observe the
6752 setting of the "keep-memory" flag. The following functions wrap the
6753 standard BFD functions to take care of this for us. */
6755 static Elf_Internal_Rela
*
6756 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bool keep_memory
)
6758 Elf_Internal_Rela
*internal_relocs
;
6760 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6763 internal_relocs
= elf_section_data (sec
)->relocs
;
6764 if (internal_relocs
== NULL
)
6765 internal_relocs
= (_bfd_elf_link_read_relocs
6766 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6767 return internal_relocs
;
6772 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6774 elf_section_data (sec
)->relocs
= internal_relocs
;
6779 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6781 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
6782 free (internal_relocs
);
6787 retrieve_contents (bfd
*abfd
, asection
*sec
, bool keep_memory
)
6790 bfd_size_type sec_size
;
6792 sec_size
= bfd_get_section_limit (abfd
, sec
);
6793 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6795 if (contents
== NULL
&& sec_size
!= 0)
6797 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6803 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6810 pin_contents (asection
*sec
, bfd_byte
*contents
)
6812 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6817 release_contents (asection
*sec
, bfd_byte
*contents
)
6819 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6824 static Elf_Internal_Sym
*
6825 retrieve_local_syms (bfd
*input_bfd
)
6827 Elf_Internal_Shdr
*symtab_hdr
;
6828 Elf_Internal_Sym
*isymbuf
;
6831 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6832 locsymcount
= symtab_hdr
->sh_info
;
6834 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6835 if (isymbuf
== NULL
&& locsymcount
!= 0)
6836 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6839 /* Save the symbols for this input file so they won't be read again. */
6840 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6841 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6847 /* Code for link-time relaxation. */
6849 /* Initialization for relaxation: */
6850 static bool analyze_relocations (struct bfd_link_info
*);
6851 static bool find_relaxable_sections
6852 (bfd
*, asection
*, struct bfd_link_info
*, bool *);
6853 static bool collect_source_relocs
6854 (bfd
*, asection
*, struct bfd_link_info
*);
6855 static bool is_resolvable_asm_expansion
6856 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6858 static Elf_Internal_Rela
*find_associated_l32r_irel
6859 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6860 static bool compute_text_actions
6861 (bfd
*, asection
*, struct bfd_link_info
*);
6862 static bool compute_ebb_proposed_actions (ebb_constraint
*);
6863 static bool compute_ebb_actions (ebb_constraint
*);
6864 typedef struct reloc_range_list_struct reloc_range_list
;
6865 static bool check_section_ebb_pcrels_fit
6866 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6867 reloc_range_list
*, const ebb_constraint
*,
6868 const xtensa_opcode
*);
6869 static bool check_section_ebb_reduces (const ebb_constraint
*);
6870 static void text_action_add_proposed
6871 (text_action_list
*, const ebb_constraint
*, asection
*);
6874 static bool compute_removed_literals
6875 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6876 static Elf_Internal_Rela
*get_irel_at_offset
6877 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6878 static bool is_removable_literal
6879 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6880 property_table_entry
*, int);
6881 static bool remove_dead_literal
6882 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6883 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6884 static bool identify_literal_placement
6885 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6886 value_map_hash_table
*, bool *, Elf_Internal_Rela
*, int,
6887 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6889 static bool relocations_reach (source_reloc
*, int, const r_reloc
*);
6890 static bool coalesce_shared_literal
6891 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6892 static bool move_shared_literal
6893 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6894 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6897 static bool relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6898 static bool translate_section_fixes (asection
*);
6899 static bool translate_reloc_bfd_fix (reloc_bfd_fix
*);
6900 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6901 static void shrink_dynamic_reloc_sections
6902 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6903 static bool move_literal
6904 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6905 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6906 static bool relax_property_section
6907 (bfd
*, asection
*, struct bfd_link_info
*);
6910 static bool relax_section_symbols (bfd
*, asection
*);
6914 elf_xtensa_relax_section (bfd
*abfd
,
6916 struct bfd_link_info
*link_info
,
6919 static value_map_hash_table
*values
= NULL
;
6920 static bool relocations_analyzed
= false;
6921 xtensa_relax_info
*relax_info
;
6923 if (!relocations_analyzed
)
6925 /* Do some overall initialization for relaxation. */
6926 values
= value_map_hash_table_init ();
6929 relaxing_section
= true;
6930 if (!analyze_relocations (link_info
))
6932 relocations_analyzed
= true;
6936 /* Don't mess with linker-created sections. */
6937 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6940 relax_info
= get_xtensa_relax_info (sec
);
6941 BFD_ASSERT (relax_info
!= NULL
);
6943 switch (relax_info
->visited
)
6946 /* Note: It would be nice to fold this pass into
6947 analyze_relocations, but it is important for this step that the
6948 sections be examined in link order. */
6949 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6956 value_map_hash_table_delete (values
);
6958 if (!relax_section (abfd
, sec
, link_info
))
6964 if (!relax_section_symbols (abfd
, sec
))
6969 relax_info
->visited
++;
6974 /* Initialization for relaxation. */
6976 /* This function is called once at the start of relaxation. It scans
6977 all the input sections and marks the ones that are relaxable (i.e.,
6978 literal sections with L32R relocations against them), and then
6979 collects source_reloc information for all the relocations against
6980 those relaxable sections. During this process, it also detects
6981 longcalls, i.e., calls relaxed by the assembler into indirect
6982 calls, that can be optimized back into direct calls. Within each
6983 extended basic block (ebb) containing an optimized longcall, it
6984 computes a set of "text actions" that can be performed to remove
6985 the L32R associated with the longcall while optionally preserving
6986 branch target alignments. */
6989 analyze_relocations (struct bfd_link_info
*link_info
)
6993 bool is_relaxable
= false;
6995 /* Initialize the per-section relaxation info. */
6996 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6997 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6999 init_xtensa_relax_info (sec
);
7002 /* Mark relaxable sections (and count relocations against each one). */
7003 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7004 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7006 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
7010 /* Bail out if there are no relaxable sections. */
7014 /* Allocate space for source_relocs. */
7015 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7016 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7018 xtensa_relax_info
*relax_info
;
7020 relax_info
= get_xtensa_relax_info (sec
);
7021 if (relax_info
->is_relaxable_literal_section
7022 || relax_info
->is_relaxable_asm_section
)
7024 relax_info
->src_relocs
= (source_reloc
*)
7025 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
7028 relax_info
->src_count
= 0;
7031 /* Collect info on relocations against each relaxable section. */
7032 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7033 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7035 if (!collect_source_relocs (abfd
, sec
, link_info
))
7039 /* Compute the text actions. */
7040 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7041 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7043 if (!compute_text_actions (abfd
, sec
, link_info
))
7051 /* Find all the sections that might be relaxed. The motivation for
7052 this pass is that collect_source_relocs() needs to record _all_ the
7053 relocations that target each relaxable section. That is expensive
7054 and unnecessary unless the target section is actually going to be
7055 relaxed. This pass identifies all such sections by checking if
7056 they have L32Rs pointing to them. In the process, the total number
7057 of relocations targeting each section is also counted so that we
7058 know how much space to allocate for source_relocs against each
7059 relaxable literal section. */
7062 find_relaxable_sections (bfd
*abfd
,
7064 struct bfd_link_info
*link_info
,
7065 bool *is_relaxable_p
)
7067 Elf_Internal_Rela
*internal_relocs
;
7071 xtensa_relax_info
*source_relax_info
;
7074 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7075 link_info
->keep_memory
);
7076 if (internal_relocs
== NULL
)
7079 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7080 if (contents
== NULL
&& sec
->size
!= 0)
7086 source_relax_info
= get_xtensa_relax_info (sec
);
7087 for (i
= 0; i
< sec
->reloc_count
; i
++)
7089 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7091 asection
*target_sec
;
7092 xtensa_relax_info
*target_relax_info
;
7094 /* If this section has not already been marked as "relaxable", and
7095 if it contains any ASM_EXPAND relocations (marking expanded
7096 longcalls) that can be optimized into direct calls, then mark
7097 the section as "relaxable". */
7098 if (source_relax_info
7099 && !source_relax_info
->is_relaxable_asm_section
7100 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
7102 bool is_reachable
= false;
7103 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
7104 link_info
, &is_reachable
)
7107 source_relax_info
->is_relaxable_asm_section
= true;
7108 *is_relaxable_p
= true;
7112 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7113 bfd_get_section_limit (abfd
, sec
));
7115 target_sec
= r_reloc_get_section (&r_rel
);
7116 target_relax_info
= get_xtensa_relax_info (target_sec
);
7117 if (!target_relax_info
)
7120 /* Count PC-relative operand relocations against the target section.
7121 Note: The conditions tested here must match the conditions under
7122 which init_source_reloc is called in collect_source_relocs(). */
7123 is_l32r_reloc
= false;
7124 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7126 xtensa_opcode opcode
=
7127 get_relocation_opcode (abfd
, sec
, contents
, irel
);
7128 if (opcode
!= XTENSA_UNDEFINED
)
7130 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
7131 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
7133 target_relax_info
->src_count
++;
7137 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7139 /* Mark the target section as relaxable. */
7140 target_relax_info
->is_relaxable_literal_section
= true;
7141 *is_relaxable_p
= true;
7146 release_contents (sec
, contents
);
7147 release_internal_relocs (sec
, internal_relocs
);
7152 /* Record _all_ the relocations that point to relaxable sections, and
7153 get rid of ASM_EXPAND relocs by either converting them to
7154 ASM_SIMPLIFY or by removing them. */
7157 collect_source_relocs (bfd
*abfd
,
7159 struct bfd_link_info
*link_info
)
7161 Elf_Internal_Rela
*internal_relocs
;
7165 bfd_size_type sec_size
;
7167 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7168 link_info
->keep_memory
);
7169 if (internal_relocs
== NULL
)
7172 sec_size
= bfd_get_section_limit (abfd
, sec
);
7173 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7174 if (contents
== NULL
&& sec_size
!= 0)
7180 /* Record relocations against relaxable literal sections. */
7181 for (i
= 0; i
< sec
->reloc_count
; i
++)
7183 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7185 asection
*target_sec
;
7186 xtensa_relax_info
*target_relax_info
;
7188 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7190 target_sec
= r_reloc_get_section (&r_rel
);
7191 target_relax_info
= get_xtensa_relax_info (target_sec
);
7193 if (target_relax_info
7194 && (target_relax_info
->is_relaxable_literal_section
7195 || target_relax_info
->is_relaxable_asm_section
))
7197 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7199 bool is_abs_literal
= false;
7201 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7203 /* None of the current alternate relocs are PC-relative,
7204 and only PC-relative relocs matter here. However, we
7205 still need to record the opcode for literal
7207 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7208 if (opcode
== get_l32r_opcode ())
7210 is_abs_literal
= true;
7214 opcode
= XTENSA_UNDEFINED
;
7216 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7218 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7219 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7222 if (opcode
!= XTENSA_UNDEFINED
)
7224 int src_next
= target_relax_info
->src_next
++;
7225 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7227 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7233 /* Now get rid of ASM_EXPAND relocations. At this point, the
7234 src_relocs array for the target literal section may still be
7235 incomplete, but it must at least contain the entries for the L32R
7236 relocations associated with ASM_EXPANDs because they were just
7237 added in the preceding loop over the relocations. */
7239 for (i
= 0; i
< sec
->reloc_count
; i
++)
7241 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7244 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7250 Elf_Internal_Rela
*l32r_irel
;
7252 asection
*target_sec
;
7253 xtensa_relax_info
*target_relax_info
;
7255 /* Mark the source_reloc for the L32R so that it will be
7256 removed in compute_removed_literals(), along with the
7257 associated literal. */
7258 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7259 irel
, internal_relocs
);
7260 if (l32r_irel
== NULL
)
7263 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7265 target_sec
= r_reloc_get_section (&r_rel
);
7266 target_relax_info
= get_xtensa_relax_info (target_sec
);
7268 if (target_relax_info
7269 && (target_relax_info
->is_relaxable_literal_section
7270 || target_relax_info
->is_relaxable_asm_section
))
7272 source_reloc
*s_reloc
;
7274 /* Search the source_relocs for the entry corresponding to
7275 the l32r_irel. Note: The src_relocs array is not yet
7276 sorted, but it wouldn't matter anyway because we're
7277 searching by source offset instead of target offset. */
7278 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7279 target_relax_info
->src_next
,
7281 BFD_ASSERT (s_reloc
);
7282 s_reloc
->is_null
= true;
7285 /* Convert this reloc to ASM_SIMPLIFY. */
7286 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7287 R_XTENSA_ASM_SIMPLIFY
);
7288 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7290 pin_internal_relocs (sec
, internal_relocs
);
7294 /* It is resolvable but doesn't reach. We resolve now
7295 by eliminating the relocation -- the call will remain
7296 expanded into L32R/CALLX. */
7297 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7298 pin_internal_relocs (sec
, internal_relocs
);
7303 release_contents (sec
, contents
);
7304 release_internal_relocs (sec
, internal_relocs
);
7309 /* Return TRUE if the asm expansion can be resolved. Generally it can
7310 be resolved on a final link or when a partial link locates it in the
7311 same section as the target. Set "is_reachable" flag if the target of
7312 the call is within the range of a direct call, given the current VMA
7313 for this section and the target section. */
7316 is_resolvable_asm_expansion (bfd
*abfd
,
7319 Elf_Internal_Rela
*irel
,
7320 struct bfd_link_info
*link_info
,
7321 bool *is_reachable_p
)
7323 asection
*target_sec
;
7327 unsigned int first_align
;
7328 unsigned int adjust
;
7329 bfd_vma target_offset
;
7331 xtensa_opcode opcode
, direct_call_opcode
;
7332 bfd_vma self_address
;
7333 bfd_vma dest_address
;
7335 bfd_size_type sec_size
;
7337 *is_reachable_p
= false;
7339 if (contents
== NULL
)
7342 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7345 sec_size
= bfd_get_section_limit (abfd
, sec
);
7346 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7347 sec_size
- irel
->r_offset
, &uses_l32r
);
7348 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7352 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7353 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7356 /* Check and see that the target resolves. */
7357 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7358 if (!r_reloc_is_defined (&r_rel
))
7361 target_sec
= r_reloc_get_section (&r_rel
);
7362 target_offset
= r_rel
.target_offset
;
7364 /* If the target is in a shared library, then it doesn't reach. This
7365 isn't supposed to come up because the compiler should never generate
7366 non-PIC calls on systems that use shared libraries, but the linker
7367 shouldn't crash regardless. */
7368 if (!target_sec
->output_section
)
7371 /* For relocatable sections, we can only simplify when the output
7372 section of the target is the same as the output section of the
7374 if (bfd_link_relocatable (link_info
)
7375 && (target_sec
->output_section
!= sec
->output_section
7376 || is_reloc_sym_weak (abfd
, irel
)))
7379 if (target_sec
->output_section
!= sec
->output_section
)
7381 /* If the two sections are sufficiently far away that relaxation
7382 might take the call out of range, we can't simplify. For
7383 example, a positive displacement call into another memory
7384 could get moved to a lower address due to literal removal,
7385 but the destination won't move, and so the displacment might
7388 If the displacement is negative, assume the destination could
7389 move as far back as the start of the output section. The
7390 self_address will be at least as far into the output section
7391 as it is prior to relaxation.
7393 If the displacement is postive, assume the destination will be in
7394 it's pre-relaxed location (because relaxation only makes sections
7395 smaller). The self_address could go all the way to the beginning
7396 of the output section. */
7398 dest_address
= target_sec
->output_section
->vma
;
7399 self_address
= sec
->output_section
->vma
;
7401 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7402 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7404 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7405 /* Call targets should be four-byte aligned. */
7406 dest_address
= (dest_address
+ 3) & ~3;
7411 self_address
= (sec
->output_section
->vma
7412 + sec
->output_offset
+ irel
->r_offset
+ 3);
7413 dest_address
= (target_sec
->output_section
->vma
7414 + target_sec
->output_offset
+ target_offset
);
7417 /* Adjust addresses with alignments for the worst case to see if call insn
7418 can fit. Don't relax l32r + callx to call if the target can be out of
7419 range due to alignment.
7420 Caller and target addresses are highest and lowest address.
7421 Search all sections between caller and target, looking for max alignment.
7422 The adjustment is max alignment bytes. If the alignment at the lowest
7423 address is less than the adjustment, apply the adjustment to highest
7426 /* Start from lowest address.
7427 Lowest address aligmnet is from input section.
7428 Initial alignment (adjust) is from input section. */
7429 if (dest_address
> self_address
)
7431 s
= sec
->output_section
;
7432 last_vma
= dest_address
;
7433 first_align
= sec
->alignment_power
;
7434 adjust
= target_sec
->alignment_power
;
7438 s
= target_sec
->output_section
;
7439 last_vma
= self_address
;
7440 first_align
= target_sec
->alignment_power
;
7441 adjust
= sec
->alignment_power
;
7446 /* Find the largest alignment in output section list. */
7447 for (; s
&& s
->vma
>= first_vma
&& s
->vma
<= last_vma
; s
= s
->next
)
7449 if (s
->alignment_power
> adjust
)
7450 adjust
= s
->alignment_power
;
7453 if (adjust
> first_align
)
7455 /* Alignment may enlarge the range, adjust highest address. */
7456 adjust
= 1 << adjust
;
7457 if (dest_address
> self_address
)
7459 dest_address
+= adjust
;
7463 self_address
+= adjust
;
7467 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7468 self_address
, dest_address
);
7470 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7471 (dest_address
>> CALL_SEGMENT_BITS
))
7478 static Elf_Internal_Rela
*
7479 find_associated_l32r_irel (bfd
*abfd
,
7482 Elf_Internal_Rela
*other_irel
,
7483 Elf_Internal_Rela
*internal_relocs
)
7487 for (i
= 0; i
< sec
->reloc_count
; i
++)
7489 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7491 if (irel
== other_irel
)
7493 if (irel
->r_offset
!= other_irel
->r_offset
)
7495 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7503 static xtensa_opcode
*
7504 build_reloc_opcodes (bfd
*abfd
,
7507 Elf_Internal_Rela
*internal_relocs
)
7510 xtensa_opcode
*reloc_opcodes
=
7511 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7512 for (i
= 0; i
< sec
->reloc_count
; i
++)
7514 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7515 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7517 return reloc_opcodes
;
7520 struct reloc_range_struct
7523 bool add
; /* TRUE if start of a range, FALSE otherwise. */
7524 /* Original irel index in the array of relocations for a section. */
7525 unsigned irel_index
;
7527 typedef struct reloc_range_struct reloc_range
;
7529 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7530 struct reloc_range_list_entry_struct
7532 reloc_range_list_entry
*next
;
7533 reloc_range_list_entry
*prev
;
7534 Elf_Internal_Rela
*irel
;
7535 xtensa_opcode opcode
;
7539 struct reloc_range_list_struct
7541 /* The rest of the structure is only meaningful when ok is TRUE. */
7544 unsigned n_range
; /* Number of range markers. */
7545 reloc_range
*range
; /* Sorted range markers. */
7547 unsigned first
; /* Index of a first range element in the list. */
7548 unsigned last
; /* One past index of a last range element in the list. */
7550 unsigned n_list
; /* Number of list elements. */
7551 reloc_range_list_entry
*reloc
; /* */
7552 reloc_range_list_entry list_root
;
7556 reloc_range_compare (const void *a
, const void *b
)
7558 const reloc_range
*ra
= a
;
7559 const reloc_range
*rb
= b
;
7561 if (ra
->addr
!= rb
->addr
)
7562 return ra
->addr
< rb
->addr
? -1 : 1;
7563 if (ra
->add
!= rb
->add
)
7564 return ra
->add
? -1 : 1;
7569 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7571 Elf_Internal_Rela
*internal_relocs
,
7572 xtensa_opcode
*reloc_opcodes
,
7573 reloc_range_list
*list
)
7578 reloc_range
*ranges
= NULL
;
7579 reloc_range_list_entry
*reloc
=
7580 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7582 memset (list
, 0, sizeof (*list
));
7585 for (i
= 0; i
< sec
->reloc_count
; i
++)
7587 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7588 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7589 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7592 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7593 || r_type
== R_XTENSA_32_PCREL
7594 || !howto
->pc_relative
)
7597 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7598 bfd_get_section_limit (abfd
, sec
));
7600 if (r_reloc_get_section (&r_rel
) != sec
)
7605 max_n
= (max_n
+ 2) * 2;
7606 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7609 ranges
[n
].addr
= irel
->r_offset
;
7610 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7612 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7613 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7615 ranges
[n
].irel_index
= i
;
7616 ranges
[n
+ 1].irel_index
= i
;
7620 reloc
[i
].irel
= irel
;
7622 /* Every relocation won't possibly be checked in the optimized version of
7623 check_section_ebb_pcrels_fit, so this needs to be done here. */
7624 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7626 /* None of the current alternate relocs are PC-relative,
7627 and only PC-relative relocs matter here. */
7631 xtensa_opcode opcode
;
7635 opcode
= reloc_opcodes
[i
];
7637 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7639 if (opcode
== XTENSA_UNDEFINED
)
7645 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7646 if (opnum
== XTENSA_UNDEFINED
)
7652 /* Record relocation opcode and opnum as we've calculated them
7653 anyway and they won't change. */
7654 reloc
[i
].opcode
= opcode
;
7655 reloc
[i
].opnum
= opnum
;
7661 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7662 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7665 list
->range
= ranges
;
7666 list
->reloc
= reloc
;
7667 list
->list_root
.prev
= &list
->list_root
;
7668 list
->list_root
.next
= &list
->list_root
;
7677 static void reloc_range_list_append (reloc_range_list
*list
,
7678 unsigned irel_index
)
7680 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7682 entry
->prev
= list
->list_root
.prev
;
7683 entry
->next
= &list
->list_root
;
7684 entry
->prev
->next
= entry
;
7685 entry
->next
->prev
= entry
;
7689 static void reloc_range_list_remove (reloc_range_list
*list
,
7690 unsigned irel_index
)
7692 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7694 entry
->next
->prev
= entry
->prev
;
7695 entry
->prev
->next
= entry
->next
;
7699 /* Update relocation list object so that it lists all relocations that cross
7700 [first; last] range. Range bounds should not decrease with successive
7702 static void reloc_range_list_update_range (reloc_range_list
*list
,
7703 bfd_vma first
, bfd_vma last
)
7705 /* This should not happen: EBBs are iterated from lower addresses to higher.
7706 But even if that happens there's no need to break: just flush current list
7707 and start from scratch. */
7708 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7709 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7714 list
->list_root
.next
= &list
->list_root
;
7715 list
->list_root
.prev
= &list
->list_root
;
7716 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7719 for (; list
->last
< list
->n_range
&&
7720 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7721 if (list
->range
[list
->last
].add
)
7722 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7724 for (; list
->first
< list
->n_range
&&
7725 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7726 if (!list
->range
[list
->first
].add
)
7727 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7730 static void free_reloc_range_list (reloc_range_list
*list
)
7736 /* The compute_text_actions function will build a list of potential
7737 transformation actions for code in the extended basic block of each
7738 longcall that is optimized to a direct call. From this list we
7739 generate a set of actions to actually perform that optimizes for
7740 space and, if not using size_opt, maintains branch target
7743 These actions to be performed are placed on a per-section list.
7744 The actual changes are performed by relax_section() in the second
7748 compute_text_actions (bfd
*abfd
,
7750 struct bfd_link_info
*link_info
)
7752 xtensa_opcode
*reloc_opcodes
= NULL
;
7753 xtensa_relax_info
*relax_info
;
7755 Elf_Internal_Rela
*internal_relocs
;
7758 property_table_entry
*prop_table
= 0;
7760 bfd_size_type sec_size
;
7761 reloc_range_list relevant_relocs
;
7763 relax_info
= get_xtensa_relax_info (sec
);
7764 BFD_ASSERT (relax_info
);
7765 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7767 /* Do nothing if the section contains no optimized longcalls. */
7768 if (!relax_info
->is_relaxable_asm_section
)
7771 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7772 link_info
->keep_memory
);
7774 if (internal_relocs
)
7775 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7776 internal_reloc_compare
);
7778 sec_size
= bfd_get_section_limit (abfd
, sec
);
7779 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7780 if (contents
== NULL
&& sec_size
!= 0)
7786 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7787 XTENSA_PROP_SEC_NAME
, false);
7794 /* Precompute the opcode for each relocation. */
7795 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7797 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7800 for (i
= 0; i
< sec
->reloc_count
; i
++)
7802 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7804 property_table_entry
*the_entry
;
7807 ebb_constraint ebb_table
;
7808 bfd_size_type simplify_size
;
7810 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7812 r_offset
= irel
->r_offset
;
7814 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7815 if (simplify_size
== 0)
7818 /* xgettext:c-format */
7819 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7820 "XTENSA_ASM_SIMPLIFY relocation; "
7821 "possible configuration mismatch"),
7822 sec
->owner
, sec
, (uint64_t) r_offset
);
7826 /* If the instruction table is not around, then don't do this
7828 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7829 sec
->vma
+ irel
->r_offset
);
7830 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7832 text_action_add (&relax_info
->action_list
,
7833 ta_convert_longcall
, sec
, r_offset
,
7838 /* If the next longcall happens to be at the same address as an
7839 unreachable section of size 0, then skip forward. */
7840 ptbl_idx
= the_entry
- prop_table
;
7841 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7842 && the_entry
->size
== 0
7843 && ptbl_idx
+ 1 < ptblsize
7844 && (prop_table
[ptbl_idx
+ 1].address
7845 == prop_table
[ptbl_idx
].address
))
7851 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7852 /* NO_REORDER is OK */
7855 init_ebb_constraint (&ebb_table
);
7856 ebb
= &ebb_table
.ebb
;
7857 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7858 internal_relocs
, sec
->reloc_count
);
7859 ebb
->start_offset
= r_offset
+ simplify_size
;
7860 ebb
->end_offset
= r_offset
+ simplify_size
;
7861 ebb
->start_ptbl_idx
= ptbl_idx
;
7862 ebb
->end_ptbl_idx
= ptbl_idx
;
7863 ebb
->start_reloc_idx
= i
;
7864 ebb
->end_reloc_idx
= i
;
7866 if (!extend_ebb_bounds (ebb
)
7867 || !compute_ebb_proposed_actions (&ebb_table
)
7868 || !compute_ebb_actions (&ebb_table
)
7869 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7872 &ebb_table
, reloc_opcodes
)
7873 || !check_section_ebb_reduces (&ebb_table
))
7875 /* If anything goes wrong or we get unlucky and something does
7876 not fit, with our plan because of expansion between
7877 critical branches, just convert to a NOP. */
7879 text_action_add (&relax_info
->action_list
,
7880 ta_convert_longcall
, sec
, r_offset
, 0);
7881 i
= ebb_table
.ebb
.end_reloc_idx
;
7882 free_ebb_constraint (&ebb_table
);
7886 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7888 /* Update the index so we do not go looking at the relocations
7889 we have already processed. */
7890 i
= ebb_table
.ebb
.end_reloc_idx
;
7891 free_ebb_constraint (&ebb_table
);
7894 free_reloc_range_list (&relevant_relocs
);
7897 if (action_list_count (&relax_info
->action_list
))
7898 print_action_list (stderr
, &relax_info
->action_list
);
7902 release_contents (sec
, contents
);
7903 release_internal_relocs (sec
, internal_relocs
);
7905 free (reloc_opcodes
);
7911 /* Do not widen an instruction if it is preceeded by a
7912 loop opcode. It might cause misalignment. */
7915 prev_instr_is_a_loop (bfd_byte
*contents
,
7916 bfd_size_type content_length
,
7917 bfd_size_type offset
)
7919 xtensa_opcode prev_opcode
;
7923 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7924 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7928 /* Find all of the possible actions for an extended basic block. */
7931 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7933 const ebb_t
*ebb
= &ebb_table
->ebb
;
7934 unsigned rel_idx
= ebb
->start_reloc_idx
;
7935 property_table_entry
*entry
, *start_entry
, *end_entry
;
7937 xtensa_isa isa
= xtensa_default_isa
;
7939 static xtensa_insnbuf insnbuf
= NULL
;
7940 static xtensa_insnbuf slotbuf
= NULL
;
7942 if (insnbuf
== NULL
)
7944 insnbuf
= xtensa_insnbuf_alloc (isa
);
7945 slotbuf
= xtensa_insnbuf_alloc (isa
);
7948 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7949 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7951 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7953 bfd_vma start_offset
, end_offset
;
7954 bfd_size_type insn_len
;
7956 start_offset
= entry
->address
- ebb
->sec
->vma
;
7957 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7959 if (entry
== start_entry
)
7960 start_offset
= ebb
->start_offset
;
7961 if (entry
== end_entry
)
7962 end_offset
= ebb
->end_offset
;
7963 offset
= start_offset
;
7965 if (offset
== entry
->address
- ebb
->sec
->vma
7966 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7968 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7969 BFD_ASSERT (offset
!= end_offset
);
7970 if (offset
== end_offset
)
7973 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7978 if (check_branch_target_aligned_address (offset
, insn_len
))
7979 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7981 ebb_propose_action (ebb_table
, align_type
, 0,
7982 ta_none
, offset
, 0, true);
7985 while (offset
!= end_offset
)
7987 Elf_Internal_Rela
*irel
;
7988 xtensa_opcode opcode
;
7990 while (rel_idx
< ebb
->end_reloc_idx
7991 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7992 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7993 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
7994 != R_XTENSA_ASM_SIMPLIFY
))))
7997 /* Check for longcall. */
7998 irel
= &ebb
->relocs
[rel_idx
];
7999 if (irel
->r_offset
== offset
8000 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
8002 bfd_size_type simplify_size
;
8004 simplify_size
= get_asm_simplify_size (ebb
->contents
,
8005 ebb
->content_length
,
8007 if (simplify_size
== 0)
8010 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8011 ta_convert_longcall
, offset
, 0, true);
8013 offset
+= simplify_size
;
8017 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
8019 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
8020 ebb
->content_length
- offset
);
8021 fmt
= xtensa_format_decode (isa
, insnbuf
);
8022 if (fmt
== XTENSA_UNDEFINED
)
8024 insn_len
= xtensa_format_length (isa
, fmt
);
8025 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
8028 if (xtensa_format_num_slots (isa
, fmt
) != 1)
8034 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
8035 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
8036 if (opcode
== XTENSA_UNDEFINED
)
8039 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
8040 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8041 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
8043 /* Add an instruction narrow action. */
8044 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8045 ta_narrow_insn
, offset
, 0, false);
8047 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8048 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
8049 && ! prev_instr_is_a_loop (ebb
->contents
,
8050 ebb
->content_length
, offset
))
8052 /* Add an instruction widen action. */
8053 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8054 ta_widen_insn
, offset
, 0, false);
8056 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
8058 /* Check for branch targets. */
8059 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
8060 ta_none
, offset
, 0, true);
8067 if (ebb
->ends_unreachable
)
8069 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8070 ta_fill
, ebb
->end_offset
, 0, true);
8077 /* xgettext:c-format */
8078 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
8079 "possible configuration mismatch"),
8080 ebb
->sec
->owner
, ebb
->sec
, (uint64_t) offset
);
8085 /* After all of the information has collected about the
8086 transformations possible in an EBB, compute the appropriate actions
8087 here in compute_ebb_actions. We still must check later to make
8088 sure that the actions do not break any relocations. The algorithm
8089 used here is pretty greedy. Basically, it removes as many no-ops
8090 as possible so that the end of the EBB has the same alignment
8091 characteristics as the original. First, it uses narrowing, then
8092 fill space at the end of the EBB, and finally widenings. If that
8093 does not work, it tries again with one fewer no-op removed. The
8094 optimization will only be performed if all of the branch targets
8095 that were aligned before transformation are also aligned after the
8098 When the size_opt flag is set, ignore the branch target alignments,
8099 narrow all wide instructions, and remove all no-ops unless the end
8100 of the EBB prevents it. */
8103 compute_ebb_actions (ebb_constraint
*ebb_table
)
8107 int removed_bytes
= 0;
8108 ebb_t
*ebb
= &ebb_table
->ebb
;
8109 unsigned seg_idx_start
= 0;
8110 unsigned seg_idx_end
= 0;
8112 /* We perform this like the assembler relaxation algorithm: Start by
8113 assuming all instructions are narrow and all no-ops removed; then
8116 /* For each segment of this that has a solid constraint, check to
8117 see if there are any combinations that will keep the constraint.
8119 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
8121 bool requires_text_end_align
= false;
8122 unsigned longcall_count
= 0;
8123 unsigned longcall_convert_count
= 0;
8124 unsigned narrowable_count
= 0;
8125 unsigned narrowable_convert_count
= 0;
8126 unsigned widenable_count
= 0;
8127 unsigned widenable_convert_count
= 0;
8129 proposed_action
*action
= NULL
;
8130 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
8132 seg_idx_start
= seg_idx_end
;
8134 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
8136 action
= &ebb_table
->actions
[i
];
8137 if (action
->action
== ta_convert_longcall
)
8139 if (action
->action
== ta_narrow_insn
)
8141 if (action
->action
== ta_widen_insn
)
8143 if (action
->action
== ta_fill
)
8145 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8147 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
8148 && !elf32xtensa_size_opt
)
8153 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
8154 requires_text_end_align
= true;
8156 if (elf32xtensa_size_opt
&& !requires_text_end_align
8157 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
8158 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
8160 longcall_convert_count
= longcall_count
;
8161 narrowable_convert_count
= narrowable_count
;
8162 widenable_convert_count
= 0;
8166 /* There is a constraint. Convert the max number of longcalls. */
8167 narrowable_convert_count
= 0;
8168 longcall_convert_count
= 0;
8169 widenable_convert_count
= 0;
8171 for (j
= 0; j
< longcall_count
; j
++)
8173 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
8174 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
8175 unsigned desire_widen
= removed
;
8176 if (desire_narrow
<= narrowable_count
)
8178 narrowable_convert_count
= desire_narrow
;
8179 narrowable_convert_count
+=
8180 (align
* ((narrowable_count
- narrowable_convert_count
)
8182 longcall_convert_count
= (longcall_count
- j
);
8183 widenable_convert_count
= 0;
8186 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
8188 narrowable_convert_count
= 0;
8189 longcall_convert_count
= longcall_count
- j
;
8190 widenable_convert_count
= desire_widen
;
8196 /* Now the number of conversions are saved. Do them. */
8197 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
8199 action
= &ebb_table
->actions
[i
];
8200 switch (action
->action
)
8202 case ta_convert_longcall
:
8203 if (longcall_convert_count
!= 0)
8205 action
->action
= ta_remove_longcall
;
8206 action
->do_action
= true;
8207 action
->removed_bytes
+= 3;
8208 longcall_convert_count
--;
8211 case ta_narrow_insn
:
8212 if (narrowable_convert_count
!= 0)
8214 action
->do_action
= true;
8215 action
->removed_bytes
+= 1;
8216 narrowable_convert_count
--;
8220 if (widenable_convert_count
!= 0)
8222 action
->do_action
= true;
8223 action
->removed_bytes
-= 1;
8224 widenable_convert_count
--;
8233 /* Now we move on to some local opts. Try to remove each of the
8234 remaining longcalls. */
8236 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8239 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8241 int old_removed_bytes
= removed_bytes
;
8242 proposed_action
*action
= &ebb_table
->actions
[i
];
8244 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8246 bool bad_alignment
= false;
8248 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8250 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8251 bfd_vma offset
= new_action
->offset
;
8252 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8254 if (!check_branch_target_aligned
8255 (ebb_table
->ebb
.contents
,
8256 ebb_table
->ebb
.content_length
,
8257 offset
, offset
- removed_bytes
))
8259 bad_alignment
= true;
8263 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8265 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8266 ebb_table
->ebb
.content_length
,
8268 offset
- removed_bytes
))
8270 bad_alignment
= true;
8274 if (new_action
->action
== ta_narrow_insn
8275 && !new_action
->do_action
8276 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8278 /* Narrow an instruction and we are done. */
8279 new_action
->do_action
= true;
8280 new_action
->removed_bytes
+= 1;
8281 bad_alignment
= false;
8284 if (new_action
->action
== ta_widen_insn
8285 && new_action
->do_action
8286 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8288 /* Narrow an instruction and we are done. */
8289 new_action
->do_action
= false;
8290 new_action
->removed_bytes
+= 1;
8291 bad_alignment
= false;
8294 if (new_action
->do_action
)
8295 removed_bytes
+= new_action
->removed_bytes
;
8299 action
->removed_bytes
+= 3;
8300 action
->action
= ta_remove_longcall
;
8301 action
->do_action
= true;
8304 removed_bytes
= old_removed_bytes
;
8305 if (action
->do_action
)
8306 removed_bytes
+= action
->removed_bytes
;
8311 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8313 proposed_action
*action
= &ebb_table
->actions
[i
];
8314 if (action
->do_action
)
8315 removed_bytes
+= action
->removed_bytes
;
8318 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8319 && ebb
->ends_unreachable
)
8321 proposed_action
*action
;
8325 BFD_ASSERT (ebb_table
->action_count
!= 0);
8326 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8327 BFD_ASSERT (action
->action
== ta_fill
);
8328 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8330 extra_space
= xtensa_compute_fill_extra_space (ebb
->ends_unreachable
);
8331 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8332 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8334 action
->removed_bytes
= extra_space
- br
;
8340 /* The xlate_map is a sorted array of address mappings designed to
8341 answer the offset_with_removed_text() query with a binary search instead
8342 of a linear search through the section's action_list. */
8344 typedef struct xlate_map_entry xlate_map_entry_t
;
8345 typedef struct xlate_map xlate_map_t
;
8347 struct xlate_map_entry
8349 bfd_vma orig_address
;
8350 bfd_vma new_address
;
8356 unsigned entry_count
;
8357 xlate_map_entry_t
*entry
;
8362 xlate_compare (const void *a_v
, const void *b_v
)
8364 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8365 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8366 if (a
->orig_address
< b
->orig_address
)
8368 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8375 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8376 text_action_list
*action_list
,
8380 xlate_map_entry_t
*e
;
8381 struct xlate_map_entry se
;
8384 return offset_with_removed_text (action_list
, offset
);
8386 if (map
->entry_count
== 0)
8389 se
.orig_address
= offset
;
8390 r
= bsearch (&se
, map
->entry
, map
->entry_count
,
8391 sizeof (xlate_map_entry_t
), &xlate_compare
);
8392 e
= (xlate_map_entry_t
*) r
;
8394 /* There could be a jump past the end of the section,
8395 allow it using the last xlate map entry to translate its address. */
8398 e
= map
->entry
+ map
->entry_count
- 1;
8399 if (xlate_compare (&se
, e
) <= 0)
8402 BFD_ASSERT (e
!= NULL
);
8405 return e
->new_address
- e
->orig_address
+ offset
;
8408 typedef struct xlate_map_context_struct xlate_map_context
;
8409 struct xlate_map_context_struct
8412 xlate_map_entry_t
*current_entry
;
8417 xlate_map_fn (splay_tree_node node
, void *p
)
8419 text_action
*r
= (text_action
*)node
->value
;
8420 xlate_map_context
*ctx
= p
;
8421 unsigned orig_size
= 0;
8426 case ta_remove_insn
:
8427 case ta_convert_longcall
:
8428 case ta_remove_literal
:
8429 case ta_add_literal
:
8431 case ta_remove_longcall
:
8434 case ta_narrow_insn
:
8443 ctx
->current_entry
->size
=
8444 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8445 if (ctx
->current_entry
->size
!= 0)
8447 ctx
->current_entry
++;
8448 ctx
->map
->entry_count
++;
8450 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8451 ctx
->removed
+= r
->removed_bytes
;
8452 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8453 ctx
->current_entry
->size
= 0;
8457 /* Build a binary searchable offset translation map from a section's
8460 static xlate_map_t
*
8461 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8463 text_action_list
*action_list
= &relax_info
->action_list
;
8464 unsigned num_actions
= 0;
8465 xlate_map_context ctx
;
8467 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8469 if (ctx
.map
== NULL
)
8472 num_actions
= action_list_count (action_list
);
8473 ctx
.map
->entry
= (xlate_map_entry_t
*)
8474 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8475 if (ctx
.map
->entry
== NULL
)
8480 ctx
.map
->entry_count
= 0;
8483 ctx
.current_entry
= &ctx
.map
->entry
[0];
8485 ctx
.current_entry
->orig_address
= 0;
8486 ctx
.current_entry
->new_address
= 0;
8487 ctx
.current_entry
->size
= 0;
8489 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8491 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8492 - ctx
.current_entry
->orig_address
);
8493 if (ctx
.current_entry
->size
!= 0)
8494 ctx
.map
->entry_count
++;
8500 /* Free an offset translation map. */
8503 free_xlate_map (xlate_map_t
*map
)
8513 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8514 relocations in a section will fit if a proposed set of actions
8518 check_section_ebb_pcrels_fit (bfd
*abfd
,
8521 Elf_Internal_Rela
*internal_relocs
,
8522 reloc_range_list
*relevant_relocs
,
8523 const ebb_constraint
*constraint
,
8524 const xtensa_opcode
*reloc_opcodes
)
8527 unsigned n
= sec
->reloc_count
;
8528 Elf_Internal_Rela
*irel
;
8529 xlate_map_t
*xmap
= NULL
;
8531 xtensa_relax_info
*relax_info
;
8532 reloc_range_list_entry
*entry
= NULL
;
8534 relax_info
= get_xtensa_relax_info (sec
);
8536 if (relax_info
&& sec
->reloc_count
> 100)
8538 xmap
= build_xlate_map (sec
, relax_info
);
8539 /* NULL indicates out of memory, but the slow version
8540 can still be used. */
8543 if (relevant_relocs
&& constraint
->action_count
)
8545 if (!relevant_relocs
->ok
)
8552 bfd_vma min_offset
, max_offset
;
8553 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8555 for (i
= 1; i
< constraint
->action_count
; ++i
)
8557 proposed_action
*action
= &constraint
->actions
[i
];
8558 bfd_vma offset
= action
->offset
;
8560 if (offset
< min_offset
)
8561 min_offset
= offset
;
8562 if (offset
> max_offset
)
8563 max_offset
= offset
;
8565 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8567 n
= relevant_relocs
->n_list
;
8568 entry
= &relevant_relocs
->list_root
;
8573 relevant_relocs
= NULL
;
8576 for (i
= 0; i
< n
; i
++)
8579 bfd_vma orig_self_offset
, orig_target_offset
;
8580 bfd_vma self_offset
, target_offset
;
8582 reloc_howto_type
*howto
;
8583 int self_removed_bytes
, target_removed_bytes
;
8585 if (relevant_relocs
)
8587 entry
= entry
->next
;
8592 irel
= internal_relocs
+ i
;
8594 r_type
= ELF32_R_TYPE (irel
->r_info
);
8596 howto
= &elf_howto_table
[r_type
];
8597 /* We maintain the required invariant: PC-relative relocations
8598 that fit before linking must fit after linking. Thus we only
8599 need to deal with relocations to the same section that are
8601 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8602 || r_type
== R_XTENSA_32_PCREL
8603 || !howto
->pc_relative
)
8606 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8607 bfd_get_section_limit (abfd
, sec
));
8609 if (r_reloc_get_section (&r_rel
) != sec
)
8612 orig_self_offset
= irel
->r_offset
;
8613 orig_target_offset
= r_rel
.target_offset
;
8615 self_offset
= orig_self_offset
;
8616 target_offset
= orig_target_offset
;
8621 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8624 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8625 orig_target_offset
);
8628 self_removed_bytes
= 0;
8629 target_removed_bytes
= 0;
8631 for (j
= 0; j
< constraint
->action_count
; ++j
)
8633 proposed_action
*action
= &constraint
->actions
[j
];
8634 bfd_vma offset
= action
->offset
;
8635 int removed_bytes
= action
->removed_bytes
;
8636 if (offset
< orig_self_offset
8637 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8638 && action
->removed_bytes
< 0))
8639 self_removed_bytes
+= removed_bytes
;
8640 if (offset
< orig_target_offset
8641 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8642 && action
->removed_bytes
< 0))
8643 target_removed_bytes
+= removed_bytes
;
8645 self_offset
-= self_removed_bytes
;
8646 target_offset
-= target_removed_bytes
;
8648 /* Try to encode it. Get the operand and check. */
8649 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8651 /* None of the current alternate relocs are PC-relative,
8652 and only PC-relative relocs matter here. */
8656 xtensa_opcode opcode
;
8659 if (relevant_relocs
)
8661 opcode
= entry
->opcode
;
8662 opnum
= entry
->opnum
;
8667 opcode
= reloc_opcodes
[relevant_relocs
?
8668 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8670 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8671 if (opcode
== XTENSA_UNDEFINED
)
8677 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8678 if (opnum
== XTENSA_UNDEFINED
)
8685 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8693 free_xlate_map (xmap
);
8700 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8705 for (i
= 0; i
< constraint
->action_count
; i
++)
8707 const proposed_action
*action
= &constraint
->actions
[i
];
8708 if (action
->do_action
)
8709 removed
+= action
->removed_bytes
;
8719 text_action_add_proposed (text_action_list
*l
,
8720 const ebb_constraint
*ebb_table
,
8725 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8727 proposed_action
*action
= &ebb_table
->actions
[i
];
8729 if (!action
->do_action
)
8731 switch (action
->action
)
8733 case ta_remove_insn
:
8734 case ta_remove_longcall
:
8735 case ta_convert_longcall
:
8736 case ta_narrow_insn
:
8739 case ta_remove_literal
:
8740 text_action_add (l
, action
->action
, sec
, action
->offset
,
8741 action
->removed_bytes
);
8754 xtensa_compute_fill_extra_space (property_table_entry
*entry
)
8756 int fill_extra_space
;
8761 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8764 fill_extra_space
= entry
->size
;
8765 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8767 /* Fill bytes for alignment:
8768 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8769 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8770 int nsm
= (1 << pow
) - 1;
8771 bfd_vma addr
= entry
->address
+ entry
->size
;
8772 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8773 fill_extra_space
+= align_fill
;
8775 return fill_extra_space
;
8779 /* First relaxation pass. */
8781 /* If the section contains relaxable literals, check each literal to
8782 see if it has the same value as another literal that has already
8783 been seen, either in the current section or a previous one. If so,
8784 add an entry to the per-section list of removed literals. The
8785 actual changes are deferred until the next pass. */
8788 compute_removed_literals (bfd
*abfd
,
8790 struct bfd_link_info
*link_info
,
8791 value_map_hash_table
*values
)
8793 xtensa_relax_info
*relax_info
;
8795 Elf_Internal_Rela
*internal_relocs
;
8796 source_reloc
*src_relocs
, *rel
;
8798 property_table_entry
*prop_table
= NULL
;
8801 bool last_loc_is_prev
= false;
8802 bfd_vma last_target_offset
= 0;
8803 section_cache_t target_sec_cache
;
8804 bfd_size_type sec_size
;
8806 init_section_cache (&target_sec_cache
);
8808 /* Do nothing if it is not a relaxable literal section. */
8809 relax_info
= get_xtensa_relax_info (sec
);
8810 BFD_ASSERT (relax_info
);
8811 if (!relax_info
->is_relaxable_literal_section
)
8814 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8815 link_info
->keep_memory
);
8817 sec_size
= bfd_get_section_limit (abfd
, sec
);
8818 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8819 if (contents
== NULL
&& sec_size
!= 0)
8825 /* Sort the source_relocs by target offset. */
8826 src_relocs
= relax_info
->src_relocs
;
8827 qsort (src_relocs
, relax_info
->src_count
,
8828 sizeof (source_reloc
), source_reloc_compare
);
8829 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8830 internal_reloc_compare
);
8832 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8833 XTENSA_PROP_SEC_NAME
, false);
8841 for (i
= 0; i
< relax_info
->src_count
; i
++)
8843 Elf_Internal_Rela
*irel
= NULL
;
8845 rel
= &src_relocs
[i
];
8846 if (get_l32r_opcode () != rel
->opcode
)
8848 irel
= get_irel_at_offset (sec
, internal_relocs
,
8849 rel
->r_rel
.target_offset
);
8851 /* If the relocation on this is not a simple R_XTENSA_32 or
8852 R_XTENSA_PLT then do not consider it. This may happen when
8853 the difference of two symbols is used in a literal. */
8854 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8855 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8858 /* If the target_offset for this relocation is the same as the
8859 previous relocation, then we've already considered whether the
8860 literal can be coalesced. Skip to the next one.... */
8861 if (i
!= 0 && prev_i
!= -1
8862 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8866 if (last_loc_is_prev
&&
8867 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8868 last_loc_is_prev
= false;
8870 /* Check if the relocation was from an L32R that is being removed
8871 because a CALLX was converted to a direct CALL, and check if
8872 there are no other relocations to the literal. */
8873 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8874 sec
, prop_table
, ptblsize
))
8876 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8877 irel
, rel
, prop_table
, ptblsize
))
8882 last_target_offset
= rel
->r_rel
.target_offset
;
8886 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8888 &last_loc_is_prev
, irel
,
8889 relax_info
->src_count
- i
, rel
,
8890 prop_table
, ptblsize
,
8891 &target_sec_cache
, rel
->is_abs_literal
))
8896 last_target_offset
= rel
->r_rel
.target_offset
;
8900 print_removed_literals (stderr
, &relax_info
->removed_list
);
8901 print_action_list (stderr
, &relax_info
->action_list
);
8906 free_section_cache (&target_sec_cache
);
8908 release_contents (sec
, contents
);
8909 release_internal_relocs (sec
, internal_relocs
);
8914 static Elf_Internal_Rela
*
8915 get_irel_at_offset (asection
*sec
,
8916 Elf_Internal_Rela
*internal_relocs
,
8920 Elf_Internal_Rela
*irel
;
8922 Elf_Internal_Rela key
;
8924 if (!internal_relocs
)
8927 key
.r_offset
= offset
;
8928 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8929 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8933 /* bsearch does not guarantee which will be returned if there are
8934 multiple matches. We need the first that is not an alignment. */
8935 i
= irel
- internal_relocs
;
8938 if (internal_relocs
[i
-1].r_offset
!= offset
)
8942 for ( ; i
< sec
->reloc_count
; i
++)
8944 irel
= &internal_relocs
[i
];
8945 r_type
= ELF32_R_TYPE (irel
->r_info
);
8946 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8955 is_removable_literal (const source_reloc
*rel
,
8957 const source_reloc
*src_relocs
,
8960 property_table_entry
*prop_table
,
8963 const source_reloc
*curr_rel
;
8964 property_table_entry
*entry
;
8969 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8970 sec
->vma
+ rel
->r_rel
.target_offset
);
8971 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8974 for (++i
; i
< src_count
; ++i
)
8976 curr_rel
= &src_relocs
[i
];
8977 /* If all others have the same target offset.... */
8978 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8981 if (!curr_rel
->is_null
8982 && !xtensa_is_property_section (curr_rel
->source_sec
)
8983 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8991 remove_dead_literal (bfd
*abfd
,
8993 struct bfd_link_info
*link_info
,
8994 Elf_Internal_Rela
*internal_relocs
,
8995 Elf_Internal_Rela
*irel
,
8997 property_table_entry
*prop_table
,
9000 property_table_entry
*entry
;
9001 xtensa_relax_info
*relax_info
;
9003 relax_info
= get_xtensa_relax_info (sec
);
9007 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9008 sec
->vma
+ rel
->r_rel
.target_offset
);
9010 /* Mark the unused literal so that it will be removed. */
9011 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
9013 text_action_add (&relax_info
->action_list
,
9014 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9016 /* If the section is 4-byte aligned, do not add fill. */
9017 if (sec
->alignment_power
> 2)
9019 int fill_extra_space
;
9020 bfd_vma entry_sec_offset
;
9022 property_table_entry
*the_add_entry
;
9026 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9028 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9030 /* If the literal range is at the end of the section,
9032 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9034 fill_extra_space
= xtensa_compute_fill_extra_space (the_add_entry
);
9036 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9037 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9038 -4, fill_extra_space
);
9040 adjust_fill_action (fa
, removed_diff
);
9042 text_action_add (&relax_info
->action_list
,
9043 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9046 /* Zero out the relocation on this literal location. */
9049 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9050 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9052 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9053 pin_internal_relocs (sec
, internal_relocs
);
9056 /* Do not modify "last_loc_is_prev". */
9062 identify_literal_placement (bfd
*abfd
,
9065 struct bfd_link_info
*link_info
,
9066 value_map_hash_table
*values
,
9067 bool *last_loc_is_prev_p
,
9068 Elf_Internal_Rela
*irel
,
9069 int remaining_src_rels
,
9071 property_table_entry
*prop_table
,
9073 section_cache_t
*target_sec_cache
,
9074 bool is_abs_literal
)
9078 xtensa_relax_info
*relax_info
;
9079 bool literal_placed
= false;
9081 unsigned long value
;
9082 bool final_static_link
;
9083 bfd_size_type sec_size
;
9085 relax_info
= get_xtensa_relax_info (sec
);
9089 sec_size
= bfd_get_section_limit (abfd
, sec
);
9092 (!bfd_link_relocatable (link_info
)
9093 && !elf_hash_table (link_info
)->dynamic_sections_created
);
9095 /* The placement algorithm first checks to see if the literal is
9096 already in the value map. If so and the value map is reachable
9097 from all uses, then the literal is moved to that location. If
9098 not, then we identify the last location where a fresh literal was
9099 placed. If the literal can be safely moved there, then we do so.
9100 If not, then we assume that the literal is not to move and leave
9101 the literal where it is, marking it as the last literal
9104 /* Find the literal value. */
9106 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9109 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
9110 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
9112 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
9114 /* Check if we've seen another literal with the same value that
9115 is in the same output section. */
9116 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
9119 && (r_reloc_get_section (&val_map
->loc
)->output_section
9120 == sec
->output_section
)
9121 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
9122 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
9124 /* No change to last_loc_is_prev. */
9125 literal_placed
= true;
9128 /* For relocatable links, do not try to move literals. To do it
9129 correctly might increase the number of relocations in an input
9130 section making the default relocatable linking fail. */
9131 if (!bfd_link_relocatable (link_info
) && !literal_placed
9132 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
9134 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
9135 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
9137 /* Increment the virtual offset. */
9138 r_reloc try_loc
= values
->last_loc
;
9139 try_loc
.virtual_offset
+= 4;
9141 /* There is a last loc that was in the same output section. */
9142 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
9143 && move_shared_literal (sec
, link_info
, rel
,
9144 prop_table
, ptblsize
,
9145 &try_loc
, &val
, target_sec_cache
))
9147 values
->last_loc
.virtual_offset
+= 4;
9148 literal_placed
= true;
9150 val_map
= add_value_map (values
, &val
, &try_loc
,
9153 val_map
->loc
= try_loc
;
9158 if (!literal_placed
)
9160 /* Nothing worked, leave the literal alone but update the last loc. */
9161 values
->has_last_loc
= true;
9162 values
->last_loc
= rel
->r_rel
;
9164 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
9166 val_map
->loc
= rel
->r_rel
;
9167 *last_loc_is_prev_p
= true;
9174 /* Check if the original relocations (presumably on L32R instructions)
9175 identified by reloc[0..N] can be changed to reference the literal
9176 identified by r_rel. If r_rel is out of range for any of the
9177 original relocations, then we don't want to coalesce the original
9178 literal with the one at r_rel. We only check reloc[0..N], where the
9179 offsets are all the same as for reloc[0] (i.e., they're all
9180 referencing the same literal) and where N is also bounded by the
9181 number of remaining entries in the "reloc" array. The "reloc" array
9182 is sorted by target offset so we know all the entries for the same
9183 literal will be contiguous. */
9186 relocations_reach (source_reloc
*reloc
,
9187 int remaining_relocs
,
9188 const r_reloc
*r_rel
)
9190 bfd_vma from_offset
, source_address
, dest_address
;
9194 if (!r_reloc_is_defined (r_rel
))
9197 sec
= r_reloc_get_section (r_rel
);
9198 from_offset
= reloc
[0].r_rel
.target_offset
;
9200 for (i
= 0; i
< remaining_relocs
; i
++)
9202 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9205 /* Ignore relocations that have been removed. */
9206 if (reloc
[i
].is_null
)
9209 /* The original and new output section for these must be the same
9210 in order to coalesce. */
9211 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9212 != sec
->output_section
)
9215 /* Absolute literals in the same output section can always be
9217 if (reloc
[i
].is_abs_literal
)
9220 /* A literal with no PC-relative relocations can be moved anywhere. */
9221 if (reloc
[i
].opnd
!= -1)
9223 /* Otherwise, check to see that it fits. */
9224 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9225 + reloc
[i
].source_sec
->output_offset
9226 + reloc
[i
].r_rel
.rela
.r_offset
);
9227 dest_address
= (sec
->output_section
->vma
9228 + sec
->output_offset
9229 + r_rel
->target_offset
);
9231 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9232 source_address
, dest_address
))
9241 /* Move a literal to another literal location because it is
9242 the same as the other literal value. */
9245 coalesce_shared_literal (asection
*sec
,
9247 property_table_entry
*prop_table
,
9251 property_table_entry
*entry
;
9253 property_table_entry
*the_add_entry
;
9255 xtensa_relax_info
*relax_info
;
9257 relax_info
= get_xtensa_relax_info (sec
);
9261 entry
= elf_xtensa_find_property_entry
9262 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9263 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9266 /* Mark that the literal will be coalesced. */
9267 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9269 text_action_add (&relax_info
->action_list
,
9270 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9272 /* If the section is 4-byte aligned, do not add fill. */
9273 if (sec
->alignment_power
> 2)
9275 int fill_extra_space
;
9276 bfd_vma entry_sec_offset
;
9279 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9281 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9283 /* If the literal range is at the end of the section,
9285 fill_extra_space
= 0;
9286 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9288 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9289 fill_extra_space
= the_add_entry
->size
;
9291 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9292 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9293 -4, fill_extra_space
);
9295 adjust_fill_action (fa
, removed_diff
);
9297 text_action_add (&relax_info
->action_list
,
9298 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9305 /* Move a literal to another location. This may actually increase the
9306 total amount of space used because of alignments so we need to do
9307 this carefully. Also, it may make a branch go out of range. */
9310 move_shared_literal (asection
*sec
,
9311 struct bfd_link_info
*link_info
,
9313 property_table_entry
*prop_table
,
9315 const r_reloc
*target_loc
,
9316 const literal_value
*lit_value
,
9317 section_cache_t
*target_sec_cache
)
9319 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9320 text_action
*fa
, *target_fa
;
9322 xtensa_relax_info
*relax_info
, *target_relax_info
;
9323 asection
*target_sec
;
9325 ebb_constraint ebb_table
;
9328 /* If this routine always returns FALSE, the literals that cannot be
9329 coalesced will not be moved. */
9330 if (elf32xtensa_no_literal_movement
)
9333 relax_info
= get_xtensa_relax_info (sec
);
9337 target_sec
= r_reloc_get_section (target_loc
);
9338 target_relax_info
= get_xtensa_relax_info (target_sec
);
9340 /* Literals to undefined sections may not be moved because they
9341 must report an error. */
9342 if (bfd_is_und_section (target_sec
))
9345 src_entry
= elf_xtensa_find_property_entry
9346 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9348 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9351 target_entry
= elf_xtensa_find_property_entry
9352 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9353 target_sec
->vma
+ target_loc
->target_offset
);
9358 /* Make sure that we have not broken any branches. */
9361 init_ebb_constraint (&ebb_table
);
9362 ebb
= &ebb_table
.ebb
;
9363 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9364 target_sec_cache
->content_length
,
9365 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9366 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9368 /* Propose to add 4 bytes + worst-case alignment size increase to
9370 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9371 ta_fill
, target_loc
->target_offset
,
9372 -4 - (1 << target_sec
->alignment_power
), true);
9374 /* Check all of the PC-relative relocations to make sure they still fit. */
9375 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9376 target_sec_cache
->contents
,
9377 target_sec_cache
->relocs
, NULL
,
9383 text_action_add_literal (&target_relax_info
->action_list
,
9384 ta_add_literal
, target_loc
, lit_value
, -4);
9386 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9388 /* May need to add or remove some fill to maintain alignment. */
9389 int fill_extra_space
;
9390 bfd_vma entry_sec_offset
;
9393 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9395 /* If the literal range is at the end of the section,
9397 fill_extra_space
= 0;
9399 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9400 target_sec_cache
->pte_count
,
9402 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9403 fill_extra_space
= the_add_entry
->size
;
9405 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9406 target_sec
, entry_sec_offset
);
9407 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9408 entry_sec_offset
, 4,
9411 adjust_fill_action (target_fa
, removed_diff
);
9413 text_action_add (&target_relax_info
->action_list
,
9414 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9417 /* Mark that the literal will be moved to the new location. */
9418 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9420 /* Remove the literal. */
9421 text_action_add (&relax_info
->action_list
,
9422 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9424 /* If the section is 4-byte aligned, do not add fill. */
9425 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9427 int fill_extra_space
;
9428 bfd_vma entry_sec_offset
;
9431 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9433 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9435 /* If the literal range is at the end of the section,
9437 fill_extra_space
= 0;
9438 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9440 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9441 fill_extra_space
= the_add_entry
->size
;
9443 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9444 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9445 -4, fill_extra_space
);
9447 adjust_fill_action (fa
, removed_diff
);
9449 text_action_add (&relax_info
->action_list
,
9450 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9457 /* Second relaxation pass. */
9460 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9462 bfd_size_type
*final_size
= p
;
9463 text_action
*action
= (text_action
*)node
->value
;
9465 *final_size
-= action
->removed_bytes
;
9469 /* Modify all of the relocations to point to the right spot, and if this
9470 is a relaxable section, delete the unwanted literals and fix the
9474 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9476 Elf_Internal_Rela
*internal_relocs
;
9477 xtensa_relax_info
*relax_info
;
9482 bool virtual_action
;
9483 bfd_size_type sec_size
;
9485 sec_size
= bfd_get_section_limit (abfd
, sec
);
9486 relax_info
= get_xtensa_relax_info (sec
);
9487 BFD_ASSERT (relax_info
);
9489 /* First translate any of the fixes that have been added already. */
9490 translate_section_fixes (sec
);
9492 /* Handle property sections (e.g., literal tables) specially. */
9493 if (xtensa_is_property_section (sec
))
9495 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9496 return relax_property_section (abfd
, sec
, link_info
);
9499 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9500 link_info
->keep_memory
);
9501 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9504 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9505 if (contents
== NULL
&& sec_size
!= 0)
9511 if (internal_relocs
)
9513 for (i
= 0; i
< sec
->reloc_count
; i
++)
9515 Elf_Internal_Rela
*irel
;
9516 xtensa_relax_info
*target_relax_info
;
9517 bfd_vma source_offset
, old_source_offset
;
9520 asection
*target_sec
;
9522 /* Locally change the source address.
9523 Translate the target to the new target address.
9524 If it points to this section and has been removed,
9528 irel
= &internal_relocs
[i
];
9529 source_offset
= irel
->r_offset
;
9530 old_source_offset
= source_offset
;
9532 r_type
= ELF32_R_TYPE (irel
->r_info
);
9533 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9534 bfd_get_section_limit (abfd
, sec
));
9536 /* If this section could have changed then we may need to
9537 change the relocation's offset. */
9539 if (relax_info
->is_relaxable_literal_section
9540 || relax_info
->is_relaxable_asm_section
)
9542 pin_internal_relocs (sec
, internal_relocs
);
9544 if (r_type
!= R_XTENSA_NONE
9545 && find_removed_literal (&relax_info
->removed_list
,
9548 /* Remove this relocation. */
9549 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9550 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9551 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9552 irel
->r_offset
= offset_with_removed_text_map
9553 (&relax_info
->action_list
, irel
->r_offset
);
9557 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9559 text_action
*action
=
9560 find_insn_action (&relax_info
->action_list
,
9562 if (action
&& (action
->action
== ta_convert_longcall
9563 || action
->action
== ta_remove_longcall
))
9565 bfd_reloc_status_type retval
;
9566 char *error_message
= NULL
;
9568 retval
= contract_asm_expansion (contents
, sec_size
,
9569 irel
, &error_message
);
9570 if (retval
!= bfd_reloc_ok
)
9572 (*link_info
->callbacks
->reloc_dangerous
)
9573 (link_info
, error_message
, abfd
, sec
,
9577 /* Update the action so that the code that moves
9578 the contents will do the right thing. */
9579 /* ta_remove_longcall and ta_remove_insn actions are
9580 grouped together in the tree as well as
9581 ta_convert_longcall and ta_none, so that changes below
9582 can be done w/o removing and reinserting action into
9585 if (action
->action
== ta_remove_longcall
)
9586 action
->action
= ta_remove_insn
;
9588 action
->action
= ta_none
;
9589 /* Refresh the info in the r_rel. */
9590 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9591 r_type
= ELF32_R_TYPE (irel
->r_info
);
9595 source_offset
= offset_with_removed_text_map
9596 (&relax_info
->action_list
, irel
->r_offset
);
9597 irel
->r_offset
= source_offset
;
9600 /* If the target section could have changed then
9601 we may need to change the relocation's target offset. */
9603 target_sec
= r_reloc_get_section (&r_rel
);
9605 /* For a reference to a discarded section from a DWARF section,
9606 i.e., where action_discarded is PRETEND, the symbol will
9607 eventually be modified to refer to the kept section (at least if
9608 the kept and discarded sections are the same size). Anticipate
9609 that here and adjust things accordingly. */
9610 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9611 && elf_xtensa_action_discarded (sec
) == PRETEND
9612 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9613 && target_sec
!= NULL
9614 && discarded_section (target_sec
))
9616 /* It would be natural to call _bfd_elf_check_kept_section
9617 here, but it's not exported from elflink.c. It's also a
9618 fairly expensive check. Adjusting the relocations to the
9619 discarded section is fairly harmless; it will only adjust
9620 some addends and difference values. If it turns out that
9621 _bfd_elf_check_kept_section fails later, it won't matter,
9622 so just compare the section names to find the right group
9624 asection
*kept
= target_sec
->kept_section
;
9627 if ((kept
->flags
& SEC_GROUP
) != 0)
9629 asection
*first
= elf_next_in_group (kept
);
9630 asection
*s
= first
;
9635 if (strcmp (s
->name
, target_sec
->name
) == 0)
9640 s
= elf_next_in_group (s
);
9647 && ((target_sec
->rawsize
!= 0
9648 ? target_sec
->rawsize
: target_sec
->size
)
9649 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9653 target_relax_info
= get_xtensa_relax_info (target_sec
);
9654 if (target_relax_info
9655 && (target_relax_info
->is_relaxable_literal_section
9656 || target_relax_info
->is_relaxable_asm_section
))
9659 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9661 if (r_type
== R_XTENSA_DIFF8
9662 || r_type
== R_XTENSA_DIFF16
9663 || r_type
== R_XTENSA_DIFF32
9664 || r_type
== R_XTENSA_PDIFF8
9665 || r_type
== R_XTENSA_PDIFF16
9666 || r_type
== R_XTENSA_PDIFF32
9667 || r_type
== R_XTENSA_NDIFF8
9668 || r_type
== R_XTENSA_NDIFF16
9669 || r_type
== R_XTENSA_NDIFF32
)
9671 bfd_signed_vma diff_value
= 0;
9672 bfd_vma new_end_offset
, diff_mask
= 0;
9674 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9676 (*link_info
->callbacks
->reloc_dangerous
)
9677 (link_info
, _("invalid relocation address"),
9678 abfd
, sec
, old_source_offset
);
9684 case R_XTENSA_DIFF8
:
9687 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9689 case R_XTENSA_DIFF16
:
9692 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9694 case R_XTENSA_DIFF32
:
9695 diff_mask
= 0x7fffffff;
9697 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9699 case R_XTENSA_PDIFF8
:
9700 case R_XTENSA_NDIFF8
:
9703 bfd_get_8 (abfd
, &contents
[old_source_offset
]);
9705 case R_XTENSA_PDIFF16
:
9706 case R_XTENSA_NDIFF16
:
9709 bfd_get_16 (abfd
, &contents
[old_source_offset
]);
9711 case R_XTENSA_PDIFF32
:
9712 case R_XTENSA_NDIFF32
:
9713 diff_mask
= 0xffffffff;
9715 bfd_get_32 (abfd
, &contents
[old_source_offset
]);
9719 if (r_type
>= R_XTENSA_NDIFF8
9720 && r_type
<= R_XTENSA_NDIFF32
9722 diff_value
|= ~diff_mask
;
9724 new_end_offset
= offset_with_removed_text_map
9725 (&target_relax_info
->action_list
,
9726 r_rel
.target_offset
+ diff_value
);
9727 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9731 case R_XTENSA_DIFF8
:
9732 bfd_put_signed_8 (abfd
, diff_value
,
9733 &contents
[old_source_offset
]);
9735 case R_XTENSA_DIFF16
:
9736 bfd_put_signed_16 (abfd
, diff_value
,
9737 &contents
[old_source_offset
]);
9739 case R_XTENSA_DIFF32
:
9740 bfd_put_signed_32 (abfd
, diff_value
,
9741 &contents
[old_source_offset
]);
9743 case R_XTENSA_PDIFF8
:
9744 case R_XTENSA_NDIFF8
:
9745 bfd_put_8 (abfd
, diff_value
,
9746 &contents
[old_source_offset
]);
9748 case R_XTENSA_PDIFF16
:
9749 case R_XTENSA_NDIFF16
:
9750 bfd_put_16 (abfd
, diff_value
,
9751 &contents
[old_source_offset
]);
9753 case R_XTENSA_PDIFF32
:
9754 case R_XTENSA_NDIFF32
:
9755 bfd_put_32 (abfd
, diff_value
,
9756 &contents
[old_source_offset
]);
9760 /* Check for overflow. Sign bits must be all zeroes or
9761 all ones. When sign bits are all ones diff_value
9763 if (((diff_value
& ~diff_mask
) != 0
9764 && (diff_value
& ~diff_mask
) != ~diff_mask
)
9765 || (diff_value
&& (bfd_vma
) diff_value
== ~diff_mask
))
9767 (*link_info
->callbacks
->reloc_dangerous
)
9768 (link_info
, _("overflow after relaxation"),
9769 abfd
, sec
, old_source_offset
);
9773 pin_contents (sec
, contents
);
9776 /* If the relocation still references a section in the same
9777 input file, modify the relocation directly instead of
9778 adding a "fix" record. */
9779 if (target_sec
->owner
== abfd
)
9781 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9782 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9783 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9784 pin_internal_relocs (sec
, internal_relocs
);
9788 bfd_vma addend_displacement
;
9791 addend_displacement
=
9792 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9793 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9795 addend_displacement
, true);
9802 if ((relax_info
->is_relaxable_literal_section
9803 || relax_info
->is_relaxable_asm_section
)
9804 && action_list_count (&relax_info
->action_list
))
9806 /* Walk through the planned actions and build up a table
9807 of move, copy and fill records. Use the move, copy and
9808 fill records to perform the actions once. */
9810 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9811 bfd_byte
*scratch
= NULL
;
9812 bfd_byte
*dup_contents
= NULL
;
9813 bfd_size_type orig_size
= sec
->size
;
9814 bfd_vma orig_dot
= 0;
9815 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9816 orig dot in physical memory. */
9817 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9818 bfd_vma dup_dot
= 0;
9820 text_action
*action
;
9822 final_size
= sec
->size
;
9824 splay_tree_foreach (relax_info
->action_list
.tree
,
9825 action_remove_bytes_fn
, &final_size
);
9826 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9827 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9829 /* The dot is the current fill location. */
9831 print_action_list (stderr
, &relax_info
->action_list
);
9834 for (action
= action_first (&relax_info
->action_list
); action
;
9835 action
= action_next (&relax_info
->action_list
, action
))
9837 virtual_action
= false;
9838 if (action
->offset
> orig_dot
)
9840 orig_dot
+= orig_dot_copied
;
9841 orig_dot_copied
= 0;
9843 /* Out of the virtual world. */
9846 if (action
->offset
> orig_dot
)
9848 copy_size
= action
->offset
- orig_dot
;
9849 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9850 orig_dot
+= copy_size
;
9851 dup_dot
+= copy_size
;
9852 BFD_ASSERT (action
->offset
== orig_dot
);
9854 else if (action
->offset
< orig_dot
)
9856 if (action
->action
== ta_fill
9857 && action
->offset
- action
->removed_bytes
== orig_dot
)
9859 /* This is OK because the fill only effects the dup_dot. */
9861 else if (action
->action
== ta_add_literal
)
9863 /* TBD. Might need to handle this. */
9866 if (action
->offset
== orig_dot
)
9868 if (action
->virtual_offset
> orig_dot_vo
)
9870 if (orig_dot_vo
== 0)
9872 /* Need to copy virtual_offset bytes. Probably four. */
9873 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9874 memmove (&dup_contents
[dup_dot
],
9875 &contents
[orig_dot
], copy_size
);
9876 orig_dot_copied
= copy_size
;
9877 dup_dot
+= copy_size
;
9879 virtual_action
= true;
9882 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9884 switch (action
->action
)
9886 case ta_remove_literal
:
9887 case ta_remove_insn
:
9888 BFD_ASSERT (action
->removed_bytes
>= 0);
9889 orig_dot
+= action
->removed_bytes
;
9892 case ta_narrow_insn
:
9895 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9896 BFD_ASSERT (action
->removed_bytes
== 1);
9897 rv
= narrow_instruction (scratch
, final_size
, 0);
9899 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9900 orig_dot
+= orig_insn_size
;
9901 dup_dot
+= copy_size
;
9905 if (action
->removed_bytes
>= 0)
9906 orig_dot
+= action
->removed_bytes
;
9909 /* Already zeroed in dup_contents. Just bump the
9911 dup_dot
+= (-action
->removed_bytes
);
9916 BFD_ASSERT (action
->removed_bytes
== 0);
9919 case ta_convert_longcall
:
9920 case ta_remove_longcall
:
9921 /* These will be removed or converted before we get here. */
9928 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9929 BFD_ASSERT (action
->removed_bytes
== -1);
9930 rv
= widen_instruction (scratch
, final_size
, 0);
9932 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9933 orig_dot
+= orig_insn_size
;
9934 dup_dot
+= copy_size
;
9937 case ta_add_literal
:
9940 BFD_ASSERT (action
->removed_bytes
== -4);
9941 /* TBD -- place the literal value here and insert
9943 memset (&dup_contents
[dup_dot
], 0, 4);
9944 pin_internal_relocs (sec
, internal_relocs
);
9945 pin_contents (sec
, contents
);
9947 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9948 relax_info
, &internal_relocs
, &action
->value
))
9952 orig_dot_vo
+= copy_size
;
9954 orig_dot
+= orig_insn_size
;
9955 dup_dot
+= copy_size
;
9959 /* Not implemented yet. */
9964 BFD_ASSERT (dup_dot
<= final_size
);
9965 BFD_ASSERT (orig_dot
<= orig_size
);
9968 orig_dot
+= orig_dot_copied
;
9969 orig_dot_copied
= 0;
9971 if (orig_dot
!= orig_size
)
9973 copy_size
= orig_size
- orig_dot
;
9974 BFD_ASSERT (orig_size
> orig_dot
);
9975 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9976 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9977 orig_dot
+= copy_size
;
9978 dup_dot
+= copy_size
;
9980 BFD_ASSERT (orig_size
== orig_dot
);
9981 BFD_ASSERT (final_size
== dup_dot
);
9983 /* Move the dup_contents back. */
9984 if (final_size
> orig_size
)
9986 /* Contents need to be reallocated. Swap the dup_contents into
9988 sec
->contents
= dup_contents
;
9990 contents
= dup_contents
;
9991 pin_contents (sec
, contents
);
9995 BFD_ASSERT (final_size
<= orig_size
);
9996 memset (contents
, 0, orig_size
);
9997 memcpy (contents
, dup_contents
, final_size
);
9998 free (dup_contents
);
10001 pin_contents (sec
, contents
);
10003 if (sec
->rawsize
== 0)
10004 sec
->rawsize
= sec
->size
;
10005 sec
->size
= final_size
;
10009 release_internal_relocs (sec
, internal_relocs
);
10010 release_contents (sec
, contents
);
10016 translate_section_fixes (asection
*sec
)
10018 xtensa_relax_info
*relax_info
;
10021 relax_info
= get_xtensa_relax_info (sec
);
10025 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
10026 if (!translate_reloc_bfd_fix (r
))
10033 /* Translate a fix given the mapping in the relax info for the target
10034 section. If it has already been translated, no work is required. */
10037 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
10039 reloc_bfd_fix new_fix
;
10041 xtensa_relax_info
*relax_info
;
10042 removed_literal
*removed
;
10043 bfd_vma new_offset
, target_offset
;
10045 if (fix
->translated
)
10048 sec
= fix
->target_sec
;
10049 target_offset
= fix
->target_offset
;
10051 relax_info
= get_xtensa_relax_info (sec
);
10054 fix
->translated
= true;
10060 /* The fix does not need to be translated if the section cannot change. */
10061 if (!relax_info
->is_relaxable_literal_section
10062 && !relax_info
->is_relaxable_asm_section
)
10064 fix
->translated
= true;
10068 /* If the literal has been moved and this relocation was on an
10069 opcode, then the relocation should move to the new literal
10070 location. Otherwise, the relocation should move within the
10074 if (is_operand_relocation (fix
->src_type
))
10076 /* Check if the original relocation is against a literal being
10078 removed
= find_removed_literal (&relax_info
->removed_list
,
10086 /* The fact that there is still a relocation to this literal indicates
10087 that the literal is being coalesced, not simply removed. */
10088 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10090 /* This was moved to some other address (possibly another section). */
10091 new_sec
= r_reloc_get_section (&removed
->to
);
10092 if (new_sec
!= sec
)
10095 relax_info
= get_xtensa_relax_info (sec
);
10097 (!relax_info
->is_relaxable_literal_section
10098 && !relax_info
->is_relaxable_asm_section
))
10100 target_offset
= removed
->to
.target_offset
;
10101 new_fix
.target_sec
= new_sec
;
10102 new_fix
.target_offset
= target_offset
;
10103 new_fix
.translated
= true;
10108 target_offset
= removed
->to
.target_offset
;
10109 new_fix
.target_sec
= new_sec
;
10112 /* The target address may have been moved within its section. */
10113 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
10116 new_fix
.target_offset
= new_offset
;
10117 new_fix
.target_offset
= new_offset
;
10118 new_fix
.translated
= true;
10124 /* Fix up a relocation to take account of removed literals. */
10127 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
10129 xtensa_relax_info
*relax_info
;
10130 removed_literal
*removed
;
10131 bfd_vma target_offset
, base_offset
;
10133 *new_rel
= *orig_rel
;
10135 if (!r_reloc_is_defined (orig_rel
))
10138 relax_info
= get_xtensa_relax_info (sec
);
10139 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
10140 || relax_info
->is_relaxable_asm_section
));
10142 target_offset
= orig_rel
->target_offset
;
10145 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
10147 /* Check if the original relocation is against a literal being
10149 removed
= find_removed_literal (&relax_info
->removed_list
,
10152 if (removed
&& removed
->to
.abfd
)
10156 /* The fact that there is still a relocation to this literal indicates
10157 that the literal is being coalesced, not simply removed. */
10158 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10160 /* This was moved to some other address
10161 (possibly in another section). */
10162 *new_rel
= removed
->to
;
10163 new_sec
= r_reloc_get_section (new_rel
);
10164 if (new_sec
!= sec
)
10167 relax_info
= get_xtensa_relax_info (sec
);
10169 || (!relax_info
->is_relaxable_literal_section
10170 && !relax_info
->is_relaxable_asm_section
))
10173 target_offset
= new_rel
->target_offset
;
10176 /* Find the base offset of the reloc symbol, excluding any addend from the
10177 reloc or from the section contents (for a partial_inplace reloc). Then
10178 find the adjusted values of the offsets due to relaxation. The base
10179 offset is needed to determine the change to the reloc's addend; the reloc
10180 addend should not be adjusted due to relaxations located before the base
10183 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
10184 if (base_offset
<= target_offset
)
10186 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
10187 base_offset
, false);
10188 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10189 target_offset
, false) -
10192 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
10193 new_rel
->rela
.r_addend
-= addend_removed
;
10197 /* Handle a negative addend. The base offset comes first. */
10198 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
10199 target_offset
, false);
10200 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10201 base_offset
, false) -
10204 new_rel
->target_offset
= target_offset
- tgt_removed
;
10205 new_rel
->rela
.r_addend
+= addend_removed
;
10212 /* For dynamic links, there may be a dynamic relocation for each
10213 literal. The number of dynamic relocations must be computed in
10214 size_dynamic_sections, which occurs before relaxation. When a
10215 literal is removed, this function checks if there is a corresponding
10216 dynamic relocation and shrinks the size of the appropriate dynamic
10217 relocation section accordingly. At this point, the contents of the
10218 dynamic relocation sections have not yet been filled in, so there's
10219 nothing else that needs to be done. */
10222 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
10224 asection
*input_section
,
10225 Elf_Internal_Rela
*rel
)
10227 struct elf_xtensa_link_hash_table
*htab
;
10228 Elf_Internal_Shdr
*symtab_hdr
;
10229 struct elf_link_hash_entry
**sym_hashes
;
10230 unsigned long r_symndx
;
10232 struct elf_link_hash_entry
*h
;
10233 bool dynamic_symbol
;
10235 htab
= elf_xtensa_hash_table (info
);
10239 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10240 sym_hashes
= elf_sym_hashes (abfd
);
10242 r_type
= ELF32_R_TYPE (rel
->r_info
);
10243 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10245 if (r_symndx
< symtab_hdr
->sh_info
)
10248 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10250 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10252 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10253 && (input_section
->flags
& SEC_ALLOC
) != 0
10255 || (bfd_link_pic (info
)
10256 && (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
))))
10259 bool is_plt
= false;
10261 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10263 srel
= htab
->elf
.srelplt
;
10267 srel
= htab
->elf
.srelgot
;
10269 /* Reduce size of the .rela.* section by one reloc. */
10270 BFD_ASSERT (srel
!= NULL
);
10271 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10272 srel
->size
-= sizeof (Elf32_External_Rela
);
10276 asection
*splt
, *sgotplt
, *srelgot
;
10277 int reloc_index
, chunk
;
10279 /* Find the PLT reloc index of the entry being removed. This
10280 is computed from the size of ".rela.plt". It is needed to
10281 figure out which PLT chunk to resize. Usually "last index
10282 = size - 1" since the index starts at zero, but in this
10283 context, the size has just been decremented so there's no
10284 need to subtract one. */
10285 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10287 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10288 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10289 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10290 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10292 /* Check if an entire PLT chunk has just been eliminated. */
10293 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10295 /* The two magic GOT entries for that chunk can go away. */
10296 srelgot
= htab
->elf
.srelgot
;
10297 BFD_ASSERT (srelgot
!= NULL
);
10298 srelgot
->reloc_count
-= 2;
10299 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10300 sgotplt
->size
-= 8;
10302 /* There should be only one entry left (and it will be
10304 BFD_ASSERT (sgotplt
->size
== 4);
10305 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10308 BFD_ASSERT (sgotplt
->size
>= 4);
10309 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10311 sgotplt
->size
-= 4;
10312 splt
->size
-= PLT_ENTRY_SIZE
;
10318 /* Take an r_rel and move it to another section. This usually
10319 requires extending the interal_relocation array and pinning it. If
10320 the original r_rel is from the same BFD, we can complete this here.
10321 Otherwise, we add a fix record to let the final link fix the
10322 appropriate address. Contents and internal relocations for the
10323 section must be pinned after calling this routine. */
10326 move_literal (bfd
*abfd
,
10327 struct bfd_link_info
*link_info
,
10330 bfd_byte
*contents
,
10331 xtensa_relax_info
*relax_info
,
10332 Elf_Internal_Rela
**internal_relocs_p
,
10333 const literal_value
*lit
)
10335 Elf_Internal_Rela
*new_relocs
= NULL
;
10336 size_t new_relocs_count
= 0;
10337 Elf_Internal_Rela this_rela
;
10338 const r_reloc
*r_rel
;
10340 r_rel
= &lit
->r_rel
;
10341 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10343 if (r_reloc_is_const (r_rel
))
10344 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10349 reloc_bfd_fix
*fix
;
10350 unsigned insert_at
;
10352 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10354 /* This is the difficult case. We have to create a fix up. */
10355 this_rela
.r_offset
= offset
;
10356 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10357 this_rela
.r_addend
=
10358 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10359 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10361 /* Currently, we cannot move relocations during a relocatable link. */
10362 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10363 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10364 r_reloc_get_section (r_rel
),
10365 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10367 /* We also need to mark that relocations are needed here. */
10368 sec
->flags
|= SEC_RELOC
;
10370 translate_reloc_bfd_fix (fix
);
10371 /* This fix has not yet been translated. */
10372 add_fix (sec
, fix
);
10374 /* Add the relocation. If we have already allocated our own
10375 space for the relocations and we have room for more, then use
10376 it. Otherwise, allocate new space and move the literals. */
10377 insert_at
= sec
->reloc_count
;
10378 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10380 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10387 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10388 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10390 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10391 || sec
->reloc_count
== relax_info
->relocs_count
);
10393 if (relax_info
->allocated_relocs_count
== 0)
10394 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10396 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10398 new_relocs
= (Elf_Internal_Rela
*)
10399 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10403 /* We could handle this more quickly by finding the split point. */
10404 if (insert_at
!= 0)
10405 memcpy (new_relocs
, *internal_relocs_p
,
10406 insert_at
* sizeof (Elf_Internal_Rela
));
10408 new_relocs
[insert_at
] = this_rela
;
10410 if (insert_at
!= sec
->reloc_count
)
10411 memcpy (new_relocs
+ insert_at
+ 1,
10412 (*internal_relocs_p
) + insert_at
,
10413 (sec
->reloc_count
- insert_at
)
10414 * sizeof (Elf_Internal_Rela
));
10416 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10418 /* The first time we re-allocate, we can only free the
10419 old relocs if they were allocated with bfd_malloc.
10420 This is not true when keep_memory is in effect. */
10421 if (!link_info
->keep_memory
)
10422 free (*internal_relocs_p
);
10425 free (*internal_relocs_p
);
10426 relax_info
->allocated_relocs
= new_relocs
;
10427 relax_info
->allocated_relocs_count
= new_relocs_count
;
10428 elf_section_data (sec
)->relocs
= new_relocs
;
10429 sec
->reloc_count
++;
10430 relax_info
->relocs_count
= sec
->reloc_count
;
10431 *internal_relocs_p
= new_relocs
;
10435 if (insert_at
!= sec
->reloc_count
)
10438 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10439 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10441 (*internal_relocs_p
)[insert_at
] = this_rela
;
10442 sec
->reloc_count
++;
10443 if (relax_info
->allocated_relocs
)
10444 relax_info
->relocs_count
= sec
->reloc_count
;
10451 /* This is similar to relax_section except that when a target is moved,
10452 we shift addresses up. We also need to modify the size. This
10453 algorithm does NOT allow for relocations into the middle of the
10454 property sections. */
10457 relax_property_section (bfd
*abfd
,
10459 struct bfd_link_info
*link_info
)
10461 Elf_Internal_Rela
*internal_relocs
;
10462 bfd_byte
*contents
;
10465 bool is_full_prop_section
;
10466 size_t last_zfill_target_offset
= 0;
10467 asection
*last_zfill_target_sec
= NULL
;
10468 bfd_size_type sec_size
;
10469 bfd_size_type entry_size
;
10471 sec_size
= bfd_get_section_limit (abfd
, sec
);
10472 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10473 link_info
->keep_memory
);
10474 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10475 if (contents
== NULL
&& sec_size
!= 0)
10481 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10482 if (is_full_prop_section
)
10487 if (internal_relocs
)
10489 for (i
= 0; i
< sec
->reloc_count
; i
++)
10491 Elf_Internal_Rela
*irel
;
10492 xtensa_relax_info
*target_relax_info
;
10494 asection
*target_sec
;
10496 bfd_byte
*size_p
, *flags_p
;
10498 /* Locally change the source address.
10499 Translate the target to the new target address.
10500 If it points to this section and has been removed, MOVE IT.
10501 Also, don't forget to modify the associated SIZE at
10504 irel
= &internal_relocs
[i
];
10505 r_type
= ELF32_R_TYPE (irel
->r_info
);
10506 if (r_type
== R_XTENSA_NONE
)
10509 /* Find the literal value. */
10510 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10511 size_p
= &contents
[irel
->r_offset
+ 4];
10513 if (is_full_prop_section
)
10514 flags_p
= &contents
[irel
->r_offset
+ 8];
10515 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10517 target_sec
= r_reloc_get_section (&val
.r_rel
);
10518 target_relax_info
= get_xtensa_relax_info (target_sec
);
10520 if (target_relax_info
10521 && (target_relax_info
->is_relaxable_literal_section
10522 || target_relax_info
->is_relaxable_asm_section
))
10524 /* Translate the relocation's destination. */
10525 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10526 bfd_vma new_offset
;
10527 long old_size
, new_size
;
10528 int removed_by_old_offset
=
10529 removed_by_actions_map (&target_relax_info
->action_list
,
10530 old_offset
, false);
10531 new_offset
= old_offset
- removed_by_old_offset
;
10533 /* Assert that we are not out of bounds. */
10534 old_size
= bfd_get_32 (abfd
, size_p
);
10535 new_size
= old_size
;
10539 /* Only the first zero-sized unreachable entry is
10540 allowed to expand. In this case the new offset
10541 should be the offset before the fill and the new
10542 size is the expansion size. For other zero-sized
10543 entries the resulting size should be zero with an
10544 offset before or after the fill address depending
10545 on whether the expanding unreachable entry
10547 if (last_zfill_target_sec
== 0
10548 || last_zfill_target_sec
!= target_sec
10549 || last_zfill_target_offset
!= old_offset
)
10551 bfd_vma new_end_offset
= new_offset
;
10553 /* Recompute the new_offset, but this time don't
10554 include any fill inserted by relaxation. */
10555 removed_by_old_offset
=
10556 removed_by_actions_map (&target_relax_info
->action_list
,
10558 new_offset
= old_offset
- removed_by_old_offset
;
10560 /* If it is not unreachable and we have not yet
10561 seen an unreachable at this address, place it
10562 before the fill address. */
10563 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10564 & XTENSA_PROP_UNREACHABLE
) != 0)
10566 new_size
= new_end_offset
- new_offset
;
10568 last_zfill_target_sec
= target_sec
;
10569 last_zfill_target_offset
= old_offset
;
10575 int removed_by_old_offset_size
=
10576 removed_by_actions_map (&target_relax_info
->action_list
,
10577 old_offset
+ old_size
, true);
10578 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10581 if (new_size
!= old_size
)
10583 bfd_put_32 (abfd
, new_size
, size_p
);
10584 pin_contents (sec
, contents
);
10587 if (new_offset
!= old_offset
)
10589 bfd_vma diff
= new_offset
- old_offset
;
10590 irel
->r_addend
+= diff
;
10591 pin_internal_relocs (sec
, internal_relocs
);
10597 /* Combine adjacent property table entries. This is also done in
10598 finish_dynamic_sections() but at that point it's too late to
10599 reclaim the space in the output section, so we do this twice. */
10601 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10602 || xtensa_is_littable_section (sec
)))
10604 Elf_Internal_Rela
*last_irel
= NULL
;
10605 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10606 int removed_bytes
= 0;
10608 flagword predef_flags
;
10610 predef_flags
= xtensa_get_property_predef_flags (sec
);
10612 /* Walk over memory and relocations at the same time.
10613 This REQUIRES that the internal_relocs be sorted by offset. */
10614 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10615 internal_reloc_compare
);
10617 pin_internal_relocs (sec
, internal_relocs
);
10618 pin_contents (sec
, contents
);
10620 next_rel
= internal_relocs
;
10621 rel_end
= internal_relocs
+ sec
->reloc_count
;
10623 BFD_ASSERT (sec
->size
% entry_size
== 0);
10625 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10627 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10628 bfd_vma bytes_to_remove
, size
, actual_offset
;
10629 bool remove_this_rel
;
10632 /* Find the first relocation for the entry at the current offset.
10633 Adjust the offsets of any extra relocations for the previous
10638 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10640 if ((irel
->r_offset
== offset
10641 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10642 || irel
->r_offset
> offset
)
10647 irel
->r_offset
-= removed_bytes
;
10651 /* Find the next relocation (if there are any left). */
10655 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10657 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10665 /* Check if there are relocations on the current entry. There
10666 should usually be a relocation on the offset field. If there
10667 are relocations on the size or flags, then we can't optimize
10668 this entry. Also, find the next relocation to examine on the
10672 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10674 next_rel
= offset_rel
;
10675 /* There are no relocations on the current entry, but we
10676 might still be able to remove it if the size is zero. */
10679 else if (offset_rel
->r_offset
> offset
10681 && extra_rel
->r_offset
< offset
+ entry_size
))
10683 /* There is a relocation on the size or flags, so we can't
10684 do anything with this entry. Continue with the next. */
10685 next_rel
= offset_rel
;
10690 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10691 offset_rel
->r_offset
-= removed_bytes
;
10692 next_rel
= offset_rel
+ 1;
10698 remove_this_rel
= false;
10699 bytes_to_remove
= 0;
10700 actual_offset
= offset
- removed_bytes
;
10701 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10703 if (is_full_prop_section
)
10704 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10706 flags
= predef_flags
;
10709 && (flags
& XTENSA_PROP_ALIGN
) == 0
10710 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10712 /* Always remove entries with zero size and no alignment. */
10713 bytes_to_remove
= entry_size
;
10715 remove_this_rel
= true;
10717 else if (offset_rel
10718 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10722 flagword old_flags
;
10724 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10725 bfd_vma old_address
=
10726 (last_irel
->r_addend
10727 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10728 bfd_vma new_address
=
10729 (offset_rel
->r_addend
10730 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10731 if (is_full_prop_section
)
10732 old_flags
= bfd_get_32
10733 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10735 old_flags
= predef_flags
;
10737 if ((ELF32_R_SYM (offset_rel
->r_info
)
10738 == ELF32_R_SYM (last_irel
->r_info
))
10739 && old_address
+ old_size
== new_address
10740 && old_flags
== flags
10741 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10742 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10744 /* Fix the old size. */
10745 bfd_put_32 (abfd
, old_size
+ size
,
10746 &contents
[last_irel
->r_offset
+ 4]);
10747 bytes_to_remove
= entry_size
;
10748 remove_this_rel
= true;
10751 last_irel
= offset_rel
;
10754 last_irel
= offset_rel
;
10757 if (remove_this_rel
)
10759 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10760 offset_rel
->r_offset
= 0;
10763 if (bytes_to_remove
!= 0)
10765 removed_bytes
+= bytes_to_remove
;
10766 if (offset
+ bytes_to_remove
< sec
->size
)
10767 memmove (&contents
[actual_offset
],
10768 &contents
[actual_offset
+ bytes_to_remove
],
10769 sec
->size
- offset
- bytes_to_remove
);
10775 /* Fix up any extra relocations on the last entry. */
10776 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10777 irel
->r_offset
-= removed_bytes
;
10779 /* Clear the removed bytes. */
10780 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10782 if (sec
->rawsize
== 0)
10783 sec
->rawsize
= sec
->size
;
10784 sec
->size
-= removed_bytes
;
10786 if (xtensa_is_littable_section (sec
))
10788 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10790 sgotloc
->size
-= removed_bytes
;
10796 release_internal_relocs (sec
, internal_relocs
);
10797 release_contents (sec
, contents
);
10802 /* Third relaxation pass. */
10804 /* Change symbol values to account for removed literals. */
10807 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10809 xtensa_relax_info
*relax_info
;
10810 unsigned int sec_shndx
;
10811 Elf_Internal_Shdr
*symtab_hdr
;
10812 Elf_Internal_Sym
*isymbuf
;
10813 unsigned i
, num_syms
, num_locals
;
10815 relax_info
= get_xtensa_relax_info (sec
);
10816 BFD_ASSERT (relax_info
);
10818 if (!relax_info
->is_relaxable_literal_section
10819 && !relax_info
->is_relaxable_asm_section
)
10822 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10824 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10825 isymbuf
= retrieve_local_syms (abfd
);
10827 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10828 num_locals
= symtab_hdr
->sh_info
;
10830 /* Adjust the local symbols defined in this section. */
10831 for (i
= 0; i
< num_locals
; i
++)
10833 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10835 if (isym
->st_shndx
== sec_shndx
)
10837 bfd_vma orig_addr
= isym
->st_value
;
10838 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10841 isym
->st_value
-= removed
;
10842 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10844 removed_by_actions_map (&relax_info
->action_list
,
10845 orig_addr
+ isym
->st_size
, false) -
10850 /* Now adjust the global symbols defined in this section. */
10851 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10853 struct elf_link_hash_entry
*sym_hash
;
10855 sym_hash
= elf_sym_hashes (abfd
)[i
];
10857 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10858 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10860 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10861 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10862 && sym_hash
->root
.u
.def
.section
== sec
)
10864 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10865 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10868 sym_hash
->root
.u
.def
.value
-= removed
;
10870 if (sym_hash
->type
== STT_FUNC
)
10872 removed_by_actions_map (&relax_info
->action_list
,
10873 orig_addr
+ sym_hash
->size
, false) -
10882 /* "Fix" handling functions, called while performing relocations. */
10885 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10887 asection
*input_section
,
10888 bfd_byte
*contents
)
10891 asection
*sec
, *old_sec
;
10892 bfd_vma old_offset
;
10893 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10894 reloc_bfd_fix
*fix
;
10896 if (r_type
== R_XTENSA_NONE
)
10899 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10903 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10904 bfd_get_section_limit (input_bfd
, input_section
));
10905 old_sec
= r_reloc_get_section (&r_rel
);
10906 old_offset
= r_rel
.target_offset
;
10908 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10910 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10913 /* xgettext:c-format */
10914 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10915 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10916 elf_howto_table
[r_type
].name
);
10919 /* Leave it be. Resolution will happen in a later stage. */
10923 sec
= fix
->target_sec
;
10924 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10925 - (old_sec
->output_offset
+ old_offset
));
10932 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10934 asection
*input_section
,
10935 bfd_byte
*contents
,
10936 bfd_vma
*relocationp
)
10939 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10940 reloc_bfd_fix
*fix
;
10941 bfd_vma fixup_diff
;
10943 if (r_type
== R_XTENSA_NONE
)
10946 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10950 sec
= fix
->target_sec
;
10952 fixup_diff
= rel
->r_addend
;
10953 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10955 bfd_vma inplace_val
;
10956 BFD_ASSERT (fix
->src_offset
10957 < bfd_get_section_limit (input_bfd
, input_section
));
10958 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10959 fixup_diff
+= inplace_val
;
10962 *relocationp
= (sec
->output_section
->vma
10963 + sec
->output_offset
10964 + fix
->target_offset
- fixup_diff
);
10968 /* Miscellaneous utility functions.... */
10971 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10977 return elf_hash_table (info
)->splt
;
10979 dynobj
= elf_hash_table (info
)->dynobj
;
10980 sprintf (plt_name
, ".plt.%u", chunk
);
10981 return bfd_get_linker_section (dynobj
, plt_name
);
10986 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10992 return elf_hash_table (info
)->sgotplt
;
10994 dynobj
= elf_hash_table (info
)->dynobj
;
10995 sprintf (got_name
, ".got.plt.%u", chunk
);
10996 return bfd_get_linker_section (dynobj
, got_name
);
11000 /* Get the input section for a given symbol index.
11002 . a section symbol, return the section;
11003 . a common symbol, return the common section;
11004 . an undefined symbol, return the undefined section;
11005 . an indirect symbol, follow the links;
11006 . an absolute value, return the absolute section. */
11009 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
11011 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11012 asection
*target_sec
= NULL
;
11013 if (r_symndx
< symtab_hdr
->sh_info
)
11015 Elf_Internal_Sym
*isymbuf
;
11016 unsigned int section_index
;
11018 isymbuf
= retrieve_local_syms (abfd
);
11019 section_index
= isymbuf
[r_symndx
].st_shndx
;
11021 if (section_index
== SHN_UNDEF
)
11022 target_sec
= bfd_und_section_ptr
;
11023 else if (section_index
== SHN_ABS
)
11024 target_sec
= bfd_abs_section_ptr
;
11025 else if (section_index
== SHN_COMMON
)
11026 target_sec
= bfd_com_section_ptr
;
11028 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
11032 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11033 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
11035 while (h
->root
.type
== bfd_link_hash_indirect
11036 || h
->root
.type
== bfd_link_hash_warning
)
11037 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11039 switch (h
->root
.type
)
11041 case bfd_link_hash_defined
:
11042 case bfd_link_hash_defweak
:
11043 target_sec
= h
->root
.u
.def
.section
;
11045 case bfd_link_hash_common
:
11046 target_sec
= bfd_com_section_ptr
;
11048 case bfd_link_hash_undefined
:
11049 case bfd_link_hash_undefweak
:
11050 target_sec
= bfd_und_section_ptr
;
11052 default: /* New indirect warning. */
11053 target_sec
= bfd_und_section_ptr
;
11061 static struct elf_link_hash_entry
*
11062 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
11064 unsigned long indx
;
11065 struct elf_link_hash_entry
*h
;
11066 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11068 if (r_symndx
< symtab_hdr
->sh_info
)
11071 indx
= r_symndx
- symtab_hdr
->sh_info
;
11072 h
= elf_sym_hashes (abfd
)[indx
];
11073 while (h
->root
.type
== bfd_link_hash_indirect
11074 || h
->root
.type
== bfd_link_hash_warning
)
11075 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11080 /* Get the section-relative offset for a symbol number. */
11083 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
11085 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11086 bfd_vma offset
= 0;
11088 if (r_symndx
< symtab_hdr
->sh_info
)
11090 Elf_Internal_Sym
*isymbuf
;
11091 isymbuf
= retrieve_local_syms (abfd
);
11092 offset
= isymbuf
[r_symndx
].st_value
;
11096 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11097 struct elf_link_hash_entry
*h
=
11098 elf_sym_hashes (abfd
)[indx
];
11100 while (h
->root
.type
== bfd_link_hash_indirect
11101 || h
->root
.type
== bfd_link_hash_warning
)
11102 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11103 if (h
->root
.type
== bfd_link_hash_defined
11104 || h
->root
.type
== bfd_link_hash_defweak
)
11105 offset
= h
->root
.u
.def
.value
;
11112 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
11114 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
11115 struct elf_link_hash_entry
*h
;
11117 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
11118 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
11125 pcrel_reloc_fits (xtensa_opcode opc
,
11127 bfd_vma self_address
,
11128 bfd_vma dest_address
)
11130 xtensa_isa isa
= xtensa_default_isa
;
11131 uint32 valp
= dest_address
;
11132 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
11133 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
11140 xtensa_is_property_section (asection
*sec
)
11142 if (xtensa_is_insntable_section (sec
)
11143 || xtensa_is_littable_section (sec
)
11144 || xtensa_is_proptable_section (sec
))
11152 xtensa_is_insntable_section (asection
*sec
)
11154 if (startswith (sec
->name
, XTENSA_INSN_SEC_NAME
)
11155 || startswith (sec
->name
, ".gnu.linkonce.x."))
11163 xtensa_is_littable_section (asection
*sec
)
11165 if (startswith (sec
->name
, XTENSA_LIT_SEC_NAME
)
11166 || startswith (sec
->name
, ".gnu.linkonce.p."))
11174 xtensa_is_proptable_section (asection
*sec
)
11176 if (startswith (sec
->name
, XTENSA_PROP_SEC_NAME
)
11177 || startswith (sec
->name
, ".gnu.linkonce.prop."))
11185 internal_reloc_compare (const void *ap
, const void *bp
)
11187 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11188 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11190 if (a
->r_offset
!= b
->r_offset
)
11191 return (a
->r_offset
- b
->r_offset
);
11193 /* We don't need to sort on these criteria for correctness,
11194 but enforcing a more strict ordering prevents unstable qsort
11195 from behaving differently with different implementations.
11196 Without the code below we get correct but different results
11197 on Solaris 2.7 and 2.8. We would like to always produce the
11198 same results no matter the host. */
11200 if (a
->r_info
!= b
->r_info
)
11201 return (a
->r_info
- b
->r_info
);
11203 return (a
->r_addend
- b
->r_addend
);
11208 internal_reloc_matches (const void *ap
, const void *bp
)
11210 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11211 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11213 /* Check if one entry overlaps with the other; this shouldn't happen
11214 except when searching for a match. */
11215 return (a
->r_offset
- b
->r_offset
);
11219 /* Predicate function used to look up a section in a particular group. */
11222 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
11224 const char *gname
= inf
;
11225 const char *group_name
= elf_group_name (sec
);
11227 return (group_name
== gname
11228 || (group_name
!= NULL
11230 && strcmp (group_name
, gname
) == 0));
11235 xtensa_add_names (const char *base
, const char *suffix
)
11239 size_t base_len
= strlen (base
);
11240 size_t suffix_len
= strlen (suffix
);
11241 char *str
= bfd_malloc (base_len
+ suffix_len
+ 1);
11243 memcpy (str
, base
, base_len
);
11244 memcpy (str
+ base_len
, suffix
, suffix_len
+ 1);
11249 return strdup (base
);
11253 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11256 xtensa_property_section_name (asection
*sec
, const char *base_name
,
11257 bool separate_sections
)
11259 const char *suffix
, *group_name
;
11260 char *prop_sec_name
;
11262 group_name
= elf_group_name (sec
);
11265 suffix
= strrchr (sec
->name
, '.');
11266 if (suffix
== sec
->name
)
11268 prop_sec_name
= xtensa_add_names (base_name
, suffix
);
11270 else if (startswith (sec
->name
, ".gnu.linkonce."))
11272 char *linkonce_kind
= 0;
11274 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11275 linkonce_kind
= "x.";
11276 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11277 linkonce_kind
= "p.";
11278 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11279 linkonce_kind
= "prop.";
11283 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11284 + strlen (linkonce_kind
) + 1);
11285 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11286 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11288 suffix
= sec
->name
+ linkonce_len
;
11289 /* For backward compatibility, replace "t." instead of inserting
11290 the new linkonce_kind (but not for "prop" sections). */
11291 if (startswith (suffix
, "t.") && linkonce_kind
[1] == '.')
11293 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11297 prop_sec_name
= xtensa_add_names (base_name
,
11298 separate_sections
? sec
->name
: NULL
);
11301 return prop_sec_name
;
11306 xtensa_get_separate_property_section (asection
*sec
, const char *base_name
,
11307 bool separate_section
)
11309 char *prop_sec_name
;
11310 asection
*prop_sec
;
11312 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11314 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11315 match_section_group
,
11316 (void *) elf_group_name (sec
));
11317 free (prop_sec_name
);
11322 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11324 asection
*prop_sec
;
11326 /* Try individual property section first. */
11327 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, true);
11329 /* Refer to a common property section if individual is not present. */
11331 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, false);
11338 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11340 char *prop_sec_name
;
11341 asection
*prop_sec
;
11343 /* Check if the section already exists. */
11344 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11345 elf32xtensa_separate_props
);
11346 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11347 match_section_group
,
11348 (void *) elf_group_name (sec
));
11349 /* If not, create it. */
11352 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11353 flags
|= (bfd_section_flags (sec
)
11354 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11356 prop_sec
= bfd_make_section_anyway_with_flags
11357 (sec
->owner
, strdup (prop_sec_name
), flags
);
11361 elf_group_name (prop_sec
) = elf_group_name (sec
);
11364 free (prop_sec_name
);
11370 xtensa_get_property_predef_flags (asection
*sec
)
11372 if (xtensa_is_insntable_section (sec
))
11373 return (XTENSA_PROP_INSN
11374 | XTENSA_PROP_NO_TRANSFORM
11375 | XTENSA_PROP_INSN_NO_REORDER
);
11377 if (xtensa_is_littable_section (sec
))
11378 return (XTENSA_PROP_LITERAL
11379 | XTENSA_PROP_NO_TRANSFORM
11380 | XTENSA_PROP_INSN_NO_REORDER
);
11386 /* Other functions called directly by the linker. */
11389 xtensa_callback_required_dependence (bfd
*abfd
,
11391 struct bfd_link_info
*link_info
,
11392 deps_callback_t callback
,
11395 Elf_Internal_Rela
*internal_relocs
;
11396 bfd_byte
*contents
;
11399 bfd_size_type sec_size
;
11401 sec_size
= bfd_get_section_limit (abfd
, sec
);
11403 /* ".plt*" sections have no explicit relocations but they contain L32R
11404 instructions that reference the corresponding ".got.plt*" sections. */
11405 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11406 && startswith (sec
->name
, ".plt"))
11410 /* Find the corresponding ".got.plt*" section. */
11411 if (sec
->name
[4] == '\0')
11412 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11418 BFD_ASSERT (sec
->name
[4] == '.');
11419 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11421 sprintf (got_name
, ".got.plt.%u", chunk
);
11422 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11424 BFD_ASSERT (sgotplt
);
11426 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11427 section referencing a literal at the very beginning of
11428 ".got.plt". This is very close to the real dependence, anyway. */
11429 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11432 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11433 when building uclibc, which runs "ld -b binary /dev/null". */
11434 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11437 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11438 link_info
->keep_memory
);
11439 if (internal_relocs
== NULL
11440 || sec
->reloc_count
== 0)
11443 /* Cache the contents for the duration of this scan. */
11444 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11445 if (contents
== NULL
&& sec_size
!= 0)
11451 if (!xtensa_default_isa
)
11452 xtensa_default_isa
= xtensa_isa_init (0, 0);
11454 for (i
= 0; i
< sec
->reloc_count
; i
++)
11456 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11457 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11460 asection
*target_sec
;
11461 bfd_vma target_offset
;
11463 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11466 /* L32Rs must be local to the input file. */
11467 if (r_reloc_is_defined (&l32r_rel
))
11469 target_sec
= r_reloc_get_section (&l32r_rel
);
11470 target_offset
= l32r_rel
.target_offset
;
11472 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11478 release_internal_relocs (sec
, internal_relocs
);
11479 release_contents (sec
, contents
);
11483 /* The default literal sections should always be marked as "code" (i.e.,
11484 SHF_EXECINSTR). This is particularly important for the Linux kernel
11485 module loader so that the literals are not placed after the text. */
11486 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11488 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11489 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11490 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11491 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11492 { NULL
, 0, 0, 0, 0 }
11495 #define ELF_TARGET_ID XTENSA_ELF_DATA
11497 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11498 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11499 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11500 #define TARGET_BIG_NAME "elf32-xtensa-be"
11501 #define ELF_ARCH bfd_arch_xtensa
11503 #define ELF_MACHINE_CODE EM_XTENSA
11504 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11506 #define ELF_MAXPAGESIZE 0x1000
11507 #endif /* ELF_ARCH */
11509 #define elf_backend_can_gc_sections 1
11510 #define elf_backend_can_refcount 1
11511 #define elf_backend_plt_readonly 1
11512 #define elf_backend_got_header_size 4
11513 #define elf_backend_want_dynbss 0
11514 #define elf_backend_want_got_plt 1
11515 #define elf_backend_dtrel_excludes_plt 1
11517 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11519 #define bfd_elf32_mkobject elf_xtensa_mkobject
11521 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11522 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11523 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11524 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11525 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11526 #define bfd_elf32_bfd_reloc_name_lookup \
11527 elf_xtensa_reloc_name_lookup
11528 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11529 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11531 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11532 #define elf_backend_check_relocs elf_xtensa_check_relocs
11533 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11534 #define elf_backend_discard_info elf_xtensa_discard_info
11535 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11536 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11537 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11538 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11539 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11540 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11541 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11542 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11543 #define elf_backend_object_p elf_xtensa_object_p
11544 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11545 #define elf_backend_relocate_section elf_xtensa_relocate_section
11546 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11547 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11548 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11549 #define elf_backend_special_sections elf_xtensa_special_sections
11550 #define elf_backend_action_discarded elf_xtensa_action_discarded
11551 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11553 #include "elf32-target.h"