1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright (C) 2003-2022 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, 0, 0, false, 0, complain_overflow_dont
,
195 bfd_elf_xtensa_reloc
, "R_XTENSA_NONE",
197 HOWTO (R_XTENSA_32
, 0, 4, 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, 4, 32, false, 0, complain_overflow_dont
,
207 NULL
, "R_XTENSA_RTLD", false, 0, 0, false),
209 HOWTO (R_XTENSA_GLOB_DAT
, 0, 4, 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, 4, 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, 4, 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, 4, 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, 4, 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, 4, 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, 4, 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, 1, 8, false, 0, complain_overflow_signed
,
256 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF8", false, 0, 0xff, false),
257 HOWTO (R_XTENSA_DIFF16
, 0, 2, 16, false, 0, complain_overflow_signed
,
258 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF16", false, 0, 0xffff, false),
259 HOWTO (R_XTENSA_DIFF32
, 0, 4, 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, 4, 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, 4, 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, 4, 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, 4, 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, 1, 8, false, 0, complain_overflow_bitfield
,
350 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF8", false, 0, 0xff, false),
351 HOWTO (R_XTENSA_PDIFF16
, 0, 2, 16, false, 0, complain_overflow_bitfield
,
352 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF16", false, 0, 0xffff, false),
353 HOWTO (R_XTENSA_PDIFF32
, 0, 4, 32, false, 0, complain_overflow_bitfield
,
354 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF32", false, 0, 0xffffffff, false),
356 HOWTO (R_XTENSA_NDIFF8
, 0, 1, 8, false, 0, complain_overflow_bitfield
,
357 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF8", false, 0, 0xff, false),
358 HOWTO (R_XTENSA_NDIFF16
, 0, 2, 16, false, 0, complain_overflow_bitfield
,
359 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF16", false, 0, 0xffff, false),
360 HOWTO (R_XTENSA_NDIFF32
, 0, 4, 32, false, 0, complain_overflow_bitfield
,
361 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF32", false, 0, 0xffffffff, false),
366 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
371 static reloc_howto_type
*
372 elf_xtensa_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
373 bfd_reloc_code_real_type code
)
378 TRACE ("BFD_RELOC_NONE");
379 return &elf_howto_table
[(unsigned) R_XTENSA_NONE
];
382 TRACE ("BFD_RELOC_32");
383 return &elf_howto_table
[(unsigned) R_XTENSA_32
];
385 case BFD_RELOC_32_PCREL
:
386 TRACE ("BFD_RELOC_32_PCREL");
387 return &elf_howto_table
[(unsigned) R_XTENSA_32_PCREL
];
389 case BFD_RELOC_XTENSA_DIFF8
:
390 TRACE ("BFD_RELOC_XTENSA_DIFF8");
391 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF8
];
393 case BFD_RELOC_XTENSA_DIFF16
:
394 TRACE ("BFD_RELOC_XTENSA_DIFF16");
395 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF16
];
397 case BFD_RELOC_XTENSA_DIFF32
:
398 TRACE ("BFD_RELOC_XTENSA_DIFF32");
399 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF32
];
401 case BFD_RELOC_XTENSA_PDIFF8
:
402 TRACE ("BFD_RELOC_XTENSA_PDIFF8");
403 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF8
];
405 case BFD_RELOC_XTENSA_PDIFF16
:
406 TRACE ("BFD_RELOC_XTENSA_PDIFF16");
407 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF16
];
409 case BFD_RELOC_XTENSA_PDIFF32
:
410 TRACE ("BFD_RELOC_XTENSA_PDIFF32");
411 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF32
];
413 case BFD_RELOC_XTENSA_NDIFF8
:
414 TRACE ("BFD_RELOC_XTENSA_NDIFF8");
415 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF8
];
417 case BFD_RELOC_XTENSA_NDIFF16
:
418 TRACE ("BFD_RELOC_XTENSA_NDIFF16");
419 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF16
];
421 case BFD_RELOC_XTENSA_NDIFF32
:
422 TRACE ("BFD_RELOC_XTENSA_NDIFF32");
423 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF32
];
425 case BFD_RELOC_XTENSA_RTLD
:
426 TRACE ("BFD_RELOC_XTENSA_RTLD");
427 return &elf_howto_table
[(unsigned) R_XTENSA_RTLD
];
429 case BFD_RELOC_XTENSA_GLOB_DAT
:
430 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
431 return &elf_howto_table
[(unsigned) R_XTENSA_GLOB_DAT
];
433 case BFD_RELOC_XTENSA_JMP_SLOT
:
434 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
435 return &elf_howto_table
[(unsigned) R_XTENSA_JMP_SLOT
];
437 case BFD_RELOC_XTENSA_RELATIVE
:
438 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
439 return &elf_howto_table
[(unsigned) R_XTENSA_RELATIVE
];
441 case BFD_RELOC_XTENSA_PLT
:
442 TRACE ("BFD_RELOC_XTENSA_PLT");
443 return &elf_howto_table
[(unsigned) R_XTENSA_PLT
];
445 case BFD_RELOC_XTENSA_OP0
:
446 TRACE ("BFD_RELOC_XTENSA_OP0");
447 return &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
449 case BFD_RELOC_XTENSA_OP1
:
450 TRACE ("BFD_RELOC_XTENSA_OP1");
451 return &elf_howto_table
[(unsigned) R_XTENSA_OP1
];
453 case BFD_RELOC_XTENSA_OP2
:
454 TRACE ("BFD_RELOC_XTENSA_OP2");
455 return &elf_howto_table
[(unsigned) R_XTENSA_OP2
];
457 case BFD_RELOC_XTENSA_ASM_EXPAND
:
458 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
459 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_EXPAND
];
461 case BFD_RELOC_XTENSA_ASM_SIMPLIFY
:
462 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
463 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_SIMPLIFY
];
465 case BFD_RELOC_VTABLE_INHERIT
:
466 TRACE ("BFD_RELOC_VTABLE_INHERIT");
467 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTINHERIT
];
469 case BFD_RELOC_VTABLE_ENTRY
:
470 TRACE ("BFD_RELOC_VTABLE_ENTRY");
471 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTENTRY
];
473 case BFD_RELOC_XTENSA_TLSDESC_FN
:
474 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
475 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_FN
];
477 case BFD_RELOC_XTENSA_TLSDESC_ARG
:
478 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
479 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_ARG
];
481 case BFD_RELOC_XTENSA_TLS_DTPOFF
:
482 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
483 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_DTPOFF
];
485 case BFD_RELOC_XTENSA_TLS_TPOFF
:
486 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
487 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_TPOFF
];
489 case BFD_RELOC_XTENSA_TLS_FUNC
:
490 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
491 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_FUNC
];
493 case BFD_RELOC_XTENSA_TLS_ARG
:
494 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
495 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_ARG
];
497 case BFD_RELOC_XTENSA_TLS_CALL
:
498 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
499 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_CALL
];
502 if (code
>= BFD_RELOC_XTENSA_SLOT0_OP
503 && code
<= BFD_RELOC_XTENSA_SLOT14_OP
)
505 unsigned n
= (R_XTENSA_SLOT0_OP
+
506 (code
- BFD_RELOC_XTENSA_SLOT0_OP
));
507 return &elf_howto_table
[n
];
510 if (code
>= BFD_RELOC_XTENSA_SLOT0_ALT
511 && code
<= BFD_RELOC_XTENSA_SLOT14_ALT
)
513 unsigned n
= (R_XTENSA_SLOT0_ALT
+
514 (code
- BFD_RELOC_XTENSA_SLOT0_ALT
));
515 return &elf_howto_table
[n
];
521 /* xgettext:c-format */
522 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
, (int) code
);
523 bfd_set_error (bfd_error_bad_value
);
528 static reloc_howto_type
*
529 elf_xtensa_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
534 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
535 if (elf_howto_table
[i
].name
!= NULL
536 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
537 return &elf_howto_table
[i
];
543 /* Given an ELF "rela" relocation, find the corresponding howto and record
544 it in the BFD internal arelent representation of the relocation. */
547 elf_xtensa_info_to_howto_rela (bfd
*abfd
,
549 Elf_Internal_Rela
*dst
)
551 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
553 if (r_type
>= (unsigned int) R_XTENSA_max
)
555 /* xgettext:c-format */
556 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
558 bfd_set_error (bfd_error_bad_value
);
561 cache_ptr
->howto
= &elf_howto_table
[r_type
];
566 /* Functions for the Xtensa ELF linker. */
568 /* The name of the dynamic interpreter. This is put in the .interp
571 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
573 /* The size in bytes of an entry in the procedure linkage table.
574 (This does _not_ include the space for the literals associated with
577 #define PLT_ENTRY_SIZE 16
579 /* For _really_ large PLTs, we may need to alternate between literals
580 and code to keep the literals within the 256K range of the L32R
581 instructions in the code. It's unlikely that anyone would ever need
582 such a big PLT, but an arbitrary limit on the PLT size would be bad.
583 Thus, we split the PLT into chunks. Since there's very little
584 overhead (2 extra literals) for each chunk, the chunk size is kept
585 small so that the code for handling multiple chunks get used and
586 tested regularly. With 254 entries, there are 1K of literals for
587 each chunk, and that seems like a nice round number. */
589 #define PLT_ENTRIES_PER_CHUNK 254
591 /* PLT entries are actually used as stub functions for lazy symbol
592 resolution. Once the symbol is resolved, the stub function is never
593 invoked. Note: the 32-byte frame size used here cannot be changed
594 without a corresponding change in the runtime linker. */
596 static const bfd_byte elf_xtensa_be_plt_entry
[][PLT_ENTRY_SIZE
] =
599 0x6c, 0x10, 0x04, /* entry sp, 32 */
600 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
601 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
602 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
603 0x0a, 0x80, 0x00, /* jx a8 */
607 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
608 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
609 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
610 0x0a, 0x80, 0x00, /* jx a8 */
615 static const bfd_byte elf_xtensa_le_plt_entry
[][PLT_ENTRY_SIZE
] =
618 0x36, 0x41, 0x00, /* entry sp, 32 */
619 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
620 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
621 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
622 0xa0, 0x08, 0x00, /* jx a8 */
626 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
627 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
628 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
629 0xa0, 0x08, 0x00, /* jx a8 */
634 /* The size of the thread control block. */
637 struct elf_xtensa_link_hash_entry
639 struct elf_link_hash_entry elf
;
641 bfd_signed_vma tlsfunc_refcount
;
643 #define GOT_UNKNOWN 0
645 #define GOT_TLS_GD 2 /* global or local dynamic */
646 #define GOT_TLS_IE 4 /* initial or local exec */
647 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
648 unsigned char tls_type
;
651 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
653 struct elf_xtensa_obj_tdata
655 struct elf_obj_tdata root
;
657 /* tls_type for each local got entry. */
658 char *local_got_tls_type
;
660 bfd_signed_vma
*local_tlsfunc_refcounts
;
663 #define elf_xtensa_tdata(abfd) \
664 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
666 #define elf_xtensa_local_got_tls_type(abfd) \
667 (elf_xtensa_tdata (abfd)->local_got_tls_type)
669 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
670 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
672 #define is_xtensa_elf(bfd) \
673 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
674 && elf_tdata (bfd) != NULL \
675 && elf_object_id (bfd) == XTENSA_ELF_DATA)
678 elf_xtensa_mkobject (bfd
*abfd
)
680 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_xtensa_obj_tdata
),
684 /* Xtensa ELF linker hash table. */
686 struct elf_xtensa_link_hash_table
688 struct elf_link_hash_table elf
;
690 /* Short-cuts to get to dynamic linker sections. */
692 asection
*spltlittbl
;
694 /* Total count of PLT relocations seen during check_relocs.
695 The actual PLT code must be split into multiple sections and all
696 the sections have to be created before size_dynamic_sections,
697 where we figure out the exact number of PLT entries that will be
698 needed. It is OK if this count is an overestimate, e.g., some
699 relocations may be removed by GC. */
702 struct elf_xtensa_link_hash_entry
*tlsbase
;
705 /* Get the Xtensa ELF linker hash table from a link_info structure. */
707 #define elf_xtensa_hash_table(p) \
708 ((is_elf_hash_table ((p)->hash) \
709 && elf_hash_table_id (elf_hash_table (p)) == XTENSA_ELF_DATA) \
710 ? (struct elf_xtensa_link_hash_table *) (p)->hash : NULL)
712 /* Create an entry in an Xtensa ELF linker hash table. */
714 static struct bfd_hash_entry
*
715 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
716 struct bfd_hash_table
*table
,
719 /* Allocate the structure if it has not already been allocated by a
723 entry
= bfd_hash_allocate (table
,
724 sizeof (struct elf_xtensa_link_hash_entry
));
729 /* Call the allocation method of the superclass. */
730 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
733 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (entry
);
734 eh
->tlsfunc_refcount
= 0;
735 eh
->tls_type
= GOT_UNKNOWN
;
741 /* Create an Xtensa ELF linker hash table. */
743 static struct bfd_link_hash_table
*
744 elf_xtensa_link_hash_table_create (bfd
*abfd
)
746 struct elf_link_hash_entry
*tlsbase
;
747 struct elf_xtensa_link_hash_table
*ret
;
748 size_t amt
= sizeof (struct elf_xtensa_link_hash_table
);
750 ret
= bfd_zmalloc (amt
);
754 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
755 elf_xtensa_link_hash_newfunc
,
756 sizeof (struct elf_xtensa_link_hash_entry
),
763 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
765 tlsbase
= elf_link_hash_lookup (&ret
->elf
, "_TLS_MODULE_BASE_",
767 tlsbase
->root
.type
= bfd_link_hash_new
;
768 tlsbase
->root
.u
.undef
.abfd
= NULL
;
769 tlsbase
->non_elf
= 0;
770 ret
->elf
.dt_pltgot_required
= true;
771 ret
->tlsbase
= elf_xtensa_hash_entry (tlsbase
);
772 ret
->tlsbase
->tls_type
= GOT_UNKNOWN
;
774 return &ret
->elf
.root
;
777 /* Copy the extra info we tack onto an elf_link_hash_entry. */
780 elf_xtensa_copy_indirect_symbol (struct bfd_link_info
*info
,
781 struct elf_link_hash_entry
*dir
,
782 struct elf_link_hash_entry
*ind
)
784 struct elf_xtensa_link_hash_entry
*edir
, *eind
;
786 edir
= elf_xtensa_hash_entry (dir
);
787 eind
= elf_xtensa_hash_entry (ind
);
789 if (ind
->root
.type
== bfd_link_hash_indirect
)
791 edir
->tlsfunc_refcount
+= eind
->tlsfunc_refcount
;
792 eind
->tlsfunc_refcount
= 0;
794 if (dir
->got
.refcount
<= 0)
796 edir
->tls_type
= eind
->tls_type
;
797 eind
->tls_type
= GOT_UNKNOWN
;
801 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
805 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
806 struct bfd_link_info
*info
)
808 /* Check if we should do dynamic things to this symbol. The
809 "ignore_protected" argument need not be set, because Xtensa code
810 does not require special handling of STV_PROTECTED to make function
811 pointer comparisons work properly. The PLT addresses are never
812 used for function pointers. */
814 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
819 property_table_compare (const void *ap
, const void *bp
)
821 const property_table_entry
*a
= (const property_table_entry
*) ap
;
822 const property_table_entry
*b
= (const property_table_entry
*) bp
;
824 if (a
->address
== b
->address
)
826 if (a
->size
!= b
->size
)
827 return (a
->size
- b
->size
);
829 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
830 return ((b
->flags
& XTENSA_PROP_ALIGN
)
831 - (a
->flags
& XTENSA_PROP_ALIGN
));
833 if ((a
->flags
& XTENSA_PROP_ALIGN
)
834 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
835 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
836 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
837 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
839 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
840 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
841 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
842 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
844 return (a
->flags
- b
->flags
);
847 return (a
->address
- b
->address
);
852 property_table_matches (const void *ap
, const void *bp
)
854 const property_table_entry
*a
= (const property_table_entry
*) ap
;
855 const property_table_entry
*b
= (const property_table_entry
*) bp
;
857 /* Check if one entry overlaps with the other. */
858 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
859 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
862 return (a
->address
- b
->address
);
866 /* Get the literal table or property table entries for the given
867 section. Sets TABLE_P and returns the number of entries. On
868 error, returns a negative value. */
871 xtensa_read_table_entries (bfd
*abfd
,
873 property_table_entry
**table_p
,
874 const char *sec_name
,
877 asection
*table_section
;
878 bfd_size_type table_size
= 0;
879 bfd_byte
*table_data
;
880 property_table_entry
*blocks
;
881 int blk
, block_count
;
882 bfd_size_type num_records
;
883 Elf_Internal_Rela
*internal_relocs
, *irel
, *rel_end
;
884 bfd_vma section_addr
, off
;
885 flagword predef_flags
;
886 bfd_size_type table_entry_size
, section_limit
;
888 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
890 || !(section
->flags
& SEC_ALLOC
)
891 || (section
->flags
& SEC_DEBUGGING
))
897 table_section
= xtensa_get_property_section (section
, sec_name
);
899 table_size
= table_section
->size
;
907 predef_flags
= xtensa_get_property_predef_flags (table_section
);
908 table_entry_size
= 12;
910 table_entry_size
-= 4;
912 num_records
= table_size
/ table_entry_size
;
914 table_data
= retrieve_contents (abfd
, table_section
, true);
915 if (table_data
== NULL
)
921 blocks
= (property_table_entry
*)
922 bfd_malloc (num_records
* sizeof (property_table_entry
));
926 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
928 section_addr
= section
->vma
;
930 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, true);
931 if (internal_relocs
&& !table_section
->reloc_done
)
933 qsort (internal_relocs
, table_section
->reloc_count
,
934 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
935 irel
= internal_relocs
;
940 section_limit
= bfd_get_section_limit (abfd
, section
);
941 rel_end
= internal_relocs
+ table_section
->reloc_count
;
943 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
945 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
947 /* Skip any relocations before the current offset. This should help
948 avoid confusion caused by unexpected relocations for the preceding
951 (irel
->r_offset
< off
952 || (irel
->r_offset
== off
953 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
960 if (irel
&& irel
->r_offset
== off
)
963 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
964 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
966 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
969 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
970 BFD_ASSERT (sym_off
== 0);
971 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
975 if (address
< section_addr
976 || address
>= section_addr
+ section_limit
)
980 blocks
[block_count
].address
= address
;
981 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
983 blocks
[block_count
].flags
= predef_flags
;
985 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
989 release_contents (table_section
, table_data
);
990 release_internal_relocs (table_section
, internal_relocs
);
994 /* Now sort them into address order for easy reference. */
995 qsort (blocks
, block_count
, sizeof (property_table_entry
),
996 property_table_compare
);
998 /* Check that the table contents are valid. Problems may occur,
999 for example, if an unrelocated object file is stripped. */
1000 for (blk
= 1; blk
< block_count
; blk
++)
1002 /* The only circumstance where two entries may legitimately
1003 have the same address is when one of them is a zero-size
1004 placeholder to mark a place where fill can be inserted.
1005 The zero-size entry should come first. */
1006 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
1007 blocks
[blk
- 1].size
!= 0)
1009 /* xgettext:c-format */
1010 _bfd_error_handler (_("%pB(%pA): invalid property table"),
1012 bfd_set_error (bfd_error_bad_value
);
1024 static property_table_entry
*
1025 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
1026 int property_table_size
,
1029 property_table_entry entry
;
1030 property_table_entry
*rv
;
1032 if (property_table_size
== 0)
1035 entry
.address
= addr
;
1039 rv
= bsearch (&entry
, property_table
, property_table_size
,
1040 sizeof (property_table_entry
), property_table_matches
);
1046 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
1050 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
1057 /* Look through the relocs for a section during the first phase, and
1058 calculate needed space in the dynamic reloc sections. */
1061 elf_xtensa_check_relocs (bfd
*abfd
,
1062 struct bfd_link_info
*info
,
1064 const Elf_Internal_Rela
*relocs
)
1066 struct elf_xtensa_link_hash_table
*htab
;
1067 Elf_Internal_Shdr
*symtab_hdr
;
1068 struct elf_link_hash_entry
**sym_hashes
;
1069 const Elf_Internal_Rela
*rel
;
1070 const Elf_Internal_Rela
*rel_end
;
1072 if (bfd_link_relocatable (info
))
1075 BFD_ASSERT (is_xtensa_elf (abfd
));
1077 htab
= elf_xtensa_hash_table (info
);
1081 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1082 sym_hashes
= elf_sym_hashes (abfd
);
1084 rel_end
= relocs
+ sec
->reloc_count
;
1085 for (rel
= relocs
; rel
< rel_end
; rel
++)
1087 unsigned int r_type
;
1089 struct elf_link_hash_entry
*h
= NULL
;
1090 struct elf_xtensa_link_hash_entry
*eh
;
1091 int tls_type
, old_tls_type
;
1092 bool is_got
= false;
1093 bool is_plt
= false;
1094 bool is_tlsfunc
= false;
1096 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1097 r_type
= ELF32_R_TYPE (rel
->r_info
);
1099 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1101 /* xgettext:c-format */
1102 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1107 if (r_symndx
>= symtab_hdr
->sh_info
)
1109 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1110 while (h
->root
.type
== bfd_link_hash_indirect
1111 || h
->root
.type
== bfd_link_hash_warning
)
1112 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1114 eh
= elf_xtensa_hash_entry (h
);
1118 case R_XTENSA_TLSDESC_FN
:
1119 if (bfd_link_pic (info
))
1121 tls_type
= GOT_TLS_GD
;
1126 tls_type
= GOT_TLS_IE
;
1129 case R_XTENSA_TLSDESC_ARG
:
1130 if (bfd_link_pic (info
))
1132 tls_type
= GOT_TLS_GD
;
1137 tls_type
= GOT_TLS_IE
;
1138 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1143 case R_XTENSA_TLS_DTPOFF
:
1144 if (bfd_link_pic (info
))
1145 tls_type
= GOT_TLS_GD
;
1147 tls_type
= GOT_TLS_IE
;
1150 case R_XTENSA_TLS_TPOFF
:
1151 tls_type
= GOT_TLS_IE
;
1152 if (bfd_link_pic (info
))
1153 info
->flags
|= DF_STATIC_TLS
;
1154 if (bfd_link_pic (info
) || h
)
1159 tls_type
= GOT_NORMAL
;
1164 tls_type
= GOT_NORMAL
;
1168 case R_XTENSA_GNU_VTINHERIT
:
1169 /* This relocation describes the C++ object vtable hierarchy.
1170 Reconstruct it for later use during GC. */
1171 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1175 case R_XTENSA_GNU_VTENTRY
:
1176 /* This relocation describes which C++ vtable entries are actually
1177 used. Record for later use during GC. */
1178 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1183 /* Nothing to do for any other relocations. */
1191 if (h
->plt
.refcount
<= 0)
1194 h
->plt
.refcount
= 1;
1197 h
->plt
.refcount
+= 1;
1199 /* Keep track of the total PLT relocation count even if we
1200 don't yet know whether the dynamic sections will be
1202 htab
->plt_reloc_count
+= 1;
1204 if (elf_hash_table (info
)->dynamic_sections_created
)
1206 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1212 if (h
->got
.refcount
<= 0)
1213 h
->got
.refcount
= 1;
1215 h
->got
.refcount
+= 1;
1219 eh
->tlsfunc_refcount
+= 1;
1221 old_tls_type
= eh
->tls_type
;
1225 /* Allocate storage the first time. */
1226 if (elf_local_got_refcounts (abfd
) == NULL
)
1228 bfd_size_type size
= symtab_hdr
->sh_info
;
1231 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1234 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1236 mem
= bfd_zalloc (abfd
, size
);
1239 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1241 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1244 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1245 = (bfd_signed_vma
*) mem
;
1248 /* This is a global offset table entry for a local symbol. */
1249 if (is_got
|| is_plt
)
1250 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1253 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1255 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1258 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1259 tls_type
|= old_tls_type
;
1260 /* If a TLS symbol is accessed using IE at least once,
1261 there is no point to use a dynamic model for it. */
1262 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1263 && ((old_tls_type
& GOT_TLS_GD
) == 0
1264 || (tls_type
& GOT_TLS_IE
) == 0))
1266 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1267 tls_type
= old_tls_type
;
1268 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1269 tls_type
|= old_tls_type
;
1273 /* xgettext:c-format */
1274 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1276 h
? h
->root
.root
.string
: "<local>");
1281 if (old_tls_type
!= tls_type
)
1284 eh
->tls_type
= tls_type
;
1286 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1295 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1296 struct elf_link_hash_entry
*h
)
1298 if (bfd_link_pic (info
))
1300 if (h
->plt
.refcount
> 0)
1302 /* For shared objects, there's no need for PLT entries for local
1303 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1304 if (h
->got
.refcount
< 0)
1305 h
->got
.refcount
= 0;
1306 h
->got
.refcount
+= h
->plt
.refcount
;
1307 h
->plt
.refcount
= 0;
1312 /* Don't need any dynamic relocations at all. */
1313 h
->plt
.refcount
= 0;
1314 h
->got
.refcount
= 0;
1320 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1321 struct elf_link_hash_entry
*h
,
1324 /* For a shared link, move the plt refcount to the got refcount to leave
1325 space for RELATIVE relocs. */
1326 elf_xtensa_make_sym_local (info
, h
);
1328 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1332 /* Return the section that should be marked against GC for a given
1336 elf_xtensa_gc_mark_hook (asection
*sec
,
1337 struct bfd_link_info
*info
,
1338 Elf_Internal_Rela
*rel
,
1339 struct elf_link_hash_entry
*h
,
1340 Elf_Internal_Sym
*sym
)
1342 /* Property sections are marked "KEEP" in the linker scripts, but they
1343 should not cause other sections to be marked. (This approach relies
1344 on elf_xtensa_discard_info to remove property table entries that
1345 describe discarded sections. Alternatively, it might be more
1346 efficient to avoid using "KEEP" in the linker scripts and instead use
1347 the gc_mark_extra_sections hook to mark only the property sections
1348 that describe marked sections. That alternative does not work well
1349 with the current property table sections, which do not correspond
1350 one-to-one with the sections they describe, but that should be fixed
1352 if (xtensa_is_property_section (sec
))
1356 switch (ELF32_R_TYPE (rel
->r_info
))
1358 case R_XTENSA_GNU_VTINHERIT
:
1359 case R_XTENSA_GNU_VTENTRY
:
1363 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1367 /* Create all the dynamic sections. */
1370 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1372 struct elf_xtensa_link_hash_table
*htab
;
1373 flagword flags
, noalloc_flags
;
1375 htab
= elf_xtensa_hash_table (info
);
1379 /* First do all the standard stuff. */
1380 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1383 /* Create any extra PLT sections in case check_relocs has already
1384 been called on all the non-dynamic input files. */
1385 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1388 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1389 | SEC_LINKER_CREATED
| SEC_READONLY
);
1390 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1392 /* Mark the ".got.plt" section READONLY. */
1393 if (htab
->elf
.sgotplt
== NULL
1394 || !bfd_set_section_flags (htab
->elf
.sgotplt
, flags
))
1397 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1398 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1400 if (htab
->sgotloc
== NULL
1401 || !bfd_set_section_alignment (htab
->sgotloc
, 2))
1404 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1405 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1407 if (htab
->spltlittbl
== NULL
1408 || !bfd_set_section_alignment (htab
->spltlittbl
, 2))
1416 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1418 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1421 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1422 ".got.plt" sections. */
1423 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1429 /* Stop when we find a section has already been created. */
1430 if (elf_xtensa_get_plt_section (info
, chunk
))
1433 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1434 | SEC_LINKER_CREATED
| SEC_READONLY
);
1436 sname
= (char *) bfd_malloc (10);
1437 sprintf (sname
, ".plt.%u", chunk
);
1438 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1440 || !bfd_set_section_alignment (s
, 2))
1443 sname
= (char *) bfd_malloc (14);
1444 sprintf (sname
, ".got.plt.%u", chunk
);
1445 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1447 || !bfd_set_section_alignment (s
, 2))
1455 /* Adjust a symbol defined by a dynamic object and referenced by a
1456 regular object. The current definition is in some section of the
1457 dynamic object, but we're not including those sections. We have to
1458 change the definition to something the rest of the link can
1462 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1463 struct elf_link_hash_entry
*h
)
1465 /* If this is a weak symbol, and there is a real definition, the
1466 processor independent code will have arranged for us to see the
1467 real definition first, and we can just use the same value. */
1468 if (h
->is_weakalias
)
1470 struct elf_link_hash_entry
*def
= weakdef (h
);
1471 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1472 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1473 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1477 /* This is a reference to a symbol defined by a dynamic object. The
1478 reference must go through the GOT, so there's no need for COPY relocs,
1486 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1488 struct bfd_link_info
*info
;
1489 struct elf_xtensa_link_hash_table
*htab
;
1490 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1492 if (h
->root
.type
== bfd_link_hash_indirect
)
1495 info
= (struct bfd_link_info
*) arg
;
1496 htab
= elf_xtensa_hash_table (info
);
1500 /* If we saw any use of an IE model for this symbol, we can then optimize
1501 away GOT entries for any TLSDESC_FN relocs. */
1502 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1504 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1505 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1508 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1509 elf_xtensa_make_sym_local (info
, h
);
1511 if (! elf_xtensa_dynamic_symbol_p (h
, info
)
1512 && h
->root
.type
== bfd_link_hash_undefweak
)
1515 if (h
->plt
.refcount
> 0)
1516 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1518 if (h
->got
.refcount
> 0)
1519 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1526 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1528 struct elf_xtensa_link_hash_table
*htab
;
1531 htab
= elf_xtensa_hash_table (info
);
1535 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1537 bfd_signed_vma
*local_got_refcounts
;
1538 bfd_size_type j
, cnt
;
1539 Elf_Internal_Shdr
*symtab_hdr
;
1541 local_got_refcounts
= elf_local_got_refcounts (i
);
1542 if (!local_got_refcounts
)
1545 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1546 cnt
= symtab_hdr
->sh_info
;
1548 for (j
= 0; j
< cnt
; ++j
)
1550 /* If we saw any use of an IE model for this symbol, we can
1551 then optimize away GOT entries for any TLSDESC_FN relocs. */
1552 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1554 bfd_signed_vma
*tlsfunc_refcount
1555 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1556 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1557 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1560 if (local_got_refcounts
[j
] > 0)
1561 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1562 * sizeof (Elf32_External_Rela
));
1568 /* Set the sizes of the dynamic sections. */
1571 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1572 struct bfd_link_info
*info
)
1574 struct elf_xtensa_link_hash_table
*htab
;
1576 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1577 bool relplt
, relgot
;
1578 int plt_entries
, plt_chunks
, chunk
;
1583 htab
= elf_xtensa_hash_table (info
);
1587 dynobj
= elf_hash_table (info
)->dynobj
;
1590 srelgot
= htab
->elf
.srelgot
;
1591 srelplt
= htab
->elf
.srelplt
;
1593 if (elf_hash_table (info
)->dynamic_sections_created
)
1595 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1596 && htab
->elf
.srelplt
!= NULL
1597 && htab
->elf
.sgot
!= NULL
1598 && htab
->spltlittbl
!= NULL
1599 && htab
->sgotloc
!= NULL
);
1601 /* Set the contents of the .interp section to the interpreter. */
1602 if (bfd_link_executable (info
) && !info
->nointerp
)
1604 s
= bfd_get_linker_section (dynobj
, ".interp");
1607 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1608 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1611 /* Allocate room for one word in ".got". */
1612 htab
->elf
.sgot
->size
= 4;
1614 /* Allocate space in ".rela.got" for literals that reference global
1615 symbols and space in ".rela.plt" for literals that have PLT
1617 elf_link_hash_traverse (elf_hash_table (info
),
1618 elf_xtensa_allocate_dynrelocs
,
1621 /* If we are generating a shared object, we also need space in
1622 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1623 reference local symbols. */
1624 if (bfd_link_pic (info
))
1625 elf_xtensa_allocate_local_got_size (info
);
1627 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1628 each PLT entry, we need the PLT code plus a 4-byte literal.
1629 For each chunk of ".plt", we also need two more 4-byte
1630 literals, two corresponding entries in ".rela.got", and an
1631 8-byte entry in ".xt.lit.plt". */
1632 spltlittbl
= htab
->spltlittbl
;
1633 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1635 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1637 /* Iterate over all the PLT chunks, including any extra sections
1638 created earlier because the initial count of PLT relocations
1639 was an overestimate. */
1641 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1646 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1647 BFD_ASSERT (sgotplt
!= NULL
);
1649 if (chunk
< plt_chunks
- 1)
1650 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1651 else if (chunk
== plt_chunks
- 1)
1652 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1656 if (chunk_entries
!= 0)
1658 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1659 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1660 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1661 spltlittbl
->size
+= 8;
1670 /* Allocate space in ".got.loc" to match the total size of all the
1672 sgotloc
= htab
->sgotloc
;
1673 sgotloc
->size
= spltlittbl
->size
;
1674 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1676 if (abfd
->flags
& DYNAMIC
)
1678 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1680 if (! discarded_section (s
)
1681 && xtensa_is_littable_section (s
)
1683 sgotloc
->size
+= s
->size
;
1688 /* Allocate memory for dynamic sections. */
1691 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1695 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1698 /* It's OK to base decisions on the section name, because none
1699 of the dynobj section names depend upon the input files. */
1700 name
= bfd_section_name (s
);
1702 if (startswith (name
, ".rela"))
1706 if (strcmp (name
, ".rela.plt") == 0)
1708 else if (strcmp (name
, ".rela.got") == 0)
1711 /* We use the reloc_count field as a counter if we need
1712 to copy relocs into the output file. */
1716 else if (! startswith (name
, ".plt.")
1717 && ! startswith (name
, ".got.plt.")
1718 && strcmp (name
, ".got") != 0
1719 && strcmp (name
, ".plt") != 0
1720 && strcmp (name
, ".got.plt") != 0
1721 && strcmp (name
, ".xt.lit.plt") != 0
1722 && strcmp (name
, ".got.loc") != 0)
1724 /* It's not one of our sections, so don't allocate space. */
1730 /* If we don't need this section, strip it from the output
1731 file. We must create the ".plt*" and ".got.plt*"
1732 sections in create_dynamic_sections and/or check_relocs
1733 based on a conservative estimate of the PLT relocation
1734 count, because the sections must be created before the
1735 linker maps input sections to output sections. The
1736 linker does that before size_dynamic_sections, where we
1737 compute the exact size of the PLT, so there may be more
1738 of these sections than are actually needed. */
1739 s
->flags
|= SEC_EXCLUDE
;
1741 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1743 /* Allocate memory for the section contents. */
1744 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1745 if (s
->contents
== NULL
)
1750 if (elf_hash_table (info
)->dynamic_sections_created
)
1752 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1753 known until finish_dynamic_sections, but we need to get the relocs
1754 in place before they are sorted. */
1755 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1757 Elf_Internal_Rela irela
;
1761 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1764 loc
= (srelgot
->contents
1765 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1766 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1767 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1768 loc
+ sizeof (Elf32_External_Rela
));
1769 srelgot
->reloc_count
+= 2;
1772 /* Add some entries to the .dynamic section. We fill in the
1773 values later, in elf_xtensa_finish_dynamic_sections, but we
1774 must add the entries now so that we get the correct size for
1775 the .dynamic section. The DT_DEBUG entry is filled in by the
1776 dynamic linker and used by the debugger. */
1777 #define add_dynamic_entry(TAG, VAL) \
1778 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1780 if (!_bfd_elf_add_dynamic_tags (output_bfd
, info
,
1784 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1785 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1788 #undef add_dynamic_entry
1794 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1795 struct bfd_link_info
*info
)
1797 struct elf_xtensa_link_hash_table
*htab
;
1800 htab
= elf_xtensa_hash_table (info
);
1804 tls_sec
= htab
->elf
.tls_sec
;
1806 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1808 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1809 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1810 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1812 tlsbase
->type
= STT_TLS
;
1813 if (!(_bfd_generic_link_add_one_symbol
1814 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1815 tls_sec
, 0, NULL
, false,
1816 bed
->collect
, &bh
)))
1818 tlsbase
->def_regular
= 1;
1819 tlsbase
->other
= STV_HIDDEN
;
1820 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, true);
1827 /* Return the base VMA address which should be subtracted from real addresses
1828 when resolving @dtpoff relocation.
1829 This is PT_TLS segment p_vaddr. */
1832 dtpoff_base (struct bfd_link_info
*info
)
1834 /* If tls_sec is NULL, we should have signalled an error already. */
1835 if (elf_hash_table (info
)->tls_sec
== NULL
)
1837 return elf_hash_table (info
)->tls_sec
->vma
;
1840 /* Return the relocation value for @tpoff relocation
1841 if STT_TLS virtual address is ADDRESS. */
1844 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1846 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1849 /* If tls_sec is NULL, we should have signalled an error already. */
1850 if (htab
->tls_sec
== NULL
)
1852 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1853 return address
- htab
->tls_sec
->vma
+ base
;
1856 /* Perform the specified relocation. The instruction at (contents + address)
1857 is modified to set one operand to represent the value in "relocation". The
1858 operand position is determined by the relocation type recorded in the
1861 #define CALL_SEGMENT_BITS (30)
1862 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1864 static bfd_reloc_status_type
1865 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1867 asection
*input_section
,
1872 char **error_message
)
1875 xtensa_opcode opcode
;
1876 xtensa_isa isa
= xtensa_default_isa
;
1877 static xtensa_insnbuf ibuff
= NULL
;
1878 static xtensa_insnbuf sbuff
= NULL
;
1879 bfd_vma self_address
;
1880 bfd_size_type input_size
;
1886 ibuff
= xtensa_insnbuf_alloc (isa
);
1887 sbuff
= xtensa_insnbuf_alloc (isa
);
1890 input_size
= bfd_get_section_limit (abfd
, input_section
);
1892 /* Calculate the PC address for this instruction. */
1893 self_address
= (input_section
->output_section
->vma
1894 + input_section
->output_offset
1897 switch (howto
->type
)
1900 case R_XTENSA_DIFF8
:
1901 case R_XTENSA_DIFF16
:
1902 case R_XTENSA_DIFF32
:
1903 case R_XTENSA_PDIFF8
:
1904 case R_XTENSA_PDIFF16
:
1905 case R_XTENSA_PDIFF32
:
1906 case R_XTENSA_NDIFF8
:
1907 case R_XTENSA_NDIFF16
:
1908 case R_XTENSA_NDIFF32
:
1909 case R_XTENSA_TLS_FUNC
:
1910 case R_XTENSA_TLS_ARG
:
1911 case R_XTENSA_TLS_CALL
:
1912 return bfd_reloc_ok
;
1914 case R_XTENSA_ASM_EXPAND
:
1917 /* Check for windowed CALL across a 1GB boundary. */
1918 opcode
= get_expanded_call_opcode (contents
+ address
,
1919 input_size
- address
, 0);
1920 if (is_windowed_call_opcode (opcode
))
1922 if ((self_address
>> CALL_SEGMENT_BITS
)
1923 != (relocation
>> CALL_SEGMENT_BITS
))
1925 *error_message
= "windowed longcall crosses 1GB boundary; "
1927 return bfd_reloc_dangerous
;
1931 return bfd_reloc_ok
;
1933 case R_XTENSA_ASM_SIMPLIFY
:
1935 /* Convert the L32R/CALLX to CALL. */
1936 bfd_reloc_status_type retval
=
1937 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1939 if (retval
!= bfd_reloc_ok
)
1940 return bfd_reloc_dangerous
;
1942 /* The CALL needs to be relocated. Continue below for that part. */
1945 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1952 x
= bfd_get_32 (abfd
, contents
+ address
);
1954 bfd_put_32 (abfd
, x
, contents
+ address
);
1956 return bfd_reloc_ok
;
1958 case R_XTENSA_32_PCREL
:
1959 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1960 return bfd_reloc_ok
;
1963 case R_XTENSA_TLSDESC_FN
:
1964 case R_XTENSA_TLSDESC_ARG
:
1965 case R_XTENSA_TLS_DTPOFF
:
1966 case R_XTENSA_TLS_TPOFF
:
1967 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1968 return bfd_reloc_ok
;
1971 /* Only instruction slot-specific relocations handled below.... */
1972 slot
= get_relocation_slot (howto
->type
);
1973 if (slot
== XTENSA_UNDEFINED
)
1975 *error_message
= "unexpected relocation";
1976 return bfd_reloc_dangerous
;
1979 if (input_size
<= address
)
1980 return bfd_reloc_outofrange
;
1981 /* Read the instruction into a buffer and decode the opcode. */
1982 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1983 input_size
- address
);
1984 fmt
= xtensa_format_decode (isa
, ibuff
);
1985 if (fmt
== XTENSA_UNDEFINED
)
1987 *error_message
= "cannot decode instruction format";
1988 return bfd_reloc_dangerous
;
1991 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1993 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1994 if (opcode
== XTENSA_UNDEFINED
)
1996 *error_message
= "cannot decode instruction opcode";
1997 return bfd_reloc_dangerous
;
2000 /* Check for opcode-specific "alternate" relocations. */
2001 if (is_alt_relocation (howto
->type
))
2003 if (opcode
== get_l32r_opcode ())
2005 /* Handle the special-case of non-PC-relative L32R instructions. */
2006 bfd
*output_bfd
= input_section
->output_section
->owner
;
2007 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
2010 *error_message
= "relocation references missing .lit4 section";
2011 return bfd_reloc_dangerous
;
2013 self_address
= ((lit4_sec
->vma
& ~0xfff)
2014 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2015 newval
= relocation
;
2018 else if (opcode
== get_const16_opcode ())
2020 /* ALT used for high 16 bits.
2021 Ignore 32-bit overflow. */
2022 newval
= (relocation
>> 16) & 0xffff;
2027 /* No other "alternate" relocations currently defined. */
2028 *error_message
= "unexpected relocation";
2029 return bfd_reloc_dangerous
;
2032 else /* Not an "alternate" relocation.... */
2034 if (opcode
== get_const16_opcode ())
2036 newval
= relocation
& 0xffff;
2041 /* ...normal PC-relative relocation.... */
2043 /* Determine which operand is being relocated. */
2044 opnd
= get_relocation_opnd (opcode
, howto
->type
);
2045 if (opnd
== XTENSA_UNDEFINED
)
2047 *error_message
= "unexpected relocation";
2048 return bfd_reloc_dangerous
;
2051 if (!howto
->pc_relative
)
2053 *error_message
= "expected PC-relative relocation";
2054 return bfd_reloc_dangerous
;
2057 newval
= relocation
;
2061 /* Apply the relocation. */
2062 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
2063 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
2064 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2067 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2070 msg
= "cannot encode";
2071 if (is_direct_call_opcode (opcode
))
2073 if ((relocation
& 0x3) != 0)
2074 msg
= "misaligned call target";
2076 msg
= "call target out of range";
2078 else if (opcode
== get_l32r_opcode ())
2080 if ((relocation
& 0x3) != 0)
2081 msg
= "misaligned literal target";
2082 else if (is_alt_relocation (howto
->type
))
2083 msg
= "literal target out of range (too many literals)";
2084 else if (self_address
> relocation
)
2085 msg
= "literal target out of range (try using text-section-literals)";
2087 msg
= "literal placed after use";
2090 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2091 return bfd_reloc_dangerous
;
2094 /* Check for calls across 1GB boundaries. */
2095 if (is_direct_call_opcode (opcode
)
2096 && is_windowed_call_opcode (opcode
))
2098 if ((self_address
>> CALL_SEGMENT_BITS
)
2099 != (relocation
>> CALL_SEGMENT_BITS
))
2102 "windowed call crosses 1GB boundary; return may fail";
2103 return bfd_reloc_dangerous
;
2107 /* Write the modified instruction back out of the buffer. */
2108 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2109 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2110 input_size
- address
);
2111 return bfd_reloc_ok
;
2116 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2118 /* To reduce the size of the memory leak,
2119 we only use a single message buffer. */
2120 static bfd_size_type alloc_size
= 0;
2121 static char *message
= NULL
;
2122 bfd_size_type orig_len
, len
= 0;
2126 va_start (ap
, arglen
);
2128 is_append
= (origmsg
== message
);
2130 orig_len
= strlen (origmsg
);
2131 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2132 if (len
> alloc_size
)
2134 message
= (char *) bfd_realloc_or_free (message
, len
);
2137 if (message
!= NULL
)
2140 memcpy (message
, origmsg
, orig_len
);
2141 vsprintf (message
+ orig_len
, fmt
, ap
);
2148 /* This function is registered as the "special_function" in the
2149 Xtensa howto for handling simplify operations.
2150 bfd_perform_relocation / bfd_install_relocation use it to
2151 perform (install) the specified relocation. Since this replaces the code
2152 in bfd_perform_relocation, it is basically an Xtensa-specific,
2153 stripped-down version of bfd_perform_relocation. */
2155 static bfd_reloc_status_type
2156 bfd_elf_xtensa_reloc (bfd
*abfd
,
2157 arelent
*reloc_entry
,
2160 asection
*input_section
,
2162 char **error_message
)
2165 bfd_reloc_status_type flag
;
2166 bfd_size_type octets
= (reloc_entry
->address
2167 * OCTETS_PER_BYTE (abfd
, input_section
));
2168 bfd_vma output_base
= 0;
2169 reloc_howto_type
*howto
= reloc_entry
->howto
;
2170 asection
*reloc_target_output_section
;
2173 if (!xtensa_default_isa
)
2174 xtensa_default_isa
= xtensa_isa_init (0, 0);
2176 /* ELF relocs are against symbols. If we are producing relocatable
2177 output, and the reloc is against an external symbol, the resulting
2178 reloc will also be against the same symbol. In such a case, we
2179 don't want to change anything about the way the reloc is handled,
2180 since it will all be done at final link time. This test is similar
2181 to what bfd_elf_generic_reloc does except that it lets relocs with
2182 howto->partial_inplace go through even if the addend is non-zero.
2183 (The real problem is that partial_inplace is set for XTENSA_32
2184 relocs to begin with, but that's a long story and there's little we
2185 can do about it now....) */
2187 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2189 reloc_entry
->address
+= input_section
->output_offset
;
2190 return bfd_reloc_ok
;
2193 /* Is the address of the relocation really within the section? */
2194 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2195 return bfd_reloc_outofrange
;
2197 /* Work out which section the relocation is targeted at and the
2198 initial relocation command value. */
2200 /* Get symbol value. (Common symbols are special.) */
2201 if (bfd_is_com_section (symbol
->section
))
2204 relocation
= symbol
->value
;
2206 reloc_target_output_section
= symbol
->section
->output_section
;
2208 /* Convert input-section-relative symbol value to absolute. */
2209 if ((output_bfd
&& !howto
->partial_inplace
)
2210 || reloc_target_output_section
== NULL
)
2213 output_base
= reloc_target_output_section
->vma
;
2215 relocation
+= output_base
+ symbol
->section
->output_offset
;
2217 /* Add in supplied addend. */
2218 relocation
+= reloc_entry
->addend
;
2220 /* Here the variable relocation holds the final address of the
2221 symbol we are relocating against, plus any addend. */
2224 if (!howto
->partial_inplace
)
2226 /* This is a partial relocation, and we want to apply the relocation
2227 to the reloc entry rather than the raw data. Everything except
2228 relocations against section symbols has already been handled
2231 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2232 reloc_entry
->addend
= relocation
;
2233 reloc_entry
->address
+= input_section
->output_offset
;
2234 return bfd_reloc_ok
;
2238 reloc_entry
->address
+= input_section
->output_offset
;
2239 reloc_entry
->addend
= 0;
2243 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2244 && (symbol
->flags
& BSF_WEAK
) != 0);
2245 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2246 (bfd_byte
*) data
, (bfd_vma
) octets
,
2247 is_weak_undef
, error_message
);
2249 if (flag
== bfd_reloc_dangerous
)
2251 /* Add the symbol name to the error message. */
2252 if (! *error_message
)
2253 *error_message
= "";
2254 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2255 strlen (symbol
->name
) + 17,
2257 (unsigned long) reloc_entry
->addend
);
2263 int xtensa_abi_choice (void)
2265 if (elf32xtensa_abi
== XTHAL_ABI_UNDEFINED
)
2268 return elf32xtensa_abi
;
2271 /* Set up an entry in the procedure linkage table. */
2274 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2276 unsigned reloc_index
)
2278 asection
*splt
, *sgotplt
;
2279 bfd_vma plt_base
, got_base
;
2280 bfd_vma code_offset
, lit_offset
, abi_offset
;
2282 int abi
= xtensa_abi_choice ();
2284 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2285 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2286 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2287 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2289 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2290 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2292 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2293 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2295 /* Fill in the literal entry. This is the offset of the dynamic
2296 relocation entry. */
2297 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2298 sgotplt
->contents
+ lit_offset
);
2300 /* Fill in the entry in the procedure linkage table. */
2301 memcpy (splt
->contents
+ code_offset
,
2302 (bfd_big_endian (output_bfd
)
2303 ? elf_xtensa_be_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]
2304 : elf_xtensa_le_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]),
2306 abi_offset
= abi
== XTHAL_ABI_WINDOWED
? 3 : 0;
2307 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2308 plt_base
+ code_offset
+ abi_offset
),
2309 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2310 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2311 plt_base
+ code_offset
+ abi_offset
+ 3),
2312 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2313 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2314 plt_base
+ code_offset
+ abi_offset
+ 6),
2315 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2317 return plt_base
+ code_offset
;
2321 static bool get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2324 replace_tls_insn (Elf_Internal_Rela
*rel
,
2326 asection
*input_section
,
2329 char **error_message
)
2331 static xtensa_insnbuf ibuff
= NULL
;
2332 static xtensa_insnbuf sbuff
= NULL
;
2333 xtensa_isa isa
= xtensa_default_isa
;
2335 xtensa_opcode old_op
, new_op
;
2336 bfd_size_type input_size
;
2338 unsigned dest_reg
, src_reg
;
2342 ibuff
= xtensa_insnbuf_alloc (isa
);
2343 sbuff
= xtensa_insnbuf_alloc (isa
);
2346 input_size
= bfd_get_section_limit (abfd
, input_section
);
2348 /* Read the instruction into a buffer and decode the opcode. */
2349 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2350 input_size
- rel
->r_offset
);
2351 fmt
= xtensa_format_decode (isa
, ibuff
);
2352 if (fmt
== XTENSA_UNDEFINED
)
2354 *error_message
= "cannot decode instruction format";
2358 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2359 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2361 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2362 if (old_op
== XTENSA_UNDEFINED
)
2364 *error_message
= "cannot decode instruction opcode";
2368 r_type
= ELF32_R_TYPE (rel
->r_info
);
2371 case R_XTENSA_TLS_FUNC
:
2372 case R_XTENSA_TLS_ARG
:
2373 if (old_op
!= get_l32r_opcode ()
2374 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2375 sbuff
, &dest_reg
) != 0)
2377 *error_message
= "cannot extract L32R destination for TLS access";
2382 case R_XTENSA_TLS_CALL
:
2383 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2384 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2385 sbuff
, &src_reg
) != 0)
2387 *error_message
= "cannot extract CALLXn operands for TLS access";
2400 case R_XTENSA_TLS_FUNC
:
2401 case R_XTENSA_TLS_ARG
:
2402 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2403 versions of Xtensa). */
2404 new_op
= xtensa_opcode_lookup (isa
, "nop");
2405 if (new_op
== XTENSA_UNDEFINED
)
2407 new_op
= xtensa_opcode_lookup (isa
, "or");
2408 if (new_op
== XTENSA_UNDEFINED
2409 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2410 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2412 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2414 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2417 *error_message
= "cannot encode OR for TLS access";
2423 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2425 *error_message
= "cannot encode NOP for TLS access";
2431 case R_XTENSA_TLS_CALL
:
2432 /* Read THREADPTR into the CALLX's return value register. */
2433 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2434 if (new_op
== XTENSA_UNDEFINED
2435 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2436 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2437 sbuff
, dest_reg
+ 2) != 0)
2439 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2449 case R_XTENSA_TLS_FUNC
:
2450 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2451 if (new_op
== XTENSA_UNDEFINED
2452 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2453 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2454 sbuff
, dest_reg
) != 0)
2456 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2461 case R_XTENSA_TLS_ARG
:
2462 /* Nothing to do. Keep the original L32R instruction. */
2465 case R_XTENSA_TLS_CALL
:
2466 /* Add the CALLX's src register (holding the THREADPTR value)
2467 to the first argument register (holding the offset) and put
2468 the result in the CALLX's return value register. */
2469 new_op
= xtensa_opcode_lookup (isa
, "add");
2470 if (new_op
== XTENSA_UNDEFINED
2471 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2472 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2473 sbuff
, dest_reg
+ 2) != 0
2474 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2475 sbuff
, dest_reg
+ 2) != 0
2476 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2477 sbuff
, src_reg
) != 0)
2479 *error_message
= "cannot encode ADD for TLS access";
2486 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2487 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2488 input_size
- rel
->r_offset
);
2494 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2495 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2496 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2497 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2498 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2499 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2500 || (R_TYPE) == R_XTENSA_TLS_ARG \
2501 || (R_TYPE) == R_XTENSA_TLS_CALL)
2503 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2504 both relocatable and final links. */
2507 elf_xtensa_relocate_section (bfd
*output_bfd
,
2508 struct bfd_link_info
*info
,
2510 asection
*input_section
,
2512 Elf_Internal_Rela
*relocs
,
2513 Elf_Internal_Sym
*local_syms
,
2514 asection
**local_sections
)
2516 struct elf_xtensa_link_hash_table
*htab
;
2517 Elf_Internal_Shdr
*symtab_hdr
;
2518 Elf_Internal_Rela
*rel
;
2519 Elf_Internal_Rela
*relend
;
2520 struct elf_link_hash_entry
**sym_hashes
;
2521 property_table_entry
*lit_table
= 0;
2523 char *local_got_tls_types
;
2524 char *error_message
= NULL
;
2525 bfd_size_type input_size
;
2528 if (!xtensa_default_isa
)
2529 xtensa_default_isa
= xtensa_isa_init (0, 0);
2531 if (!is_xtensa_elf (input_bfd
))
2533 bfd_set_error (bfd_error_wrong_format
);
2537 htab
= elf_xtensa_hash_table (info
);
2541 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2542 sym_hashes
= elf_sym_hashes (input_bfd
);
2543 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2545 if (elf_hash_table (info
)->dynamic_sections_created
)
2547 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2548 &lit_table
, XTENSA_LIT_SEC_NAME
,
2554 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2557 relend
= relocs
+ input_section
->reloc_count
;
2558 for (; rel
< relend
; rel
++)
2561 reloc_howto_type
*howto
;
2562 unsigned long r_symndx
;
2563 struct elf_link_hash_entry
*h
;
2564 Elf_Internal_Sym
*sym
;
2569 bfd_reloc_status_type r
;
2571 bool unresolved_reloc
;
2573 bool dynamic_symbol
;
2575 r_type
= ELF32_R_TYPE (rel
->r_info
);
2576 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2577 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2580 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2582 bfd_set_error (bfd_error_bad_value
);
2585 howto
= &elf_howto_table
[r_type
];
2587 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2592 is_weak_undef
= false;
2593 unresolved_reloc
= false;
2596 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2598 /* Because R_XTENSA_32 was made partial_inplace to fix some
2599 problems with DWARF info in partial links, there may be
2600 an addend stored in the contents. Take it out of there
2601 and move it back into the addend field of the reloc. */
2602 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2603 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2606 if (r_symndx
< symtab_hdr
->sh_info
)
2608 sym
= local_syms
+ r_symndx
;
2609 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2610 sec
= local_sections
[r_symndx
];
2611 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2617 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2618 r_symndx
, symtab_hdr
, sym_hashes
,
2620 unresolved_reloc
, warned
, ignored
);
2623 && !unresolved_reloc
2624 && h
->root
.type
== bfd_link_hash_undefweak
)
2625 is_weak_undef
= true;
2630 if (sec
!= NULL
&& discarded_section (sec
))
2631 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2632 rel
, 1, relend
, howto
, 0, contents
);
2634 if (bfd_link_relocatable (info
))
2637 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2639 /* This is a relocatable link.
2640 1) If the reloc is against a section symbol, adjust
2641 according to the output section.
2642 2) If there is a new target for this relocation,
2643 the new target will be in the same output section.
2644 We adjust the relocation by the output section
2647 if (relaxing_section
)
2649 /* Check if this references a section in another input file. */
2650 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2655 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2656 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2658 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2660 error_message
= NULL
;
2661 /* Convert ASM_SIMPLIFY into the simpler relocation
2662 so that they never escape a relaxing link. */
2663 r
= contract_asm_expansion (contents
, input_size
, rel
,
2665 if (r
!= bfd_reloc_ok
)
2666 (*info
->callbacks
->reloc_dangerous
)
2667 (info
, error_message
,
2668 input_bfd
, input_section
, rel
->r_offset
);
2670 r_type
= ELF32_R_TYPE (rel
->r_info
);
2673 /* This is a relocatable link, so we don't have to change
2674 anything unless the reloc is against a section symbol,
2675 in which case we have to adjust according to where the
2676 section symbol winds up in the output section. */
2677 if (r_symndx
< symtab_hdr
->sh_info
)
2679 sym
= local_syms
+ r_symndx
;
2680 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2682 sec
= local_sections
[r_symndx
];
2683 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2687 /* If there is an addend with a partial_inplace howto,
2688 then move the addend to the contents. This is a hack
2689 to work around problems with DWARF in relocatable links
2690 with some previous version of BFD. Now we can't easily get
2691 rid of the hack without breaking backward compatibility.... */
2693 howto
= &elf_howto_table
[r_type
];
2694 if (howto
->partial_inplace
&& rel
->r_addend
)
2696 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2697 rel
->r_addend
, contents
,
2698 rel
->r_offset
, false,
2704 /* Put the correct bits in the target instruction, even
2705 though the relocation will still be present in the output
2706 file. This makes disassembly clearer, as well as
2707 allowing loadable kernel modules to work without needing
2708 relocations on anything other than calls and l32r's. */
2710 /* If it is not in the same section, there is nothing we can do. */
2711 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2712 sym_sec
->output_section
== input_section
->output_section
)
2714 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2715 dest_addr
, contents
,
2716 rel
->r_offset
, false,
2720 if (r
!= bfd_reloc_ok
)
2721 (*info
->callbacks
->reloc_dangerous
)
2722 (info
, error_message
,
2723 input_bfd
, input_section
, rel
->r_offset
);
2725 /* Done with work for relocatable link; continue with next reloc. */
2729 /* This is a final link. */
2731 if (relaxing_section
)
2733 /* Check if this references a section in another input file. */
2734 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2738 /* Sanity check the address. */
2739 if (rel
->r_offset
>= input_size
2740 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2743 /* xgettext:c-format */
2744 (_("%pB(%pA+%#" PRIx64
"): "
2745 "relocation offset out of range (size=%#" PRIx64
")"),
2746 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2747 (uint64_t) input_size
);
2748 bfd_set_error (bfd_error_bad_value
);
2753 name
= h
->root
.root
.string
;
2756 name
= (bfd_elf_string_from_elf_section
2757 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2758 if (name
== NULL
|| *name
== '\0')
2759 name
= bfd_section_name (sec
);
2762 if (r_symndx
!= STN_UNDEF
2763 && r_type
!= R_XTENSA_NONE
2765 || h
->root
.type
== bfd_link_hash_defined
2766 || h
->root
.type
== bfd_link_hash_defweak
)
2767 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2770 ((sym_type
== STT_TLS
2771 /* xgettext:c-format */
2772 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2773 /* xgettext:c-format */
2774 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2777 (uint64_t) rel
->r_offset
,
2782 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2784 tls_type
= GOT_UNKNOWN
;
2786 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2787 else if (local_got_tls_types
)
2788 tls_type
= local_got_tls_types
[r_symndx
];
2794 if (elf_hash_table (info
)->dynamic_sections_created
2795 && (input_section
->flags
& SEC_ALLOC
) != 0
2796 && (dynamic_symbol
|| bfd_link_pic (info
)))
2798 Elf_Internal_Rela outrel
;
2802 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2803 srel
= htab
->elf
.srelplt
;
2805 srel
= htab
->elf
.srelgot
;
2807 BFD_ASSERT (srel
!= NULL
);
2810 _bfd_elf_section_offset (output_bfd
, info
,
2811 input_section
, rel
->r_offset
);
2813 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2814 memset (&outrel
, 0, sizeof outrel
);
2817 outrel
.r_offset
+= (input_section
->output_section
->vma
2818 + input_section
->output_offset
);
2820 /* Complain if the relocation is in a read-only section
2821 and not in a literal pool. */
2822 if ((input_section
->flags
& SEC_READONLY
) != 0
2823 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2827 _("dynamic relocation in read-only section");
2828 (*info
->callbacks
->reloc_dangerous
)
2829 (info
, error_message
,
2830 input_bfd
, input_section
, rel
->r_offset
);
2835 outrel
.r_addend
= rel
->r_addend
;
2838 if (r_type
== R_XTENSA_32
)
2841 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2844 else /* r_type == R_XTENSA_PLT */
2847 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2849 /* Create the PLT entry and set the initial
2850 contents of the literal entry to the address of
2853 elf_xtensa_create_plt_entry (info
, output_bfd
,
2856 unresolved_reloc
= false;
2858 else if (!is_weak_undef
)
2860 /* Generate a RELATIVE relocation. */
2861 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2862 outrel
.r_addend
= 0;
2870 loc
= (srel
->contents
2871 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2872 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2873 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2876 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2878 /* This should only happen for non-PIC code, which is not
2879 supposed to be used on systems with dynamic linking.
2880 Just ignore these relocations. */
2885 case R_XTENSA_TLS_TPOFF
:
2886 /* Switch to LE model for local symbols in an executable. */
2887 if (! bfd_link_pic (info
) && ! dynamic_symbol
)
2889 relocation
= tpoff (info
, relocation
);
2894 case R_XTENSA_TLSDESC_FN
:
2895 case R_XTENSA_TLSDESC_ARG
:
2897 if (r_type
== R_XTENSA_TLSDESC_FN
)
2899 if (! bfd_link_pic (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2900 r_type
= R_XTENSA_NONE
;
2902 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2904 if (bfd_link_pic (info
))
2906 if ((tls_type
& GOT_TLS_IE
) != 0)
2907 r_type
= R_XTENSA_TLS_TPOFF
;
2911 r_type
= R_XTENSA_TLS_TPOFF
;
2912 if (! dynamic_symbol
)
2914 relocation
= tpoff (info
, relocation
);
2920 if (r_type
== R_XTENSA_NONE
)
2921 /* Nothing to do here; skip to the next reloc. */
2924 if (! elf_hash_table (info
)->dynamic_sections_created
)
2927 _("TLS relocation invalid without dynamic sections");
2928 (*info
->callbacks
->reloc_dangerous
)
2929 (info
, error_message
,
2930 input_bfd
, input_section
, rel
->r_offset
);
2934 Elf_Internal_Rela outrel
;
2936 asection
*srel
= htab
->elf
.srelgot
;
2939 outrel
.r_offset
= (input_section
->output_section
->vma
2940 + input_section
->output_offset
2943 /* Complain if the relocation is in a read-only section
2944 and not in a literal pool. */
2945 if ((input_section
->flags
& SEC_READONLY
) != 0
2946 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2950 _("dynamic relocation in read-only section");
2951 (*info
->callbacks
->reloc_dangerous
)
2952 (info
, error_message
,
2953 input_bfd
, input_section
, rel
->r_offset
);
2956 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2958 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2960 outrel
.r_addend
= 0;
2963 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2965 unresolved_reloc
= false;
2968 loc
= (srel
->contents
2969 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2970 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2971 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2977 case R_XTENSA_TLS_DTPOFF
:
2978 if (! bfd_link_pic (info
))
2979 /* Switch from LD model to LE model. */
2980 relocation
= tpoff (info
, relocation
);
2982 relocation
-= dtpoff_base (info
);
2985 case R_XTENSA_TLS_FUNC
:
2986 case R_XTENSA_TLS_ARG
:
2987 case R_XTENSA_TLS_CALL
:
2988 /* Check if optimizing to IE or LE model. */
2989 if ((tls_type
& GOT_TLS_IE
) != 0)
2992 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
2993 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
2994 is_ld_model
, &error_message
))
2995 (*info
->callbacks
->reloc_dangerous
)
2996 (info
, error_message
,
2997 input_bfd
, input_section
, rel
->r_offset
);
2999 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
3001 /* Skip subsequent relocations on the same instruction. */
3002 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
3009 if (elf_hash_table (info
)->dynamic_sections_created
3010 && dynamic_symbol
&& (is_operand_relocation (r_type
)
3011 || r_type
== R_XTENSA_32_PCREL
))
3014 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3015 strlen (name
) + 2, name
);
3016 (*info
->callbacks
->reloc_dangerous
)
3017 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3023 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3024 because such sections are not SEC_ALLOC and thus ld.so will
3025 not process them. */
3026 if (unresolved_reloc
3027 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3029 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3030 rel
->r_offset
) != (bfd_vma
) -1)
3033 /* xgettext:c-format */
3034 (_("%pB(%pA+%#" PRIx64
"): "
3035 "unresolvable %s relocation against symbol `%s'"),
3038 (uint64_t) rel
->r_offset
,
3044 /* TLS optimizations may have changed r_type; update "howto". */
3045 howto
= &elf_howto_table
[r_type
];
3047 /* There's no point in calling bfd_perform_relocation here.
3048 Just go directly to our "special function". */
3049 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
3050 relocation
+ rel
->r_addend
,
3051 contents
, rel
->r_offset
, is_weak_undef
,
3054 if (r
!= bfd_reloc_ok
&& !warned
)
3056 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
3057 BFD_ASSERT (error_message
!= NULL
);
3059 if (rel
->r_addend
== 0)
3060 error_message
= vsprint_msg (error_message
, ": %s",
3061 strlen (name
) + 2, name
);
3063 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
3065 name
, (int) rel
->r_addend
);
3067 (*info
->callbacks
->reloc_dangerous
)
3068 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3073 input_section
->reloc_done
= true;
3079 /* Finish up dynamic symbol handling. There's not much to do here since
3080 the PLT and GOT entries are all set up by relocate_section. */
3083 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3084 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3085 struct elf_link_hash_entry
*h
,
3086 Elf_Internal_Sym
*sym
)
3088 if (h
->needs_plt
&& !h
->def_regular
)
3090 /* Mark the symbol as undefined, rather than as defined in
3091 the .plt section. Leave the value alone. */
3092 sym
->st_shndx
= SHN_UNDEF
;
3093 /* If the symbol is weak, we do need to clear the value.
3094 Otherwise, the PLT entry would provide a definition for
3095 the symbol even if the symbol wasn't defined anywhere,
3096 and so the symbol would never be NULL. */
3097 if (!h
->ref_regular_nonweak
)
3101 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3102 if (h
== elf_hash_table (info
)->hdynamic
3103 || h
== elf_hash_table (info
)->hgot
)
3104 sym
->st_shndx
= SHN_ABS
;
3110 /* Combine adjacent literal table entries in the output. Adjacent
3111 entries within each input section may have been removed during
3112 relaxation, but we repeat the process here, even though it's too late
3113 to shrink the output section, because it's important to minimize the
3114 number of literal table entries to reduce the start-up work for the
3115 runtime linker. Returns the number of remaining table entries or -1
3119 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3124 property_table_entry
*table
;
3125 bfd_size_type section_size
, sgotloc_size
;
3129 section_size
= sxtlit
->size
;
3130 if (section_size
== 0)
3133 BFD_ASSERT (section_size
% 8 == 0);
3134 num
= section_size
/ 8;
3136 sgotloc_size
= sgotloc
->size
;
3137 if (sgotloc_size
!= section_size
)
3140 (_("internal inconsistency in size of .got.loc section"));
3144 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3148 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3149 propagates to the output section, where it doesn't really apply and
3150 where it breaks the following call to bfd_malloc_and_get_section. */
3151 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3153 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3160 /* There should never be any relocations left at this point, so this
3161 is quite a bit easier than what is done during relaxation. */
3163 /* Copy the raw contents into a property table array and sort it. */
3165 for (n
= 0; n
< num
; n
++)
3167 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3168 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3171 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3173 for (n
= 0; n
< num
; n
++)
3175 bool remove_entry
= false;
3177 if (table
[n
].size
== 0)
3178 remove_entry
= true;
3180 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3182 table
[n
-1].size
+= table
[n
].size
;
3183 remove_entry
= true;
3188 for (m
= n
; m
< num
- 1; m
++)
3190 table
[m
].address
= table
[m
+1].address
;
3191 table
[m
].size
= table
[m
+1].size
;
3199 /* Copy the data back to the raw contents. */
3201 for (n
= 0; n
< num
; n
++)
3203 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3204 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3208 /* Clear the removed bytes. */
3209 if ((bfd_size_type
) (num
* 8) < section_size
)
3210 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3212 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3216 /* Copy the contents to ".got.loc". */
3217 memcpy (sgotloc
->contents
, contents
, section_size
);
3225 /* Finish up the dynamic sections. */
3228 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3229 struct bfd_link_info
*info
)
3231 struct elf_xtensa_link_hash_table
*htab
;
3233 asection
*sdyn
, *srelplt
, *srelgot
, *sgot
, *sxtlit
, *sgotloc
;
3234 Elf32_External_Dyn
*dyncon
, *dynconend
;
3235 int num_xtlit_entries
= 0;
3237 if (! elf_hash_table (info
)->dynamic_sections_created
)
3240 htab
= elf_xtensa_hash_table (info
);
3244 dynobj
= elf_hash_table (info
)->dynobj
;
3245 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3246 BFD_ASSERT (sdyn
!= NULL
);
3248 /* Set the first entry in the global offset table to the address of
3249 the dynamic section. */
3250 sgot
= htab
->elf
.sgot
;
3253 BFD_ASSERT (sgot
->size
== 4);
3255 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3257 bfd_put_32 (output_bfd
,
3258 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3262 srelplt
= htab
->elf
.srelplt
;
3263 srelgot
= htab
->elf
.srelgot
;
3264 if (srelplt
&& srelplt
->size
!= 0)
3266 asection
*sgotplt
, *spltlittbl
;
3267 int chunk
, plt_chunks
, plt_entries
;
3268 Elf_Internal_Rela irela
;
3270 unsigned rtld_reloc
;
3272 spltlittbl
= htab
->spltlittbl
;
3273 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3275 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3276 of them follow immediately after.... */
3277 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3279 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3280 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3281 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3284 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3286 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3288 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3290 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3292 int chunk_entries
= 0;
3294 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3295 BFD_ASSERT (sgotplt
!= NULL
);
3297 /* Emit special RTLD relocations for the first two entries in
3298 each chunk of the .got.plt section. */
3300 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3301 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3302 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3303 irela
.r_offset
= (sgotplt
->output_section
->vma
3304 + sgotplt
->output_offset
);
3305 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3306 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3308 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3310 /* Next literal immediately follows the first. */
3311 loc
+= sizeof (Elf32_External_Rela
);
3312 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3313 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3314 irela
.r_offset
= (sgotplt
->output_section
->vma
3315 + sgotplt
->output_offset
+ 4);
3316 /* Tell rtld to set value to object's link map. */
3318 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3320 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3322 /* Fill in the literal table. */
3323 if (chunk
< plt_chunks
- 1)
3324 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3326 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3328 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3329 bfd_put_32 (output_bfd
,
3330 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3331 spltlittbl
->contents
+ (chunk
* 8) + 0);
3332 bfd_put_32 (output_bfd
,
3333 8 + (chunk_entries
* 4),
3334 spltlittbl
->contents
+ (chunk
* 8) + 4);
3337 /* The .xt.lit.plt section has just been modified. This must
3338 happen before the code below which combines adjacent literal
3339 table entries, and the .xt.lit.plt contents have to be forced to
3341 if (! bfd_set_section_contents (output_bfd
,
3342 spltlittbl
->output_section
,
3343 spltlittbl
->contents
,
3344 spltlittbl
->output_offset
,
3347 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3348 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3351 /* All the dynamic relocations have been emitted at this point.
3352 Make sure the relocation sections are the correct size. */
3353 if ((srelgot
&& srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3354 * srelgot
->reloc_count
))
3355 || (srelplt
&& srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3356 * srelplt
->reloc_count
)))
3359 /* Combine adjacent literal table entries. */
3360 BFD_ASSERT (! bfd_link_relocatable (info
));
3361 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3362 sgotloc
= htab
->sgotloc
;
3363 BFD_ASSERT (sgotloc
);
3367 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3368 if (num_xtlit_entries
< 0)
3372 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3373 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3374 for (; dyncon
< dynconend
; dyncon
++)
3376 Elf_Internal_Dyn dyn
;
3378 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3385 case DT_XTENSA_GOT_LOC_SZ
:
3386 dyn
.d_un
.d_val
= num_xtlit_entries
;
3389 case DT_XTENSA_GOT_LOC_OFF
:
3390 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3391 + htab
->sgotloc
->output_offset
);
3395 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3396 + htab
->elf
.sgot
->output_offset
);
3400 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3401 + htab
->elf
.srelplt
->output_offset
);
3405 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3409 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3416 /* Functions for dealing with the e_flags field. */
3418 /* Merge backend specific data from an object file to the output
3419 object file when linking. */
3422 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3424 bfd
*obfd
= info
->output_bfd
;
3425 unsigned out_mach
, in_mach
;
3426 flagword out_flag
, in_flag
;
3428 /* Check if we have the same endianness. */
3429 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3432 /* Don't even pretend to support mixed-format linking. */
3433 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3434 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3437 out_flag
= elf_elfheader (obfd
)->e_flags
;
3438 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3440 out_mach
= out_flag
& EF_XTENSA_MACH
;
3441 in_mach
= in_flag
& EF_XTENSA_MACH
;
3442 if (out_mach
!= in_mach
)
3445 /* xgettext:c-format */
3446 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3447 ibfd
, out_mach
, in_mach
);
3448 bfd_set_error (bfd_error_wrong_format
);
3452 if (! elf_flags_init (obfd
))
3454 elf_flags_init (obfd
) = true;
3455 elf_elfheader (obfd
)->e_flags
= in_flag
;
3457 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3458 && bfd_get_arch_info (obfd
)->the_default
)
3459 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3460 bfd_get_mach (ibfd
));
3465 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3466 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3468 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3469 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3476 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3478 BFD_ASSERT (!elf_flags_init (abfd
)
3479 || elf_elfheader (abfd
)->e_flags
== flags
);
3481 elf_elfheader (abfd
)->e_flags
|= flags
;
3482 elf_flags_init (abfd
) = true;
3489 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3491 FILE *f
= (FILE *) farg
;
3492 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3494 fprintf (f
, "\nXtensa header:\n");
3495 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3496 fprintf (f
, "\nMachine = Base\n");
3498 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3500 fprintf (f
, "Insn tables = %s\n",
3501 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3503 fprintf (f
, "Literal tables = %s\n",
3504 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3506 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3510 /* Set the right machine number for an Xtensa ELF file. */
3513 elf_xtensa_object_p (bfd
*abfd
)
3516 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3521 mach
= bfd_mach_xtensa
;
3527 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3532 /* The final processing done just before writing out an Xtensa ELF object
3533 file. This gets the Xtensa architecture right based on the machine
3537 elf_xtensa_final_write_processing (bfd
*abfd
)
3540 unsigned long val
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3542 switch (mach
= bfd_get_mach (abfd
))
3544 case bfd_mach_xtensa
:
3545 val
= E_XTENSA_MACH
;
3551 elf_elfheader (abfd
)->e_flags
&= ~EF_XTENSA_MACH
;
3552 elf_elfheader (abfd
)->e_flags
|= val
;
3553 return _bfd_elf_final_write_processing (abfd
);
3557 static enum elf_reloc_type_class
3558 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3559 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3560 const Elf_Internal_Rela
*rela
)
3562 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3564 case R_XTENSA_RELATIVE
:
3565 return reloc_class_relative
;
3566 case R_XTENSA_JMP_SLOT
:
3567 return reloc_class_plt
;
3569 return reloc_class_normal
;
3575 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3576 struct elf_reloc_cookie
*cookie
,
3577 struct bfd_link_info
*info
,
3581 bfd_vma offset
, actual_offset
;
3582 bfd_size_type removed_bytes
= 0;
3583 bfd_size_type entry_size
;
3585 if (sec
->output_section
3586 && bfd_is_abs_section (sec
->output_section
))
3589 if (xtensa_is_proptable_section (sec
))
3594 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3597 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3601 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3604 release_contents (sec
, contents
);
3608 /* Sort the relocations. They should already be in order when
3609 relaxation is enabled, but it might not be. */
3610 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3611 internal_reloc_compare
);
3613 cookie
->rel
= cookie
->rels
;
3614 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3616 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3618 actual_offset
= offset
- removed_bytes
;
3620 /* The ...symbol_deleted_p function will skip over relocs but it
3621 won't adjust their offsets, so do that here. */
3622 while (cookie
->rel
< cookie
->relend
3623 && cookie
->rel
->r_offset
< offset
)
3625 cookie
->rel
->r_offset
-= removed_bytes
;
3629 while (cookie
->rel
< cookie
->relend
3630 && cookie
->rel
->r_offset
== offset
)
3632 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3634 /* Remove the table entry. (If the reloc type is NONE, then
3635 the entry has already been merged with another and deleted
3636 during relaxation.) */
3637 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3639 /* Shift the contents up. */
3640 if (offset
+ entry_size
< sec
->size
)
3641 memmove (&contents
[actual_offset
],
3642 &contents
[actual_offset
+ entry_size
],
3643 sec
->size
- offset
- entry_size
);
3644 removed_bytes
+= entry_size
;
3647 /* Remove this relocation. */
3648 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3651 /* Adjust the relocation offset for previous removals. This
3652 should not be done before calling ...symbol_deleted_p
3653 because it might mess up the offset comparisons there.
3654 Make sure the offset doesn't underflow in the case where
3655 the first entry is removed. */
3656 if (cookie
->rel
->r_offset
>= removed_bytes
)
3657 cookie
->rel
->r_offset
-= removed_bytes
;
3659 cookie
->rel
->r_offset
= 0;
3665 if (removed_bytes
!= 0)
3667 /* Adjust any remaining relocs (shouldn't be any). */
3668 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3670 if (cookie
->rel
->r_offset
>= removed_bytes
)
3671 cookie
->rel
->r_offset
-= removed_bytes
;
3673 cookie
->rel
->r_offset
= 0;
3676 /* Clear the removed bytes. */
3677 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3679 pin_contents (sec
, contents
);
3680 pin_internal_relocs (sec
, cookie
->rels
);
3683 if (sec
->rawsize
== 0)
3684 sec
->rawsize
= sec
->size
;
3685 sec
->size
-= removed_bytes
;
3687 if (xtensa_is_littable_section (sec
))
3689 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3691 sgotloc
->size
-= removed_bytes
;
3696 release_contents (sec
, contents
);
3697 release_internal_relocs (sec
, cookie
->rels
);
3700 return (removed_bytes
!= 0);
3705 elf_xtensa_discard_info (bfd
*abfd
,
3706 struct elf_reloc_cookie
*cookie
,
3707 struct bfd_link_info
*info
)
3710 bool changed
= false;
3712 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3714 if (xtensa_is_property_section (sec
))
3716 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3726 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3728 return xtensa_is_property_section (sec
);
3733 elf_xtensa_action_discarded (asection
*sec
)
3735 if (strcmp (".xt_except_table", sec
->name
) == 0)
3738 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3741 return _bfd_elf_default_action_discarded (sec
);
3745 /* Support for core dump NOTE sections. */
3748 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3753 if (elf_tdata (abfd
) == NULL
3754 || elf_tdata (abfd
)->core
== NULL
)
3757 /* The size for Xtensa is variable, so don't try to recognize the format
3758 based on the size. Just assume this is GNU/Linux. */
3759 if (note
== NULL
|| note
->descsz
< 28)
3763 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3766 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3770 size
= note
->descsz
- offset
- 4;
3772 /* Make a ".reg/999" section. */
3773 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3774 size
, note
->descpos
+ offset
);
3778 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3780 switch (note
->descsz
)
3785 case 128: /* GNU/Linux elf_prpsinfo */
3786 elf_tdata (abfd
)->core
->program
3787 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3788 elf_tdata (abfd
)->core
->command
3789 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3792 /* Note that for some reason, a spurious space is tacked
3793 onto the end of the args in some (at least one anyway)
3794 implementations, so strip it off if it exists. */
3797 char *command
= elf_tdata (abfd
)->core
->command
;
3798 int n
= strlen (command
);
3800 if (0 < n
&& command
[n
- 1] == ' ')
3801 command
[n
- 1] = '\0';
3808 /* Generic Xtensa configurability stuff. */
3810 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3811 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3812 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3813 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3814 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3815 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3816 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3817 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3820 init_call_opcodes (void)
3822 if (callx0_op
== XTENSA_UNDEFINED
)
3824 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3825 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3826 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3827 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3828 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3829 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3830 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3831 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3837 is_indirect_call_opcode (xtensa_opcode opcode
)
3839 init_call_opcodes ();
3840 return (opcode
== callx0_op
3841 || opcode
== callx4_op
3842 || opcode
== callx8_op
3843 || opcode
== callx12_op
);
3848 is_direct_call_opcode (xtensa_opcode opcode
)
3850 init_call_opcodes ();
3851 return (opcode
== call0_op
3852 || opcode
== call4_op
3853 || opcode
== call8_op
3854 || opcode
== call12_op
);
3859 is_windowed_call_opcode (xtensa_opcode opcode
)
3861 init_call_opcodes ();
3862 return (opcode
== call4_op
3863 || opcode
== call8_op
3864 || opcode
== call12_op
3865 || opcode
== callx4_op
3866 || opcode
== callx8_op
3867 || opcode
== callx12_op
);
3872 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3874 unsigned dst
= (unsigned) -1;
3876 init_call_opcodes ();
3877 if (opcode
== callx0_op
)
3879 else if (opcode
== callx4_op
)
3881 else if (opcode
== callx8_op
)
3883 else if (opcode
== callx12_op
)
3886 if (dst
== (unsigned) -1)
3894 static xtensa_opcode
3895 get_const16_opcode (void)
3897 static bool done_lookup
= false;
3898 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3901 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3904 return const16_opcode
;
3908 static xtensa_opcode
3909 get_l32r_opcode (void)
3911 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3912 static bool done_lookup
= false;
3916 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3924 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3928 offset
= addr
- ((pc
+3) & -4);
3929 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3930 offset
= (signed int) offset
>> 2;
3931 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3936 static xtensa_opcode
3937 get_rsr_lend_opcode (void)
3939 static xtensa_opcode rsr_lend_opcode
= XTENSA_UNDEFINED
;
3940 static bool done_lookup
= false;
3943 rsr_lend_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "rsr.lend");
3946 return rsr_lend_opcode
;
3949 static xtensa_opcode
3950 get_wsr_lbeg_opcode (void)
3952 static xtensa_opcode wsr_lbeg_opcode
= XTENSA_UNDEFINED
;
3953 static bool done_lookup
= false;
3956 wsr_lbeg_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "wsr.lbeg");
3959 return wsr_lbeg_opcode
;
3964 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3966 xtensa_isa isa
= xtensa_default_isa
;
3967 int last_immed
, last_opnd
, opi
;
3969 if (opcode
== XTENSA_UNDEFINED
)
3970 return XTENSA_UNDEFINED
;
3972 /* Find the last visible PC-relative immediate operand for the opcode.
3973 If there are no PC-relative immediates, then choose the last visible
3974 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3975 last_immed
= XTENSA_UNDEFINED
;
3976 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3977 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3979 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3981 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3986 if (last_immed
== XTENSA_UNDEFINED
3987 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3991 return XTENSA_UNDEFINED
;
3993 /* If the operand number was specified in an old-style relocation,
3994 check for consistency with the operand computed above. */
3995 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3997 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3998 if (reloc_opnd
!= last_immed
)
3999 return XTENSA_UNDEFINED
;
4007 get_relocation_slot (int r_type
)
4017 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4018 return r_type
- R_XTENSA_SLOT0_OP
;
4019 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4020 return r_type
- R_XTENSA_SLOT0_ALT
;
4024 return XTENSA_UNDEFINED
;
4028 /* Get the opcode for a relocation. */
4030 static xtensa_opcode
4031 get_relocation_opcode (bfd
*abfd
,
4034 Elf_Internal_Rela
*irel
)
4036 static xtensa_insnbuf ibuff
= NULL
;
4037 static xtensa_insnbuf sbuff
= NULL
;
4038 xtensa_isa isa
= xtensa_default_isa
;
4042 if (contents
== NULL
)
4043 return XTENSA_UNDEFINED
;
4045 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
4046 return XTENSA_UNDEFINED
;
4050 ibuff
= xtensa_insnbuf_alloc (isa
);
4051 sbuff
= xtensa_insnbuf_alloc (isa
);
4054 /* Decode the instruction. */
4055 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
4056 sec
->size
- irel
->r_offset
);
4057 fmt
= xtensa_format_decode (isa
, ibuff
);
4058 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
4059 if (slot
== XTENSA_UNDEFINED
)
4060 return XTENSA_UNDEFINED
;
4061 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
4062 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
4067 is_l32r_relocation (bfd
*abfd
,
4070 Elf_Internal_Rela
*irel
)
4072 xtensa_opcode opcode
;
4073 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
4075 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
4076 return (opcode
== get_l32r_opcode ());
4080 static bfd_size_type
4081 get_asm_simplify_size (bfd_byte
*contents
,
4082 bfd_size_type content_len
,
4083 bfd_size_type offset
)
4085 bfd_size_type insnlen
, size
= 0;
4087 /* Decode the size of the next two instructions. */
4088 insnlen
= insn_decode_len (contents
, content_len
, offset
);
4094 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
4104 is_alt_relocation (int r_type
)
4106 return (r_type
>= R_XTENSA_SLOT0_ALT
4107 && r_type
<= R_XTENSA_SLOT14_ALT
);
4112 is_operand_relocation (int r_type
)
4122 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4124 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4133 #define MIN_INSN_LENGTH 2
4135 /* Return 0 if it fails to decode. */
4138 insn_decode_len (bfd_byte
*contents
,
4139 bfd_size_type content_len
,
4140 bfd_size_type offset
)
4143 xtensa_isa isa
= xtensa_default_isa
;
4145 static xtensa_insnbuf ibuff
= NULL
;
4147 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4151 ibuff
= xtensa_insnbuf_alloc (isa
);
4152 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4153 content_len
- offset
);
4154 fmt
= xtensa_format_decode (isa
, ibuff
);
4155 if (fmt
== XTENSA_UNDEFINED
)
4157 insn_len
= xtensa_format_length (isa
, fmt
);
4158 if (insn_len
== XTENSA_UNDEFINED
)
4164 insn_num_slots (bfd_byte
*contents
,
4165 bfd_size_type content_len
,
4166 bfd_size_type offset
)
4168 xtensa_isa isa
= xtensa_default_isa
;
4170 static xtensa_insnbuf ibuff
= NULL
;
4172 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4173 return XTENSA_UNDEFINED
;
4176 ibuff
= xtensa_insnbuf_alloc (isa
);
4177 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4178 content_len
- offset
);
4179 fmt
= xtensa_format_decode (isa
, ibuff
);
4180 if (fmt
== XTENSA_UNDEFINED
)
4181 return XTENSA_UNDEFINED
;
4182 return xtensa_format_num_slots (isa
, fmt
);
4186 /* Decode the opcode for a single slot instruction.
4187 Return 0 if it fails to decode or the instruction is multi-slot. */
4190 insn_decode_opcode (bfd_byte
*contents
,
4191 bfd_size_type content_len
,
4192 bfd_size_type offset
,
4195 xtensa_isa isa
= xtensa_default_isa
;
4197 static xtensa_insnbuf insnbuf
= NULL
;
4198 static xtensa_insnbuf slotbuf
= NULL
;
4200 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4201 return XTENSA_UNDEFINED
;
4203 if (insnbuf
== NULL
)
4205 insnbuf
= xtensa_insnbuf_alloc (isa
);
4206 slotbuf
= xtensa_insnbuf_alloc (isa
);
4209 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4210 content_len
- offset
);
4211 fmt
= xtensa_format_decode (isa
, insnbuf
);
4212 if (fmt
== XTENSA_UNDEFINED
)
4213 return XTENSA_UNDEFINED
;
4215 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4216 return XTENSA_UNDEFINED
;
4218 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4219 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4223 /* The offset is the offset in the contents.
4224 The address is the address of that offset. */
4227 check_branch_target_aligned (bfd_byte
*contents
,
4228 bfd_size_type content_length
,
4232 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4235 return check_branch_target_aligned_address (address
, insn_len
);
4240 check_loop_aligned (bfd_byte
*contents
,
4241 bfd_size_type content_length
,
4245 bfd_size_type loop_len
, insn_len
;
4246 xtensa_opcode opcode
;
4248 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4249 if (opcode
== XTENSA_UNDEFINED
4250 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4256 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4257 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4258 if (loop_len
== 0 || insn_len
== 0)
4264 /* If this is relaxed loop, analyze first instruction of the actual loop
4265 body. It must be at offset 27 from the loop instruction address. */
4267 && insn_num_slots (contents
, content_length
, offset
+ loop_len
) == 1
4268 && insn_decode_opcode (contents
, content_length
,
4269 offset
+ loop_len
, 0) == get_rsr_lend_opcode()
4270 && insn_decode_len (contents
, content_length
, offset
+ loop_len
+ 3) == 3
4271 && insn_num_slots (contents
, content_length
, offset
+ loop_len
+ 3) == 1
4272 && insn_decode_opcode (contents
, content_length
,
4273 offset
+ loop_len
+ 3, 0) == get_wsr_lbeg_opcode())
4276 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4278 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4283 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4286 return (addr
% 8 == 0);
4287 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4291 /* Instruction widening and narrowing. */
4293 /* When FLIX is available we need to access certain instructions only
4294 when they are 16-bit or 24-bit instructions. This table caches
4295 information about such instructions by walking through all the
4296 opcodes and finding the smallest single-slot format into which each
4299 static xtensa_format
*op_single_fmt_table
= NULL
;
4303 init_op_single_format_table (void)
4305 xtensa_isa isa
= xtensa_default_isa
;
4306 xtensa_insnbuf ibuf
;
4307 xtensa_opcode opcode
;
4311 if (op_single_fmt_table
)
4314 ibuf
= xtensa_insnbuf_alloc (isa
);
4315 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4317 op_single_fmt_table
= (xtensa_format
*)
4318 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4319 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4321 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4322 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4324 if (xtensa_format_num_slots (isa
, fmt
) == 1
4325 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4327 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4328 int fmt_length
= xtensa_format_length (isa
, fmt
);
4329 if (old_fmt
== XTENSA_UNDEFINED
4330 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4331 op_single_fmt_table
[opcode
] = fmt
;
4335 xtensa_insnbuf_free (isa
, ibuf
);
4339 static xtensa_format
4340 get_single_format (xtensa_opcode opcode
)
4342 init_op_single_format_table ();
4343 return op_single_fmt_table
[opcode
];
4347 /* For the set of narrowable instructions we do NOT include the
4348 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4349 involved during linker relaxation that may require these to
4350 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4351 requires special case code to ensure it only works when op1 == op2. */
4359 const struct string_pair narrowable
[] =
4362 { "addi", "addi.n" },
4363 { "addmi", "addi.n" },
4364 { "l32i", "l32i.n" },
4365 { "movi", "movi.n" },
4367 { "retw", "retw.n" },
4368 { "s32i", "s32i.n" },
4369 { "or", "mov.n" } /* special case only when op1 == op2 */
4372 const struct string_pair widenable
[] =
4375 { "addi", "addi.n" },
4376 { "addmi", "addi.n" },
4377 { "beqz", "beqz.n" },
4378 { "bnez", "bnez.n" },
4379 { "l32i", "l32i.n" },
4380 { "movi", "movi.n" },
4382 { "retw", "retw.n" },
4383 { "s32i", "s32i.n" },
4384 { "or", "mov.n" } /* special case only when op1 == op2 */
4388 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4389 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4390 return the instruction buffer holding the narrow instruction. Otherwise,
4391 return 0. The set of valid narrowing are specified by a string table
4392 but require some special case operand checks in some cases. */
4394 static xtensa_insnbuf
4395 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4397 xtensa_opcode opcode
)
4399 xtensa_isa isa
= xtensa_default_isa
;
4400 xtensa_format o_fmt
;
4403 static xtensa_insnbuf o_insnbuf
= NULL
;
4404 static xtensa_insnbuf o_slotbuf
= NULL
;
4406 if (o_insnbuf
== NULL
)
4408 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4409 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4412 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4414 bool is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4416 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4418 uint32 value
, newval
;
4419 int i
, operand_count
, o_operand_count
;
4420 xtensa_opcode o_opcode
;
4422 /* Address does not matter in this case. We might need to
4423 fix it to handle branches/jumps. */
4424 bfd_vma self_address
= 0;
4426 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4427 if (o_opcode
== XTENSA_UNDEFINED
)
4429 o_fmt
= get_single_format (o_opcode
);
4430 if (o_fmt
== XTENSA_UNDEFINED
)
4433 if (xtensa_format_length (isa
, fmt
) != 3
4434 || xtensa_format_length (isa
, o_fmt
) != 2)
4437 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4438 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4439 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4441 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4446 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4451 uint32 rawval0
, rawval1
, rawval2
;
4453 if (o_operand_count
+ 1 != operand_count
4454 || xtensa_operand_get_field (isa
, opcode
, 0,
4455 fmt
, 0, slotbuf
, &rawval0
) != 0
4456 || xtensa_operand_get_field (isa
, opcode
, 1,
4457 fmt
, 0, slotbuf
, &rawval1
) != 0
4458 || xtensa_operand_get_field (isa
, opcode
, 2,
4459 fmt
, 0, slotbuf
, &rawval2
) != 0
4460 || rawval1
!= rawval2
4461 || rawval0
== rawval1
/* it is a nop */)
4465 for (i
= 0; i
< o_operand_count
; ++i
)
4467 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4469 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4472 /* PC-relative branches need adjustment, but
4473 the PC-rel operand will always have a relocation. */
4475 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4477 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4478 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4483 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4493 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4494 the action in-place directly into the contents and return TRUE. Otherwise,
4495 the return value is FALSE and the contents are not modified. */
4498 narrow_instruction (bfd_byte
*contents
,
4499 bfd_size_type content_length
,
4500 bfd_size_type offset
)
4502 xtensa_opcode opcode
;
4503 bfd_size_type insn_len
;
4504 xtensa_isa isa
= xtensa_default_isa
;
4506 xtensa_insnbuf o_insnbuf
;
4508 static xtensa_insnbuf insnbuf
= NULL
;
4509 static xtensa_insnbuf slotbuf
= NULL
;
4511 if (insnbuf
== NULL
)
4513 insnbuf
= xtensa_insnbuf_alloc (isa
);
4514 slotbuf
= xtensa_insnbuf_alloc (isa
);
4517 BFD_ASSERT (offset
< content_length
);
4519 if (content_length
< 2)
4522 /* We will hand-code a few of these for a little while.
4523 These have all been specified in the assembler aleady. */
4524 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4525 content_length
- offset
);
4526 fmt
= xtensa_format_decode (isa
, insnbuf
);
4527 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4530 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4533 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4534 if (opcode
== XTENSA_UNDEFINED
)
4536 insn_len
= xtensa_format_length (isa
, fmt
);
4537 if (insn_len
> content_length
)
4540 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4543 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4544 content_length
- offset
);
4552 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4553 "density" instruction to a standard 3-byte instruction. If it is valid,
4554 return the instruction buffer holding the wide instruction. Otherwise,
4555 return 0. The set of valid widenings are specified by a string table
4556 but require some special case operand checks in some cases. */
4558 static xtensa_insnbuf
4559 can_widen_instruction (xtensa_insnbuf slotbuf
,
4561 xtensa_opcode opcode
)
4563 xtensa_isa isa
= xtensa_default_isa
;
4564 xtensa_format o_fmt
;
4567 static xtensa_insnbuf o_insnbuf
= NULL
;
4568 static xtensa_insnbuf o_slotbuf
= NULL
;
4570 if (o_insnbuf
== NULL
)
4572 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4573 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4576 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4578 bool is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4579 bool is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4580 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4582 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4584 uint32 value
, newval
;
4585 int i
, operand_count
, o_operand_count
, check_operand_count
;
4586 xtensa_opcode o_opcode
;
4588 /* Address does not matter in this case. We might need to fix it
4589 to handle branches/jumps. */
4590 bfd_vma self_address
= 0;
4592 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4593 if (o_opcode
== XTENSA_UNDEFINED
)
4595 o_fmt
= get_single_format (o_opcode
);
4596 if (o_fmt
== XTENSA_UNDEFINED
)
4599 if (xtensa_format_length (isa
, fmt
) != 2
4600 || xtensa_format_length (isa
, o_fmt
) != 3)
4603 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4604 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4605 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4606 check_operand_count
= o_operand_count
;
4608 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4613 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4618 uint32 rawval0
, rawval1
;
4620 if (o_operand_count
!= operand_count
+ 1
4621 || xtensa_operand_get_field (isa
, opcode
, 0,
4622 fmt
, 0, slotbuf
, &rawval0
) != 0
4623 || xtensa_operand_get_field (isa
, opcode
, 1,
4624 fmt
, 0, slotbuf
, &rawval1
) != 0
4625 || rawval0
== rawval1
/* it is a nop */)
4629 check_operand_count
--;
4631 for (i
= 0; i
< check_operand_count
; i
++)
4634 if (is_or
&& i
== o_operand_count
- 1)
4636 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4638 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4641 /* PC-relative branches need adjustment, but
4642 the PC-rel operand will always have a relocation. */
4644 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4646 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4647 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4652 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4662 /* Attempt to widen an instruction. If the widening is valid, perform
4663 the action in-place directly into the contents and return TRUE. Otherwise,
4664 the return value is FALSE and the contents are not modified. */
4667 widen_instruction (bfd_byte
*contents
,
4668 bfd_size_type content_length
,
4669 bfd_size_type offset
)
4671 xtensa_opcode opcode
;
4672 bfd_size_type insn_len
;
4673 xtensa_isa isa
= xtensa_default_isa
;
4675 xtensa_insnbuf o_insnbuf
;
4677 static xtensa_insnbuf insnbuf
= NULL
;
4678 static xtensa_insnbuf slotbuf
= NULL
;
4680 if (insnbuf
== NULL
)
4682 insnbuf
= xtensa_insnbuf_alloc (isa
);
4683 slotbuf
= xtensa_insnbuf_alloc (isa
);
4686 BFD_ASSERT (offset
< content_length
);
4688 if (content_length
< 2)
4691 /* We will hand-code a few of these for a little while.
4692 These have all been specified in the assembler aleady. */
4693 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4694 content_length
- offset
);
4695 fmt
= xtensa_format_decode (isa
, insnbuf
);
4696 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4699 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4702 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4703 if (opcode
== XTENSA_UNDEFINED
)
4705 insn_len
= xtensa_format_length (isa
, fmt
);
4706 if (insn_len
> content_length
)
4709 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4712 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4713 content_length
- offset
);
4720 /* Code for transforming CALLs at link-time. */
4722 static bfd_reloc_status_type
4723 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4725 bfd_vma content_length
,
4726 char **error_message
)
4728 static xtensa_insnbuf insnbuf
= NULL
;
4729 static xtensa_insnbuf slotbuf
= NULL
;
4730 xtensa_format core_format
= XTENSA_UNDEFINED
;
4731 xtensa_opcode opcode
;
4732 xtensa_opcode direct_call_opcode
;
4733 xtensa_isa isa
= xtensa_default_isa
;
4734 bfd_byte
*chbuf
= contents
+ address
;
4737 if (insnbuf
== NULL
)
4739 insnbuf
= xtensa_insnbuf_alloc (isa
);
4740 slotbuf
= xtensa_insnbuf_alloc (isa
);
4743 if (content_length
< address
)
4745 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4746 return bfd_reloc_other
;
4749 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4750 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4751 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4753 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4754 return bfd_reloc_other
;
4757 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4758 core_format
= xtensa_format_lookup (isa
, "x24");
4759 opcode
= xtensa_opcode_lookup (isa
, "or");
4760 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4761 for (opn
= 0; opn
< 3; opn
++)
4764 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4765 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 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
, content_length
- address
);
4772 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4773 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4774 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4776 xtensa_format_encode (isa
, core_format
, insnbuf
);
4777 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4778 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4779 content_length
- address
- 3);
4781 return bfd_reloc_ok
;
4785 static bfd_reloc_status_type
4786 contract_asm_expansion (bfd_byte
*contents
,
4787 bfd_vma content_length
,
4788 Elf_Internal_Rela
*irel
,
4789 char **error_message
)
4791 bfd_reloc_status_type retval
=
4792 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4795 if (retval
!= bfd_reloc_ok
)
4796 return bfd_reloc_dangerous
;
4798 /* Update the irel->r_offset field so that the right immediate and
4799 the right instruction are modified during the relocation. */
4800 irel
->r_offset
+= 3;
4801 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4802 return bfd_reloc_ok
;
4806 static xtensa_opcode
4807 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4809 init_call_opcodes ();
4811 if (opcode
== callx0_op
) return call0_op
;
4812 if (opcode
== callx4_op
) return call4_op
;
4813 if (opcode
== callx8_op
) return call8_op
;
4814 if (opcode
== callx12_op
) return call12_op
;
4816 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4817 return XTENSA_UNDEFINED
;
4821 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4822 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4823 If not, return XTENSA_UNDEFINED. */
4825 #define L32R_TARGET_REG_OPERAND 0
4826 #define CONST16_TARGET_REG_OPERAND 0
4827 #define CALLN_SOURCE_OPERAND 0
4829 static xtensa_opcode
4830 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bool *p_uses_l32r
)
4832 static xtensa_insnbuf insnbuf
= NULL
;
4833 static xtensa_insnbuf slotbuf
= NULL
;
4835 xtensa_opcode opcode
;
4836 xtensa_isa isa
= xtensa_default_isa
;
4837 uint32 regno
, const16_regno
, call_regno
;
4840 if (insnbuf
== NULL
)
4842 insnbuf
= xtensa_insnbuf_alloc (isa
);
4843 slotbuf
= xtensa_insnbuf_alloc (isa
);
4846 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4847 fmt
= xtensa_format_decode (isa
, insnbuf
);
4848 if (fmt
== XTENSA_UNDEFINED
4849 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4850 return XTENSA_UNDEFINED
;
4852 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4853 if (opcode
== XTENSA_UNDEFINED
)
4854 return XTENSA_UNDEFINED
;
4856 if (opcode
== get_l32r_opcode ())
4859 *p_uses_l32r
= true;
4860 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4861 fmt
, 0, slotbuf
, ®no
)
4862 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4864 return XTENSA_UNDEFINED
;
4866 else if (opcode
== get_const16_opcode ())
4869 *p_uses_l32r
= false;
4870 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4871 fmt
, 0, slotbuf
, ®no
)
4872 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4874 return XTENSA_UNDEFINED
;
4876 /* Check that the next instruction is also CONST16. */
4877 offset
+= xtensa_format_length (isa
, fmt
);
4878 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4879 fmt
= xtensa_format_decode (isa
, insnbuf
);
4880 if (fmt
== XTENSA_UNDEFINED
4881 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4882 return XTENSA_UNDEFINED
;
4883 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4884 if (opcode
!= get_const16_opcode ())
4885 return XTENSA_UNDEFINED
;
4887 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4888 fmt
, 0, slotbuf
, &const16_regno
)
4889 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4891 || const16_regno
!= regno
)
4892 return XTENSA_UNDEFINED
;
4895 return XTENSA_UNDEFINED
;
4897 /* Next instruction should be an CALLXn with operand 0 == regno. */
4898 offset
+= xtensa_format_length (isa
, fmt
);
4899 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4900 fmt
= xtensa_format_decode (isa
, insnbuf
);
4901 if (fmt
== XTENSA_UNDEFINED
4902 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4903 return XTENSA_UNDEFINED
;
4904 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4905 if (opcode
== XTENSA_UNDEFINED
4906 || !is_indirect_call_opcode (opcode
))
4907 return XTENSA_UNDEFINED
;
4909 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4910 fmt
, 0, slotbuf
, &call_regno
)
4911 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4913 return XTENSA_UNDEFINED
;
4915 if (call_regno
!= regno
)
4916 return XTENSA_UNDEFINED
;
4922 /* Data structures used during relaxation. */
4924 /* r_reloc: relocation values. */
4926 /* Through the relaxation process, we need to keep track of the values
4927 that will result from evaluating relocations. The standard ELF
4928 relocation structure is not sufficient for this purpose because we're
4929 operating on multiple input files at once, so we need to know which
4930 input file a relocation refers to. The r_reloc structure thus
4931 records both the input file (bfd) and ELF relocation.
4933 For efficiency, an r_reloc also contains a "target_offset" field to
4934 cache the target-section-relative offset value that is represented by
4937 The r_reloc also contains a virtual offset that allows multiple
4938 inserted literals to be placed at the same "address" with
4939 different offsets. */
4941 typedef struct r_reloc_struct r_reloc
;
4943 struct r_reloc_struct
4946 Elf_Internal_Rela rela
;
4947 bfd_vma target_offset
;
4948 bfd_vma virtual_offset
;
4952 /* The r_reloc structure is included by value in literal_value, but not
4953 every literal_value has an associated relocation -- some are simple
4954 constants. In such cases, we set all the fields in the r_reloc
4955 struct to zero. The r_reloc_is_const function should be used to
4956 detect this case. */
4959 r_reloc_is_const (const r_reloc
*r_rel
)
4961 return (r_rel
->abfd
== NULL
);
4966 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4968 bfd_vma target_offset
;
4969 unsigned long r_symndx
;
4971 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4972 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4973 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4974 return (target_offset
+ r_rel
->rela
.r_addend
);
4978 static struct elf_link_hash_entry
*
4979 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4981 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4982 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4987 r_reloc_get_section (const r_reloc
*r_rel
)
4989 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4990 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4995 r_reloc_is_defined (const r_reloc
*r_rel
)
5001 sec
= r_reloc_get_section (r_rel
);
5002 if (sec
== bfd_abs_section_ptr
5003 || sec
== bfd_com_section_ptr
5004 || sec
== bfd_und_section_ptr
)
5011 r_reloc_init (r_reloc
*r_rel
,
5013 Elf_Internal_Rela
*irel
,
5015 bfd_size_type content_length
)
5018 reloc_howto_type
*howto
;
5022 r_rel
->rela
= *irel
;
5024 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
5025 r_rel
->virtual_offset
= 0;
5026 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
5027 howto
= &elf_howto_table
[r_type
];
5028 if (howto
->partial_inplace
)
5030 bfd_vma inplace_val
;
5031 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
5033 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
5034 r_rel
->target_offset
+= inplace_val
;
5038 memset (r_rel
, 0, sizeof (r_reloc
));
5045 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
5047 if (r_reloc_is_defined (r_rel
))
5049 asection
*sec
= r_reloc_get_section (r_rel
);
5050 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
5052 else if (r_reloc_get_hash_entry (r_rel
))
5053 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
5055 fprintf (fp
, " ?? + ");
5057 fprintf (fp
, "%" PRIx64
, (uint64_t) r_rel
->target_offset
);
5058 if (r_rel
->virtual_offset
)
5059 fprintf (fp
, " + %" PRIx64
, (uint64_t) r_rel
->virtual_offset
);
5067 /* source_reloc: relocations that reference literals. */
5069 /* To determine whether literals can be coalesced, we need to first
5070 record all the relocations that reference the literals. The
5071 source_reloc structure below is used for this purpose. The
5072 source_reloc entries are kept in a per-literal-section array, sorted
5073 by offset within the literal section (i.e., target offset).
5075 The source_sec and r_rel.rela.r_offset fields identify the source of
5076 the relocation. The r_rel field records the relocation value, i.e.,
5077 the offset of the literal being referenced. The opnd field is needed
5078 to determine the range of the immediate field to which the relocation
5079 applies, so we can determine whether another literal with the same
5080 value is within range. The is_null field is true when the relocation
5081 is being removed (e.g., when an L32R is being removed due to a CALLX
5082 that is converted to a direct CALL). */
5084 typedef struct source_reloc_struct source_reloc
;
5086 struct source_reloc_struct
5088 asection
*source_sec
;
5090 xtensa_opcode opcode
;
5093 bool is_abs_literal
;
5098 init_source_reloc (source_reloc
*reloc
,
5099 asection
*source_sec
,
5100 const r_reloc
*r_rel
,
5101 xtensa_opcode opcode
,
5103 bool is_abs_literal
)
5105 reloc
->source_sec
= source_sec
;
5106 reloc
->r_rel
= *r_rel
;
5107 reloc
->opcode
= opcode
;
5109 reloc
->is_null
= false;
5110 reloc
->is_abs_literal
= is_abs_literal
;
5114 /* Find the source_reloc for a particular source offset and relocation
5115 type. Note that the array is sorted by _target_ offset, so this is
5116 just a linear search. */
5118 static source_reloc
*
5119 find_source_reloc (source_reloc
*src_relocs
,
5122 Elf_Internal_Rela
*irel
)
5126 for (i
= 0; i
< src_count
; i
++)
5128 if (src_relocs
[i
].source_sec
== sec
5129 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
5130 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
5131 == ELF32_R_TYPE (irel
->r_info
)))
5132 return &src_relocs
[i
];
5140 source_reloc_compare (const void *ap
, const void *bp
)
5142 const source_reloc
*a
= (const source_reloc
*) ap
;
5143 const source_reloc
*b
= (const source_reloc
*) bp
;
5145 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
5146 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5148 /* We don't need to sort on these criteria for correctness,
5149 but enforcing a more strict ordering prevents unstable qsort
5150 from behaving differently with different implementations.
5151 Without the code below we get correct but different results
5152 on Solaris 2.7 and 2.8. We would like to always produce the
5153 same results no matter the host. */
5155 if ((!a
->is_null
) - (!b
->is_null
))
5156 return ((!a
->is_null
) - (!b
->is_null
));
5157 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5161 /* Literal values and value hash tables. */
5163 /* Literals with the same value can be coalesced. The literal_value
5164 structure records the value of a literal: the "r_rel" field holds the
5165 information from the relocation on the literal (if there is one) and
5166 the "value" field holds the contents of the literal word itself.
5168 The value_map structure records a literal value along with the
5169 location of a literal holding that value. The value_map hash table
5170 is indexed by the literal value, so that we can quickly check if a
5171 particular literal value has been seen before and is thus a candidate
5174 typedef struct literal_value_struct literal_value
;
5175 typedef struct value_map_struct value_map
;
5176 typedef struct value_map_hash_table_struct value_map_hash_table
;
5178 struct literal_value_struct
5181 unsigned long value
;
5182 bool is_abs_literal
;
5185 struct value_map_struct
5187 literal_value val
; /* The literal value. */
5188 r_reloc loc
; /* Location of the literal. */
5192 struct value_map_hash_table_struct
5194 unsigned bucket_count
;
5195 value_map
**buckets
;
5203 init_literal_value (literal_value
*lit
,
5204 const r_reloc
*r_rel
,
5205 unsigned long value
,
5206 bool is_abs_literal
)
5208 lit
->r_rel
= *r_rel
;
5210 lit
->is_abs_literal
= is_abs_literal
;
5215 literal_value_equal (const literal_value
*src1
,
5216 const literal_value
*src2
,
5217 bool final_static_link
)
5219 struct elf_link_hash_entry
*h1
, *h2
;
5221 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5224 if (r_reloc_is_const (&src1
->r_rel
))
5225 return (src1
->value
== src2
->value
);
5227 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5228 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5231 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5234 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5237 if (src1
->value
!= src2
->value
)
5240 /* Now check for the same section (if defined) or the same elf_hash
5241 (if undefined or weak). */
5242 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5243 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5244 if (r_reloc_is_defined (&src1
->r_rel
)
5245 && (final_static_link
5246 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5247 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5249 if (r_reloc_get_section (&src1
->r_rel
)
5250 != r_reloc_get_section (&src2
->r_rel
))
5255 /* Require that the hash entries (i.e., symbols) be identical. */
5256 if (h1
!= h2
|| h1
== 0)
5260 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5267 /* Must be power of 2. */
5268 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5270 static value_map_hash_table
*
5271 value_map_hash_table_init (void)
5273 value_map_hash_table
*values
;
5275 values
= (value_map_hash_table
*)
5276 bfd_zmalloc (sizeof (value_map_hash_table
));
5277 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5279 values
->buckets
= (value_map
**)
5280 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5281 if (values
->buckets
== NULL
)
5286 values
->has_last_loc
= false;
5293 value_map_hash_table_delete (value_map_hash_table
*table
)
5295 free (table
->buckets
);
5301 hash_bfd_vma (bfd_vma val
)
5303 return (val
>> 2) + (val
>> 10);
5308 literal_value_hash (const literal_value
*src
)
5312 hash_val
= hash_bfd_vma (src
->value
);
5313 if (!r_reloc_is_const (&src
->r_rel
))
5317 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5318 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5319 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5321 /* Now check for the same section and the same elf_hash. */
5322 if (r_reloc_is_defined (&src
->r_rel
))
5323 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5325 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5326 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5332 /* Check if the specified literal_value has been seen before. */
5335 value_map_get_cached_value (value_map_hash_table
*map
,
5336 const literal_value
*val
,
5337 bool final_static_link
)
5343 idx
= literal_value_hash (val
);
5344 idx
= idx
& (map
->bucket_count
- 1);
5345 bucket
= map
->buckets
[idx
];
5346 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5348 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5355 /* Record a new literal value. It is illegal to call this if VALUE
5356 already has an entry here. */
5359 add_value_map (value_map_hash_table
*map
,
5360 const literal_value
*val
,
5362 bool final_static_link
)
5364 value_map
**bucket_p
;
5367 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5370 bfd_set_error (bfd_error_no_memory
);
5374 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5378 idx
= literal_value_hash (val
);
5379 idx
= idx
& (map
->bucket_count
- 1);
5380 bucket_p
= &map
->buckets
[idx
];
5382 val_e
->next
= *bucket_p
;
5385 /* FIXME: Consider resizing the hash table if we get too many entries. */
5391 /* Lists of text actions (ta_) for narrowing, widening, longcall
5392 conversion, space fill, code & literal removal, etc. */
5394 /* The following text actions are generated:
5396 "ta_remove_insn" remove an instruction or instructions
5397 "ta_remove_longcall" convert longcall to call
5398 "ta_convert_longcall" convert longcall to nop/call
5399 "ta_narrow_insn" narrow a wide instruction
5400 "ta_widen" widen a narrow instruction
5401 "ta_fill" add fill or remove fill
5402 removed < 0 is a fill; branches to the fill address will be
5403 changed to address + fill size (e.g., address - removed)
5404 removed >= 0 branches to the fill address will stay unchanged
5405 "ta_remove_literal" remove a literal; this action is
5406 indicated when a literal is removed
5408 "ta_add_literal" insert a new literal; this action is
5409 indicated when a literal has been moved.
5410 It may use a virtual_offset because
5411 multiple literals can be placed at the
5414 For each of these text actions, we also record the number of bytes
5415 removed by performing the text action. In the case of a "ta_widen"
5416 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5418 typedef struct text_action_struct text_action
;
5419 typedef struct text_action_list_struct text_action_list
;
5420 typedef enum text_action_enum_t text_action_t
;
5422 enum text_action_enum_t
5425 ta_remove_insn
, /* removed = -size */
5426 ta_remove_longcall
, /* removed = -size */
5427 ta_convert_longcall
, /* removed = 0 */
5428 ta_narrow_insn
, /* removed = -1 */
5429 ta_widen_insn
, /* removed = +1 */
5430 ta_fill
, /* removed = +size */
5436 /* Structure for a text action record. */
5437 struct text_action_struct
5439 text_action_t action
;
5440 asection
*sec
; /* Optional */
5442 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5444 literal_value value
; /* Only valid when adding literals. */
5447 struct removal_by_action_entry_struct
5452 int eq_removed_before_fill
;
5454 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5456 struct removal_by_action_map_struct
5459 removal_by_action_entry
*entry
;
5461 typedef struct removal_by_action_map_struct removal_by_action_map
;
5464 /* List of all of the actions taken on a text section. */
5465 struct text_action_list_struct
5469 removal_by_action_map map
;
5473 static text_action
*
5474 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5478 /* It is not necessary to fill at the end of a section. */
5479 if (sec
->size
== offset
)
5485 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5487 return (text_action
*)node
->value
;
5493 compute_removed_action_diff (const text_action
*ta
,
5497 int removable_space
)
5500 int current_removed
= 0;
5503 current_removed
= ta
->removed_bytes
;
5505 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5506 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5508 /* It is not necessary to fill at the end of a section. Clean this up. */
5509 if (sec
->size
== offset
)
5510 new_removed
= removable_space
- 0;
5514 int added
= -removed
- current_removed
;
5515 /* Ignore multiples of the section alignment. */
5516 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5517 new_removed
= (-added
);
5519 /* Modify for removable. */
5520 space
= removable_space
- new_removed
;
5521 new_removed
= (removable_space
5522 - (((1 << sec
->alignment_power
) - 1) & space
));
5524 return (new_removed
- current_removed
);
5529 adjust_fill_action (text_action
*ta
, int fill_diff
)
5531 ta
->removed_bytes
+= fill_diff
;
5536 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5538 text_action
*pa
= (text_action
*)a
;
5539 text_action
*pb
= (text_action
*)b
;
5540 static const int action_priority
[] =
5544 [ta_convert_longcall
] = 2,
5545 [ta_narrow_insn
] = 3,
5546 [ta_remove_insn
] = 4,
5547 [ta_remove_longcall
] = 5,
5548 [ta_remove_literal
] = 6,
5549 [ta_widen_insn
] = 7,
5550 [ta_add_literal
] = 8,
5553 if (pa
->offset
== pb
->offset
)
5555 if (pa
->action
== pb
->action
)
5557 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5560 return pa
->offset
< pb
->offset
? -1 : 1;
5563 static text_action
*
5564 action_first (text_action_list
*action_list
)
5566 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5567 return node
? (text_action
*)node
->value
: NULL
;
5570 static text_action
*
5571 action_next (text_action_list
*action_list
, text_action
*action
)
5573 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5574 (splay_tree_key
)action
);
5575 return node
? (text_action
*)node
->value
: NULL
;
5578 /* Add a modification action to the text. For the case of adding or
5579 removing space, modify any current fill and assume that
5580 "unreachable_space" bytes can be freely contracted. Note that a
5581 negative removed value is a fill. */
5584 text_action_add (text_action_list
*l
,
5585 text_action_t action
,
5593 /* It is not necessary to fill at the end of a section. */
5594 if (action
== ta_fill
&& sec
->size
== offset
)
5597 /* It is not necessary to fill 0 bytes. */
5598 if (action
== ta_fill
&& removed
== 0)
5604 if (action
== ta_fill
)
5606 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5610 ta
= (text_action
*)node
->value
;
5611 ta
->removed_bytes
+= removed
;
5616 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5618 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5619 ta
->action
= action
;
5621 ta
->offset
= offset
;
5622 ta
->removed_bytes
= removed
;
5623 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5629 text_action_add_literal (text_action_list
*l
,
5630 text_action_t action
,
5632 const literal_value
*value
,
5636 asection
*sec
= r_reloc_get_section (loc
);
5637 bfd_vma offset
= loc
->target_offset
;
5638 bfd_vma virtual_offset
= loc
->virtual_offset
;
5640 BFD_ASSERT (action
== ta_add_literal
);
5642 /* Create a new record and fill it up. */
5643 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5644 ta
->action
= action
;
5646 ta
->offset
= offset
;
5647 ta
->virtual_offset
= virtual_offset
;
5649 ta
->removed_bytes
= removed
;
5651 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5652 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5657 /* Find the total offset adjustment for the relaxations specified by
5658 text_actions, beginning from a particular starting action. This is
5659 typically used from offset_with_removed_text to search an entire list of
5660 actions, but it may also be called directly when adjusting adjacent offsets
5661 so that each search may begin where the previous one left off. */
5664 removed_by_actions (text_action_list
*action_list
,
5665 text_action
**p_start_action
,
5672 r
= *p_start_action
;
5675 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5677 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5682 if (r
->offset
> offset
)
5685 if (r
->offset
== offset
5686 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5689 removed
+= r
->removed_bytes
;
5691 r
= action_next (action_list
, r
);
5694 *p_start_action
= r
;
5700 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5702 text_action
*r
= action_first (action_list
);
5704 return offset
- removed_by_actions (action_list
, &r
, offset
, false);
5709 action_list_count (text_action_list
*action_list
)
5711 return action_list
->count
;
5714 typedef struct map_action_fn_context_struct map_action_fn_context
;
5715 struct map_action_fn_context_struct
5718 removal_by_action_map map
;
5723 map_action_fn (splay_tree_node node
, void *p
)
5725 map_action_fn_context
*ctx
= p
;
5726 text_action
*r
= (text_action
*)node
->value
;
5727 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5729 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5735 ++ctx
->map
.n_entries
;
5736 ctx
->eq_complete
= false;
5737 ientry
->offset
= r
->offset
;
5738 ientry
->eq_removed_before_fill
= ctx
->removed
;
5741 if (!ctx
->eq_complete
)
5743 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5745 ientry
->eq_removed
= ctx
->removed
;
5746 ctx
->eq_complete
= true;
5749 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5752 ctx
->removed
+= r
->removed_bytes
;
5753 ientry
->removed
= ctx
->removed
;
5758 map_removal_by_action (text_action_list
*action_list
)
5760 map_action_fn_context ctx
;
5763 ctx
.map
.n_entries
= 0;
5764 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5765 sizeof (removal_by_action_entry
));
5766 ctx
.eq_complete
= false;
5768 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5769 action_list
->map
= ctx
.map
;
5773 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5778 if (!action_list
->map
.entry
)
5779 map_removal_by_action (action_list
);
5781 if (!action_list
->map
.n_entries
)
5785 b
= action_list
->map
.n_entries
;
5789 unsigned c
= (a
+ b
) / 2;
5791 if (action_list
->map
.entry
[c
].offset
<= offset
)
5797 if (action_list
->map
.entry
[a
].offset
< offset
)
5799 return action_list
->map
.entry
[a
].removed
;
5801 else if (action_list
->map
.entry
[a
].offset
== offset
)
5803 return before_fill
?
5804 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5805 action_list
->map
.entry
[a
].eq_removed
;
5814 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5816 int removed
= removed_by_actions_map (action_list
, offset
, false);
5817 return offset
- removed
;
5821 /* The find_insn_action routine will only find non-fill actions. */
5823 static text_action
*
5824 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5826 static const text_action_t action
[] =
5828 ta_convert_longcall
,
5838 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5840 splay_tree_node node
;
5842 a
.action
= action
[i
];
5843 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5845 return (text_action
*)node
->value
;
5854 print_action (FILE *fp
, text_action
*r
)
5856 const char *t
= "unknown";
5859 case ta_remove_insn
:
5860 t
= "remove_insn"; break;
5861 case ta_remove_longcall
:
5862 t
= "remove_longcall"; break;
5863 case ta_convert_longcall
:
5864 t
= "convert_longcall"; break;
5865 case ta_narrow_insn
:
5866 t
= "narrow_insn"; break;
5868 t
= "widen_insn"; break;
5873 case ta_remove_literal
:
5874 t
= "remove_literal"; break;
5875 case ta_add_literal
:
5876 t
= "add_literal"; break;
5879 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5880 r
->sec
->owner
->filename
,
5881 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5885 print_action_list_fn (splay_tree_node node
, void *p
)
5887 text_action
*r
= (text_action
*)node
->value
;
5889 print_action (p
, r
);
5894 print_action_list (FILE *fp
, text_action_list
*action_list
)
5896 fprintf (fp
, "Text Action\n");
5897 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5903 /* Lists of literals being coalesced or removed. */
5905 /* In the usual case, the literal identified by "from" is being
5906 coalesced with another literal identified by "to". If the literal is
5907 unused and is being removed altogether, "to.abfd" will be NULL.
5908 The removed_literal entries are kept on a per-section list, sorted
5909 by the "from" offset field. */
5911 typedef struct removed_literal_struct removed_literal
;
5912 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5913 typedef struct removed_literal_list_struct removed_literal_list
;
5915 struct removed_literal_struct
5919 removed_literal
*next
;
5922 struct removed_literal_map_entry_struct
5925 removed_literal
*literal
;
5928 struct removed_literal_list_struct
5930 removed_literal
*head
;
5931 removed_literal
*tail
;
5934 removed_literal_map_entry
*map
;
5938 /* Record that the literal at "from" is being removed. If "to" is not
5939 NULL, the "from" literal is being coalesced with the "to" literal. */
5942 add_removed_literal (removed_literal_list
*removed_list
,
5943 const r_reloc
*from
,
5946 removed_literal
*r
, *new_r
, *next_r
;
5948 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5950 new_r
->from
= *from
;
5954 new_r
->to
.abfd
= NULL
;
5957 r
= removed_list
->head
;
5960 removed_list
->head
= new_r
;
5961 removed_list
->tail
= new_r
;
5963 /* Special check for common case of append. */
5964 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5966 removed_list
->tail
->next
= new_r
;
5967 removed_list
->tail
= new_r
;
5971 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5977 new_r
->next
= next_r
;
5979 removed_list
->tail
= new_r
;
5984 map_removed_literal (removed_literal_list
*removed_list
)
5988 removed_literal_map_entry
*map
= NULL
;
5989 removed_literal
*r
= removed_list
->head
;
5991 for (i
= 0; r
; ++i
, r
= r
->next
)
5995 n_map
= (n_map
* 2) + 2;
5996 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5998 map
[i
].addr
= r
->from
.target_offset
;
6001 removed_list
->map
= map
;
6002 removed_list
->n_map
= i
;
6006 removed_literal_compare (const void *a
, const void *b
)
6008 const bfd_vma
*key
= a
;
6009 const removed_literal_map_entry
*memb
= b
;
6011 if (*key
== memb
->addr
)
6014 return *key
< memb
->addr
? -1 : 1;
6017 /* Check if the list of removed literals contains an entry for the
6018 given address. Return the entry if found. */
6020 static removed_literal
*
6021 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
6023 removed_literal_map_entry
*p
;
6024 removed_literal
*r
= NULL
;
6026 if (removed_list
->map
== NULL
)
6027 map_removed_literal (removed_list
);
6029 if (removed_list
->map
!= NULL
)
6031 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
6032 sizeof (*removed_list
->map
), removed_literal_compare
);
6035 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
6047 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
6050 r
= removed_list
->head
;
6052 fprintf (fp
, "Removed Literals\n");
6053 for (; r
!= NULL
; r
= r
->next
)
6055 print_r_reloc (fp
, &r
->from
);
6056 fprintf (fp
, " => ");
6057 if (r
->to
.abfd
== NULL
)
6058 fprintf (fp
, "REMOVED");
6060 print_r_reloc (fp
, &r
->to
);
6068 /* Per-section data for relaxation. */
6070 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
6072 struct xtensa_relax_info_struct
6074 bool is_relaxable_literal_section
;
6075 bool is_relaxable_asm_section
;
6076 int visited
; /* Number of times visited. */
6078 source_reloc
*src_relocs
; /* Array[src_count]. */
6080 int src_next
; /* Next src_relocs entry to assign. */
6082 removed_literal_list removed_list
;
6083 text_action_list action_list
;
6085 reloc_bfd_fix
*fix_list
;
6086 reloc_bfd_fix
*fix_array
;
6087 unsigned fix_array_count
;
6089 /* Support for expanding the reloc array that is stored
6090 in the section structure. If the relocations have been
6091 reallocated, the newly allocated relocations will be referenced
6092 here along with the actual size allocated. The relocation
6093 count will always be found in the section structure. */
6094 Elf_Internal_Rela
*allocated_relocs
;
6095 unsigned relocs_count
;
6096 unsigned allocated_relocs_count
;
6099 struct elf_xtensa_section_data
6101 struct bfd_elf_section_data elf
;
6102 xtensa_relax_info relax_info
;
6107 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
6109 if (!sec
->used_by_bfd
)
6111 struct elf_xtensa_section_data
*sdata
;
6112 size_t amt
= sizeof (*sdata
);
6114 sdata
= bfd_zalloc (abfd
, amt
);
6117 sec
->used_by_bfd
= sdata
;
6120 return _bfd_elf_new_section_hook (abfd
, sec
);
6124 static xtensa_relax_info
*
6125 get_xtensa_relax_info (asection
*sec
)
6127 struct elf_xtensa_section_data
*section_data
;
6129 /* No info available if no section or if it is an output section. */
6130 if (!sec
|| sec
== sec
->output_section
)
6133 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
6134 return §ion_data
->relax_info
;
6139 init_xtensa_relax_info (asection
*sec
)
6141 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6143 relax_info
->is_relaxable_literal_section
= false;
6144 relax_info
->is_relaxable_asm_section
= false;
6145 relax_info
->visited
= 0;
6147 relax_info
->src_relocs
= NULL
;
6148 relax_info
->src_count
= 0;
6149 relax_info
->src_next
= 0;
6151 relax_info
->removed_list
.head
= NULL
;
6152 relax_info
->removed_list
.tail
= NULL
;
6154 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6156 relax_info
->action_list
.map
.n_entries
= 0;
6157 relax_info
->action_list
.map
.entry
= NULL
;
6159 relax_info
->fix_list
= NULL
;
6160 relax_info
->fix_array
= NULL
;
6161 relax_info
->fix_array_count
= 0;
6163 relax_info
->allocated_relocs
= NULL
;
6164 relax_info
->relocs_count
= 0;
6165 relax_info
->allocated_relocs_count
= 0;
6169 /* Coalescing literals may require a relocation to refer to a section in
6170 a different input file, but the standard relocation information
6171 cannot express that. Instead, the reloc_bfd_fix structures are used
6172 to "fix" the relocations that refer to sections in other input files.
6173 These structures are kept on per-section lists. The "src_type" field
6174 records the relocation type in case there are multiple relocations on
6175 the same location. FIXME: This is ugly; an alternative might be to
6176 add new symbols with the "owner" field to some other input file. */
6178 struct reloc_bfd_fix_struct
6182 unsigned src_type
; /* Relocation type. */
6184 asection
*target_sec
;
6185 bfd_vma target_offset
;
6188 reloc_bfd_fix
*next
;
6192 static reloc_bfd_fix
*
6193 reloc_bfd_fix_init (asection
*src_sec
,
6196 asection
*target_sec
,
6197 bfd_vma target_offset
,
6202 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6203 fix
->src_sec
= src_sec
;
6204 fix
->src_offset
= src_offset
;
6205 fix
->src_type
= src_type
;
6206 fix
->target_sec
= target_sec
;
6207 fix
->target_offset
= target_offset
;
6208 fix
->translated
= translated
;
6215 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6217 xtensa_relax_info
*relax_info
;
6219 relax_info
= get_xtensa_relax_info (src_sec
);
6220 fix
->next
= relax_info
->fix_list
;
6221 relax_info
->fix_list
= fix
;
6226 fix_compare (const void *ap
, const void *bp
)
6228 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6229 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6231 if (a
->src_offset
!= b
->src_offset
)
6232 return (a
->src_offset
- b
->src_offset
);
6233 return (a
->src_type
- b
->src_type
);
6238 cache_fix_array (asection
*sec
)
6240 unsigned i
, count
= 0;
6242 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6244 if (relax_info
== NULL
)
6246 if (relax_info
->fix_list
== NULL
)
6249 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6252 relax_info
->fix_array
=
6253 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6254 relax_info
->fix_array_count
= count
;
6256 r
= relax_info
->fix_list
;
6257 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6259 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6260 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6263 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6264 sizeof (reloc_bfd_fix
), fix_compare
);
6268 static reloc_bfd_fix
*
6269 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6271 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6275 if (relax_info
== NULL
)
6277 if (relax_info
->fix_list
== NULL
)
6280 if (relax_info
->fix_array
== NULL
)
6281 cache_fix_array (sec
);
6283 key
.src_offset
= offset
;
6284 key
.src_type
= type
;
6285 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6286 sizeof (reloc_bfd_fix
), fix_compare
);
6291 /* Section caching. */
6293 typedef struct section_cache_struct section_cache_t
;
6295 struct section_cache_struct
6299 bfd_byte
*contents
; /* Cache of the section contents. */
6300 bfd_size_type content_length
;
6302 property_table_entry
*ptbl
; /* Cache of the section property table. */
6305 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6306 unsigned reloc_count
;
6311 init_section_cache (section_cache_t
*sec_cache
)
6313 memset (sec_cache
, 0, sizeof (*sec_cache
));
6318 free_section_cache (section_cache_t
*sec_cache
)
6322 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6323 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6324 free (sec_cache
->ptbl
);
6330 section_cache_section (section_cache_t
*sec_cache
,
6332 struct bfd_link_info
*link_info
)
6335 property_table_entry
*prop_table
= NULL
;
6337 bfd_byte
*contents
= NULL
;
6338 Elf_Internal_Rela
*internal_relocs
= NULL
;
6339 bfd_size_type sec_size
;
6343 if (sec
== sec_cache
->sec
)
6347 sec_size
= bfd_get_section_limit (abfd
, sec
);
6349 /* Get the contents. */
6350 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6351 if (contents
== NULL
&& sec_size
!= 0)
6354 /* Get the relocations. */
6355 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6356 link_info
->keep_memory
);
6358 /* Get the entry table. */
6359 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6360 XTENSA_PROP_SEC_NAME
, false);
6364 /* Fill in the new section cache. */
6365 free_section_cache (sec_cache
);
6366 init_section_cache (sec_cache
);
6368 sec_cache
->sec
= sec
;
6369 sec_cache
->contents
= contents
;
6370 sec_cache
->content_length
= sec_size
;
6371 sec_cache
->relocs
= internal_relocs
;
6372 sec_cache
->reloc_count
= sec
->reloc_count
;
6373 sec_cache
->pte_count
= ptblsize
;
6374 sec_cache
->ptbl
= prop_table
;
6379 release_contents (sec
, contents
);
6380 release_internal_relocs (sec
, internal_relocs
);
6386 /* Extended basic blocks. */
6388 /* An ebb_struct represents an Extended Basic Block. Within this
6389 range, we guarantee that all instructions are decodable, the
6390 property table entries are contiguous, and no property table
6391 specifies a segment that cannot have instructions moved. This
6392 structure contains caches of the contents, property table and
6393 relocations for the specified section for easy use. The range is
6394 specified by ranges of indices for the byte offset, property table
6395 offsets and relocation offsets. These must be consistent. */
6397 typedef struct ebb_struct ebb_t
;
6403 bfd_byte
*contents
; /* Cache of the section contents. */
6404 bfd_size_type content_length
;
6406 property_table_entry
*ptbl
; /* Cache of the section property table. */
6409 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6410 unsigned reloc_count
;
6412 bfd_vma start_offset
; /* Offset in section. */
6413 unsigned start_ptbl_idx
; /* Offset in the property table. */
6414 unsigned start_reloc_idx
; /* Offset in the relocations. */
6417 unsigned end_ptbl_idx
;
6418 unsigned end_reloc_idx
;
6420 bool ends_section
; /* Is this the last ebb in a section? */
6422 /* The unreachable property table at the end of this set of blocks;
6423 NULL if the end is not an unreachable block. */
6424 property_table_entry
*ends_unreachable
;
6428 enum ebb_target_enum
6431 EBB_DESIRE_TGT_ALIGN
,
6432 EBB_REQUIRE_TGT_ALIGN
,
6433 EBB_REQUIRE_LOOP_ALIGN
,
6438 /* proposed_action_struct is similar to the text_action_struct except
6439 that is represents a potential transformation, not one that will
6440 occur. We build a list of these for an extended basic block
6441 and use them to compute the actual actions desired. We must be
6442 careful that the entire set of actual actions we perform do not
6443 break any relocations that would fit if the actions were not
6446 typedef struct proposed_action_struct proposed_action
;
6448 struct proposed_action_struct
6450 enum ebb_target_enum align_type
; /* for the target alignment */
6451 bfd_vma alignment_pow
;
6452 text_action_t action
;
6455 bool do_action
; /* If false, then we will not perform the action. */
6459 /* The ebb_constraint_struct keeps a set of proposed actions for an
6460 extended basic block. */
6462 typedef struct ebb_constraint_struct ebb_constraint
;
6464 struct ebb_constraint_struct
6469 /* Bytes of extra space at the beginning if movable. */
6470 int start_extra_space
;
6472 enum ebb_target_enum start_align
;
6476 /* Bytes of extra space at the end if movable. */
6477 int end_extra_space
;
6479 unsigned action_count
;
6480 unsigned action_allocated
;
6482 /* Array of proposed actions. */
6483 proposed_action
*actions
;
6485 /* Action alignments -- one for each proposed action. */
6486 enum ebb_target_enum
*action_aligns
;
6491 init_ebb_constraint (ebb_constraint
*c
)
6493 memset (c
, 0, sizeof (ebb_constraint
));
6498 free_ebb_constraint (ebb_constraint
*c
)
6505 init_ebb (ebb_t
*ebb
,
6508 bfd_size_type content_length
,
6509 property_table_entry
*prop_table
,
6511 Elf_Internal_Rela
*internal_relocs
,
6512 unsigned reloc_count
)
6514 memset (ebb
, 0, sizeof (ebb_t
));
6516 ebb
->contents
= contents
;
6517 ebb
->content_length
= content_length
;
6518 ebb
->ptbl
= prop_table
;
6519 ebb
->pte_count
= ptblsize
;
6520 ebb
->relocs
= internal_relocs
;
6521 ebb
->reloc_count
= reloc_count
;
6522 ebb
->start_offset
= 0;
6523 ebb
->end_offset
= ebb
->content_length
- 1;
6524 ebb
->start_ptbl_idx
= 0;
6525 ebb
->end_ptbl_idx
= ptblsize
;
6526 ebb
->start_reloc_idx
= 0;
6527 ebb
->end_reloc_idx
= reloc_count
;
6531 /* Extend the ebb to all decodable contiguous sections. The algorithm
6532 for building a basic block around an instruction is to push it
6533 forward until we hit the end of a section, an unreachable block or
6534 a block that cannot be transformed. Then we push it backwards
6535 searching for similar conditions. */
6537 static bool extend_ebb_bounds_forward (ebb_t
*);
6538 static bool extend_ebb_bounds_backward (ebb_t
*);
6539 static bfd_size_type insn_block_decodable_len
6540 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6543 extend_ebb_bounds (ebb_t
*ebb
)
6545 if (!extend_ebb_bounds_forward (ebb
))
6547 if (!extend_ebb_bounds_backward (ebb
))
6554 extend_ebb_bounds_forward (ebb_t
*ebb
)
6556 property_table_entry
*the_entry
, *new_entry
;
6558 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6560 /* Stop when (1) we cannot decode an instruction, (2) we are at
6561 the end of the property tables, (3) we hit a non-contiguous property
6562 table entry, (4) we hit a NO_TRANSFORM region. */
6567 bfd_size_type insn_block_len
;
6569 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6571 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6573 entry_end
- ebb
->end_offset
);
6574 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6577 /* xgettext:c-format */
6578 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6579 "possible configuration mismatch"),
6580 ebb
->sec
->owner
, ebb
->sec
,
6581 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6584 ebb
->end_offset
+= insn_block_len
;
6586 if (ebb
->end_offset
== ebb
->sec
->size
)
6587 ebb
->ends_section
= true;
6589 /* Update the reloc counter. */
6590 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6591 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6594 ebb
->end_reloc_idx
++;
6597 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6600 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6601 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6602 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6603 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6606 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6609 the_entry
= new_entry
;
6610 ebb
->end_ptbl_idx
++;
6613 /* Quick check for an unreachable or end of file just at the end. */
6614 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6616 if (ebb
->end_offset
== ebb
->content_length
)
6617 ebb
->ends_section
= true;
6621 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6622 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6623 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6624 ebb
->ends_unreachable
= new_entry
;
6627 /* Any other ending requires exact alignment. */
6633 extend_ebb_bounds_backward (ebb_t
*ebb
)
6635 property_table_entry
*the_entry
, *new_entry
;
6637 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6639 /* Stop when (1) we cannot decode the instructions in the current entry.
6640 (2) we are at the beginning of the property tables, (3) we hit a
6641 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6645 bfd_vma block_begin
;
6646 bfd_size_type insn_block_len
;
6648 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6650 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6652 ebb
->start_offset
- block_begin
);
6653 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6656 /* xgettext:c-format */
6657 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6658 "possible configuration mismatch"),
6659 ebb
->sec
->owner
, ebb
->sec
,
6660 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6663 ebb
->start_offset
-= insn_block_len
;
6665 /* Update the reloc counter. */
6666 while (ebb
->start_reloc_idx
> 0
6667 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6668 >= ebb
->start_offset
))
6670 ebb
->start_reloc_idx
--;
6673 if (ebb
->start_ptbl_idx
== 0)
6676 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6677 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6678 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6679 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6681 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6684 the_entry
= new_entry
;
6685 ebb
->start_ptbl_idx
--;
6691 static bfd_size_type
6692 insn_block_decodable_len (bfd_byte
*contents
,
6693 bfd_size_type content_len
,
6694 bfd_vma block_offset
,
6695 bfd_size_type block_len
)
6697 bfd_vma offset
= block_offset
;
6699 while (offset
< block_offset
+ block_len
)
6701 bfd_size_type insn_len
= 0;
6703 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6705 return (offset
- block_offset
);
6708 return (offset
- block_offset
);
6713 ebb_propose_action (ebb_constraint
*c
,
6714 enum ebb_target_enum align_type
,
6715 bfd_vma alignment_pow
,
6716 text_action_t action
,
6721 proposed_action
*act
;
6723 if (c
->action_allocated
<= c
->action_count
)
6725 unsigned new_allocated
, i
;
6726 proposed_action
*new_actions
;
6728 new_allocated
= (c
->action_count
+ 2) * 2;
6729 new_actions
= (proposed_action
*)
6730 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6732 for (i
= 0; i
< c
->action_count
; i
++)
6733 new_actions
[i
] = c
->actions
[i
];
6735 c
->actions
= new_actions
;
6736 c
->action_allocated
= new_allocated
;
6739 act
= &c
->actions
[c
->action_count
];
6740 act
->align_type
= align_type
;
6741 act
->alignment_pow
= alignment_pow
;
6742 act
->action
= action
;
6743 act
->offset
= offset
;
6744 act
->removed_bytes
= removed_bytes
;
6745 act
->do_action
= do_action
;
6751 /* Access to internal relocations, section contents and symbols. */
6753 /* During relaxation, we need to modify relocations, section contents,
6754 and symbol definitions, and we need to keep the original values from
6755 being reloaded from the input files, i.e., we need to "pin" the
6756 modified values in memory. We also want to continue to observe the
6757 setting of the "keep-memory" flag. The following functions wrap the
6758 standard BFD functions to take care of this for us. */
6760 static Elf_Internal_Rela
*
6761 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bool keep_memory
)
6763 Elf_Internal_Rela
*internal_relocs
;
6765 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6768 internal_relocs
= elf_section_data (sec
)->relocs
;
6769 if (internal_relocs
== NULL
)
6770 internal_relocs
= (_bfd_elf_link_read_relocs
6771 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6772 return internal_relocs
;
6777 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6779 elf_section_data (sec
)->relocs
= internal_relocs
;
6784 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6786 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
6787 free (internal_relocs
);
6792 retrieve_contents (bfd
*abfd
, asection
*sec
, bool keep_memory
)
6795 bfd_size_type sec_size
;
6797 sec_size
= bfd_get_section_limit (abfd
, sec
);
6798 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6800 if (contents
== NULL
&& sec_size
!= 0)
6802 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6808 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6815 pin_contents (asection
*sec
, bfd_byte
*contents
)
6817 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6822 release_contents (asection
*sec
, bfd_byte
*contents
)
6824 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6829 static Elf_Internal_Sym
*
6830 retrieve_local_syms (bfd
*input_bfd
)
6832 Elf_Internal_Shdr
*symtab_hdr
;
6833 Elf_Internal_Sym
*isymbuf
;
6836 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6837 locsymcount
= symtab_hdr
->sh_info
;
6839 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6840 if (isymbuf
== NULL
&& locsymcount
!= 0)
6841 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6844 /* Save the symbols for this input file so they won't be read again. */
6845 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6846 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6852 /* Code for link-time relaxation. */
6854 /* Initialization for relaxation: */
6855 static bool analyze_relocations (struct bfd_link_info
*);
6856 static bool find_relaxable_sections
6857 (bfd
*, asection
*, struct bfd_link_info
*, bool *);
6858 static bool collect_source_relocs
6859 (bfd
*, asection
*, struct bfd_link_info
*);
6860 static bool is_resolvable_asm_expansion
6861 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6863 static Elf_Internal_Rela
*find_associated_l32r_irel
6864 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6865 static bool compute_text_actions
6866 (bfd
*, asection
*, struct bfd_link_info
*);
6867 static bool compute_ebb_proposed_actions (ebb_constraint
*);
6868 static bool compute_ebb_actions (ebb_constraint
*);
6869 typedef struct reloc_range_list_struct reloc_range_list
;
6870 static bool check_section_ebb_pcrels_fit
6871 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6872 reloc_range_list
*, const ebb_constraint
*,
6873 const xtensa_opcode
*);
6874 static bool check_section_ebb_reduces (const ebb_constraint
*);
6875 static void text_action_add_proposed
6876 (text_action_list
*, const ebb_constraint
*, asection
*);
6879 static bool compute_removed_literals
6880 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6881 static Elf_Internal_Rela
*get_irel_at_offset
6882 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6883 static bool is_removable_literal
6884 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6885 property_table_entry
*, int);
6886 static bool remove_dead_literal
6887 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6888 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6889 static bool identify_literal_placement
6890 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6891 value_map_hash_table
*, bool *, Elf_Internal_Rela
*, int,
6892 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6894 static bool relocations_reach (source_reloc
*, int, const r_reloc
*);
6895 static bool coalesce_shared_literal
6896 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6897 static bool move_shared_literal
6898 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6899 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6902 static bool relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6903 static bool translate_section_fixes (asection
*);
6904 static bool translate_reloc_bfd_fix (reloc_bfd_fix
*);
6905 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6906 static void shrink_dynamic_reloc_sections
6907 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6908 static bool move_literal
6909 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6910 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6911 static bool relax_property_section
6912 (bfd
*, asection
*, struct bfd_link_info
*);
6915 static bool relax_section_symbols (bfd
*, asection
*);
6919 elf_xtensa_relax_section (bfd
*abfd
,
6921 struct bfd_link_info
*link_info
,
6924 static value_map_hash_table
*values
= NULL
;
6925 static bool relocations_analyzed
= false;
6926 xtensa_relax_info
*relax_info
;
6928 if (!relocations_analyzed
)
6930 /* Do some overall initialization for relaxation. */
6931 values
= value_map_hash_table_init ();
6934 relaxing_section
= true;
6935 if (!analyze_relocations (link_info
))
6937 relocations_analyzed
= true;
6941 /* Don't mess with linker-created sections. */
6942 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6945 relax_info
= get_xtensa_relax_info (sec
);
6946 BFD_ASSERT (relax_info
!= NULL
);
6948 switch (relax_info
->visited
)
6951 /* Note: It would be nice to fold this pass into
6952 analyze_relocations, but it is important for this step that the
6953 sections be examined in link order. */
6954 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6961 value_map_hash_table_delete (values
);
6963 if (!relax_section (abfd
, sec
, link_info
))
6969 if (!relax_section_symbols (abfd
, sec
))
6974 relax_info
->visited
++;
6979 /* Initialization for relaxation. */
6981 /* This function is called once at the start of relaxation. It scans
6982 all the input sections and marks the ones that are relaxable (i.e.,
6983 literal sections with L32R relocations against them), and then
6984 collects source_reloc information for all the relocations against
6985 those relaxable sections. During this process, it also detects
6986 longcalls, i.e., calls relaxed by the assembler into indirect
6987 calls, that can be optimized back into direct calls. Within each
6988 extended basic block (ebb) containing an optimized longcall, it
6989 computes a set of "text actions" that can be performed to remove
6990 the L32R associated with the longcall while optionally preserving
6991 branch target alignments. */
6994 analyze_relocations (struct bfd_link_info
*link_info
)
6998 bool is_relaxable
= false;
7000 /* Initialize the per-section relaxation info. */
7001 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7002 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7004 init_xtensa_relax_info (sec
);
7007 /* Mark relaxable sections (and count relocations against each one). */
7008 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7009 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7011 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
7015 /* Bail out if there are no relaxable sections. */
7019 /* Allocate space for source_relocs. */
7020 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7021 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7023 xtensa_relax_info
*relax_info
;
7025 relax_info
= get_xtensa_relax_info (sec
);
7026 if (relax_info
->is_relaxable_literal_section
7027 || relax_info
->is_relaxable_asm_section
)
7029 relax_info
->src_relocs
= (source_reloc
*)
7030 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
7033 relax_info
->src_count
= 0;
7036 /* Collect info on relocations against each relaxable section. */
7037 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7038 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7040 if (!collect_source_relocs (abfd
, sec
, link_info
))
7044 /* Compute the text actions. */
7045 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7046 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7048 if (!compute_text_actions (abfd
, sec
, link_info
))
7056 /* Find all the sections that might be relaxed. The motivation for
7057 this pass is that collect_source_relocs() needs to record _all_ the
7058 relocations that target each relaxable section. That is expensive
7059 and unnecessary unless the target section is actually going to be
7060 relaxed. This pass identifies all such sections by checking if
7061 they have L32Rs pointing to them. In the process, the total number
7062 of relocations targeting each section is also counted so that we
7063 know how much space to allocate for source_relocs against each
7064 relaxable literal section. */
7067 find_relaxable_sections (bfd
*abfd
,
7069 struct bfd_link_info
*link_info
,
7070 bool *is_relaxable_p
)
7072 Elf_Internal_Rela
*internal_relocs
;
7076 xtensa_relax_info
*source_relax_info
;
7079 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7080 link_info
->keep_memory
);
7081 if (internal_relocs
== NULL
)
7084 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7085 if (contents
== NULL
&& sec
->size
!= 0)
7091 source_relax_info
= get_xtensa_relax_info (sec
);
7092 for (i
= 0; i
< sec
->reloc_count
; i
++)
7094 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7096 asection
*target_sec
;
7097 xtensa_relax_info
*target_relax_info
;
7099 /* If this section has not already been marked as "relaxable", and
7100 if it contains any ASM_EXPAND relocations (marking expanded
7101 longcalls) that can be optimized into direct calls, then mark
7102 the section as "relaxable". */
7103 if (source_relax_info
7104 && !source_relax_info
->is_relaxable_asm_section
7105 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
7107 bool is_reachable
= false;
7108 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
7109 link_info
, &is_reachable
)
7112 source_relax_info
->is_relaxable_asm_section
= true;
7113 *is_relaxable_p
= true;
7117 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7118 bfd_get_section_limit (abfd
, sec
));
7120 target_sec
= r_reloc_get_section (&r_rel
);
7121 target_relax_info
= get_xtensa_relax_info (target_sec
);
7122 if (!target_relax_info
)
7125 /* Count PC-relative operand relocations against the target section.
7126 Note: The conditions tested here must match the conditions under
7127 which init_source_reloc is called in collect_source_relocs(). */
7128 is_l32r_reloc
= false;
7129 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7131 xtensa_opcode opcode
=
7132 get_relocation_opcode (abfd
, sec
, contents
, irel
);
7133 if (opcode
!= XTENSA_UNDEFINED
)
7135 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
7136 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
7138 target_relax_info
->src_count
++;
7142 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7144 /* Mark the target section as relaxable. */
7145 target_relax_info
->is_relaxable_literal_section
= true;
7146 *is_relaxable_p
= true;
7151 release_contents (sec
, contents
);
7152 release_internal_relocs (sec
, internal_relocs
);
7157 /* Record _all_ the relocations that point to relaxable sections, and
7158 get rid of ASM_EXPAND relocs by either converting them to
7159 ASM_SIMPLIFY or by removing them. */
7162 collect_source_relocs (bfd
*abfd
,
7164 struct bfd_link_info
*link_info
)
7166 Elf_Internal_Rela
*internal_relocs
;
7170 bfd_size_type sec_size
;
7172 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7173 link_info
->keep_memory
);
7174 if (internal_relocs
== NULL
)
7177 sec_size
= bfd_get_section_limit (abfd
, sec
);
7178 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7179 if (contents
== NULL
&& sec_size
!= 0)
7185 /* Record relocations against relaxable literal sections. */
7186 for (i
= 0; i
< sec
->reloc_count
; i
++)
7188 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7190 asection
*target_sec
;
7191 xtensa_relax_info
*target_relax_info
;
7193 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7195 target_sec
= r_reloc_get_section (&r_rel
);
7196 target_relax_info
= get_xtensa_relax_info (target_sec
);
7198 if (target_relax_info
7199 && (target_relax_info
->is_relaxable_literal_section
7200 || target_relax_info
->is_relaxable_asm_section
))
7202 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7204 bool is_abs_literal
= false;
7206 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7208 /* None of the current alternate relocs are PC-relative,
7209 and only PC-relative relocs matter here. However, we
7210 still need to record the opcode for literal
7212 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7213 if (opcode
== get_l32r_opcode ())
7215 is_abs_literal
= true;
7219 opcode
= XTENSA_UNDEFINED
;
7221 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7223 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7224 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7227 if (opcode
!= XTENSA_UNDEFINED
)
7229 int src_next
= target_relax_info
->src_next
++;
7230 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7232 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7238 /* Now get rid of ASM_EXPAND relocations. At this point, the
7239 src_relocs array for the target literal section may still be
7240 incomplete, but it must at least contain the entries for the L32R
7241 relocations associated with ASM_EXPANDs because they were just
7242 added in the preceding loop over the relocations. */
7244 for (i
= 0; i
< sec
->reloc_count
; i
++)
7246 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7249 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7255 Elf_Internal_Rela
*l32r_irel
;
7257 asection
*target_sec
;
7258 xtensa_relax_info
*target_relax_info
;
7260 /* Mark the source_reloc for the L32R so that it will be
7261 removed in compute_removed_literals(), along with the
7262 associated literal. */
7263 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7264 irel
, internal_relocs
);
7265 if (l32r_irel
== NULL
)
7268 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7270 target_sec
= r_reloc_get_section (&r_rel
);
7271 target_relax_info
= get_xtensa_relax_info (target_sec
);
7273 if (target_relax_info
7274 && (target_relax_info
->is_relaxable_literal_section
7275 || target_relax_info
->is_relaxable_asm_section
))
7277 source_reloc
*s_reloc
;
7279 /* Search the source_relocs for the entry corresponding to
7280 the l32r_irel. Note: The src_relocs array is not yet
7281 sorted, but it wouldn't matter anyway because we're
7282 searching by source offset instead of target offset. */
7283 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7284 target_relax_info
->src_next
,
7286 BFD_ASSERT (s_reloc
);
7287 s_reloc
->is_null
= true;
7290 /* Convert this reloc to ASM_SIMPLIFY. */
7291 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7292 R_XTENSA_ASM_SIMPLIFY
);
7293 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7295 pin_internal_relocs (sec
, internal_relocs
);
7299 /* It is resolvable but doesn't reach. We resolve now
7300 by eliminating the relocation -- the call will remain
7301 expanded into L32R/CALLX. */
7302 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7303 pin_internal_relocs (sec
, internal_relocs
);
7308 release_contents (sec
, contents
);
7309 release_internal_relocs (sec
, internal_relocs
);
7314 /* Return TRUE if the asm expansion can be resolved. Generally it can
7315 be resolved on a final link or when a partial link locates it in the
7316 same section as the target. Set "is_reachable" flag if the target of
7317 the call is within the range of a direct call, given the current VMA
7318 for this section and the target section. */
7321 is_resolvable_asm_expansion (bfd
*abfd
,
7324 Elf_Internal_Rela
*irel
,
7325 struct bfd_link_info
*link_info
,
7326 bool *is_reachable_p
)
7328 asection
*target_sec
;
7332 unsigned int first_align
;
7333 unsigned int adjust
;
7334 bfd_vma target_offset
;
7336 xtensa_opcode opcode
, direct_call_opcode
;
7337 bfd_vma self_address
;
7338 bfd_vma dest_address
;
7340 bfd_size_type sec_size
;
7342 *is_reachable_p
= false;
7344 if (contents
== NULL
)
7347 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7350 sec_size
= bfd_get_section_limit (abfd
, sec
);
7351 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7352 sec_size
- irel
->r_offset
, &uses_l32r
);
7353 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7357 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7358 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7361 /* Check and see that the target resolves. */
7362 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7363 if (!r_reloc_is_defined (&r_rel
))
7366 target_sec
= r_reloc_get_section (&r_rel
);
7367 target_offset
= r_rel
.target_offset
;
7369 /* If the target is in a shared library, then it doesn't reach. This
7370 isn't supposed to come up because the compiler should never generate
7371 non-PIC calls on systems that use shared libraries, but the linker
7372 shouldn't crash regardless. */
7373 if (!target_sec
->output_section
)
7376 /* For relocatable sections, we can only simplify when the output
7377 section of the target is the same as the output section of the
7379 if (bfd_link_relocatable (link_info
)
7380 && (target_sec
->output_section
!= sec
->output_section
7381 || is_reloc_sym_weak (abfd
, irel
)))
7384 if (target_sec
->output_section
!= sec
->output_section
)
7386 /* If the two sections are sufficiently far away that relaxation
7387 might take the call out of range, we can't simplify. For
7388 example, a positive displacement call into another memory
7389 could get moved to a lower address due to literal removal,
7390 but the destination won't move, and so the displacment might
7393 If the displacement is negative, assume the destination could
7394 move as far back as the start of the output section. The
7395 self_address will be at least as far into the output section
7396 as it is prior to relaxation.
7398 If the displacement is postive, assume the destination will be in
7399 it's pre-relaxed location (because relaxation only makes sections
7400 smaller). The self_address could go all the way to the beginning
7401 of the output section. */
7403 dest_address
= target_sec
->output_section
->vma
;
7404 self_address
= sec
->output_section
->vma
;
7406 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7407 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7409 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7410 /* Call targets should be four-byte aligned. */
7411 dest_address
= (dest_address
+ 3) & ~3;
7416 self_address
= (sec
->output_section
->vma
7417 + sec
->output_offset
+ irel
->r_offset
+ 3);
7418 dest_address
= (target_sec
->output_section
->vma
7419 + target_sec
->output_offset
+ target_offset
);
7422 /* Adjust addresses with alignments for the worst case to see if call insn
7423 can fit. Don't relax l32r + callx to call if the target can be out of
7424 range due to alignment.
7425 Caller and target addresses are highest and lowest address.
7426 Search all sections between caller and target, looking for max alignment.
7427 The adjustment is max alignment bytes. If the alignment at the lowest
7428 address is less than the adjustment, apply the adjustment to highest
7431 /* Start from lowest address.
7432 Lowest address aligmnet is from input section.
7433 Initial alignment (adjust) is from input section. */
7434 if (dest_address
> self_address
)
7436 s
= sec
->output_section
;
7437 last_vma
= dest_address
;
7438 first_align
= sec
->alignment_power
;
7439 adjust
= target_sec
->alignment_power
;
7443 s
= target_sec
->output_section
;
7444 last_vma
= self_address
;
7445 first_align
= target_sec
->alignment_power
;
7446 adjust
= sec
->alignment_power
;
7451 /* Find the largest alignment in output section list. */
7452 for (; s
&& s
->vma
>= first_vma
&& s
->vma
<= last_vma
; s
= s
->next
)
7454 if (s
->alignment_power
> adjust
)
7455 adjust
= s
->alignment_power
;
7458 if (adjust
> first_align
)
7460 /* Alignment may enlarge the range, adjust highest address. */
7461 adjust
= 1 << adjust
;
7462 if (dest_address
> self_address
)
7464 dest_address
+= adjust
;
7468 self_address
+= adjust
;
7472 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7473 self_address
, dest_address
);
7475 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7476 (dest_address
>> CALL_SEGMENT_BITS
))
7483 static Elf_Internal_Rela
*
7484 find_associated_l32r_irel (bfd
*abfd
,
7487 Elf_Internal_Rela
*other_irel
,
7488 Elf_Internal_Rela
*internal_relocs
)
7492 for (i
= 0; i
< sec
->reloc_count
; i
++)
7494 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7496 if (irel
== other_irel
)
7498 if (irel
->r_offset
!= other_irel
->r_offset
)
7500 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7508 static xtensa_opcode
*
7509 build_reloc_opcodes (bfd
*abfd
,
7512 Elf_Internal_Rela
*internal_relocs
)
7515 xtensa_opcode
*reloc_opcodes
=
7516 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7517 for (i
= 0; i
< sec
->reloc_count
; i
++)
7519 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7520 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7522 return reloc_opcodes
;
7525 struct reloc_range_struct
7528 bool add
; /* TRUE if start of a range, FALSE otherwise. */
7529 /* Original irel index in the array of relocations for a section. */
7530 unsigned irel_index
;
7532 typedef struct reloc_range_struct reloc_range
;
7534 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7535 struct reloc_range_list_entry_struct
7537 reloc_range_list_entry
*next
;
7538 reloc_range_list_entry
*prev
;
7539 Elf_Internal_Rela
*irel
;
7540 xtensa_opcode opcode
;
7544 struct reloc_range_list_struct
7546 /* The rest of the structure is only meaningful when ok is TRUE. */
7549 unsigned n_range
; /* Number of range markers. */
7550 reloc_range
*range
; /* Sorted range markers. */
7552 unsigned first
; /* Index of a first range element in the list. */
7553 unsigned last
; /* One past index of a last range element in the list. */
7555 unsigned n_list
; /* Number of list elements. */
7556 reloc_range_list_entry
*reloc
; /* */
7557 reloc_range_list_entry list_root
;
7561 reloc_range_compare (const void *a
, const void *b
)
7563 const reloc_range
*ra
= a
;
7564 const reloc_range
*rb
= b
;
7566 if (ra
->addr
!= rb
->addr
)
7567 return ra
->addr
< rb
->addr
? -1 : 1;
7568 if (ra
->add
!= rb
->add
)
7569 return ra
->add
? -1 : 1;
7574 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7576 Elf_Internal_Rela
*internal_relocs
,
7577 xtensa_opcode
*reloc_opcodes
,
7578 reloc_range_list
*list
)
7583 reloc_range
*ranges
= NULL
;
7584 reloc_range_list_entry
*reloc
=
7585 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7587 memset (list
, 0, sizeof (*list
));
7590 for (i
= 0; i
< sec
->reloc_count
; i
++)
7592 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7593 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7594 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7597 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7598 || r_type
== R_XTENSA_32_PCREL
7599 || !howto
->pc_relative
)
7602 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7603 bfd_get_section_limit (abfd
, sec
));
7605 if (r_reloc_get_section (&r_rel
) != sec
)
7610 max_n
= (max_n
+ 2) * 2;
7611 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7614 ranges
[n
].addr
= irel
->r_offset
;
7615 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7617 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7618 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7620 ranges
[n
].irel_index
= i
;
7621 ranges
[n
+ 1].irel_index
= i
;
7625 reloc
[i
].irel
= irel
;
7627 /* Every relocation won't possibly be checked in the optimized version of
7628 check_section_ebb_pcrels_fit, so this needs to be done here. */
7629 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7631 /* None of the current alternate relocs are PC-relative,
7632 and only PC-relative relocs matter here. */
7636 xtensa_opcode opcode
;
7640 opcode
= reloc_opcodes
[i
];
7642 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7644 if (opcode
== XTENSA_UNDEFINED
)
7650 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7651 if (opnum
== XTENSA_UNDEFINED
)
7657 /* Record relocation opcode and opnum as we've calculated them
7658 anyway and they won't change. */
7659 reloc
[i
].opcode
= opcode
;
7660 reloc
[i
].opnum
= opnum
;
7666 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7667 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7670 list
->range
= ranges
;
7671 list
->reloc
= reloc
;
7672 list
->list_root
.prev
= &list
->list_root
;
7673 list
->list_root
.next
= &list
->list_root
;
7682 static void reloc_range_list_append (reloc_range_list
*list
,
7683 unsigned irel_index
)
7685 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7687 entry
->prev
= list
->list_root
.prev
;
7688 entry
->next
= &list
->list_root
;
7689 entry
->prev
->next
= entry
;
7690 entry
->next
->prev
= entry
;
7694 static void reloc_range_list_remove (reloc_range_list
*list
,
7695 unsigned irel_index
)
7697 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7699 entry
->next
->prev
= entry
->prev
;
7700 entry
->prev
->next
= entry
->next
;
7704 /* Update relocation list object so that it lists all relocations that cross
7705 [first; last] range. Range bounds should not decrease with successive
7707 static void reloc_range_list_update_range (reloc_range_list
*list
,
7708 bfd_vma first
, bfd_vma last
)
7710 /* This should not happen: EBBs are iterated from lower addresses to higher.
7711 But even if that happens there's no need to break: just flush current list
7712 and start from scratch. */
7713 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7714 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7719 list
->list_root
.next
= &list
->list_root
;
7720 list
->list_root
.prev
= &list
->list_root
;
7721 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7724 for (; list
->last
< list
->n_range
&&
7725 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7726 if (list
->range
[list
->last
].add
)
7727 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7729 for (; list
->first
< list
->n_range
&&
7730 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7731 if (!list
->range
[list
->first
].add
)
7732 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7735 static void free_reloc_range_list (reloc_range_list
*list
)
7741 /* The compute_text_actions function will build a list of potential
7742 transformation actions for code in the extended basic block of each
7743 longcall that is optimized to a direct call. From this list we
7744 generate a set of actions to actually perform that optimizes for
7745 space and, if not using size_opt, maintains branch target
7748 These actions to be performed are placed on a per-section list.
7749 The actual changes are performed by relax_section() in the second
7753 compute_text_actions (bfd
*abfd
,
7755 struct bfd_link_info
*link_info
)
7757 xtensa_opcode
*reloc_opcodes
= NULL
;
7758 xtensa_relax_info
*relax_info
;
7760 Elf_Internal_Rela
*internal_relocs
;
7763 property_table_entry
*prop_table
= 0;
7765 bfd_size_type sec_size
;
7766 reloc_range_list relevant_relocs
;
7768 relax_info
= get_xtensa_relax_info (sec
);
7769 BFD_ASSERT (relax_info
);
7770 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7772 /* Do nothing if the section contains no optimized longcalls. */
7773 if (!relax_info
->is_relaxable_asm_section
)
7776 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7777 link_info
->keep_memory
);
7779 if (internal_relocs
)
7780 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7781 internal_reloc_compare
);
7783 sec_size
= bfd_get_section_limit (abfd
, sec
);
7784 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7785 if (contents
== NULL
&& sec_size
!= 0)
7791 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7792 XTENSA_PROP_SEC_NAME
, false);
7799 /* Precompute the opcode for each relocation. */
7800 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7802 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7805 for (i
= 0; i
< sec
->reloc_count
; i
++)
7807 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7809 property_table_entry
*the_entry
;
7812 ebb_constraint ebb_table
;
7813 bfd_size_type simplify_size
;
7815 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7817 r_offset
= irel
->r_offset
;
7819 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7820 if (simplify_size
== 0)
7823 /* xgettext:c-format */
7824 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7825 "XTENSA_ASM_SIMPLIFY relocation; "
7826 "possible configuration mismatch"),
7827 sec
->owner
, sec
, (uint64_t) r_offset
);
7831 /* If the instruction table is not around, then don't do this
7833 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7834 sec
->vma
+ irel
->r_offset
);
7835 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7837 text_action_add (&relax_info
->action_list
,
7838 ta_convert_longcall
, sec
, r_offset
,
7843 /* If the next longcall happens to be at the same address as an
7844 unreachable section of size 0, then skip forward. */
7845 ptbl_idx
= the_entry
- prop_table
;
7846 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7847 && the_entry
->size
== 0
7848 && ptbl_idx
+ 1 < ptblsize
7849 && (prop_table
[ptbl_idx
+ 1].address
7850 == prop_table
[ptbl_idx
].address
))
7856 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7857 /* NO_REORDER is OK */
7860 init_ebb_constraint (&ebb_table
);
7861 ebb
= &ebb_table
.ebb
;
7862 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7863 internal_relocs
, sec
->reloc_count
);
7864 ebb
->start_offset
= r_offset
+ simplify_size
;
7865 ebb
->end_offset
= r_offset
+ simplify_size
;
7866 ebb
->start_ptbl_idx
= ptbl_idx
;
7867 ebb
->end_ptbl_idx
= ptbl_idx
;
7868 ebb
->start_reloc_idx
= i
;
7869 ebb
->end_reloc_idx
= i
;
7871 if (!extend_ebb_bounds (ebb
)
7872 || !compute_ebb_proposed_actions (&ebb_table
)
7873 || !compute_ebb_actions (&ebb_table
)
7874 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7877 &ebb_table
, reloc_opcodes
)
7878 || !check_section_ebb_reduces (&ebb_table
))
7880 /* If anything goes wrong or we get unlucky and something does
7881 not fit, with our plan because of expansion between
7882 critical branches, just convert to a NOP. */
7884 text_action_add (&relax_info
->action_list
,
7885 ta_convert_longcall
, sec
, r_offset
, 0);
7886 i
= ebb_table
.ebb
.end_reloc_idx
;
7887 free_ebb_constraint (&ebb_table
);
7891 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7893 /* Update the index so we do not go looking at the relocations
7894 we have already processed. */
7895 i
= ebb_table
.ebb
.end_reloc_idx
;
7896 free_ebb_constraint (&ebb_table
);
7899 free_reloc_range_list (&relevant_relocs
);
7902 if (action_list_count (&relax_info
->action_list
))
7903 print_action_list (stderr
, &relax_info
->action_list
);
7907 release_contents (sec
, contents
);
7908 release_internal_relocs (sec
, internal_relocs
);
7910 free (reloc_opcodes
);
7916 /* Do not widen an instruction if it is preceeded by a
7917 loop opcode. It might cause misalignment. */
7920 prev_instr_is_a_loop (bfd_byte
*contents
,
7921 bfd_size_type content_length
,
7922 bfd_size_type offset
)
7924 xtensa_opcode prev_opcode
;
7928 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7929 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7933 /* Find all of the possible actions for an extended basic block. */
7936 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7938 const ebb_t
*ebb
= &ebb_table
->ebb
;
7939 unsigned rel_idx
= ebb
->start_reloc_idx
;
7940 property_table_entry
*entry
, *start_entry
, *end_entry
;
7942 xtensa_isa isa
= xtensa_default_isa
;
7944 static xtensa_insnbuf insnbuf
= NULL
;
7945 static xtensa_insnbuf slotbuf
= NULL
;
7947 if (insnbuf
== NULL
)
7949 insnbuf
= xtensa_insnbuf_alloc (isa
);
7950 slotbuf
= xtensa_insnbuf_alloc (isa
);
7953 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7954 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7956 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7958 bfd_vma start_offset
, end_offset
;
7959 bfd_size_type insn_len
;
7961 start_offset
= entry
->address
- ebb
->sec
->vma
;
7962 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7964 if (entry
== start_entry
)
7965 start_offset
= ebb
->start_offset
;
7966 if (entry
== end_entry
)
7967 end_offset
= ebb
->end_offset
;
7968 offset
= start_offset
;
7970 if (offset
== entry
->address
- ebb
->sec
->vma
7971 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7973 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7974 BFD_ASSERT (offset
!= end_offset
);
7975 if (offset
== end_offset
)
7978 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7983 if (check_branch_target_aligned_address (offset
, insn_len
))
7984 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7986 ebb_propose_action (ebb_table
, align_type
, 0,
7987 ta_none
, offset
, 0, true);
7990 while (offset
!= end_offset
)
7992 Elf_Internal_Rela
*irel
;
7993 xtensa_opcode opcode
;
7995 while (rel_idx
< ebb
->end_reloc_idx
7996 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7997 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7998 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
7999 != R_XTENSA_ASM_SIMPLIFY
))))
8002 /* Check for longcall. */
8003 irel
= &ebb
->relocs
[rel_idx
];
8004 if (irel
->r_offset
== offset
8005 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
8007 bfd_size_type simplify_size
;
8009 simplify_size
= get_asm_simplify_size (ebb
->contents
,
8010 ebb
->content_length
,
8012 if (simplify_size
== 0)
8015 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8016 ta_convert_longcall
, offset
, 0, true);
8018 offset
+= simplify_size
;
8022 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
8024 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
8025 ebb
->content_length
- offset
);
8026 fmt
= xtensa_format_decode (isa
, insnbuf
);
8027 if (fmt
== XTENSA_UNDEFINED
)
8029 insn_len
= xtensa_format_length (isa
, fmt
);
8030 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
8033 if (xtensa_format_num_slots (isa
, fmt
) != 1)
8039 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
8040 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
8041 if (opcode
== XTENSA_UNDEFINED
)
8044 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
8045 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8046 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
8048 /* Add an instruction narrow action. */
8049 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8050 ta_narrow_insn
, offset
, 0, false);
8052 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8053 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
8054 && ! prev_instr_is_a_loop (ebb
->contents
,
8055 ebb
->content_length
, offset
))
8057 /* Add an instruction widen action. */
8058 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8059 ta_widen_insn
, offset
, 0, false);
8061 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
8063 /* Check for branch targets. */
8064 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
8065 ta_none
, offset
, 0, true);
8072 if (ebb
->ends_unreachable
)
8074 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8075 ta_fill
, ebb
->end_offset
, 0, true);
8082 /* xgettext:c-format */
8083 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
8084 "possible configuration mismatch"),
8085 ebb
->sec
->owner
, ebb
->sec
, (uint64_t) offset
);
8090 /* After all of the information has collected about the
8091 transformations possible in an EBB, compute the appropriate actions
8092 here in compute_ebb_actions. We still must check later to make
8093 sure that the actions do not break any relocations. The algorithm
8094 used here is pretty greedy. Basically, it removes as many no-ops
8095 as possible so that the end of the EBB has the same alignment
8096 characteristics as the original. First, it uses narrowing, then
8097 fill space at the end of the EBB, and finally widenings. If that
8098 does not work, it tries again with one fewer no-op removed. The
8099 optimization will only be performed if all of the branch targets
8100 that were aligned before transformation are also aligned after the
8103 When the size_opt flag is set, ignore the branch target alignments,
8104 narrow all wide instructions, and remove all no-ops unless the end
8105 of the EBB prevents it. */
8108 compute_ebb_actions (ebb_constraint
*ebb_table
)
8112 int removed_bytes
= 0;
8113 ebb_t
*ebb
= &ebb_table
->ebb
;
8114 unsigned seg_idx_start
= 0;
8115 unsigned seg_idx_end
= 0;
8117 /* We perform this like the assembler relaxation algorithm: Start by
8118 assuming all instructions are narrow and all no-ops removed; then
8121 /* For each segment of this that has a solid constraint, check to
8122 see if there are any combinations that will keep the constraint.
8124 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
8126 bool requires_text_end_align
= false;
8127 unsigned longcall_count
= 0;
8128 unsigned longcall_convert_count
= 0;
8129 unsigned narrowable_count
= 0;
8130 unsigned narrowable_convert_count
= 0;
8131 unsigned widenable_count
= 0;
8132 unsigned widenable_convert_count
= 0;
8134 proposed_action
*action
= NULL
;
8135 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
8137 seg_idx_start
= seg_idx_end
;
8139 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
8141 action
= &ebb_table
->actions
[i
];
8142 if (action
->action
== ta_convert_longcall
)
8144 if (action
->action
== ta_narrow_insn
)
8146 if (action
->action
== ta_widen_insn
)
8148 if (action
->action
== ta_fill
)
8150 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8152 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
8153 && !elf32xtensa_size_opt
)
8158 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
8159 requires_text_end_align
= true;
8161 if (elf32xtensa_size_opt
&& !requires_text_end_align
8162 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
8163 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
8165 longcall_convert_count
= longcall_count
;
8166 narrowable_convert_count
= narrowable_count
;
8167 widenable_convert_count
= 0;
8171 /* There is a constraint. Convert the max number of longcalls. */
8172 narrowable_convert_count
= 0;
8173 longcall_convert_count
= 0;
8174 widenable_convert_count
= 0;
8176 for (j
= 0; j
< longcall_count
; j
++)
8178 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
8179 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
8180 unsigned desire_widen
= removed
;
8181 if (desire_narrow
<= narrowable_count
)
8183 narrowable_convert_count
= desire_narrow
;
8184 narrowable_convert_count
+=
8185 (align
* ((narrowable_count
- narrowable_convert_count
)
8187 longcall_convert_count
= (longcall_count
- j
);
8188 widenable_convert_count
= 0;
8191 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
8193 narrowable_convert_count
= 0;
8194 longcall_convert_count
= longcall_count
- j
;
8195 widenable_convert_count
= desire_widen
;
8201 /* Now the number of conversions are saved. Do them. */
8202 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
8204 action
= &ebb_table
->actions
[i
];
8205 switch (action
->action
)
8207 case ta_convert_longcall
:
8208 if (longcall_convert_count
!= 0)
8210 action
->action
= ta_remove_longcall
;
8211 action
->do_action
= true;
8212 action
->removed_bytes
+= 3;
8213 longcall_convert_count
--;
8216 case ta_narrow_insn
:
8217 if (narrowable_convert_count
!= 0)
8219 action
->do_action
= true;
8220 action
->removed_bytes
+= 1;
8221 narrowable_convert_count
--;
8225 if (widenable_convert_count
!= 0)
8227 action
->do_action
= true;
8228 action
->removed_bytes
-= 1;
8229 widenable_convert_count
--;
8238 /* Now we move on to some local opts. Try to remove each of the
8239 remaining longcalls. */
8241 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8244 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8246 int old_removed_bytes
= removed_bytes
;
8247 proposed_action
*action
= &ebb_table
->actions
[i
];
8249 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8251 bool bad_alignment
= false;
8253 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8255 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8256 bfd_vma offset
= new_action
->offset
;
8257 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8259 if (!check_branch_target_aligned
8260 (ebb_table
->ebb
.contents
,
8261 ebb_table
->ebb
.content_length
,
8262 offset
, offset
- removed_bytes
))
8264 bad_alignment
= true;
8268 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8270 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8271 ebb_table
->ebb
.content_length
,
8273 offset
- removed_bytes
))
8275 bad_alignment
= true;
8279 if (new_action
->action
== ta_narrow_insn
8280 && !new_action
->do_action
8281 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8283 /* Narrow an instruction and we are done. */
8284 new_action
->do_action
= true;
8285 new_action
->removed_bytes
+= 1;
8286 bad_alignment
= false;
8289 if (new_action
->action
== ta_widen_insn
8290 && new_action
->do_action
8291 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8293 /* Narrow an instruction and we are done. */
8294 new_action
->do_action
= false;
8295 new_action
->removed_bytes
+= 1;
8296 bad_alignment
= false;
8299 if (new_action
->do_action
)
8300 removed_bytes
+= new_action
->removed_bytes
;
8304 action
->removed_bytes
+= 3;
8305 action
->action
= ta_remove_longcall
;
8306 action
->do_action
= true;
8309 removed_bytes
= old_removed_bytes
;
8310 if (action
->do_action
)
8311 removed_bytes
+= action
->removed_bytes
;
8316 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8318 proposed_action
*action
= &ebb_table
->actions
[i
];
8319 if (action
->do_action
)
8320 removed_bytes
+= action
->removed_bytes
;
8323 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8324 && ebb
->ends_unreachable
)
8326 proposed_action
*action
;
8330 BFD_ASSERT (ebb_table
->action_count
!= 0);
8331 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8332 BFD_ASSERT (action
->action
== ta_fill
);
8333 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8335 extra_space
= xtensa_compute_fill_extra_space (ebb
->ends_unreachable
);
8336 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8337 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8339 action
->removed_bytes
= extra_space
- br
;
8345 /* The xlate_map is a sorted array of address mappings designed to
8346 answer the offset_with_removed_text() query with a binary search instead
8347 of a linear search through the section's action_list. */
8349 typedef struct xlate_map_entry xlate_map_entry_t
;
8350 typedef struct xlate_map xlate_map_t
;
8352 struct xlate_map_entry
8354 bfd_vma orig_address
;
8355 bfd_vma new_address
;
8361 unsigned entry_count
;
8362 xlate_map_entry_t
*entry
;
8367 xlate_compare (const void *a_v
, const void *b_v
)
8369 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8370 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8371 if (a
->orig_address
< b
->orig_address
)
8373 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8380 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8381 text_action_list
*action_list
,
8385 xlate_map_entry_t
*e
;
8386 struct xlate_map_entry se
;
8389 return offset_with_removed_text (action_list
, offset
);
8391 if (map
->entry_count
== 0)
8394 se
.orig_address
= offset
;
8395 r
= bsearch (&se
, map
->entry
, map
->entry_count
,
8396 sizeof (xlate_map_entry_t
), &xlate_compare
);
8397 e
= (xlate_map_entry_t
*) r
;
8399 /* There could be a jump past the end of the section,
8400 allow it using the last xlate map entry to translate its address. */
8403 e
= map
->entry
+ map
->entry_count
- 1;
8404 if (xlate_compare (&se
, e
) <= 0)
8407 BFD_ASSERT (e
!= NULL
);
8410 return e
->new_address
- e
->orig_address
+ offset
;
8413 typedef struct xlate_map_context_struct xlate_map_context
;
8414 struct xlate_map_context_struct
8417 xlate_map_entry_t
*current_entry
;
8422 xlate_map_fn (splay_tree_node node
, void *p
)
8424 text_action
*r
= (text_action
*)node
->value
;
8425 xlate_map_context
*ctx
= p
;
8426 unsigned orig_size
= 0;
8431 case ta_remove_insn
:
8432 case ta_convert_longcall
:
8433 case ta_remove_literal
:
8434 case ta_add_literal
:
8436 case ta_remove_longcall
:
8439 case ta_narrow_insn
:
8448 ctx
->current_entry
->size
=
8449 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8450 if (ctx
->current_entry
->size
!= 0)
8452 ctx
->current_entry
++;
8453 ctx
->map
->entry_count
++;
8455 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8456 ctx
->removed
+= r
->removed_bytes
;
8457 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8458 ctx
->current_entry
->size
= 0;
8462 /* Build a binary searchable offset translation map from a section's
8465 static xlate_map_t
*
8466 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8468 text_action_list
*action_list
= &relax_info
->action_list
;
8469 unsigned num_actions
= 0;
8470 xlate_map_context ctx
;
8472 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8474 if (ctx
.map
== NULL
)
8477 num_actions
= action_list_count (action_list
);
8478 ctx
.map
->entry
= (xlate_map_entry_t
*)
8479 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8480 if (ctx
.map
->entry
== NULL
)
8485 ctx
.map
->entry_count
= 0;
8488 ctx
.current_entry
= &ctx
.map
->entry
[0];
8490 ctx
.current_entry
->orig_address
= 0;
8491 ctx
.current_entry
->new_address
= 0;
8492 ctx
.current_entry
->size
= 0;
8494 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8496 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8497 - ctx
.current_entry
->orig_address
);
8498 if (ctx
.current_entry
->size
!= 0)
8499 ctx
.map
->entry_count
++;
8505 /* Free an offset translation map. */
8508 free_xlate_map (xlate_map_t
*map
)
8518 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8519 relocations in a section will fit if a proposed set of actions
8523 check_section_ebb_pcrels_fit (bfd
*abfd
,
8526 Elf_Internal_Rela
*internal_relocs
,
8527 reloc_range_list
*relevant_relocs
,
8528 const ebb_constraint
*constraint
,
8529 const xtensa_opcode
*reloc_opcodes
)
8532 unsigned n
= sec
->reloc_count
;
8533 Elf_Internal_Rela
*irel
;
8534 xlate_map_t
*xmap
= NULL
;
8536 xtensa_relax_info
*relax_info
;
8537 reloc_range_list_entry
*entry
= NULL
;
8539 relax_info
= get_xtensa_relax_info (sec
);
8541 if (relax_info
&& sec
->reloc_count
> 100)
8543 xmap
= build_xlate_map (sec
, relax_info
);
8544 /* NULL indicates out of memory, but the slow version
8545 can still be used. */
8548 if (relevant_relocs
&& constraint
->action_count
)
8550 if (!relevant_relocs
->ok
)
8557 bfd_vma min_offset
, max_offset
;
8558 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8560 for (i
= 1; i
< constraint
->action_count
; ++i
)
8562 proposed_action
*action
= &constraint
->actions
[i
];
8563 bfd_vma offset
= action
->offset
;
8565 if (offset
< min_offset
)
8566 min_offset
= offset
;
8567 if (offset
> max_offset
)
8568 max_offset
= offset
;
8570 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8572 n
= relevant_relocs
->n_list
;
8573 entry
= &relevant_relocs
->list_root
;
8578 relevant_relocs
= NULL
;
8581 for (i
= 0; i
< n
; i
++)
8584 bfd_vma orig_self_offset
, orig_target_offset
;
8585 bfd_vma self_offset
, target_offset
;
8587 reloc_howto_type
*howto
;
8588 int self_removed_bytes
, target_removed_bytes
;
8590 if (relevant_relocs
)
8592 entry
= entry
->next
;
8597 irel
= internal_relocs
+ i
;
8599 r_type
= ELF32_R_TYPE (irel
->r_info
);
8601 howto
= &elf_howto_table
[r_type
];
8602 /* We maintain the required invariant: PC-relative relocations
8603 that fit before linking must fit after linking. Thus we only
8604 need to deal with relocations to the same section that are
8606 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8607 || r_type
== R_XTENSA_32_PCREL
8608 || !howto
->pc_relative
)
8611 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8612 bfd_get_section_limit (abfd
, sec
));
8614 if (r_reloc_get_section (&r_rel
) != sec
)
8617 orig_self_offset
= irel
->r_offset
;
8618 orig_target_offset
= r_rel
.target_offset
;
8620 self_offset
= orig_self_offset
;
8621 target_offset
= orig_target_offset
;
8626 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8629 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8630 orig_target_offset
);
8633 self_removed_bytes
= 0;
8634 target_removed_bytes
= 0;
8636 for (j
= 0; j
< constraint
->action_count
; ++j
)
8638 proposed_action
*action
= &constraint
->actions
[j
];
8639 bfd_vma offset
= action
->offset
;
8640 int removed_bytes
= action
->removed_bytes
;
8641 if (offset
< orig_self_offset
8642 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8643 && action
->removed_bytes
< 0))
8644 self_removed_bytes
+= removed_bytes
;
8645 if (offset
< orig_target_offset
8646 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8647 && action
->removed_bytes
< 0))
8648 target_removed_bytes
+= removed_bytes
;
8650 self_offset
-= self_removed_bytes
;
8651 target_offset
-= target_removed_bytes
;
8653 /* Try to encode it. Get the operand and check. */
8654 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8656 /* None of the current alternate relocs are PC-relative,
8657 and only PC-relative relocs matter here. */
8661 xtensa_opcode opcode
;
8664 if (relevant_relocs
)
8666 opcode
= entry
->opcode
;
8667 opnum
= entry
->opnum
;
8672 opcode
= reloc_opcodes
[relevant_relocs
?
8673 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8675 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8676 if (opcode
== XTENSA_UNDEFINED
)
8682 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8683 if (opnum
== XTENSA_UNDEFINED
)
8690 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8698 free_xlate_map (xmap
);
8705 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8710 for (i
= 0; i
< constraint
->action_count
; i
++)
8712 const proposed_action
*action
= &constraint
->actions
[i
];
8713 if (action
->do_action
)
8714 removed
+= action
->removed_bytes
;
8724 text_action_add_proposed (text_action_list
*l
,
8725 const ebb_constraint
*ebb_table
,
8730 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8732 proposed_action
*action
= &ebb_table
->actions
[i
];
8734 if (!action
->do_action
)
8736 switch (action
->action
)
8738 case ta_remove_insn
:
8739 case ta_remove_longcall
:
8740 case ta_convert_longcall
:
8741 case ta_narrow_insn
:
8744 case ta_remove_literal
:
8745 text_action_add (l
, action
->action
, sec
, action
->offset
,
8746 action
->removed_bytes
);
8759 xtensa_compute_fill_extra_space (property_table_entry
*entry
)
8761 int fill_extra_space
;
8766 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8769 fill_extra_space
= entry
->size
;
8770 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8772 /* Fill bytes for alignment:
8773 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8774 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8775 int nsm
= (1 << pow
) - 1;
8776 bfd_vma addr
= entry
->address
+ entry
->size
;
8777 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8778 fill_extra_space
+= align_fill
;
8780 return fill_extra_space
;
8784 /* First relaxation pass. */
8786 /* If the section contains relaxable literals, check each literal to
8787 see if it has the same value as another literal that has already
8788 been seen, either in the current section or a previous one. If so,
8789 add an entry to the per-section list of removed literals. The
8790 actual changes are deferred until the next pass. */
8793 compute_removed_literals (bfd
*abfd
,
8795 struct bfd_link_info
*link_info
,
8796 value_map_hash_table
*values
)
8798 xtensa_relax_info
*relax_info
;
8800 Elf_Internal_Rela
*internal_relocs
;
8801 source_reloc
*src_relocs
, *rel
;
8803 property_table_entry
*prop_table
= NULL
;
8806 bool last_loc_is_prev
= false;
8807 bfd_vma last_target_offset
= 0;
8808 section_cache_t target_sec_cache
;
8809 bfd_size_type sec_size
;
8811 init_section_cache (&target_sec_cache
);
8813 /* Do nothing if it is not a relaxable literal section. */
8814 relax_info
= get_xtensa_relax_info (sec
);
8815 BFD_ASSERT (relax_info
);
8816 if (!relax_info
->is_relaxable_literal_section
)
8819 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8820 link_info
->keep_memory
);
8822 sec_size
= bfd_get_section_limit (abfd
, sec
);
8823 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8824 if (contents
== NULL
&& sec_size
!= 0)
8830 /* Sort the source_relocs by target offset. */
8831 src_relocs
= relax_info
->src_relocs
;
8832 qsort (src_relocs
, relax_info
->src_count
,
8833 sizeof (source_reloc
), source_reloc_compare
);
8834 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8835 internal_reloc_compare
);
8837 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8838 XTENSA_PROP_SEC_NAME
, false);
8846 for (i
= 0; i
< relax_info
->src_count
; i
++)
8848 Elf_Internal_Rela
*irel
= NULL
;
8850 rel
= &src_relocs
[i
];
8851 if (get_l32r_opcode () != rel
->opcode
)
8853 irel
= get_irel_at_offset (sec
, internal_relocs
,
8854 rel
->r_rel
.target_offset
);
8856 /* If the relocation on this is not a simple R_XTENSA_32 or
8857 R_XTENSA_PLT then do not consider it. This may happen when
8858 the difference of two symbols is used in a literal. */
8859 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8860 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8863 /* If the target_offset for this relocation is the same as the
8864 previous relocation, then we've already considered whether the
8865 literal can be coalesced. Skip to the next one.... */
8866 if (i
!= 0 && prev_i
!= -1
8867 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8871 if (last_loc_is_prev
&&
8872 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8873 last_loc_is_prev
= false;
8875 /* Check if the relocation was from an L32R that is being removed
8876 because a CALLX was converted to a direct CALL, and check if
8877 there are no other relocations to the literal. */
8878 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8879 sec
, prop_table
, ptblsize
))
8881 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8882 irel
, rel
, prop_table
, ptblsize
))
8887 last_target_offset
= rel
->r_rel
.target_offset
;
8891 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8893 &last_loc_is_prev
, irel
,
8894 relax_info
->src_count
- i
, rel
,
8895 prop_table
, ptblsize
,
8896 &target_sec_cache
, rel
->is_abs_literal
))
8901 last_target_offset
= rel
->r_rel
.target_offset
;
8905 print_removed_literals (stderr
, &relax_info
->removed_list
);
8906 print_action_list (stderr
, &relax_info
->action_list
);
8911 free_section_cache (&target_sec_cache
);
8913 release_contents (sec
, contents
);
8914 release_internal_relocs (sec
, internal_relocs
);
8919 static Elf_Internal_Rela
*
8920 get_irel_at_offset (asection
*sec
,
8921 Elf_Internal_Rela
*internal_relocs
,
8925 Elf_Internal_Rela
*irel
;
8927 Elf_Internal_Rela key
;
8929 if (!internal_relocs
)
8932 key
.r_offset
= offset
;
8933 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8934 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8938 /* bsearch does not guarantee which will be returned if there are
8939 multiple matches. We need the first that is not an alignment. */
8940 i
= irel
- internal_relocs
;
8943 if (internal_relocs
[i
-1].r_offset
!= offset
)
8947 for ( ; i
< sec
->reloc_count
; i
++)
8949 irel
= &internal_relocs
[i
];
8950 r_type
= ELF32_R_TYPE (irel
->r_info
);
8951 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8960 is_removable_literal (const source_reloc
*rel
,
8962 const source_reloc
*src_relocs
,
8965 property_table_entry
*prop_table
,
8968 const source_reloc
*curr_rel
;
8969 property_table_entry
*entry
;
8974 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8975 sec
->vma
+ rel
->r_rel
.target_offset
);
8976 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8979 for (++i
; i
< src_count
; ++i
)
8981 curr_rel
= &src_relocs
[i
];
8982 /* If all others have the same target offset.... */
8983 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8986 if (!curr_rel
->is_null
8987 && !xtensa_is_property_section (curr_rel
->source_sec
)
8988 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8996 remove_dead_literal (bfd
*abfd
,
8998 struct bfd_link_info
*link_info
,
8999 Elf_Internal_Rela
*internal_relocs
,
9000 Elf_Internal_Rela
*irel
,
9002 property_table_entry
*prop_table
,
9005 property_table_entry
*entry
;
9006 xtensa_relax_info
*relax_info
;
9008 relax_info
= get_xtensa_relax_info (sec
);
9012 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9013 sec
->vma
+ rel
->r_rel
.target_offset
);
9015 /* Mark the unused literal so that it will be removed. */
9016 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
9018 text_action_add (&relax_info
->action_list
,
9019 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9021 /* If the section is 4-byte aligned, do not add fill. */
9022 if (sec
->alignment_power
> 2)
9024 int fill_extra_space
;
9025 bfd_vma entry_sec_offset
;
9027 property_table_entry
*the_add_entry
;
9031 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9033 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9035 /* If the literal range is at the end of the section,
9037 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9039 fill_extra_space
= xtensa_compute_fill_extra_space (the_add_entry
);
9041 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9042 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9043 -4, fill_extra_space
);
9045 adjust_fill_action (fa
, removed_diff
);
9047 text_action_add (&relax_info
->action_list
,
9048 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9051 /* Zero out the relocation on this literal location. */
9054 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9055 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9057 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9058 pin_internal_relocs (sec
, internal_relocs
);
9061 /* Do not modify "last_loc_is_prev". */
9067 identify_literal_placement (bfd
*abfd
,
9070 struct bfd_link_info
*link_info
,
9071 value_map_hash_table
*values
,
9072 bool *last_loc_is_prev_p
,
9073 Elf_Internal_Rela
*irel
,
9074 int remaining_src_rels
,
9076 property_table_entry
*prop_table
,
9078 section_cache_t
*target_sec_cache
,
9079 bool is_abs_literal
)
9083 xtensa_relax_info
*relax_info
;
9084 bool literal_placed
= false;
9086 unsigned long value
;
9087 bool final_static_link
;
9088 bfd_size_type sec_size
;
9090 relax_info
= get_xtensa_relax_info (sec
);
9094 sec_size
= bfd_get_section_limit (abfd
, sec
);
9097 (!bfd_link_relocatable (link_info
)
9098 && !elf_hash_table (link_info
)->dynamic_sections_created
);
9100 /* The placement algorithm first checks to see if the literal is
9101 already in the value map. If so and the value map is reachable
9102 from all uses, then the literal is moved to that location. If
9103 not, then we identify the last location where a fresh literal was
9104 placed. If the literal can be safely moved there, then we do so.
9105 If not, then we assume that the literal is not to move and leave
9106 the literal where it is, marking it as the last literal
9109 /* Find the literal value. */
9111 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9114 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
9115 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
9117 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
9119 /* Check if we've seen another literal with the same value that
9120 is in the same output section. */
9121 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
9124 && (r_reloc_get_section (&val_map
->loc
)->output_section
9125 == sec
->output_section
)
9126 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
9127 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
9129 /* No change to last_loc_is_prev. */
9130 literal_placed
= true;
9133 /* For relocatable links, do not try to move literals. To do it
9134 correctly might increase the number of relocations in an input
9135 section making the default relocatable linking fail. */
9136 if (!bfd_link_relocatable (link_info
) && !literal_placed
9137 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
9139 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
9140 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
9142 /* Increment the virtual offset. */
9143 r_reloc try_loc
= values
->last_loc
;
9144 try_loc
.virtual_offset
+= 4;
9146 /* There is a last loc that was in the same output section. */
9147 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
9148 && move_shared_literal (sec
, link_info
, rel
,
9149 prop_table
, ptblsize
,
9150 &try_loc
, &val
, target_sec_cache
))
9152 values
->last_loc
.virtual_offset
+= 4;
9153 literal_placed
= true;
9155 val_map
= add_value_map (values
, &val
, &try_loc
,
9158 val_map
->loc
= try_loc
;
9163 if (!literal_placed
)
9165 /* Nothing worked, leave the literal alone but update the last loc. */
9166 values
->has_last_loc
= true;
9167 values
->last_loc
= rel
->r_rel
;
9169 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
9171 val_map
->loc
= rel
->r_rel
;
9172 *last_loc_is_prev_p
= true;
9179 /* Check if the original relocations (presumably on L32R instructions)
9180 identified by reloc[0..N] can be changed to reference the literal
9181 identified by r_rel. If r_rel is out of range for any of the
9182 original relocations, then we don't want to coalesce the original
9183 literal with the one at r_rel. We only check reloc[0..N], where the
9184 offsets are all the same as for reloc[0] (i.e., they're all
9185 referencing the same literal) and where N is also bounded by the
9186 number of remaining entries in the "reloc" array. The "reloc" array
9187 is sorted by target offset so we know all the entries for the same
9188 literal will be contiguous. */
9191 relocations_reach (source_reloc
*reloc
,
9192 int remaining_relocs
,
9193 const r_reloc
*r_rel
)
9195 bfd_vma from_offset
, source_address
, dest_address
;
9199 if (!r_reloc_is_defined (r_rel
))
9202 sec
= r_reloc_get_section (r_rel
);
9203 from_offset
= reloc
[0].r_rel
.target_offset
;
9205 for (i
= 0; i
< remaining_relocs
; i
++)
9207 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9210 /* Ignore relocations that have been removed. */
9211 if (reloc
[i
].is_null
)
9214 /* The original and new output section for these must be the same
9215 in order to coalesce. */
9216 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9217 != sec
->output_section
)
9220 /* Absolute literals in the same output section can always be
9222 if (reloc
[i
].is_abs_literal
)
9225 /* A literal with no PC-relative relocations can be moved anywhere. */
9226 if (reloc
[i
].opnd
!= -1)
9228 /* Otherwise, check to see that it fits. */
9229 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9230 + reloc
[i
].source_sec
->output_offset
9231 + reloc
[i
].r_rel
.rela
.r_offset
);
9232 dest_address
= (sec
->output_section
->vma
9233 + sec
->output_offset
9234 + r_rel
->target_offset
);
9236 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9237 source_address
, dest_address
))
9246 /* Move a literal to another literal location because it is
9247 the same as the other literal value. */
9250 coalesce_shared_literal (asection
*sec
,
9252 property_table_entry
*prop_table
,
9256 property_table_entry
*entry
;
9258 property_table_entry
*the_add_entry
;
9260 xtensa_relax_info
*relax_info
;
9262 relax_info
= get_xtensa_relax_info (sec
);
9266 entry
= elf_xtensa_find_property_entry
9267 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9268 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9271 /* Mark that the literal will be coalesced. */
9272 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9274 text_action_add (&relax_info
->action_list
,
9275 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9277 /* If the section is 4-byte aligned, do not add fill. */
9278 if (sec
->alignment_power
> 2)
9280 int fill_extra_space
;
9281 bfd_vma entry_sec_offset
;
9284 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9286 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9288 /* If the literal range is at the end of the section,
9290 fill_extra_space
= 0;
9291 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9293 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9294 fill_extra_space
= the_add_entry
->size
;
9296 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9297 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9298 -4, fill_extra_space
);
9300 adjust_fill_action (fa
, removed_diff
);
9302 text_action_add (&relax_info
->action_list
,
9303 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9310 /* Move a literal to another location. This may actually increase the
9311 total amount of space used because of alignments so we need to do
9312 this carefully. Also, it may make a branch go out of range. */
9315 move_shared_literal (asection
*sec
,
9316 struct bfd_link_info
*link_info
,
9318 property_table_entry
*prop_table
,
9320 const r_reloc
*target_loc
,
9321 const literal_value
*lit_value
,
9322 section_cache_t
*target_sec_cache
)
9324 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9325 text_action
*fa
, *target_fa
;
9327 xtensa_relax_info
*relax_info
, *target_relax_info
;
9328 asection
*target_sec
;
9330 ebb_constraint ebb_table
;
9333 /* If this routine always returns FALSE, the literals that cannot be
9334 coalesced will not be moved. */
9335 if (elf32xtensa_no_literal_movement
)
9338 relax_info
= get_xtensa_relax_info (sec
);
9342 target_sec
= r_reloc_get_section (target_loc
);
9343 target_relax_info
= get_xtensa_relax_info (target_sec
);
9345 /* Literals to undefined sections may not be moved because they
9346 must report an error. */
9347 if (bfd_is_und_section (target_sec
))
9350 src_entry
= elf_xtensa_find_property_entry
9351 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9353 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9356 target_entry
= elf_xtensa_find_property_entry
9357 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9358 target_sec
->vma
+ target_loc
->target_offset
);
9363 /* Make sure that we have not broken any branches. */
9366 init_ebb_constraint (&ebb_table
);
9367 ebb
= &ebb_table
.ebb
;
9368 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9369 target_sec_cache
->content_length
,
9370 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9371 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9373 /* Propose to add 4 bytes + worst-case alignment size increase to
9375 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9376 ta_fill
, target_loc
->target_offset
,
9377 -4 - (1 << target_sec
->alignment_power
), true);
9379 /* Check all of the PC-relative relocations to make sure they still fit. */
9380 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9381 target_sec_cache
->contents
,
9382 target_sec_cache
->relocs
, NULL
,
9388 text_action_add_literal (&target_relax_info
->action_list
,
9389 ta_add_literal
, target_loc
, lit_value
, -4);
9391 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9393 /* May need to add or remove some fill to maintain alignment. */
9394 int fill_extra_space
;
9395 bfd_vma entry_sec_offset
;
9398 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9400 /* If the literal range is at the end of the section,
9402 fill_extra_space
= 0;
9404 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9405 target_sec_cache
->pte_count
,
9407 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9408 fill_extra_space
= the_add_entry
->size
;
9410 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9411 target_sec
, entry_sec_offset
);
9412 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9413 entry_sec_offset
, 4,
9416 adjust_fill_action (target_fa
, removed_diff
);
9418 text_action_add (&target_relax_info
->action_list
,
9419 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9422 /* Mark that the literal will be moved to the new location. */
9423 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9425 /* Remove the literal. */
9426 text_action_add (&relax_info
->action_list
,
9427 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9429 /* If the section is 4-byte aligned, do not add fill. */
9430 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9432 int fill_extra_space
;
9433 bfd_vma entry_sec_offset
;
9436 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9438 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9440 /* If the literal range is at the end of the section,
9442 fill_extra_space
= 0;
9443 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9445 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9446 fill_extra_space
= the_add_entry
->size
;
9448 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9449 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9450 -4, fill_extra_space
);
9452 adjust_fill_action (fa
, removed_diff
);
9454 text_action_add (&relax_info
->action_list
,
9455 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9462 /* Second relaxation pass. */
9465 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9467 bfd_size_type
*final_size
= p
;
9468 text_action
*action
= (text_action
*)node
->value
;
9470 *final_size
-= action
->removed_bytes
;
9474 /* Modify all of the relocations to point to the right spot, and if this
9475 is a relaxable section, delete the unwanted literals and fix the
9479 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9481 Elf_Internal_Rela
*internal_relocs
;
9482 xtensa_relax_info
*relax_info
;
9487 bool virtual_action
;
9488 bfd_size_type sec_size
;
9490 sec_size
= bfd_get_section_limit (abfd
, sec
);
9491 relax_info
= get_xtensa_relax_info (sec
);
9492 BFD_ASSERT (relax_info
);
9494 /* First translate any of the fixes that have been added already. */
9495 translate_section_fixes (sec
);
9497 /* Handle property sections (e.g., literal tables) specially. */
9498 if (xtensa_is_property_section (sec
))
9500 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9501 return relax_property_section (abfd
, sec
, link_info
);
9504 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9505 link_info
->keep_memory
);
9506 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9509 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9510 if (contents
== NULL
&& sec_size
!= 0)
9516 if (internal_relocs
)
9518 for (i
= 0; i
< sec
->reloc_count
; i
++)
9520 Elf_Internal_Rela
*irel
;
9521 xtensa_relax_info
*target_relax_info
;
9522 bfd_vma source_offset
, old_source_offset
;
9525 asection
*target_sec
;
9527 /* Locally change the source address.
9528 Translate the target to the new target address.
9529 If it points to this section and has been removed,
9533 irel
= &internal_relocs
[i
];
9534 source_offset
= irel
->r_offset
;
9535 old_source_offset
= source_offset
;
9537 r_type
= ELF32_R_TYPE (irel
->r_info
);
9538 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9539 bfd_get_section_limit (abfd
, sec
));
9541 /* If this section could have changed then we may need to
9542 change the relocation's offset. */
9544 if (relax_info
->is_relaxable_literal_section
9545 || relax_info
->is_relaxable_asm_section
)
9547 pin_internal_relocs (sec
, internal_relocs
);
9549 if (r_type
!= R_XTENSA_NONE
9550 && find_removed_literal (&relax_info
->removed_list
,
9553 /* Remove this relocation. */
9554 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9555 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9556 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9557 irel
->r_offset
= offset_with_removed_text_map
9558 (&relax_info
->action_list
, irel
->r_offset
);
9562 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9564 text_action
*action
=
9565 find_insn_action (&relax_info
->action_list
,
9567 if (action
&& (action
->action
== ta_convert_longcall
9568 || action
->action
== ta_remove_longcall
))
9570 bfd_reloc_status_type retval
;
9571 char *error_message
= NULL
;
9573 retval
= contract_asm_expansion (contents
, sec_size
,
9574 irel
, &error_message
);
9575 if (retval
!= bfd_reloc_ok
)
9577 (*link_info
->callbacks
->reloc_dangerous
)
9578 (link_info
, error_message
, abfd
, sec
,
9582 /* Update the action so that the code that moves
9583 the contents will do the right thing. */
9584 /* ta_remove_longcall and ta_remove_insn actions are
9585 grouped together in the tree as well as
9586 ta_convert_longcall and ta_none, so that changes below
9587 can be done w/o removing and reinserting action into
9590 if (action
->action
== ta_remove_longcall
)
9591 action
->action
= ta_remove_insn
;
9593 action
->action
= ta_none
;
9594 /* Refresh the info in the r_rel. */
9595 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9596 r_type
= ELF32_R_TYPE (irel
->r_info
);
9600 source_offset
= offset_with_removed_text_map
9601 (&relax_info
->action_list
, irel
->r_offset
);
9602 irel
->r_offset
= source_offset
;
9605 /* If the target section could have changed then
9606 we may need to change the relocation's target offset. */
9608 target_sec
= r_reloc_get_section (&r_rel
);
9610 /* For a reference to a discarded section from a DWARF section,
9611 i.e., where action_discarded is PRETEND, the symbol will
9612 eventually be modified to refer to the kept section (at least if
9613 the kept and discarded sections are the same size). Anticipate
9614 that here and adjust things accordingly. */
9615 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9616 && elf_xtensa_action_discarded (sec
) == PRETEND
9617 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9618 && target_sec
!= NULL
9619 && discarded_section (target_sec
))
9621 /* It would be natural to call _bfd_elf_check_kept_section
9622 here, but it's not exported from elflink.c. It's also a
9623 fairly expensive check. Adjusting the relocations to the
9624 discarded section is fairly harmless; it will only adjust
9625 some addends and difference values. If it turns out that
9626 _bfd_elf_check_kept_section fails later, it won't matter,
9627 so just compare the section names to find the right group
9629 asection
*kept
= target_sec
->kept_section
;
9632 if ((kept
->flags
& SEC_GROUP
) != 0)
9634 asection
*first
= elf_next_in_group (kept
);
9635 asection
*s
= first
;
9640 if (strcmp (s
->name
, target_sec
->name
) == 0)
9645 s
= elf_next_in_group (s
);
9652 && ((target_sec
->rawsize
!= 0
9653 ? target_sec
->rawsize
: target_sec
->size
)
9654 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9658 target_relax_info
= get_xtensa_relax_info (target_sec
);
9659 if (target_relax_info
9660 && (target_relax_info
->is_relaxable_literal_section
9661 || target_relax_info
->is_relaxable_asm_section
))
9664 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9666 if (r_type
== R_XTENSA_DIFF8
9667 || r_type
== R_XTENSA_DIFF16
9668 || r_type
== R_XTENSA_DIFF32
9669 || r_type
== R_XTENSA_PDIFF8
9670 || r_type
== R_XTENSA_PDIFF16
9671 || r_type
== R_XTENSA_PDIFF32
9672 || r_type
== R_XTENSA_NDIFF8
9673 || r_type
== R_XTENSA_NDIFF16
9674 || r_type
== R_XTENSA_NDIFF32
)
9676 bfd_signed_vma diff_value
= 0;
9677 bfd_vma new_end_offset
, diff_mask
= 0;
9679 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9681 (*link_info
->callbacks
->reloc_dangerous
)
9682 (link_info
, _("invalid relocation address"),
9683 abfd
, sec
, old_source_offset
);
9689 case R_XTENSA_DIFF8
:
9692 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9694 case R_XTENSA_DIFF16
:
9697 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9699 case R_XTENSA_DIFF32
:
9700 diff_mask
= 0x7fffffff;
9702 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9704 case R_XTENSA_PDIFF8
:
9705 case R_XTENSA_NDIFF8
:
9708 bfd_get_8 (abfd
, &contents
[old_source_offset
]);
9710 case R_XTENSA_PDIFF16
:
9711 case R_XTENSA_NDIFF16
:
9714 bfd_get_16 (abfd
, &contents
[old_source_offset
]);
9716 case R_XTENSA_PDIFF32
:
9717 case R_XTENSA_NDIFF32
:
9718 diff_mask
= 0xffffffff;
9720 bfd_get_32 (abfd
, &contents
[old_source_offset
]);
9724 if (r_type
>= R_XTENSA_NDIFF8
9725 && r_type
<= R_XTENSA_NDIFF32
9727 diff_value
|= ~diff_mask
;
9729 new_end_offset
= offset_with_removed_text_map
9730 (&target_relax_info
->action_list
,
9731 r_rel
.target_offset
+ diff_value
);
9732 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9736 case R_XTENSA_DIFF8
:
9737 bfd_put_signed_8 (abfd
, diff_value
,
9738 &contents
[old_source_offset
]);
9740 case R_XTENSA_DIFF16
:
9741 bfd_put_signed_16 (abfd
, diff_value
,
9742 &contents
[old_source_offset
]);
9744 case R_XTENSA_DIFF32
:
9745 bfd_put_signed_32 (abfd
, diff_value
,
9746 &contents
[old_source_offset
]);
9748 case R_XTENSA_PDIFF8
:
9749 case R_XTENSA_NDIFF8
:
9750 bfd_put_8 (abfd
, diff_value
,
9751 &contents
[old_source_offset
]);
9753 case R_XTENSA_PDIFF16
:
9754 case R_XTENSA_NDIFF16
:
9755 bfd_put_16 (abfd
, diff_value
,
9756 &contents
[old_source_offset
]);
9758 case R_XTENSA_PDIFF32
:
9759 case R_XTENSA_NDIFF32
:
9760 bfd_put_32 (abfd
, diff_value
,
9761 &contents
[old_source_offset
]);
9765 /* Check for overflow. Sign bits must be all zeroes or
9766 all ones. When sign bits are all ones diff_value
9768 if (((diff_value
& ~diff_mask
) != 0
9769 && (diff_value
& ~diff_mask
) != ~diff_mask
)
9770 || (diff_value
&& (bfd_vma
) diff_value
== ~diff_mask
))
9772 (*link_info
->callbacks
->reloc_dangerous
)
9773 (link_info
, _("overflow after relaxation"),
9774 abfd
, sec
, old_source_offset
);
9778 pin_contents (sec
, contents
);
9781 /* If the relocation still references a section in the same
9782 input file, modify the relocation directly instead of
9783 adding a "fix" record. */
9784 if (target_sec
->owner
== abfd
)
9786 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9787 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9788 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9789 pin_internal_relocs (sec
, internal_relocs
);
9793 bfd_vma addend_displacement
;
9796 addend_displacement
=
9797 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9798 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9800 addend_displacement
, true);
9807 if ((relax_info
->is_relaxable_literal_section
9808 || relax_info
->is_relaxable_asm_section
)
9809 && action_list_count (&relax_info
->action_list
))
9811 /* Walk through the planned actions and build up a table
9812 of move, copy and fill records. Use the move, copy and
9813 fill records to perform the actions once. */
9815 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9816 bfd_byte
*scratch
= NULL
;
9817 bfd_byte
*dup_contents
= NULL
;
9818 bfd_size_type orig_size
= sec
->size
;
9819 bfd_vma orig_dot
= 0;
9820 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9821 orig dot in physical memory. */
9822 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9823 bfd_vma dup_dot
= 0;
9825 text_action
*action
;
9827 final_size
= sec
->size
;
9829 splay_tree_foreach (relax_info
->action_list
.tree
,
9830 action_remove_bytes_fn
, &final_size
);
9831 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9832 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9834 /* The dot is the current fill location. */
9836 print_action_list (stderr
, &relax_info
->action_list
);
9839 for (action
= action_first (&relax_info
->action_list
); action
;
9840 action
= action_next (&relax_info
->action_list
, action
))
9842 virtual_action
= false;
9843 if (action
->offset
> orig_dot
)
9845 orig_dot
+= orig_dot_copied
;
9846 orig_dot_copied
= 0;
9848 /* Out of the virtual world. */
9851 if (action
->offset
> orig_dot
)
9853 copy_size
= action
->offset
- orig_dot
;
9854 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9855 orig_dot
+= copy_size
;
9856 dup_dot
+= copy_size
;
9857 BFD_ASSERT (action
->offset
== orig_dot
);
9859 else if (action
->offset
< orig_dot
)
9861 if (action
->action
== ta_fill
9862 && action
->offset
- action
->removed_bytes
== orig_dot
)
9864 /* This is OK because the fill only effects the dup_dot. */
9866 else if (action
->action
== ta_add_literal
)
9868 /* TBD. Might need to handle this. */
9871 if (action
->offset
== orig_dot
)
9873 if (action
->virtual_offset
> orig_dot_vo
)
9875 if (orig_dot_vo
== 0)
9877 /* Need to copy virtual_offset bytes. Probably four. */
9878 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9879 memmove (&dup_contents
[dup_dot
],
9880 &contents
[orig_dot
], copy_size
);
9881 orig_dot_copied
= copy_size
;
9882 dup_dot
+= copy_size
;
9884 virtual_action
= true;
9887 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9889 switch (action
->action
)
9891 case ta_remove_literal
:
9892 case ta_remove_insn
:
9893 BFD_ASSERT (action
->removed_bytes
>= 0);
9894 orig_dot
+= action
->removed_bytes
;
9897 case ta_narrow_insn
:
9900 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9901 BFD_ASSERT (action
->removed_bytes
== 1);
9902 rv
= narrow_instruction (scratch
, final_size
, 0);
9904 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9905 orig_dot
+= orig_insn_size
;
9906 dup_dot
+= copy_size
;
9910 if (action
->removed_bytes
>= 0)
9911 orig_dot
+= action
->removed_bytes
;
9914 /* Already zeroed in dup_contents. Just bump the
9916 dup_dot
+= (-action
->removed_bytes
);
9921 BFD_ASSERT (action
->removed_bytes
== 0);
9924 case ta_convert_longcall
:
9925 case ta_remove_longcall
:
9926 /* These will be removed or converted before we get here. */
9933 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9934 BFD_ASSERT (action
->removed_bytes
== -1);
9935 rv
= widen_instruction (scratch
, final_size
, 0);
9937 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9938 orig_dot
+= orig_insn_size
;
9939 dup_dot
+= copy_size
;
9942 case ta_add_literal
:
9945 BFD_ASSERT (action
->removed_bytes
== -4);
9946 /* TBD -- place the literal value here and insert
9948 memset (&dup_contents
[dup_dot
], 0, 4);
9949 pin_internal_relocs (sec
, internal_relocs
);
9950 pin_contents (sec
, contents
);
9952 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9953 relax_info
, &internal_relocs
, &action
->value
))
9957 orig_dot_vo
+= copy_size
;
9959 orig_dot
+= orig_insn_size
;
9960 dup_dot
+= copy_size
;
9964 /* Not implemented yet. */
9969 BFD_ASSERT (dup_dot
<= final_size
);
9970 BFD_ASSERT (orig_dot
<= orig_size
);
9973 orig_dot
+= orig_dot_copied
;
9974 orig_dot_copied
= 0;
9976 if (orig_dot
!= orig_size
)
9978 copy_size
= orig_size
- orig_dot
;
9979 BFD_ASSERT (orig_size
> orig_dot
);
9980 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9981 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9982 orig_dot
+= copy_size
;
9983 dup_dot
+= copy_size
;
9985 BFD_ASSERT (orig_size
== orig_dot
);
9986 BFD_ASSERT (final_size
== dup_dot
);
9988 /* Move the dup_contents back. */
9989 if (final_size
> orig_size
)
9991 /* Contents need to be reallocated. Swap the dup_contents into
9993 sec
->contents
= dup_contents
;
9995 contents
= dup_contents
;
9996 pin_contents (sec
, contents
);
10000 BFD_ASSERT (final_size
<= orig_size
);
10001 memset (contents
, 0, orig_size
);
10002 memcpy (contents
, dup_contents
, final_size
);
10003 free (dup_contents
);
10006 pin_contents (sec
, contents
);
10008 if (sec
->rawsize
== 0)
10009 sec
->rawsize
= sec
->size
;
10010 sec
->size
= final_size
;
10014 release_internal_relocs (sec
, internal_relocs
);
10015 release_contents (sec
, contents
);
10021 translate_section_fixes (asection
*sec
)
10023 xtensa_relax_info
*relax_info
;
10026 relax_info
= get_xtensa_relax_info (sec
);
10030 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
10031 if (!translate_reloc_bfd_fix (r
))
10038 /* Translate a fix given the mapping in the relax info for the target
10039 section. If it has already been translated, no work is required. */
10042 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
10044 reloc_bfd_fix new_fix
;
10046 xtensa_relax_info
*relax_info
;
10047 removed_literal
*removed
;
10048 bfd_vma new_offset
, target_offset
;
10050 if (fix
->translated
)
10053 sec
= fix
->target_sec
;
10054 target_offset
= fix
->target_offset
;
10056 relax_info
= get_xtensa_relax_info (sec
);
10059 fix
->translated
= true;
10065 /* The fix does not need to be translated if the section cannot change. */
10066 if (!relax_info
->is_relaxable_literal_section
10067 && !relax_info
->is_relaxable_asm_section
)
10069 fix
->translated
= true;
10073 /* If the literal has been moved and this relocation was on an
10074 opcode, then the relocation should move to the new literal
10075 location. Otherwise, the relocation should move within the
10079 if (is_operand_relocation (fix
->src_type
))
10081 /* Check if the original relocation is against a literal being
10083 removed
= find_removed_literal (&relax_info
->removed_list
,
10091 /* The fact that there is still a relocation to this literal indicates
10092 that the literal is being coalesced, not simply removed. */
10093 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10095 /* This was moved to some other address (possibly another section). */
10096 new_sec
= r_reloc_get_section (&removed
->to
);
10097 if (new_sec
!= sec
)
10100 relax_info
= get_xtensa_relax_info (sec
);
10102 (!relax_info
->is_relaxable_literal_section
10103 && !relax_info
->is_relaxable_asm_section
))
10105 target_offset
= removed
->to
.target_offset
;
10106 new_fix
.target_sec
= new_sec
;
10107 new_fix
.target_offset
= target_offset
;
10108 new_fix
.translated
= true;
10113 target_offset
= removed
->to
.target_offset
;
10114 new_fix
.target_sec
= new_sec
;
10117 /* The target address may have been moved within its section. */
10118 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
10121 new_fix
.target_offset
= new_offset
;
10122 new_fix
.target_offset
= new_offset
;
10123 new_fix
.translated
= true;
10129 /* Fix up a relocation to take account of removed literals. */
10132 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
10134 xtensa_relax_info
*relax_info
;
10135 removed_literal
*removed
;
10136 bfd_vma target_offset
, base_offset
;
10138 *new_rel
= *orig_rel
;
10140 if (!r_reloc_is_defined (orig_rel
))
10143 relax_info
= get_xtensa_relax_info (sec
);
10144 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
10145 || relax_info
->is_relaxable_asm_section
));
10147 target_offset
= orig_rel
->target_offset
;
10150 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
10152 /* Check if the original relocation is against a literal being
10154 removed
= find_removed_literal (&relax_info
->removed_list
,
10157 if (removed
&& removed
->to
.abfd
)
10161 /* The fact that there is still a relocation to this literal indicates
10162 that the literal is being coalesced, not simply removed. */
10163 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10165 /* This was moved to some other address
10166 (possibly in another section). */
10167 *new_rel
= removed
->to
;
10168 new_sec
= r_reloc_get_section (new_rel
);
10169 if (new_sec
!= sec
)
10172 relax_info
= get_xtensa_relax_info (sec
);
10174 || (!relax_info
->is_relaxable_literal_section
10175 && !relax_info
->is_relaxable_asm_section
))
10178 target_offset
= new_rel
->target_offset
;
10181 /* Find the base offset of the reloc symbol, excluding any addend from the
10182 reloc or from the section contents (for a partial_inplace reloc). Then
10183 find the adjusted values of the offsets due to relaxation. The base
10184 offset is needed to determine the change to the reloc's addend; the reloc
10185 addend should not be adjusted due to relaxations located before the base
10188 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
10189 if (base_offset
<= target_offset
)
10191 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
10192 base_offset
, false);
10193 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10194 target_offset
, false) -
10197 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
10198 new_rel
->rela
.r_addend
-= addend_removed
;
10202 /* Handle a negative addend. The base offset comes first. */
10203 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
10204 target_offset
, false);
10205 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10206 base_offset
, false) -
10209 new_rel
->target_offset
= target_offset
- tgt_removed
;
10210 new_rel
->rela
.r_addend
+= addend_removed
;
10217 /* For dynamic links, there may be a dynamic relocation for each
10218 literal. The number of dynamic relocations must be computed in
10219 size_dynamic_sections, which occurs before relaxation. When a
10220 literal is removed, this function checks if there is a corresponding
10221 dynamic relocation and shrinks the size of the appropriate dynamic
10222 relocation section accordingly. At this point, the contents of the
10223 dynamic relocation sections have not yet been filled in, so there's
10224 nothing else that needs to be done. */
10227 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
10229 asection
*input_section
,
10230 Elf_Internal_Rela
*rel
)
10232 struct elf_xtensa_link_hash_table
*htab
;
10233 Elf_Internal_Shdr
*symtab_hdr
;
10234 struct elf_link_hash_entry
**sym_hashes
;
10235 unsigned long r_symndx
;
10237 struct elf_link_hash_entry
*h
;
10238 bool dynamic_symbol
;
10240 htab
= elf_xtensa_hash_table (info
);
10244 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10245 sym_hashes
= elf_sym_hashes (abfd
);
10247 r_type
= ELF32_R_TYPE (rel
->r_info
);
10248 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10250 if (r_symndx
< symtab_hdr
->sh_info
)
10253 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10255 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10257 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10258 && (input_section
->flags
& SEC_ALLOC
) != 0
10260 || (bfd_link_pic (info
)
10261 && (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
))))
10264 bool is_plt
= false;
10266 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10268 srel
= htab
->elf
.srelplt
;
10272 srel
= htab
->elf
.srelgot
;
10274 /* Reduce size of the .rela.* section by one reloc. */
10275 BFD_ASSERT (srel
!= NULL
);
10276 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10277 srel
->size
-= sizeof (Elf32_External_Rela
);
10281 asection
*splt
, *sgotplt
, *srelgot
;
10282 int reloc_index
, chunk
;
10284 /* Find the PLT reloc index of the entry being removed. This
10285 is computed from the size of ".rela.plt". It is needed to
10286 figure out which PLT chunk to resize. Usually "last index
10287 = size - 1" since the index starts at zero, but in this
10288 context, the size has just been decremented so there's no
10289 need to subtract one. */
10290 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10292 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10293 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10294 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10295 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10297 /* Check if an entire PLT chunk has just been eliminated. */
10298 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10300 /* The two magic GOT entries for that chunk can go away. */
10301 srelgot
= htab
->elf
.srelgot
;
10302 BFD_ASSERT (srelgot
!= NULL
);
10303 srelgot
->reloc_count
-= 2;
10304 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10305 sgotplt
->size
-= 8;
10307 /* There should be only one entry left (and it will be
10309 BFD_ASSERT (sgotplt
->size
== 4);
10310 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10313 BFD_ASSERT (sgotplt
->size
>= 4);
10314 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10316 sgotplt
->size
-= 4;
10317 splt
->size
-= PLT_ENTRY_SIZE
;
10323 /* Take an r_rel and move it to another section. This usually
10324 requires extending the interal_relocation array and pinning it. If
10325 the original r_rel is from the same BFD, we can complete this here.
10326 Otherwise, we add a fix record to let the final link fix the
10327 appropriate address. Contents and internal relocations for the
10328 section must be pinned after calling this routine. */
10331 move_literal (bfd
*abfd
,
10332 struct bfd_link_info
*link_info
,
10335 bfd_byte
*contents
,
10336 xtensa_relax_info
*relax_info
,
10337 Elf_Internal_Rela
**internal_relocs_p
,
10338 const literal_value
*lit
)
10340 Elf_Internal_Rela
*new_relocs
= NULL
;
10341 size_t new_relocs_count
= 0;
10342 Elf_Internal_Rela this_rela
;
10343 const r_reloc
*r_rel
;
10345 r_rel
= &lit
->r_rel
;
10346 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10348 if (r_reloc_is_const (r_rel
))
10349 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10354 reloc_bfd_fix
*fix
;
10355 unsigned insert_at
;
10357 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10359 /* This is the difficult case. We have to create a fix up. */
10360 this_rela
.r_offset
= offset
;
10361 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10362 this_rela
.r_addend
=
10363 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10364 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10366 /* Currently, we cannot move relocations during a relocatable link. */
10367 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10368 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10369 r_reloc_get_section (r_rel
),
10370 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10372 /* We also need to mark that relocations are needed here. */
10373 sec
->flags
|= SEC_RELOC
;
10375 translate_reloc_bfd_fix (fix
);
10376 /* This fix has not yet been translated. */
10377 add_fix (sec
, fix
);
10379 /* Add the relocation. If we have already allocated our own
10380 space for the relocations and we have room for more, then use
10381 it. Otherwise, allocate new space and move the literals. */
10382 insert_at
= sec
->reloc_count
;
10383 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10385 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10392 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10393 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10395 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10396 || sec
->reloc_count
== relax_info
->relocs_count
);
10398 if (relax_info
->allocated_relocs_count
== 0)
10399 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10401 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10403 new_relocs
= (Elf_Internal_Rela
*)
10404 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10408 /* We could handle this more quickly by finding the split point. */
10409 if (insert_at
!= 0)
10410 memcpy (new_relocs
, *internal_relocs_p
,
10411 insert_at
* sizeof (Elf_Internal_Rela
));
10413 new_relocs
[insert_at
] = this_rela
;
10415 if (insert_at
!= sec
->reloc_count
)
10416 memcpy (new_relocs
+ insert_at
+ 1,
10417 (*internal_relocs_p
) + insert_at
,
10418 (sec
->reloc_count
- insert_at
)
10419 * sizeof (Elf_Internal_Rela
));
10421 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10423 /* The first time we re-allocate, we can only free the
10424 old relocs if they were allocated with bfd_malloc.
10425 This is not true when keep_memory is in effect. */
10426 if (!link_info
->keep_memory
)
10427 free (*internal_relocs_p
);
10430 free (*internal_relocs_p
);
10431 relax_info
->allocated_relocs
= new_relocs
;
10432 relax_info
->allocated_relocs_count
= new_relocs_count
;
10433 elf_section_data (sec
)->relocs
= new_relocs
;
10434 sec
->reloc_count
++;
10435 relax_info
->relocs_count
= sec
->reloc_count
;
10436 *internal_relocs_p
= new_relocs
;
10440 if (insert_at
!= sec
->reloc_count
)
10443 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10444 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10446 (*internal_relocs_p
)[insert_at
] = this_rela
;
10447 sec
->reloc_count
++;
10448 if (relax_info
->allocated_relocs
)
10449 relax_info
->relocs_count
= sec
->reloc_count
;
10456 /* This is similar to relax_section except that when a target is moved,
10457 we shift addresses up. We also need to modify the size. This
10458 algorithm does NOT allow for relocations into the middle of the
10459 property sections. */
10462 relax_property_section (bfd
*abfd
,
10464 struct bfd_link_info
*link_info
)
10466 Elf_Internal_Rela
*internal_relocs
;
10467 bfd_byte
*contents
;
10470 bool is_full_prop_section
;
10471 size_t last_zfill_target_offset
= 0;
10472 asection
*last_zfill_target_sec
= NULL
;
10473 bfd_size_type sec_size
;
10474 bfd_size_type entry_size
;
10476 sec_size
= bfd_get_section_limit (abfd
, sec
);
10477 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10478 link_info
->keep_memory
);
10479 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10480 if (contents
== NULL
&& sec_size
!= 0)
10486 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10487 if (is_full_prop_section
)
10492 if (internal_relocs
)
10494 for (i
= 0; i
< sec
->reloc_count
; i
++)
10496 Elf_Internal_Rela
*irel
;
10497 xtensa_relax_info
*target_relax_info
;
10499 asection
*target_sec
;
10501 bfd_byte
*size_p
, *flags_p
;
10503 /* Locally change the source address.
10504 Translate the target to the new target address.
10505 If it points to this section and has been removed, MOVE IT.
10506 Also, don't forget to modify the associated SIZE at
10509 irel
= &internal_relocs
[i
];
10510 r_type
= ELF32_R_TYPE (irel
->r_info
);
10511 if (r_type
== R_XTENSA_NONE
)
10514 /* Find the literal value. */
10515 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10516 size_p
= &contents
[irel
->r_offset
+ 4];
10518 if (is_full_prop_section
)
10519 flags_p
= &contents
[irel
->r_offset
+ 8];
10520 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10522 target_sec
= r_reloc_get_section (&val
.r_rel
);
10523 target_relax_info
= get_xtensa_relax_info (target_sec
);
10525 if (target_relax_info
10526 && (target_relax_info
->is_relaxable_literal_section
10527 || target_relax_info
->is_relaxable_asm_section
))
10529 /* Translate the relocation's destination. */
10530 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10531 bfd_vma new_offset
;
10532 long old_size
, new_size
;
10533 int removed_by_old_offset
=
10534 removed_by_actions_map (&target_relax_info
->action_list
,
10535 old_offset
, false);
10536 new_offset
= old_offset
- removed_by_old_offset
;
10538 /* Assert that we are not out of bounds. */
10539 old_size
= bfd_get_32 (abfd
, size_p
);
10540 new_size
= old_size
;
10544 /* Only the first zero-sized unreachable entry is
10545 allowed to expand. In this case the new offset
10546 should be the offset before the fill and the new
10547 size is the expansion size. For other zero-sized
10548 entries the resulting size should be zero with an
10549 offset before or after the fill address depending
10550 on whether the expanding unreachable entry
10552 if (last_zfill_target_sec
== 0
10553 || last_zfill_target_sec
!= target_sec
10554 || last_zfill_target_offset
!= old_offset
)
10556 bfd_vma new_end_offset
= new_offset
;
10558 /* Recompute the new_offset, but this time don't
10559 include any fill inserted by relaxation. */
10560 removed_by_old_offset
=
10561 removed_by_actions_map (&target_relax_info
->action_list
,
10563 new_offset
= old_offset
- removed_by_old_offset
;
10565 /* If it is not unreachable and we have not yet
10566 seen an unreachable at this address, place it
10567 before the fill address. */
10568 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10569 & XTENSA_PROP_UNREACHABLE
) != 0)
10571 new_size
= new_end_offset
- new_offset
;
10573 last_zfill_target_sec
= target_sec
;
10574 last_zfill_target_offset
= old_offset
;
10580 int removed_by_old_offset_size
=
10581 removed_by_actions_map (&target_relax_info
->action_list
,
10582 old_offset
+ old_size
, true);
10583 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10586 if (new_size
!= old_size
)
10588 bfd_put_32 (abfd
, new_size
, size_p
);
10589 pin_contents (sec
, contents
);
10592 if (new_offset
!= old_offset
)
10594 bfd_vma diff
= new_offset
- old_offset
;
10595 irel
->r_addend
+= diff
;
10596 pin_internal_relocs (sec
, internal_relocs
);
10602 /* Combine adjacent property table entries. This is also done in
10603 finish_dynamic_sections() but at that point it's too late to
10604 reclaim the space in the output section, so we do this twice. */
10606 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10607 || xtensa_is_littable_section (sec
)))
10609 Elf_Internal_Rela
*last_irel
= NULL
;
10610 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10611 int removed_bytes
= 0;
10613 flagword predef_flags
;
10615 predef_flags
= xtensa_get_property_predef_flags (sec
);
10617 /* Walk over memory and relocations at the same time.
10618 This REQUIRES that the internal_relocs be sorted by offset. */
10619 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10620 internal_reloc_compare
);
10622 pin_internal_relocs (sec
, internal_relocs
);
10623 pin_contents (sec
, contents
);
10625 next_rel
= internal_relocs
;
10626 rel_end
= internal_relocs
+ sec
->reloc_count
;
10628 BFD_ASSERT (sec
->size
% entry_size
== 0);
10630 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10632 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10633 bfd_vma bytes_to_remove
, size
, actual_offset
;
10634 bool remove_this_rel
;
10637 /* Find the first relocation for the entry at the current offset.
10638 Adjust the offsets of any extra relocations for the previous
10643 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10645 if ((irel
->r_offset
== offset
10646 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10647 || irel
->r_offset
> offset
)
10652 irel
->r_offset
-= removed_bytes
;
10656 /* Find the next relocation (if there are any left). */
10660 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10662 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10670 /* Check if there are relocations on the current entry. There
10671 should usually be a relocation on the offset field. If there
10672 are relocations on the size or flags, then we can't optimize
10673 this entry. Also, find the next relocation to examine on the
10677 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10679 next_rel
= offset_rel
;
10680 /* There are no relocations on the current entry, but we
10681 might still be able to remove it if the size is zero. */
10684 else if (offset_rel
->r_offset
> offset
10686 && extra_rel
->r_offset
< offset
+ entry_size
))
10688 /* There is a relocation on the size or flags, so we can't
10689 do anything with this entry. Continue with the next. */
10690 next_rel
= offset_rel
;
10695 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10696 offset_rel
->r_offset
-= removed_bytes
;
10697 next_rel
= offset_rel
+ 1;
10703 remove_this_rel
= false;
10704 bytes_to_remove
= 0;
10705 actual_offset
= offset
- removed_bytes
;
10706 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10708 if (is_full_prop_section
)
10709 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10711 flags
= predef_flags
;
10714 && (flags
& XTENSA_PROP_ALIGN
) == 0
10715 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10717 /* Always remove entries with zero size and no alignment. */
10718 bytes_to_remove
= entry_size
;
10720 remove_this_rel
= true;
10722 else if (offset_rel
10723 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10727 flagword old_flags
;
10729 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10730 bfd_vma old_address
=
10731 (last_irel
->r_addend
10732 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10733 bfd_vma new_address
=
10734 (offset_rel
->r_addend
10735 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10736 if (is_full_prop_section
)
10737 old_flags
= bfd_get_32
10738 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10740 old_flags
= predef_flags
;
10742 if ((ELF32_R_SYM (offset_rel
->r_info
)
10743 == ELF32_R_SYM (last_irel
->r_info
))
10744 && old_address
+ old_size
== new_address
10745 && old_flags
== flags
10746 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10747 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10749 /* Fix the old size. */
10750 bfd_put_32 (abfd
, old_size
+ size
,
10751 &contents
[last_irel
->r_offset
+ 4]);
10752 bytes_to_remove
= entry_size
;
10753 remove_this_rel
= true;
10756 last_irel
= offset_rel
;
10759 last_irel
= offset_rel
;
10762 if (remove_this_rel
)
10764 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10765 offset_rel
->r_offset
= 0;
10768 if (bytes_to_remove
!= 0)
10770 removed_bytes
+= bytes_to_remove
;
10771 if (offset
+ bytes_to_remove
< sec
->size
)
10772 memmove (&contents
[actual_offset
],
10773 &contents
[actual_offset
+ bytes_to_remove
],
10774 sec
->size
- offset
- bytes_to_remove
);
10780 /* Fix up any extra relocations on the last entry. */
10781 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10782 irel
->r_offset
-= removed_bytes
;
10784 /* Clear the removed bytes. */
10785 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10787 if (sec
->rawsize
== 0)
10788 sec
->rawsize
= sec
->size
;
10789 sec
->size
-= removed_bytes
;
10791 if (xtensa_is_littable_section (sec
))
10793 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10795 sgotloc
->size
-= removed_bytes
;
10801 release_internal_relocs (sec
, internal_relocs
);
10802 release_contents (sec
, contents
);
10807 /* Third relaxation pass. */
10809 /* Change symbol values to account for removed literals. */
10812 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10814 xtensa_relax_info
*relax_info
;
10815 unsigned int sec_shndx
;
10816 Elf_Internal_Shdr
*symtab_hdr
;
10817 Elf_Internal_Sym
*isymbuf
;
10818 unsigned i
, num_syms
, num_locals
;
10820 relax_info
= get_xtensa_relax_info (sec
);
10821 BFD_ASSERT (relax_info
);
10823 if (!relax_info
->is_relaxable_literal_section
10824 && !relax_info
->is_relaxable_asm_section
)
10827 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10829 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10830 isymbuf
= retrieve_local_syms (abfd
);
10832 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10833 num_locals
= symtab_hdr
->sh_info
;
10835 /* Adjust the local symbols defined in this section. */
10836 for (i
= 0; i
< num_locals
; i
++)
10838 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10840 if (isym
->st_shndx
== sec_shndx
)
10842 bfd_vma orig_addr
= isym
->st_value
;
10843 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10846 isym
->st_value
-= removed
;
10847 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10849 removed_by_actions_map (&relax_info
->action_list
,
10850 orig_addr
+ isym
->st_size
, false) -
10855 /* Now adjust the global symbols defined in this section. */
10856 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10858 struct elf_link_hash_entry
*sym_hash
;
10860 sym_hash
= elf_sym_hashes (abfd
)[i
];
10862 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10863 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10865 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10866 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10867 && sym_hash
->root
.u
.def
.section
== sec
)
10869 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10870 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10873 sym_hash
->root
.u
.def
.value
-= removed
;
10875 if (sym_hash
->type
== STT_FUNC
)
10877 removed_by_actions_map (&relax_info
->action_list
,
10878 orig_addr
+ sym_hash
->size
, false) -
10887 /* "Fix" handling functions, called while performing relocations. */
10890 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10892 asection
*input_section
,
10893 bfd_byte
*contents
)
10896 asection
*sec
, *old_sec
;
10897 bfd_vma old_offset
;
10898 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10899 reloc_bfd_fix
*fix
;
10901 if (r_type
== R_XTENSA_NONE
)
10904 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10908 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10909 bfd_get_section_limit (input_bfd
, input_section
));
10910 old_sec
= r_reloc_get_section (&r_rel
);
10911 old_offset
= r_rel
.target_offset
;
10913 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10915 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10918 /* xgettext:c-format */
10919 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10920 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10921 elf_howto_table
[r_type
].name
);
10924 /* Leave it be. Resolution will happen in a later stage. */
10928 sec
= fix
->target_sec
;
10929 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10930 - (old_sec
->output_offset
+ old_offset
));
10937 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10939 asection
*input_section
,
10940 bfd_byte
*contents
,
10941 bfd_vma
*relocationp
)
10944 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10945 reloc_bfd_fix
*fix
;
10946 bfd_vma fixup_diff
;
10948 if (r_type
== R_XTENSA_NONE
)
10951 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10955 sec
= fix
->target_sec
;
10957 fixup_diff
= rel
->r_addend
;
10958 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10960 bfd_vma inplace_val
;
10961 BFD_ASSERT (fix
->src_offset
10962 < bfd_get_section_limit (input_bfd
, input_section
));
10963 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10964 fixup_diff
+= inplace_val
;
10967 *relocationp
= (sec
->output_section
->vma
10968 + sec
->output_offset
10969 + fix
->target_offset
- fixup_diff
);
10973 /* Miscellaneous utility functions.... */
10976 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10982 return elf_hash_table (info
)->splt
;
10984 dynobj
= elf_hash_table (info
)->dynobj
;
10985 sprintf (plt_name
, ".plt.%u", chunk
);
10986 return bfd_get_linker_section (dynobj
, plt_name
);
10991 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10997 return elf_hash_table (info
)->sgotplt
;
10999 dynobj
= elf_hash_table (info
)->dynobj
;
11000 sprintf (got_name
, ".got.plt.%u", chunk
);
11001 return bfd_get_linker_section (dynobj
, got_name
);
11005 /* Get the input section for a given symbol index.
11007 . a section symbol, return the section;
11008 . a common symbol, return the common section;
11009 . an undefined symbol, return the undefined section;
11010 . an indirect symbol, follow the links;
11011 . an absolute value, return the absolute section. */
11014 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
11016 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11017 asection
*target_sec
= NULL
;
11018 if (r_symndx
< symtab_hdr
->sh_info
)
11020 Elf_Internal_Sym
*isymbuf
;
11021 unsigned int section_index
;
11023 isymbuf
= retrieve_local_syms (abfd
);
11024 section_index
= isymbuf
[r_symndx
].st_shndx
;
11026 if (section_index
== SHN_UNDEF
)
11027 target_sec
= bfd_und_section_ptr
;
11028 else if (section_index
== SHN_ABS
)
11029 target_sec
= bfd_abs_section_ptr
;
11030 else if (section_index
== SHN_COMMON
)
11031 target_sec
= bfd_com_section_ptr
;
11033 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
11037 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11038 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
11040 while (h
->root
.type
== bfd_link_hash_indirect
11041 || h
->root
.type
== bfd_link_hash_warning
)
11042 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11044 switch (h
->root
.type
)
11046 case bfd_link_hash_defined
:
11047 case bfd_link_hash_defweak
:
11048 target_sec
= h
->root
.u
.def
.section
;
11050 case bfd_link_hash_common
:
11051 target_sec
= bfd_com_section_ptr
;
11053 case bfd_link_hash_undefined
:
11054 case bfd_link_hash_undefweak
:
11055 target_sec
= bfd_und_section_ptr
;
11057 default: /* New indirect warning. */
11058 target_sec
= bfd_und_section_ptr
;
11066 static struct elf_link_hash_entry
*
11067 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
11069 unsigned long indx
;
11070 struct elf_link_hash_entry
*h
;
11071 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11073 if (r_symndx
< symtab_hdr
->sh_info
)
11076 indx
= r_symndx
- symtab_hdr
->sh_info
;
11077 h
= elf_sym_hashes (abfd
)[indx
];
11078 while (h
->root
.type
== bfd_link_hash_indirect
11079 || h
->root
.type
== bfd_link_hash_warning
)
11080 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11085 /* Get the section-relative offset for a symbol number. */
11088 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
11090 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11091 bfd_vma offset
= 0;
11093 if (r_symndx
< symtab_hdr
->sh_info
)
11095 Elf_Internal_Sym
*isymbuf
;
11096 isymbuf
= retrieve_local_syms (abfd
);
11097 offset
= isymbuf
[r_symndx
].st_value
;
11101 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11102 struct elf_link_hash_entry
*h
=
11103 elf_sym_hashes (abfd
)[indx
];
11105 while (h
->root
.type
== bfd_link_hash_indirect
11106 || h
->root
.type
== bfd_link_hash_warning
)
11107 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11108 if (h
->root
.type
== bfd_link_hash_defined
11109 || h
->root
.type
== bfd_link_hash_defweak
)
11110 offset
= h
->root
.u
.def
.value
;
11117 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
11119 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
11120 struct elf_link_hash_entry
*h
;
11122 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
11123 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
11130 pcrel_reloc_fits (xtensa_opcode opc
,
11132 bfd_vma self_address
,
11133 bfd_vma dest_address
)
11135 xtensa_isa isa
= xtensa_default_isa
;
11136 uint32 valp
= dest_address
;
11137 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
11138 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
11145 xtensa_is_property_section (asection
*sec
)
11147 if (xtensa_is_insntable_section (sec
)
11148 || xtensa_is_littable_section (sec
)
11149 || xtensa_is_proptable_section (sec
))
11157 xtensa_is_insntable_section (asection
*sec
)
11159 if (startswith (sec
->name
, XTENSA_INSN_SEC_NAME
)
11160 || startswith (sec
->name
, ".gnu.linkonce.x."))
11168 xtensa_is_littable_section (asection
*sec
)
11170 if (startswith (sec
->name
, XTENSA_LIT_SEC_NAME
)
11171 || startswith (sec
->name
, ".gnu.linkonce.p."))
11179 xtensa_is_proptable_section (asection
*sec
)
11181 if (startswith (sec
->name
, XTENSA_PROP_SEC_NAME
)
11182 || startswith (sec
->name
, ".gnu.linkonce.prop."))
11190 internal_reloc_compare (const void *ap
, const void *bp
)
11192 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11193 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11195 if (a
->r_offset
!= b
->r_offset
)
11196 return (a
->r_offset
- b
->r_offset
);
11198 /* We don't need to sort on these criteria for correctness,
11199 but enforcing a more strict ordering prevents unstable qsort
11200 from behaving differently with different implementations.
11201 Without the code below we get correct but different results
11202 on Solaris 2.7 and 2.8. We would like to always produce the
11203 same results no matter the host. */
11205 if (a
->r_info
!= b
->r_info
)
11206 return (a
->r_info
- b
->r_info
);
11208 return (a
->r_addend
- b
->r_addend
);
11213 internal_reloc_matches (const void *ap
, const void *bp
)
11215 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11216 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11218 /* Check if one entry overlaps with the other; this shouldn't happen
11219 except when searching for a match. */
11220 return (a
->r_offset
- b
->r_offset
);
11224 /* Predicate function used to look up a section in a particular group. */
11227 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
11229 const char *gname
= inf
;
11230 const char *group_name
= elf_group_name (sec
);
11232 return (group_name
== gname
11233 || (group_name
!= NULL
11235 && strcmp (group_name
, gname
) == 0));
11240 xtensa_add_names (const char *base
, const char *suffix
)
11244 size_t base_len
= strlen (base
);
11245 size_t suffix_len
= strlen (suffix
);
11246 char *str
= bfd_malloc (base_len
+ suffix_len
+ 1);
11248 memcpy (str
, base
, base_len
);
11249 memcpy (str
+ base_len
, suffix
, suffix_len
+ 1);
11254 return strdup (base
);
11258 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11261 xtensa_property_section_name (asection
*sec
, const char *base_name
,
11262 bool separate_sections
)
11264 const char *suffix
, *group_name
;
11265 char *prop_sec_name
;
11267 group_name
= elf_group_name (sec
);
11270 suffix
= strrchr (sec
->name
, '.');
11271 if (suffix
== sec
->name
)
11273 prop_sec_name
= xtensa_add_names (base_name
, suffix
);
11275 else if (startswith (sec
->name
, ".gnu.linkonce."))
11277 char *linkonce_kind
= 0;
11279 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11280 linkonce_kind
= "x.";
11281 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11282 linkonce_kind
= "p.";
11283 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11284 linkonce_kind
= "prop.";
11288 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11289 + strlen (linkonce_kind
) + 1);
11290 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11291 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11293 suffix
= sec
->name
+ linkonce_len
;
11294 /* For backward compatibility, replace "t." instead of inserting
11295 the new linkonce_kind (but not for "prop" sections). */
11296 if (startswith (suffix
, "t.") && linkonce_kind
[1] == '.')
11298 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11302 prop_sec_name
= xtensa_add_names (base_name
,
11303 separate_sections
? sec
->name
: NULL
);
11306 return prop_sec_name
;
11311 xtensa_get_separate_property_section (asection
*sec
, const char *base_name
,
11312 bool separate_section
)
11314 char *prop_sec_name
;
11315 asection
*prop_sec
;
11317 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11319 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11320 match_section_group
,
11321 (void *) elf_group_name (sec
));
11322 free (prop_sec_name
);
11327 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11329 asection
*prop_sec
;
11331 /* Try individual property section first. */
11332 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, true);
11334 /* Refer to a common property section if individual is not present. */
11336 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, false);
11343 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11345 char *prop_sec_name
;
11346 asection
*prop_sec
;
11348 /* Check if the section already exists. */
11349 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11350 elf32xtensa_separate_props
);
11351 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11352 match_section_group
,
11353 (void *) elf_group_name (sec
));
11354 /* If not, create it. */
11357 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11358 flags
|= (bfd_section_flags (sec
)
11359 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11361 prop_sec
= bfd_make_section_anyway_with_flags
11362 (sec
->owner
, strdup (prop_sec_name
), flags
);
11366 elf_group_name (prop_sec
) = elf_group_name (sec
);
11369 free (prop_sec_name
);
11375 xtensa_get_property_predef_flags (asection
*sec
)
11377 if (xtensa_is_insntable_section (sec
))
11378 return (XTENSA_PROP_INSN
11379 | XTENSA_PROP_NO_TRANSFORM
11380 | XTENSA_PROP_INSN_NO_REORDER
);
11382 if (xtensa_is_littable_section (sec
))
11383 return (XTENSA_PROP_LITERAL
11384 | XTENSA_PROP_NO_TRANSFORM
11385 | XTENSA_PROP_INSN_NO_REORDER
);
11391 /* Other functions called directly by the linker. */
11394 xtensa_callback_required_dependence (bfd
*abfd
,
11396 struct bfd_link_info
*link_info
,
11397 deps_callback_t callback
,
11400 Elf_Internal_Rela
*internal_relocs
;
11401 bfd_byte
*contents
;
11404 bfd_size_type sec_size
;
11406 sec_size
= bfd_get_section_limit (abfd
, sec
);
11408 /* ".plt*" sections have no explicit relocations but they contain L32R
11409 instructions that reference the corresponding ".got.plt*" sections. */
11410 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11411 && startswith (sec
->name
, ".plt"))
11415 /* Find the corresponding ".got.plt*" section. */
11416 if (sec
->name
[4] == '\0')
11417 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11423 BFD_ASSERT (sec
->name
[4] == '.');
11424 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11426 sprintf (got_name
, ".got.plt.%u", chunk
);
11427 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11429 BFD_ASSERT (sgotplt
);
11431 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11432 section referencing a literal at the very beginning of
11433 ".got.plt". This is very close to the real dependence, anyway. */
11434 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11437 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11438 when building uclibc, which runs "ld -b binary /dev/null". */
11439 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11442 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11443 link_info
->keep_memory
);
11444 if (internal_relocs
== NULL
11445 || sec
->reloc_count
== 0)
11448 /* Cache the contents for the duration of this scan. */
11449 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11450 if (contents
== NULL
&& sec_size
!= 0)
11456 if (!xtensa_default_isa
)
11457 xtensa_default_isa
= xtensa_isa_init (0, 0);
11459 for (i
= 0; i
< sec
->reloc_count
; i
++)
11461 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11462 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11465 asection
*target_sec
;
11466 bfd_vma target_offset
;
11468 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11471 /* L32Rs must be local to the input file. */
11472 if (r_reloc_is_defined (&l32r_rel
))
11474 target_sec
= r_reloc_get_section (&l32r_rel
);
11475 target_offset
= l32r_rel
.target_offset
;
11477 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11483 release_internal_relocs (sec
, internal_relocs
);
11484 release_contents (sec
, contents
);
11488 /* The default literal sections should always be marked as "code" (i.e.,
11489 SHF_EXECINSTR). This is particularly important for the Linux kernel
11490 module loader so that the literals are not placed after the text. */
11491 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11493 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11494 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11495 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11496 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11497 { NULL
, 0, 0, 0, 0 }
11500 #define ELF_TARGET_ID XTENSA_ELF_DATA
11502 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11503 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11504 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11505 #define TARGET_BIG_NAME "elf32-xtensa-be"
11506 #define ELF_ARCH bfd_arch_xtensa
11508 #define ELF_MACHINE_CODE EM_XTENSA
11509 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11511 #define ELF_MAXPAGESIZE 0x1000
11512 #endif /* ELF_ARCH */
11514 #define elf_backend_can_gc_sections 1
11515 #define elf_backend_can_refcount 1
11516 #define elf_backend_plt_readonly 1
11517 #define elf_backend_got_header_size 4
11518 #define elf_backend_want_dynbss 0
11519 #define elf_backend_want_got_plt 1
11520 #define elf_backend_dtrel_excludes_plt 1
11522 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11524 #define bfd_elf32_mkobject elf_xtensa_mkobject
11526 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11527 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11528 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11529 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11530 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11531 #define bfd_elf32_bfd_reloc_name_lookup \
11532 elf_xtensa_reloc_name_lookup
11533 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11534 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11536 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11537 #define elf_backend_check_relocs elf_xtensa_check_relocs
11538 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11539 #define elf_backend_discard_info elf_xtensa_discard_info
11540 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11541 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11542 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11543 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11544 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11545 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11546 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11547 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11548 #define elf_backend_object_p elf_xtensa_object_p
11549 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11550 #define elf_backend_relocate_section elf_xtensa_relocate_section
11551 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11552 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11553 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11554 #define elf_backend_special_sections elf_xtensa_special_sections
11555 #define elf_backend_action_discarded elf_xtensa_action_discarded
11556 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11558 #include "elf32-target.h"