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_dll (info
))
1121 tls_type
= GOT_TLS_GD
;
1126 tls_type
= GOT_TLS_IE
;
1129 case R_XTENSA_TLSDESC_ARG
:
1130 if (bfd_link_dll (info
))
1132 tls_type
= GOT_TLS_GD
;
1137 tls_type
= GOT_TLS_IE
;
1138 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
1139 && elf_xtensa_dynamic_symbol_p (h
, info
))
1144 case R_XTENSA_TLS_DTPOFF
:
1145 if (bfd_link_dll (info
))
1146 tls_type
= GOT_TLS_GD
;
1148 tls_type
= GOT_TLS_IE
;
1151 case R_XTENSA_TLS_TPOFF
:
1152 tls_type
= GOT_TLS_IE
;
1153 if (bfd_link_pic (info
))
1154 info
->flags
|= DF_STATIC_TLS
;
1155 if (bfd_link_dll (info
) || elf_xtensa_dynamic_symbol_p (h
, info
))
1160 tls_type
= GOT_NORMAL
;
1165 tls_type
= GOT_NORMAL
;
1169 case R_XTENSA_GNU_VTINHERIT
:
1170 /* This relocation describes the C++ object vtable hierarchy.
1171 Reconstruct it for later use during GC. */
1172 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1176 case R_XTENSA_GNU_VTENTRY
:
1177 /* This relocation describes which C++ vtable entries are actually
1178 used. Record for later use during GC. */
1179 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1184 /* Nothing to do for any other relocations. */
1192 if (h
->plt
.refcount
<= 0)
1195 h
->plt
.refcount
= 1;
1198 h
->plt
.refcount
+= 1;
1200 /* Keep track of the total PLT relocation count even if we
1201 don't yet know whether the dynamic sections will be
1203 htab
->plt_reloc_count
+= 1;
1205 if (elf_hash_table (info
)->dynamic_sections_created
)
1207 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1213 if (h
->got
.refcount
<= 0)
1214 h
->got
.refcount
= 1;
1216 h
->got
.refcount
+= 1;
1220 eh
->tlsfunc_refcount
+= 1;
1222 old_tls_type
= eh
->tls_type
;
1226 /* Allocate storage the first time. */
1227 if (elf_local_got_refcounts (abfd
) == NULL
)
1229 bfd_size_type size
= symtab_hdr
->sh_info
;
1232 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1235 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1237 mem
= bfd_zalloc (abfd
, size
);
1240 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1242 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1245 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1246 = (bfd_signed_vma
*) mem
;
1249 /* This is a global offset table entry for a local symbol. */
1250 if (is_got
|| is_plt
)
1251 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1254 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1256 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1259 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1260 tls_type
|= old_tls_type
;
1261 /* If a TLS symbol is accessed using IE at least once,
1262 there is no point to use a dynamic model for it. */
1263 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1264 && ((old_tls_type
& GOT_TLS_GD
) == 0
1265 || (tls_type
& GOT_TLS_IE
) == 0))
1267 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1268 tls_type
= old_tls_type
;
1269 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1270 tls_type
|= old_tls_type
;
1274 /* xgettext:c-format */
1275 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1277 h
? h
->root
.root
.string
: "<local>");
1282 if (old_tls_type
!= tls_type
)
1285 eh
->tls_type
= tls_type
;
1287 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1296 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1297 struct elf_link_hash_entry
*h
)
1299 if (bfd_link_pic (info
))
1301 if (h
->plt
.refcount
> 0)
1303 /* For shared objects, there's no need for PLT entries for local
1304 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1305 if (h
->got
.refcount
< 0)
1306 h
->got
.refcount
= 0;
1307 h
->got
.refcount
+= h
->plt
.refcount
;
1308 h
->plt
.refcount
= 0;
1313 /* Don't need any dynamic relocations at all. */
1314 h
->plt
.refcount
= 0;
1315 h
->got
.refcount
= 0;
1321 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1322 struct elf_link_hash_entry
*h
,
1325 /* For a shared link, move the plt refcount to the got refcount to leave
1326 space for RELATIVE relocs. */
1327 elf_xtensa_make_sym_local (info
, h
);
1329 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1333 /* Return the section that should be marked against GC for a given
1337 elf_xtensa_gc_mark_hook (asection
*sec
,
1338 struct bfd_link_info
*info
,
1339 Elf_Internal_Rela
*rel
,
1340 struct elf_link_hash_entry
*h
,
1341 Elf_Internal_Sym
*sym
)
1343 /* Property sections are marked "KEEP" in the linker scripts, but they
1344 should not cause other sections to be marked. (This approach relies
1345 on elf_xtensa_discard_info to remove property table entries that
1346 describe discarded sections. Alternatively, it might be more
1347 efficient to avoid using "KEEP" in the linker scripts and instead use
1348 the gc_mark_extra_sections hook to mark only the property sections
1349 that describe marked sections. That alternative does not work well
1350 with the current property table sections, which do not correspond
1351 one-to-one with the sections they describe, but that should be fixed
1353 if (xtensa_is_property_section (sec
))
1357 switch (ELF32_R_TYPE (rel
->r_info
))
1359 case R_XTENSA_GNU_VTINHERIT
:
1360 case R_XTENSA_GNU_VTENTRY
:
1364 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1368 /* Create all the dynamic sections. */
1371 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1373 struct elf_xtensa_link_hash_table
*htab
;
1374 flagword flags
, noalloc_flags
;
1376 htab
= elf_xtensa_hash_table (info
);
1380 /* First do all the standard stuff. */
1381 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1384 /* Create any extra PLT sections in case check_relocs has already
1385 been called on all the non-dynamic input files. */
1386 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1389 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1390 | SEC_LINKER_CREATED
| SEC_READONLY
);
1391 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1393 /* Mark the ".got.plt" section READONLY. */
1394 if (htab
->elf
.sgotplt
== NULL
1395 || !bfd_set_section_flags (htab
->elf
.sgotplt
, flags
))
1398 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1399 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1401 if (htab
->sgotloc
== NULL
1402 || !bfd_set_section_alignment (htab
->sgotloc
, 2))
1405 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1406 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1408 if (htab
->spltlittbl
== NULL
1409 || !bfd_set_section_alignment (htab
->spltlittbl
, 2))
1417 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1419 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1422 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1423 ".got.plt" sections. */
1424 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1430 /* Stop when we find a section has already been created. */
1431 if (elf_xtensa_get_plt_section (info
, chunk
))
1434 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1435 | SEC_LINKER_CREATED
| SEC_READONLY
);
1437 sname
= (char *) bfd_malloc (10);
1438 sprintf (sname
, ".plt.%u", chunk
);
1439 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1441 || !bfd_set_section_alignment (s
, 2))
1444 sname
= (char *) bfd_malloc (14);
1445 sprintf (sname
, ".got.plt.%u", chunk
);
1446 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1448 || !bfd_set_section_alignment (s
, 2))
1456 /* Adjust a symbol defined by a dynamic object and referenced by a
1457 regular object. The current definition is in some section of the
1458 dynamic object, but we're not including those sections. We have to
1459 change the definition to something the rest of the link can
1463 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1464 struct elf_link_hash_entry
*h
)
1466 /* If this is a weak symbol, and there is a real definition, the
1467 processor independent code will have arranged for us to see the
1468 real definition first, and we can just use the same value. */
1469 if (h
->is_weakalias
)
1471 struct elf_link_hash_entry
*def
= weakdef (h
);
1472 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1473 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1474 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1478 /* This is a reference to a symbol defined by a dynamic object. The
1479 reference must go through the GOT, so there's no need for COPY relocs,
1487 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1489 struct bfd_link_info
*info
;
1490 struct elf_xtensa_link_hash_table
*htab
;
1491 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1493 if (h
->root
.type
== bfd_link_hash_indirect
)
1496 info
= (struct bfd_link_info
*) arg
;
1497 htab
= elf_xtensa_hash_table (info
);
1501 /* If we saw any use of an IE model for this symbol, we can then optimize
1502 away GOT entries for any TLSDESC_FN relocs. */
1503 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1505 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1506 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1509 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1510 elf_xtensa_make_sym_local (info
, h
);
1512 if (! elf_xtensa_dynamic_symbol_p (h
, info
)
1513 && h
->root
.type
== bfd_link_hash_undefweak
)
1516 if (h
->plt
.refcount
> 0)
1517 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1519 if (h
->got
.refcount
> 0)
1520 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1527 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1529 struct elf_xtensa_link_hash_table
*htab
;
1532 htab
= elf_xtensa_hash_table (info
);
1536 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1538 bfd_signed_vma
*local_got_refcounts
;
1539 bfd_size_type j
, cnt
;
1540 Elf_Internal_Shdr
*symtab_hdr
;
1542 local_got_refcounts
= elf_local_got_refcounts (i
);
1543 if (!local_got_refcounts
)
1546 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1547 cnt
= symtab_hdr
->sh_info
;
1549 for (j
= 0; j
< cnt
; ++j
)
1551 /* If we saw any use of an IE model for this symbol, we can
1552 then optimize away GOT entries for any TLSDESC_FN relocs. */
1553 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1555 bfd_signed_vma
*tlsfunc_refcount
1556 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1557 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1558 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1561 if (local_got_refcounts
[j
] > 0)
1562 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1563 * sizeof (Elf32_External_Rela
));
1569 /* Set the sizes of the dynamic sections. */
1572 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1573 struct bfd_link_info
*info
)
1575 struct elf_xtensa_link_hash_table
*htab
;
1577 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1578 bool relplt
, relgot
;
1579 int plt_entries
, plt_chunks
, chunk
;
1584 htab
= elf_xtensa_hash_table (info
);
1588 dynobj
= elf_hash_table (info
)->dynobj
;
1591 srelgot
= htab
->elf
.srelgot
;
1592 srelplt
= htab
->elf
.srelplt
;
1594 if (elf_hash_table (info
)->dynamic_sections_created
)
1596 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1597 && htab
->elf
.srelplt
!= NULL
1598 && htab
->elf
.sgot
!= NULL
1599 && htab
->spltlittbl
!= NULL
1600 && htab
->sgotloc
!= NULL
);
1602 /* Set the contents of the .interp section to the interpreter. */
1603 if (bfd_link_executable (info
) && !info
->nointerp
)
1605 s
= bfd_get_linker_section (dynobj
, ".interp");
1608 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1609 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1612 /* Allocate room for one word in ".got". */
1613 htab
->elf
.sgot
->size
= 4;
1615 /* Allocate space in ".rela.got" for literals that reference global
1616 symbols and space in ".rela.plt" for literals that have PLT
1618 elf_link_hash_traverse (elf_hash_table (info
),
1619 elf_xtensa_allocate_dynrelocs
,
1622 /* If we are generating a shared object, we also need space in
1623 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1624 reference local symbols. */
1625 if (bfd_link_pic (info
))
1626 elf_xtensa_allocate_local_got_size (info
);
1628 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1629 each PLT entry, we need the PLT code plus a 4-byte literal.
1630 For each chunk of ".plt", we also need two more 4-byte
1631 literals, two corresponding entries in ".rela.got", and an
1632 8-byte entry in ".xt.lit.plt". */
1633 spltlittbl
= htab
->spltlittbl
;
1634 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1636 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1638 /* Iterate over all the PLT chunks, including any extra sections
1639 created earlier because the initial count of PLT relocations
1640 was an overestimate. */
1642 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1647 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1648 BFD_ASSERT (sgotplt
!= NULL
);
1650 if (chunk
< plt_chunks
- 1)
1651 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1652 else if (chunk
== plt_chunks
- 1)
1653 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1657 if (chunk_entries
!= 0)
1659 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1660 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1661 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1662 spltlittbl
->size
+= 8;
1671 /* Allocate space in ".got.loc" to match the total size of all the
1673 sgotloc
= htab
->sgotloc
;
1674 sgotloc
->size
= spltlittbl
->size
;
1675 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1677 if (abfd
->flags
& DYNAMIC
)
1679 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1681 if (! discarded_section (s
)
1682 && xtensa_is_littable_section (s
)
1684 sgotloc
->size
+= s
->size
;
1689 /* Allocate memory for dynamic sections. */
1692 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1696 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1699 /* It's OK to base decisions on the section name, because none
1700 of the dynobj section names depend upon the input files. */
1701 name
= bfd_section_name (s
);
1703 if (startswith (name
, ".rela"))
1707 if (strcmp (name
, ".rela.plt") == 0)
1709 else if (strcmp (name
, ".rela.got") == 0)
1712 /* We use the reloc_count field as a counter if we need
1713 to copy relocs into the output file. */
1717 else if (! startswith (name
, ".plt.")
1718 && ! startswith (name
, ".got.plt.")
1719 && strcmp (name
, ".got") != 0
1720 && strcmp (name
, ".plt") != 0
1721 && strcmp (name
, ".got.plt") != 0
1722 && strcmp (name
, ".xt.lit.plt") != 0
1723 && strcmp (name
, ".got.loc") != 0)
1725 /* It's not one of our sections, so don't allocate space. */
1731 /* If we don't need this section, strip it from the output
1732 file. We must create the ".plt*" and ".got.plt*"
1733 sections in create_dynamic_sections and/or check_relocs
1734 based on a conservative estimate of the PLT relocation
1735 count, because the sections must be created before the
1736 linker maps input sections to output sections. The
1737 linker does that before size_dynamic_sections, where we
1738 compute the exact size of the PLT, so there may be more
1739 of these sections than are actually needed. */
1740 s
->flags
|= SEC_EXCLUDE
;
1742 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1744 /* Allocate memory for the section contents. */
1745 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1746 if (s
->contents
== NULL
)
1751 if (elf_hash_table (info
)->dynamic_sections_created
)
1753 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1754 known until finish_dynamic_sections, but we need to get the relocs
1755 in place before they are sorted. */
1756 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1758 Elf_Internal_Rela irela
;
1762 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1765 loc
= (srelgot
->contents
1766 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1767 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1768 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1769 loc
+ sizeof (Elf32_External_Rela
));
1770 srelgot
->reloc_count
+= 2;
1773 /* Add some entries to the .dynamic section. We fill in the
1774 values later, in elf_xtensa_finish_dynamic_sections, but we
1775 must add the entries now so that we get the correct size for
1776 the .dynamic section. The DT_DEBUG entry is filled in by the
1777 dynamic linker and used by the debugger. */
1778 #define add_dynamic_entry(TAG, VAL) \
1779 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1781 if (!_bfd_elf_add_dynamic_tags (output_bfd
, info
,
1785 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1786 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1789 #undef add_dynamic_entry
1795 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1796 struct bfd_link_info
*info
)
1798 struct elf_xtensa_link_hash_table
*htab
;
1801 htab
= elf_xtensa_hash_table (info
);
1805 tls_sec
= htab
->elf
.tls_sec
;
1807 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1809 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1810 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1811 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1813 tlsbase
->type
= STT_TLS
;
1814 if (!(_bfd_generic_link_add_one_symbol
1815 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1816 tls_sec
, 0, NULL
, false,
1817 bed
->collect
, &bh
)))
1819 tlsbase
->def_regular
= 1;
1820 tlsbase
->other
= STV_HIDDEN
;
1821 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, true);
1828 /* Return the base VMA address which should be subtracted from real addresses
1829 when resolving @dtpoff relocation.
1830 This is PT_TLS segment p_vaddr. */
1833 dtpoff_base (struct bfd_link_info
*info
)
1835 /* If tls_sec is NULL, we should have signalled an error already. */
1836 if (elf_hash_table (info
)->tls_sec
== NULL
)
1838 return elf_hash_table (info
)->tls_sec
->vma
;
1841 /* Return the relocation value for @tpoff relocation
1842 if STT_TLS virtual address is ADDRESS. */
1845 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1847 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1850 /* If tls_sec is NULL, we should have signalled an error already. */
1851 if (htab
->tls_sec
== NULL
)
1853 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1854 return address
- htab
->tls_sec
->vma
+ base
;
1857 /* Perform the specified relocation. The instruction at (contents + address)
1858 is modified to set one operand to represent the value in "relocation". The
1859 operand position is determined by the relocation type recorded in the
1862 #define CALL_SEGMENT_BITS (30)
1863 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1865 static bfd_reloc_status_type
1866 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1868 asection
*input_section
,
1873 char **error_message
)
1876 xtensa_opcode opcode
;
1877 xtensa_isa isa
= xtensa_default_isa
;
1878 static xtensa_insnbuf ibuff
= NULL
;
1879 static xtensa_insnbuf sbuff
= NULL
;
1880 bfd_vma self_address
;
1881 bfd_size_type input_size
;
1887 ibuff
= xtensa_insnbuf_alloc (isa
);
1888 sbuff
= xtensa_insnbuf_alloc (isa
);
1891 input_size
= bfd_get_section_limit (abfd
, input_section
);
1893 /* Calculate the PC address for this instruction. */
1894 self_address
= (input_section
->output_section
->vma
1895 + input_section
->output_offset
1898 switch (howto
->type
)
1901 case R_XTENSA_DIFF8
:
1902 case R_XTENSA_DIFF16
:
1903 case R_XTENSA_DIFF32
:
1904 case R_XTENSA_PDIFF8
:
1905 case R_XTENSA_PDIFF16
:
1906 case R_XTENSA_PDIFF32
:
1907 case R_XTENSA_NDIFF8
:
1908 case R_XTENSA_NDIFF16
:
1909 case R_XTENSA_NDIFF32
:
1910 case R_XTENSA_TLS_FUNC
:
1911 case R_XTENSA_TLS_ARG
:
1912 case R_XTENSA_TLS_CALL
:
1913 return bfd_reloc_ok
;
1915 case R_XTENSA_ASM_EXPAND
:
1918 /* Check for windowed CALL across a 1GB boundary. */
1919 opcode
= get_expanded_call_opcode (contents
+ address
,
1920 input_size
- address
, 0);
1921 if (is_windowed_call_opcode (opcode
))
1923 if ((self_address
>> CALL_SEGMENT_BITS
)
1924 != (relocation
>> CALL_SEGMENT_BITS
))
1926 *error_message
= "windowed longcall crosses 1GB boundary; "
1928 return bfd_reloc_dangerous
;
1932 return bfd_reloc_ok
;
1934 case R_XTENSA_ASM_SIMPLIFY
:
1936 /* Convert the L32R/CALLX to CALL. */
1937 bfd_reloc_status_type retval
=
1938 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1940 if (retval
!= bfd_reloc_ok
)
1941 return bfd_reloc_dangerous
;
1943 /* The CALL needs to be relocated. Continue below for that part. */
1946 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1953 x
= bfd_get_32 (abfd
, contents
+ address
);
1955 bfd_put_32 (abfd
, x
, contents
+ address
);
1957 return bfd_reloc_ok
;
1959 case R_XTENSA_32_PCREL
:
1960 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1961 return bfd_reloc_ok
;
1964 case R_XTENSA_TLSDESC_FN
:
1965 case R_XTENSA_TLSDESC_ARG
:
1966 case R_XTENSA_TLS_DTPOFF
:
1967 case R_XTENSA_TLS_TPOFF
:
1968 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1969 return bfd_reloc_ok
;
1972 /* Only instruction slot-specific relocations handled below.... */
1973 slot
= get_relocation_slot (howto
->type
);
1974 if (slot
== XTENSA_UNDEFINED
)
1976 *error_message
= "unexpected relocation";
1977 return bfd_reloc_dangerous
;
1980 if (input_size
<= address
)
1981 return bfd_reloc_outofrange
;
1982 /* Read the instruction into a buffer and decode the opcode. */
1983 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1984 input_size
- address
);
1985 fmt
= xtensa_format_decode (isa
, ibuff
);
1986 if (fmt
== XTENSA_UNDEFINED
)
1988 *error_message
= "cannot decode instruction format";
1989 return bfd_reloc_dangerous
;
1992 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1994 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1995 if (opcode
== XTENSA_UNDEFINED
)
1997 *error_message
= "cannot decode instruction opcode";
1998 return bfd_reloc_dangerous
;
2001 /* Check for opcode-specific "alternate" relocations. */
2002 if (is_alt_relocation (howto
->type
))
2004 if (opcode
== get_l32r_opcode ())
2006 /* Handle the special-case of non-PC-relative L32R instructions. */
2007 bfd
*output_bfd
= input_section
->output_section
->owner
;
2008 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
2011 *error_message
= "relocation references missing .lit4 section";
2012 return bfd_reloc_dangerous
;
2014 self_address
= ((lit4_sec
->vma
& ~0xfff)
2015 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2016 newval
= relocation
;
2019 else if (opcode
== get_const16_opcode ())
2021 /* ALT used for high 16 bits.
2022 Ignore 32-bit overflow. */
2023 newval
= (relocation
>> 16) & 0xffff;
2028 /* No other "alternate" relocations currently defined. */
2029 *error_message
= "unexpected relocation";
2030 return bfd_reloc_dangerous
;
2033 else /* Not an "alternate" relocation.... */
2035 if (opcode
== get_const16_opcode ())
2037 newval
= relocation
& 0xffff;
2042 /* ...normal PC-relative relocation.... */
2044 /* Determine which operand is being relocated. */
2045 opnd
= get_relocation_opnd (opcode
, howto
->type
);
2046 if (opnd
== XTENSA_UNDEFINED
)
2048 *error_message
= "unexpected relocation";
2049 return bfd_reloc_dangerous
;
2052 if (!howto
->pc_relative
)
2054 *error_message
= "expected PC-relative relocation";
2055 return bfd_reloc_dangerous
;
2058 newval
= relocation
;
2062 /* Apply the relocation. */
2063 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
2064 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
2065 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2068 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2071 msg
= "cannot encode";
2072 if (is_direct_call_opcode (opcode
))
2074 if ((relocation
& 0x3) != 0)
2075 msg
= "misaligned call target";
2077 msg
= "call target out of range";
2079 else if (opcode
== get_l32r_opcode ())
2081 if ((relocation
& 0x3) != 0)
2082 msg
= "misaligned literal target";
2083 else if (is_alt_relocation (howto
->type
))
2084 msg
= "literal target out of range (too many literals)";
2085 else if (self_address
> relocation
)
2086 msg
= "literal target out of range (try using text-section-literals)";
2088 msg
= "literal placed after use";
2091 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2092 return bfd_reloc_dangerous
;
2095 /* Check for calls across 1GB boundaries. */
2096 if (is_direct_call_opcode (opcode
)
2097 && is_windowed_call_opcode (opcode
))
2099 if ((self_address
>> CALL_SEGMENT_BITS
)
2100 != (relocation
>> CALL_SEGMENT_BITS
))
2103 "windowed call crosses 1GB boundary; return may fail";
2104 return bfd_reloc_dangerous
;
2108 /* Write the modified instruction back out of the buffer. */
2109 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2110 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2111 input_size
- address
);
2112 return bfd_reloc_ok
;
2117 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2119 /* To reduce the size of the memory leak,
2120 we only use a single message buffer. */
2121 static bfd_size_type alloc_size
= 0;
2122 static char *message
= NULL
;
2123 bfd_size_type orig_len
, len
= 0;
2127 va_start (ap
, arglen
);
2129 is_append
= (origmsg
== message
);
2131 orig_len
= strlen (origmsg
);
2132 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2133 if (len
> alloc_size
)
2135 message
= (char *) bfd_realloc_or_free (message
, len
);
2138 if (message
!= NULL
)
2141 memcpy (message
, origmsg
, orig_len
);
2142 vsprintf (message
+ orig_len
, fmt
, ap
);
2149 /* This function is registered as the "special_function" in the
2150 Xtensa howto for handling simplify operations.
2151 bfd_perform_relocation / bfd_install_relocation use it to
2152 perform (install) the specified relocation. Since this replaces the code
2153 in bfd_perform_relocation, it is basically an Xtensa-specific,
2154 stripped-down version of bfd_perform_relocation. */
2156 static bfd_reloc_status_type
2157 bfd_elf_xtensa_reloc (bfd
*abfd
,
2158 arelent
*reloc_entry
,
2161 asection
*input_section
,
2163 char **error_message
)
2166 bfd_reloc_status_type flag
;
2167 bfd_size_type octets
= (reloc_entry
->address
2168 * OCTETS_PER_BYTE (abfd
, input_section
));
2169 bfd_vma output_base
= 0;
2170 reloc_howto_type
*howto
= reloc_entry
->howto
;
2171 asection
*reloc_target_output_section
;
2174 if (!xtensa_default_isa
)
2175 xtensa_default_isa
= xtensa_isa_init (0, 0);
2177 /* ELF relocs are against symbols. If we are producing relocatable
2178 output, and the reloc is against an external symbol, the resulting
2179 reloc will also be against the same symbol. In such a case, we
2180 don't want to change anything about the way the reloc is handled,
2181 since it will all be done at final link time. This test is similar
2182 to what bfd_elf_generic_reloc does except that it lets relocs with
2183 howto->partial_inplace go through even if the addend is non-zero.
2184 (The real problem is that partial_inplace is set for XTENSA_32
2185 relocs to begin with, but that's a long story and there's little we
2186 can do about it now....) */
2188 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2190 reloc_entry
->address
+= input_section
->output_offset
;
2191 return bfd_reloc_ok
;
2194 /* Is the address of the relocation really within the section? */
2195 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2196 return bfd_reloc_outofrange
;
2198 /* Work out which section the relocation is targeted at and the
2199 initial relocation command value. */
2201 /* Get symbol value. (Common symbols are special.) */
2202 if (bfd_is_com_section (symbol
->section
))
2205 relocation
= symbol
->value
;
2207 reloc_target_output_section
= symbol
->section
->output_section
;
2209 /* Convert input-section-relative symbol value to absolute. */
2210 if ((output_bfd
&& !howto
->partial_inplace
)
2211 || reloc_target_output_section
== NULL
)
2214 output_base
= reloc_target_output_section
->vma
;
2216 relocation
+= output_base
+ symbol
->section
->output_offset
;
2218 /* Add in supplied addend. */
2219 relocation
+= reloc_entry
->addend
;
2221 /* Here the variable relocation holds the final address of the
2222 symbol we are relocating against, plus any addend. */
2225 if (!howto
->partial_inplace
)
2227 /* This is a partial relocation, and we want to apply the relocation
2228 to the reloc entry rather than the raw data. Everything except
2229 relocations against section symbols has already been handled
2232 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2233 reloc_entry
->addend
= relocation
;
2234 reloc_entry
->address
+= input_section
->output_offset
;
2235 return bfd_reloc_ok
;
2239 reloc_entry
->address
+= input_section
->output_offset
;
2240 reloc_entry
->addend
= 0;
2244 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2245 && (symbol
->flags
& BSF_WEAK
) != 0);
2246 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2247 (bfd_byte
*) data
, (bfd_vma
) octets
,
2248 is_weak_undef
, error_message
);
2250 if (flag
== bfd_reloc_dangerous
)
2252 /* Add the symbol name to the error message. */
2253 if (! *error_message
)
2254 *error_message
= "";
2255 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2256 strlen (symbol
->name
) + 17,
2258 (unsigned long) reloc_entry
->addend
);
2264 int xtensa_abi_choice (void)
2266 if (elf32xtensa_abi
== XTHAL_ABI_UNDEFINED
)
2269 return elf32xtensa_abi
;
2272 /* Set up an entry in the procedure linkage table. */
2275 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2277 unsigned reloc_index
)
2279 asection
*splt
, *sgotplt
;
2280 bfd_vma plt_base
, got_base
;
2281 bfd_vma code_offset
, lit_offset
, abi_offset
;
2283 int abi
= xtensa_abi_choice ();
2285 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2286 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2287 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2288 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2290 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2291 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2293 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2294 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2296 /* Fill in the literal entry. This is the offset of the dynamic
2297 relocation entry. */
2298 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2299 sgotplt
->contents
+ lit_offset
);
2301 /* Fill in the entry in the procedure linkage table. */
2302 memcpy (splt
->contents
+ code_offset
,
2303 (bfd_big_endian (output_bfd
)
2304 ? elf_xtensa_be_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]
2305 : elf_xtensa_le_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]),
2307 abi_offset
= abi
== XTHAL_ABI_WINDOWED
? 3 : 0;
2308 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2309 plt_base
+ code_offset
+ abi_offset
),
2310 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2311 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2312 plt_base
+ code_offset
+ abi_offset
+ 3),
2313 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2314 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2315 plt_base
+ code_offset
+ abi_offset
+ 6),
2316 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2318 return plt_base
+ code_offset
;
2322 static bool get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2325 replace_tls_insn (Elf_Internal_Rela
*rel
,
2327 asection
*input_section
,
2330 char **error_message
)
2332 static xtensa_insnbuf ibuff
= NULL
;
2333 static xtensa_insnbuf sbuff
= NULL
;
2334 xtensa_isa isa
= xtensa_default_isa
;
2336 xtensa_opcode old_op
, new_op
;
2337 bfd_size_type input_size
;
2339 unsigned dest_reg
, src_reg
;
2343 ibuff
= xtensa_insnbuf_alloc (isa
);
2344 sbuff
= xtensa_insnbuf_alloc (isa
);
2347 input_size
= bfd_get_section_limit (abfd
, input_section
);
2349 /* Read the instruction into a buffer and decode the opcode. */
2350 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2351 input_size
- rel
->r_offset
);
2352 fmt
= xtensa_format_decode (isa
, ibuff
);
2353 if (fmt
== XTENSA_UNDEFINED
)
2355 *error_message
= "cannot decode instruction format";
2359 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2360 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2362 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2363 if (old_op
== XTENSA_UNDEFINED
)
2365 *error_message
= "cannot decode instruction opcode";
2369 r_type
= ELF32_R_TYPE (rel
->r_info
);
2372 case R_XTENSA_TLS_FUNC
:
2373 case R_XTENSA_TLS_ARG
:
2374 if (old_op
!= get_l32r_opcode ()
2375 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2376 sbuff
, &dest_reg
) != 0)
2378 *error_message
= "cannot extract L32R destination for TLS access";
2383 case R_XTENSA_TLS_CALL
:
2384 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2385 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2386 sbuff
, &src_reg
) != 0)
2388 *error_message
= "cannot extract CALLXn operands for TLS access";
2401 case R_XTENSA_TLS_FUNC
:
2402 case R_XTENSA_TLS_ARG
:
2403 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2404 versions of Xtensa). */
2405 new_op
= xtensa_opcode_lookup (isa
, "nop");
2406 if (new_op
== XTENSA_UNDEFINED
)
2408 new_op
= xtensa_opcode_lookup (isa
, "or");
2409 if (new_op
== XTENSA_UNDEFINED
2410 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2411 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2413 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2415 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2418 *error_message
= "cannot encode OR for TLS access";
2424 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2426 *error_message
= "cannot encode NOP for TLS access";
2432 case R_XTENSA_TLS_CALL
:
2433 /* Read THREADPTR into the CALLX's return value register. */
2434 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2435 if (new_op
== XTENSA_UNDEFINED
2436 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2437 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2438 sbuff
, dest_reg
+ 2) != 0)
2440 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2450 case R_XTENSA_TLS_FUNC
:
2451 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2452 if (new_op
== XTENSA_UNDEFINED
2453 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2454 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2455 sbuff
, dest_reg
) != 0)
2457 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2462 case R_XTENSA_TLS_ARG
:
2463 /* Nothing to do. Keep the original L32R instruction. */
2466 case R_XTENSA_TLS_CALL
:
2467 /* Add the CALLX's src register (holding the THREADPTR value)
2468 to the first argument register (holding the offset) and put
2469 the result in the CALLX's return value register. */
2470 new_op
= xtensa_opcode_lookup (isa
, "add");
2471 if (new_op
== XTENSA_UNDEFINED
2472 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2473 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2474 sbuff
, dest_reg
+ 2) != 0
2475 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2476 sbuff
, dest_reg
+ 2) != 0
2477 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2478 sbuff
, src_reg
) != 0)
2480 *error_message
= "cannot encode ADD for TLS access";
2487 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2488 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2489 input_size
- rel
->r_offset
);
2495 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2496 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2497 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2498 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2499 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2500 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2501 || (R_TYPE) == R_XTENSA_TLS_ARG \
2502 || (R_TYPE) == R_XTENSA_TLS_CALL)
2504 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2505 both relocatable and final links. */
2508 elf_xtensa_relocate_section (bfd
*output_bfd
,
2509 struct bfd_link_info
*info
,
2511 asection
*input_section
,
2513 Elf_Internal_Rela
*relocs
,
2514 Elf_Internal_Sym
*local_syms
,
2515 asection
**local_sections
)
2517 struct elf_xtensa_link_hash_table
*htab
;
2518 Elf_Internal_Shdr
*symtab_hdr
;
2519 Elf_Internal_Rela
*rel
;
2520 Elf_Internal_Rela
*relend
;
2521 struct elf_link_hash_entry
**sym_hashes
;
2522 property_table_entry
*lit_table
= 0;
2524 char *local_got_tls_types
;
2525 char *error_message
= NULL
;
2526 bfd_size_type input_size
;
2529 if (!xtensa_default_isa
)
2530 xtensa_default_isa
= xtensa_isa_init (0, 0);
2532 if (!is_xtensa_elf (input_bfd
))
2534 bfd_set_error (bfd_error_wrong_format
);
2538 htab
= elf_xtensa_hash_table (info
);
2542 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2543 sym_hashes
= elf_sym_hashes (input_bfd
);
2544 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2546 if (elf_hash_table (info
)->dynamic_sections_created
)
2548 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2549 &lit_table
, XTENSA_LIT_SEC_NAME
,
2555 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2558 relend
= relocs
+ input_section
->reloc_count
;
2559 for (; rel
< relend
; rel
++)
2562 reloc_howto_type
*howto
;
2563 unsigned long r_symndx
;
2564 struct elf_link_hash_entry
*h
;
2565 Elf_Internal_Sym
*sym
;
2570 bfd_reloc_status_type r
;
2572 bool unresolved_reloc
;
2574 bool dynamic_symbol
;
2576 r_type
= ELF32_R_TYPE (rel
->r_info
);
2577 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2578 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2581 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2583 bfd_set_error (bfd_error_bad_value
);
2586 howto
= &elf_howto_table
[r_type
];
2588 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2593 is_weak_undef
= false;
2594 unresolved_reloc
= false;
2597 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2599 /* Because R_XTENSA_32 was made partial_inplace to fix some
2600 problems with DWARF info in partial links, there may be
2601 an addend stored in the contents. Take it out of there
2602 and move it back into the addend field of the reloc. */
2603 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2604 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2607 if (r_symndx
< symtab_hdr
->sh_info
)
2609 sym
= local_syms
+ r_symndx
;
2610 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2611 sec
= local_sections
[r_symndx
];
2612 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2618 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2619 r_symndx
, symtab_hdr
, sym_hashes
,
2621 unresolved_reloc
, warned
, ignored
);
2624 && !unresolved_reloc
2625 && h
->root
.type
== bfd_link_hash_undefweak
)
2626 is_weak_undef
= true;
2631 if (sec
!= NULL
&& discarded_section (sec
))
2632 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2633 rel
, 1, relend
, howto
, 0, contents
);
2635 if (bfd_link_relocatable (info
))
2638 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2640 /* This is a relocatable link.
2641 1) If the reloc is against a section symbol, adjust
2642 according to the output section.
2643 2) If there is a new target for this relocation,
2644 the new target will be in the same output section.
2645 We adjust the relocation by the output section
2648 if (relaxing_section
)
2650 /* Check if this references a section in another input file. */
2651 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2656 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2657 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2659 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2661 error_message
= NULL
;
2662 /* Convert ASM_SIMPLIFY into the simpler relocation
2663 so that they never escape a relaxing link. */
2664 r
= contract_asm_expansion (contents
, input_size
, rel
,
2666 if (r
!= bfd_reloc_ok
)
2667 (*info
->callbacks
->reloc_dangerous
)
2668 (info
, error_message
,
2669 input_bfd
, input_section
, rel
->r_offset
);
2671 r_type
= ELF32_R_TYPE (rel
->r_info
);
2674 /* This is a relocatable link, so we don't have to change
2675 anything unless the reloc is against a section symbol,
2676 in which case we have to adjust according to where the
2677 section symbol winds up in the output section. */
2678 if (r_symndx
< symtab_hdr
->sh_info
)
2680 sym
= local_syms
+ r_symndx
;
2681 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2683 sec
= local_sections
[r_symndx
];
2684 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2688 /* If there is an addend with a partial_inplace howto,
2689 then move the addend to the contents. This is a hack
2690 to work around problems with DWARF in relocatable links
2691 with some previous version of BFD. Now we can't easily get
2692 rid of the hack without breaking backward compatibility.... */
2694 howto
= &elf_howto_table
[r_type
];
2695 if (howto
->partial_inplace
&& rel
->r_addend
)
2697 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2698 rel
->r_addend
, contents
,
2699 rel
->r_offset
, false,
2705 /* Put the correct bits in the target instruction, even
2706 though the relocation will still be present in the output
2707 file. This makes disassembly clearer, as well as
2708 allowing loadable kernel modules to work without needing
2709 relocations on anything other than calls and l32r's. */
2711 /* If it is not in the same section, there is nothing we can do. */
2712 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2713 sym_sec
->output_section
== input_section
->output_section
)
2715 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2716 dest_addr
, contents
,
2717 rel
->r_offset
, false,
2721 if (r
!= bfd_reloc_ok
)
2722 (*info
->callbacks
->reloc_dangerous
)
2723 (info
, error_message
,
2724 input_bfd
, input_section
, rel
->r_offset
);
2726 /* Done with work for relocatable link; continue with next reloc. */
2730 /* This is a final link. */
2732 if (relaxing_section
)
2734 /* Check if this references a section in another input file. */
2735 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2739 /* Sanity check the address. */
2740 if (rel
->r_offset
>= input_size
2741 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2744 /* xgettext:c-format */
2745 (_("%pB(%pA+%#" PRIx64
"): "
2746 "relocation offset out of range (size=%#" PRIx64
")"),
2747 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2748 (uint64_t) input_size
);
2749 bfd_set_error (bfd_error_bad_value
);
2754 name
= h
->root
.root
.string
;
2757 name
= (bfd_elf_string_from_elf_section
2758 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2759 if (name
== NULL
|| *name
== '\0')
2760 name
= bfd_section_name (sec
);
2763 if (r_symndx
!= STN_UNDEF
2764 && r_type
!= R_XTENSA_NONE
2766 || h
->root
.type
== bfd_link_hash_defined
2767 || h
->root
.type
== bfd_link_hash_defweak
)
2768 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2771 ((sym_type
== STT_TLS
2772 /* xgettext:c-format */
2773 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2774 /* xgettext:c-format */
2775 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2778 (uint64_t) rel
->r_offset
,
2783 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2785 tls_type
= GOT_UNKNOWN
;
2787 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2788 else if (local_got_tls_types
)
2789 tls_type
= local_got_tls_types
[r_symndx
];
2795 if (elf_hash_table (info
)->dynamic_sections_created
2796 && (input_section
->flags
& SEC_ALLOC
) != 0
2797 && (dynamic_symbol
|| bfd_link_pic (info
)))
2799 Elf_Internal_Rela outrel
;
2803 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2804 srel
= htab
->elf
.srelplt
;
2806 srel
= htab
->elf
.srelgot
;
2808 BFD_ASSERT (srel
!= NULL
);
2811 _bfd_elf_section_offset (output_bfd
, info
,
2812 input_section
, rel
->r_offset
);
2814 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2815 memset (&outrel
, 0, sizeof outrel
);
2818 outrel
.r_offset
+= (input_section
->output_section
->vma
2819 + input_section
->output_offset
);
2821 /* Complain if the relocation is in a read-only section
2822 and not in a literal pool. */
2823 if ((input_section
->flags
& SEC_READONLY
) != 0
2824 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2828 _("dynamic relocation in read-only section");
2829 (*info
->callbacks
->reloc_dangerous
)
2830 (info
, error_message
,
2831 input_bfd
, input_section
, rel
->r_offset
);
2836 outrel
.r_addend
= rel
->r_addend
;
2839 if (r_type
== R_XTENSA_32
)
2842 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2845 else /* r_type == R_XTENSA_PLT */
2848 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2850 /* Create the PLT entry and set the initial
2851 contents of the literal entry to the address of
2854 elf_xtensa_create_plt_entry (info
, output_bfd
,
2857 unresolved_reloc
= false;
2859 else if (!is_weak_undef
)
2861 /* Generate a RELATIVE relocation. */
2862 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2863 outrel
.r_addend
= 0;
2871 loc
= (srel
->contents
2872 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2873 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2874 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2877 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2879 /* This should only happen for non-PIC code, which is not
2880 supposed to be used on systems with dynamic linking.
2881 Just ignore these relocations. */
2886 case R_XTENSA_TLS_TPOFF
:
2887 /* Switch to LE model for local symbols in an executable. */
2888 if (! bfd_link_dll (info
) && ! dynamic_symbol
)
2890 relocation
= tpoff (info
, relocation
);
2895 case R_XTENSA_TLSDESC_FN
:
2896 case R_XTENSA_TLSDESC_ARG
:
2898 if (r_type
== R_XTENSA_TLSDESC_FN
)
2900 if (! bfd_link_dll (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2901 r_type
= R_XTENSA_NONE
;
2903 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2905 if (bfd_link_dll (info
))
2907 if ((tls_type
& GOT_TLS_IE
) != 0)
2908 r_type
= R_XTENSA_TLS_TPOFF
;
2912 r_type
= R_XTENSA_TLS_TPOFF
;
2913 if (! dynamic_symbol
)
2915 relocation
= tpoff (info
, relocation
);
2921 if (r_type
== R_XTENSA_NONE
)
2922 /* Nothing to do here; skip to the next reloc. */
2925 if (! elf_hash_table (info
)->dynamic_sections_created
)
2928 _("TLS relocation invalid without dynamic sections");
2929 (*info
->callbacks
->reloc_dangerous
)
2930 (info
, error_message
,
2931 input_bfd
, input_section
, rel
->r_offset
);
2935 Elf_Internal_Rela outrel
;
2937 asection
*srel
= htab
->elf
.srelgot
;
2940 outrel
.r_offset
= (input_section
->output_section
->vma
2941 + input_section
->output_offset
2944 /* Complain if the relocation is in a read-only section
2945 and not in a literal pool. */
2946 if ((input_section
->flags
& SEC_READONLY
) != 0
2947 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2951 _("dynamic relocation in read-only section");
2952 (*info
->callbacks
->reloc_dangerous
)
2953 (info
, error_message
,
2954 input_bfd
, input_section
, rel
->r_offset
);
2957 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2959 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2961 outrel
.r_addend
= 0;
2964 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2966 unresolved_reloc
= false;
2969 loc
= (srel
->contents
2970 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2971 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2972 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2978 case R_XTENSA_TLS_DTPOFF
:
2979 if (! bfd_link_dll (info
))
2980 /* Switch from LD model to LE model. */
2981 relocation
= tpoff (info
, relocation
);
2983 relocation
-= dtpoff_base (info
);
2986 case R_XTENSA_TLS_FUNC
:
2987 case R_XTENSA_TLS_ARG
:
2988 case R_XTENSA_TLS_CALL
:
2989 /* Check if optimizing to IE or LE model. */
2990 if ((tls_type
& GOT_TLS_IE
) != 0)
2993 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
2994 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
2995 is_ld_model
, &error_message
))
2996 (*info
->callbacks
->reloc_dangerous
)
2997 (info
, error_message
,
2998 input_bfd
, input_section
, rel
->r_offset
);
3000 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
3002 /* Skip subsequent relocations on the same instruction. */
3003 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
3010 if (elf_hash_table (info
)->dynamic_sections_created
3011 && dynamic_symbol
&& (is_operand_relocation (r_type
)
3012 || r_type
== R_XTENSA_32_PCREL
))
3015 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3016 strlen (name
) + 2, name
);
3017 (*info
->callbacks
->reloc_dangerous
)
3018 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3024 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3025 because such sections are not SEC_ALLOC and thus ld.so will
3026 not process them. */
3027 if (unresolved_reloc
3028 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3030 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3031 rel
->r_offset
) != (bfd_vma
) -1)
3034 /* xgettext:c-format */
3035 (_("%pB(%pA+%#" PRIx64
"): "
3036 "unresolvable %s relocation against symbol `%s'"),
3039 (uint64_t) rel
->r_offset
,
3045 /* TLS optimizations may have changed r_type; update "howto". */
3046 howto
= &elf_howto_table
[r_type
];
3048 /* There's no point in calling bfd_perform_relocation here.
3049 Just go directly to our "special function". */
3050 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
3051 relocation
+ rel
->r_addend
,
3052 contents
, rel
->r_offset
, is_weak_undef
,
3055 if (r
!= bfd_reloc_ok
&& !warned
)
3057 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
3058 BFD_ASSERT (error_message
!= NULL
);
3060 if (rel
->r_addend
== 0)
3061 error_message
= vsprint_msg (error_message
, ": %s",
3062 strlen (name
) + 2, name
);
3064 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
3066 name
, (int) rel
->r_addend
);
3068 (*info
->callbacks
->reloc_dangerous
)
3069 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3074 input_section
->reloc_done
= true;
3080 /* Finish up dynamic symbol handling. There's not much to do here since
3081 the PLT and GOT entries are all set up by relocate_section. */
3084 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3085 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3086 struct elf_link_hash_entry
*h
,
3087 Elf_Internal_Sym
*sym
)
3089 if (h
->needs_plt
&& !h
->def_regular
)
3091 /* Mark the symbol as undefined, rather than as defined in
3092 the .plt section. Leave the value alone. */
3093 sym
->st_shndx
= SHN_UNDEF
;
3094 /* If the symbol is weak, we do need to clear the value.
3095 Otherwise, the PLT entry would provide a definition for
3096 the symbol even if the symbol wasn't defined anywhere,
3097 and so the symbol would never be NULL. */
3098 if (!h
->ref_regular_nonweak
)
3102 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3103 if (h
== elf_hash_table (info
)->hdynamic
3104 || h
== elf_hash_table (info
)->hgot
)
3105 sym
->st_shndx
= SHN_ABS
;
3111 /* Combine adjacent literal table entries in the output. Adjacent
3112 entries within each input section may have been removed during
3113 relaxation, but we repeat the process here, even though it's too late
3114 to shrink the output section, because it's important to minimize the
3115 number of literal table entries to reduce the start-up work for the
3116 runtime linker. Returns the number of remaining table entries or -1
3120 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3125 property_table_entry
*table
;
3126 bfd_size_type section_size
, sgotloc_size
;
3130 section_size
= sxtlit
->size
;
3131 if (section_size
== 0)
3134 BFD_ASSERT (section_size
% 8 == 0);
3135 num
= section_size
/ 8;
3137 sgotloc_size
= sgotloc
->size
;
3138 if (sgotloc_size
!= section_size
)
3141 (_("internal inconsistency in size of .got.loc section"));
3145 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3149 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3150 propagates to the output section, where it doesn't really apply and
3151 where it breaks the following call to bfd_malloc_and_get_section. */
3152 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3154 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3161 /* There should never be any relocations left at this point, so this
3162 is quite a bit easier than what is done during relaxation. */
3164 /* Copy the raw contents into a property table array and sort it. */
3166 for (n
= 0; n
< num
; n
++)
3168 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3169 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3172 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3174 for (n
= 0; n
< num
; n
++)
3176 bool remove_entry
= false;
3178 if (table
[n
].size
== 0)
3179 remove_entry
= true;
3181 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3183 table
[n
-1].size
+= table
[n
].size
;
3184 remove_entry
= true;
3189 for (m
= n
; m
< num
- 1; m
++)
3191 table
[m
].address
= table
[m
+1].address
;
3192 table
[m
].size
= table
[m
+1].size
;
3200 /* Copy the data back to the raw contents. */
3202 for (n
= 0; n
< num
; n
++)
3204 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3205 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3209 /* Clear the removed bytes. */
3210 if ((bfd_size_type
) (num
* 8) < section_size
)
3211 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3213 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3217 /* Copy the contents to ".got.loc". */
3218 memcpy (sgotloc
->contents
, contents
, section_size
);
3226 /* Finish up the dynamic sections. */
3229 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3230 struct bfd_link_info
*info
)
3232 struct elf_xtensa_link_hash_table
*htab
;
3234 asection
*sdyn
, *srelplt
, *srelgot
, *sgot
, *sxtlit
, *sgotloc
;
3235 Elf32_External_Dyn
*dyncon
, *dynconend
;
3236 int num_xtlit_entries
= 0;
3238 if (! elf_hash_table (info
)->dynamic_sections_created
)
3241 htab
= elf_xtensa_hash_table (info
);
3245 dynobj
= elf_hash_table (info
)->dynobj
;
3246 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3247 BFD_ASSERT (sdyn
!= NULL
);
3249 /* Set the first entry in the global offset table to the address of
3250 the dynamic section. */
3251 sgot
= htab
->elf
.sgot
;
3254 BFD_ASSERT (sgot
->size
== 4);
3256 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3258 bfd_put_32 (output_bfd
,
3259 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3263 srelplt
= htab
->elf
.srelplt
;
3264 srelgot
= htab
->elf
.srelgot
;
3265 if (srelplt
&& srelplt
->size
!= 0)
3267 asection
*sgotplt
, *spltlittbl
;
3268 int chunk
, plt_chunks
, plt_entries
;
3269 Elf_Internal_Rela irela
;
3271 unsigned rtld_reloc
;
3273 spltlittbl
= htab
->spltlittbl
;
3274 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3276 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3277 of them follow immediately after.... */
3278 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3280 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3281 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3282 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3285 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3287 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3289 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3291 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3293 int chunk_entries
= 0;
3295 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3296 BFD_ASSERT (sgotplt
!= NULL
);
3298 /* Emit special RTLD relocations for the first two entries in
3299 each chunk of the .got.plt section. */
3301 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3302 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3303 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3304 irela
.r_offset
= (sgotplt
->output_section
->vma
3305 + sgotplt
->output_offset
);
3306 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3307 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3309 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3311 /* Next literal immediately follows the first. */
3312 loc
+= sizeof (Elf32_External_Rela
);
3313 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3314 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3315 irela
.r_offset
= (sgotplt
->output_section
->vma
3316 + sgotplt
->output_offset
+ 4);
3317 /* Tell rtld to set value to object's link map. */
3319 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3321 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3323 /* Fill in the literal table. */
3324 if (chunk
< plt_chunks
- 1)
3325 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3327 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3329 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3330 bfd_put_32 (output_bfd
,
3331 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3332 spltlittbl
->contents
+ (chunk
* 8) + 0);
3333 bfd_put_32 (output_bfd
,
3334 8 + (chunk_entries
* 4),
3335 spltlittbl
->contents
+ (chunk
* 8) + 4);
3338 /* The .xt.lit.plt section has just been modified. This must
3339 happen before the code below which combines adjacent literal
3340 table entries, and the .xt.lit.plt contents have to be forced to
3342 if (! bfd_set_section_contents (output_bfd
,
3343 spltlittbl
->output_section
,
3344 spltlittbl
->contents
,
3345 spltlittbl
->output_offset
,
3348 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3349 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3352 /* All the dynamic relocations have been emitted at this point.
3353 Make sure the relocation sections are the correct size. */
3354 if ((srelgot
&& srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3355 * srelgot
->reloc_count
))
3356 || (srelplt
&& srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3357 * srelplt
->reloc_count
)))
3360 /* Combine adjacent literal table entries. */
3361 BFD_ASSERT (! bfd_link_relocatable (info
));
3362 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3363 sgotloc
= htab
->sgotloc
;
3364 BFD_ASSERT (sgotloc
);
3368 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3369 if (num_xtlit_entries
< 0)
3373 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3374 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3375 for (; dyncon
< dynconend
; dyncon
++)
3377 Elf_Internal_Dyn dyn
;
3379 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3386 case DT_XTENSA_GOT_LOC_SZ
:
3387 dyn
.d_un
.d_val
= num_xtlit_entries
;
3390 case DT_XTENSA_GOT_LOC_OFF
:
3391 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3392 + htab
->sgotloc
->output_offset
);
3396 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3397 + htab
->elf
.sgot
->output_offset
);
3401 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3402 + htab
->elf
.srelplt
->output_offset
);
3406 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3410 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3417 /* Functions for dealing with the e_flags field. */
3419 /* Merge backend specific data from an object file to the output
3420 object file when linking. */
3423 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3425 bfd
*obfd
= info
->output_bfd
;
3426 unsigned out_mach
, in_mach
;
3427 flagword out_flag
, in_flag
;
3429 /* Check if we have the same endianness. */
3430 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3433 /* Don't even pretend to support mixed-format linking. */
3434 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3435 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3438 out_flag
= elf_elfheader (obfd
)->e_flags
;
3439 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3441 out_mach
= out_flag
& EF_XTENSA_MACH
;
3442 in_mach
= in_flag
& EF_XTENSA_MACH
;
3443 if (out_mach
!= in_mach
)
3446 /* xgettext:c-format */
3447 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3448 ibfd
, out_mach
, in_mach
);
3449 bfd_set_error (bfd_error_wrong_format
);
3453 if (! elf_flags_init (obfd
))
3455 elf_flags_init (obfd
) = true;
3456 elf_elfheader (obfd
)->e_flags
= in_flag
;
3458 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3459 && bfd_get_arch_info (obfd
)->the_default
)
3460 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3461 bfd_get_mach (ibfd
));
3466 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3467 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3469 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3470 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3477 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3479 BFD_ASSERT (!elf_flags_init (abfd
)
3480 || elf_elfheader (abfd
)->e_flags
== flags
);
3482 elf_elfheader (abfd
)->e_flags
|= flags
;
3483 elf_flags_init (abfd
) = true;
3490 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3492 FILE *f
= (FILE *) farg
;
3493 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3495 fprintf (f
, "\nXtensa header:\n");
3496 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3497 fprintf (f
, "\nMachine = Base\n");
3499 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3501 fprintf (f
, "Insn tables = %s\n",
3502 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3504 fprintf (f
, "Literal tables = %s\n",
3505 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3507 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3511 /* Set the right machine number for an Xtensa ELF file. */
3514 elf_xtensa_object_p (bfd
*abfd
)
3517 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3522 mach
= bfd_mach_xtensa
;
3528 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3533 /* The final processing done just before writing out an Xtensa ELF object
3534 file. This gets the Xtensa architecture right based on the machine
3538 elf_xtensa_final_write_processing (bfd
*abfd
)
3541 unsigned long val
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3543 switch (mach
= bfd_get_mach (abfd
))
3545 case bfd_mach_xtensa
:
3546 val
= E_XTENSA_MACH
;
3552 elf_elfheader (abfd
)->e_flags
&= ~EF_XTENSA_MACH
;
3553 elf_elfheader (abfd
)->e_flags
|= val
;
3554 return _bfd_elf_final_write_processing (abfd
);
3558 static enum elf_reloc_type_class
3559 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3560 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3561 const Elf_Internal_Rela
*rela
)
3563 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3565 case R_XTENSA_RELATIVE
:
3566 return reloc_class_relative
;
3567 case R_XTENSA_JMP_SLOT
:
3568 return reloc_class_plt
;
3570 return reloc_class_normal
;
3576 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3577 struct elf_reloc_cookie
*cookie
,
3578 struct bfd_link_info
*info
,
3582 bfd_vma offset
, actual_offset
;
3583 bfd_size_type removed_bytes
= 0;
3584 bfd_size_type entry_size
;
3586 if (sec
->output_section
3587 && bfd_is_abs_section (sec
->output_section
))
3590 if (xtensa_is_proptable_section (sec
))
3595 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3598 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3602 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3605 release_contents (sec
, contents
);
3609 /* Sort the relocations. They should already be in order when
3610 relaxation is enabled, but it might not be. */
3611 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3612 internal_reloc_compare
);
3614 cookie
->rel
= cookie
->rels
;
3615 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3617 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3619 actual_offset
= offset
- removed_bytes
;
3621 /* The ...symbol_deleted_p function will skip over relocs but it
3622 won't adjust their offsets, so do that here. */
3623 while (cookie
->rel
< cookie
->relend
3624 && cookie
->rel
->r_offset
< offset
)
3626 cookie
->rel
->r_offset
-= removed_bytes
;
3630 while (cookie
->rel
< cookie
->relend
3631 && cookie
->rel
->r_offset
== offset
)
3633 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3635 /* Remove the table entry. (If the reloc type is NONE, then
3636 the entry has already been merged with another and deleted
3637 during relaxation.) */
3638 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3640 /* Shift the contents up. */
3641 if (offset
+ entry_size
< sec
->size
)
3642 memmove (&contents
[actual_offset
],
3643 &contents
[actual_offset
+ entry_size
],
3644 sec
->size
- offset
- entry_size
);
3645 removed_bytes
+= entry_size
;
3648 /* Remove this relocation. */
3649 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3652 /* Adjust the relocation offset for previous removals. This
3653 should not be done before calling ...symbol_deleted_p
3654 because it might mess up the offset comparisons there.
3655 Make sure the offset doesn't underflow in the case where
3656 the first entry is removed. */
3657 if (cookie
->rel
->r_offset
>= removed_bytes
)
3658 cookie
->rel
->r_offset
-= removed_bytes
;
3660 cookie
->rel
->r_offset
= 0;
3666 if (removed_bytes
!= 0)
3668 /* Adjust any remaining relocs (shouldn't be any). */
3669 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3671 if (cookie
->rel
->r_offset
>= removed_bytes
)
3672 cookie
->rel
->r_offset
-= removed_bytes
;
3674 cookie
->rel
->r_offset
= 0;
3677 /* Clear the removed bytes. */
3678 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3680 pin_contents (sec
, contents
);
3681 pin_internal_relocs (sec
, cookie
->rels
);
3684 if (sec
->rawsize
== 0)
3685 sec
->rawsize
= sec
->size
;
3686 sec
->size
-= removed_bytes
;
3688 if (xtensa_is_littable_section (sec
))
3690 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3692 sgotloc
->size
-= removed_bytes
;
3697 release_contents (sec
, contents
);
3698 release_internal_relocs (sec
, cookie
->rels
);
3701 return (removed_bytes
!= 0);
3706 elf_xtensa_discard_info (bfd
*abfd
,
3707 struct elf_reloc_cookie
*cookie
,
3708 struct bfd_link_info
*info
)
3711 bool changed
= false;
3713 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3715 if (xtensa_is_property_section (sec
))
3717 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3727 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3729 return xtensa_is_property_section (sec
);
3734 elf_xtensa_action_discarded (asection
*sec
)
3736 if (strcmp (".xt_except_table", sec
->name
) == 0)
3739 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3742 return _bfd_elf_default_action_discarded (sec
);
3746 /* Support for core dump NOTE sections. */
3749 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3754 if (elf_tdata (abfd
) == NULL
3755 || elf_tdata (abfd
)->core
== NULL
)
3758 /* The size for Xtensa is variable, so don't try to recognize the format
3759 based on the size. Just assume this is GNU/Linux. */
3760 if (note
== NULL
|| note
->descsz
< 28)
3764 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3767 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3771 size
= note
->descsz
- offset
- 4;
3773 /* Make a ".reg/999" section. */
3774 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3775 size
, note
->descpos
+ offset
);
3779 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3781 switch (note
->descsz
)
3786 case 128: /* GNU/Linux elf_prpsinfo */
3787 elf_tdata (abfd
)->core
->program
3788 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3789 elf_tdata (abfd
)->core
->command
3790 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3793 /* Note that for some reason, a spurious space is tacked
3794 onto the end of the args in some (at least one anyway)
3795 implementations, so strip it off if it exists. */
3798 char *command
= elf_tdata (abfd
)->core
->command
;
3799 int n
= strlen (command
);
3801 if (0 < n
&& command
[n
- 1] == ' ')
3802 command
[n
- 1] = '\0';
3809 /* Generic Xtensa configurability stuff. */
3811 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3812 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3813 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3814 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3815 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3816 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3817 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3818 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3821 init_call_opcodes (void)
3823 if (callx0_op
== XTENSA_UNDEFINED
)
3825 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3826 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3827 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3828 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3829 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3830 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3831 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3832 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3838 is_indirect_call_opcode (xtensa_opcode opcode
)
3840 init_call_opcodes ();
3841 return (opcode
== callx0_op
3842 || opcode
== callx4_op
3843 || opcode
== callx8_op
3844 || opcode
== callx12_op
);
3849 is_direct_call_opcode (xtensa_opcode opcode
)
3851 init_call_opcodes ();
3852 return (opcode
== call0_op
3853 || opcode
== call4_op
3854 || opcode
== call8_op
3855 || opcode
== call12_op
);
3860 is_windowed_call_opcode (xtensa_opcode opcode
)
3862 init_call_opcodes ();
3863 return (opcode
== call4_op
3864 || opcode
== call8_op
3865 || opcode
== call12_op
3866 || opcode
== callx4_op
3867 || opcode
== callx8_op
3868 || opcode
== callx12_op
);
3873 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3875 unsigned dst
= (unsigned) -1;
3877 init_call_opcodes ();
3878 if (opcode
== callx0_op
)
3880 else if (opcode
== callx4_op
)
3882 else if (opcode
== callx8_op
)
3884 else if (opcode
== callx12_op
)
3887 if (dst
== (unsigned) -1)
3895 static xtensa_opcode
3896 get_const16_opcode (void)
3898 static bool done_lookup
= false;
3899 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3902 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3905 return const16_opcode
;
3909 static xtensa_opcode
3910 get_l32r_opcode (void)
3912 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3913 static bool done_lookup
= false;
3917 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3925 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3929 offset
= addr
- ((pc
+3) & -4);
3930 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3931 offset
= (signed int) offset
>> 2;
3932 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3937 static xtensa_opcode
3938 get_rsr_lend_opcode (void)
3940 static xtensa_opcode rsr_lend_opcode
= XTENSA_UNDEFINED
;
3941 static bool done_lookup
= false;
3944 rsr_lend_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "rsr.lend");
3947 return rsr_lend_opcode
;
3950 static xtensa_opcode
3951 get_wsr_lbeg_opcode (void)
3953 static xtensa_opcode wsr_lbeg_opcode
= XTENSA_UNDEFINED
;
3954 static bool done_lookup
= false;
3957 wsr_lbeg_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "wsr.lbeg");
3960 return wsr_lbeg_opcode
;
3965 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3967 xtensa_isa isa
= xtensa_default_isa
;
3968 int last_immed
, last_opnd
, opi
;
3970 if (opcode
== XTENSA_UNDEFINED
)
3971 return XTENSA_UNDEFINED
;
3973 /* Find the last visible PC-relative immediate operand for the opcode.
3974 If there are no PC-relative immediates, then choose the last visible
3975 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3976 last_immed
= XTENSA_UNDEFINED
;
3977 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3978 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3980 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3982 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3987 if (last_immed
== XTENSA_UNDEFINED
3988 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3992 return XTENSA_UNDEFINED
;
3994 /* If the operand number was specified in an old-style relocation,
3995 check for consistency with the operand computed above. */
3996 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3998 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3999 if (reloc_opnd
!= last_immed
)
4000 return XTENSA_UNDEFINED
;
4008 get_relocation_slot (int r_type
)
4018 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4019 return r_type
- R_XTENSA_SLOT0_OP
;
4020 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4021 return r_type
- R_XTENSA_SLOT0_ALT
;
4025 return XTENSA_UNDEFINED
;
4029 /* Get the opcode for a relocation. */
4031 static xtensa_opcode
4032 get_relocation_opcode (bfd
*abfd
,
4035 Elf_Internal_Rela
*irel
)
4037 static xtensa_insnbuf ibuff
= NULL
;
4038 static xtensa_insnbuf sbuff
= NULL
;
4039 xtensa_isa isa
= xtensa_default_isa
;
4043 if (contents
== NULL
)
4044 return XTENSA_UNDEFINED
;
4046 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
4047 return XTENSA_UNDEFINED
;
4051 ibuff
= xtensa_insnbuf_alloc (isa
);
4052 sbuff
= xtensa_insnbuf_alloc (isa
);
4055 /* Decode the instruction. */
4056 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
4057 sec
->size
- irel
->r_offset
);
4058 fmt
= xtensa_format_decode (isa
, ibuff
);
4059 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
4060 if (slot
== XTENSA_UNDEFINED
)
4061 return XTENSA_UNDEFINED
;
4062 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
4063 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
4068 is_l32r_relocation (bfd
*abfd
,
4071 Elf_Internal_Rela
*irel
)
4073 xtensa_opcode opcode
;
4074 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
4076 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
4077 return (opcode
== get_l32r_opcode ());
4081 static bfd_size_type
4082 get_asm_simplify_size (bfd_byte
*contents
,
4083 bfd_size_type content_len
,
4084 bfd_size_type offset
)
4086 bfd_size_type insnlen
, size
= 0;
4088 /* Decode the size of the next two instructions. */
4089 insnlen
= insn_decode_len (contents
, content_len
, offset
);
4095 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
4105 is_alt_relocation (int r_type
)
4107 return (r_type
>= R_XTENSA_SLOT0_ALT
4108 && r_type
<= R_XTENSA_SLOT14_ALT
);
4113 is_operand_relocation (int r_type
)
4123 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4125 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4134 #define MIN_INSN_LENGTH 2
4136 /* Return 0 if it fails to decode. */
4139 insn_decode_len (bfd_byte
*contents
,
4140 bfd_size_type content_len
,
4141 bfd_size_type offset
)
4144 xtensa_isa isa
= xtensa_default_isa
;
4146 static xtensa_insnbuf ibuff
= NULL
;
4148 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4152 ibuff
= xtensa_insnbuf_alloc (isa
);
4153 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4154 content_len
- offset
);
4155 fmt
= xtensa_format_decode (isa
, ibuff
);
4156 if (fmt
== XTENSA_UNDEFINED
)
4158 insn_len
= xtensa_format_length (isa
, fmt
);
4159 if (insn_len
== XTENSA_UNDEFINED
)
4165 insn_num_slots (bfd_byte
*contents
,
4166 bfd_size_type content_len
,
4167 bfd_size_type offset
)
4169 xtensa_isa isa
= xtensa_default_isa
;
4171 static xtensa_insnbuf ibuff
= NULL
;
4173 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4174 return XTENSA_UNDEFINED
;
4177 ibuff
= xtensa_insnbuf_alloc (isa
);
4178 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4179 content_len
- offset
);
4180 fmt
= xtensa_format_decode (isa
, ibuff
);
4181 if (fmt
== XTENSA_UNDEFINED
)
4182 return XTENSA_UNDEFINED
;
4183 return xtensa_format_num_slots (isa
, fmt
);
4187 /* Decode the opcode for a single slot instruction.
4188 Return 0 if it fails to decode or the instruction is multi-slot. */
4191 insn_decode_opcode (bfd_byte
*contents
,
4192 bfd_size_type content_len
,
4193 bfd_size_type offset
,
4196 xtensa_isa isa
= xtensa_default_isa
;
4198 static xtensa_insnbuf insnbuf
= NULL
;
4199 static xtensa_insnbuf slotbuf
= NULL
;
4201 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4202 return XTENSA_UNDEFINED
;
4204 if (insnbuf
== NULL
)
4206 insnbuf
= xtensa_insnbuf_alloc (isa
);
4207 slotbuf
= xtensa_insnbuf_alloc (isa
);
4210 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4211 content_len
- offset
);
4212 fmt
= xtensa_format_decode (isa
, insnbuf
);
4213 if (fmt
== XTENSA_UNDEFINED
)
4214 return XTENSA_UNDEFINED
;
4216 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4217 return XTENSA_UNDEFINED
;
4219 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4220 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4224 /* The offset is the offset in the contents.
4225 The address is the address of that offset. */
4228 check_branch_target_aligned (bfd_byte
*contents
,
4229 bfd_size_type content_length
,
4233 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4236 return check_branch_target_aligned_address (address
, insn_len
);
4241 check_loop_aligned (bfd_byte
*contents
,
4242 bfd_size_type content_length
,
4246 bfd_size_type loop_len
, insn_len
;
4247 xtensa_opcode opcode
;
4249 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4250 if (opcode
== XTENSA_UNDEFINED
4251 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4257 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4258 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4259 if (loop_len
== 0 || insn_len
== 0)
4265 /* If this is relaxed loop, analyze first instruction of the actual loop
4266 body. It must be at offset 27 from the loop instruction address. */
4268 && insn_num_slots (contents
, content_length
, offset
+ loop_len
) == 1
4269 && insn_decode_opcode (contents
, content_length
,
4270 offset
+ loop_len
, 0) == get_rsr_lend_opcode()
4271 && insn_decode_len (contents
, content_length
, offset
+ loop_len
+ 3) == 3
4272 && insn_num_slots (contents
, content_length
, offset
+ loop_len
+ 3) == 1
4273 && insn_decode_opcode (contents
, content_length
,
4274 offset
+ loop_len
+ 3, 0) == get_wsr_lbeg_opcode())
4277 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4279 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4284 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4287 return (addr
% 8 == 0);
4288 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4292 /* Instruction widening and narrowing. */
4294 /* When FLIX is available we need to access certain instructions only
4295 when they are 16-bit or 24-bit instructions. This table caches
4296 information about such instructions by walking through all the
4297 opcodes and finding the smallest single-slot format into which each
4300 static xtensa_format
*op_single_fmt_table
= NULL
;
4304 init_op_single_format_table (void)
4306 xtensa_isa isa
= xtensa_default_isa
;
4307 xtensa_insnbuf ibuf
;
4308 xtensa_opcode opcode
;
4312 if (op_single_fmt_table
)
4315 ibuf
= xtensa_insnbuf_alloc (isa
);
4316 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4318 op_single_fmt_table
= (xtensa_format
*)
4319 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4320 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4322 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4323 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4325 if (xtensa_format_num_slots (isa
, fmt
) == 1
4326 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4328 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4329 int fmt_length
= xtensa_format_length (isa
, fmt
);
4330 if (old_fmt
== XTENSA_UNDEFINED
4331 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4332 op_single_fmt_table
[opcode
] = fmt
;
4336 xtensa_insnbuf_free (isa
, ibuf
);
4340 static xtensa_format
4341 get_single_format (xtensa_opcode opcode
)
4343 init_op_single_format_table ();
4344 return op_single_fmt_table
[opcode
];
4348 /* For the set of narrowable instructions we do NOT include the
4349 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4350 involved during linker relaxation that may require these to
4351 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4352 requires special case code to ensure it only works when op1 == op2. */
4360 const struct string_pair narrowable
[] =
4363 { "addi", "addi.n" },
4364 { "addmi", "addi.n" },
4365 { "l32i", "l32i.n" },
4366 { "movi", "movi.n" },
4368 { "retw", "retw.n" },
4369 { "s32i", "s32i.n" },
4370 { "or", "mov.n" } /* special case only when op1 == op2 */
4373 const struct string_pair widenable
[] =
4376 { "addi", "addi.n" },
4377 { "addmi", "addi.n" },
4378 { "beqz", "beqz.n" },
4379 { "bnez", "bnez.n" },
4380 { "l32i", "l32i.n" },
4381 { "movi", "movi.n" },
4383 { "retw", "retw.n" },
4384 { "s32i", "s32i.n" },
4385 { "or", "mov.n" } /* special case only when op1 == op2 */
4389 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4390 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4391 return the instruction buffer holding the narrow instruction. Otherwise,
4392 return 0. The set of valid narrowing are specified by a string table
4393 but require some special case operand checks in some cases. */
4395 static xtensa_insnbuf
4396 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4398 xtensa_opcode opcode
)
4400 xtensa_isa isa
= xtensa_default_isa
;
4401 xtensa_format o_fmt
;
4404 static xtensa_insnbuf o_insnbuf
= NULL
;
4405 static xtensa_insnbuf o_slotbuf
= NULL
;
4407 if (o_insnbuf
== NULL
)
4409 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4410 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4413 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4415 bool is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4417 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4419 uint32 value
, newval
;
4420 int i
, operand_count
, o_operand_count
;
4421 xtensa_opcode o_opcode
;
4423 /* Address does not matter in this case. We might need to
4424 fix it to handle branches/jumps. */
4425 bfd_vma self_address
= 0;
4427 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4428 if (o_opcode
== XTENSA_UNDEFINED
)
4430 o_fmt
= get_single_format (o_opcode
);
4431 if (o_fmt
== XTENSA_UNDEFINED
)
4434 if (xtensa_format_length (isa
, fmt
) != 3
4435 || xtensa_format_length (isa
, o_fmt
) != 2)
4438 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4439 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4440 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4442 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4447 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4452 uint32 rawval0
, rawval1
, rawval2
;
4454 if (o_operand_count
+ 1 != operand_count
4455 || xtensa_operand_get_field (isa
, opcode
, 0,
4456 fmt
, 0, slotbuf
, &rawval0
) != 0
4457 || xtensa_operand_get_field (isa
, opcode
, 1,
4458 fmt
, 0, slotbuf
, &rawval1
) != 0
4459 || xtensa_operand_get_field (isa
, opcode
, 2,
4460 fmt
, 0, slotbuf
, &rawval2
) != 0
4461 || rawval1
!= rawval2
4462 || rawval0
== rawval1
/* it is a nop */)
4466 for (i
= 0; i
< o_operand_count
; ++i
)
4468 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4470 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4473 /* PC-relative branches need adjustment, but
4474 the PC-rel operand will always have a relocation. */
4476 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4478 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4479 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4484 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4494 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4495 the action in-place directly into the contents and return TRUE. Otherwise,
4496 the return value is FALSE and the contents are not modified. */
4499 narrow_instruction (bfd_byte
*contents
,
4500 bfd_size_type content_length
,
4501 bfd_size_type offset
)
4503 xtensa_opcode opcode
;
4504 bfd_size_type insn_len
;
4505 xtensa_isa isa
= xtensa_default_isa
;
4507 xtensa_insnbuf o_insnbuf
;
4509 static xtensa_insnbuf insnbuf
= NULL
;
4510 static xtensa_insnbuf slotbuf
= NULL
;
4512 if (insnbuf
== NULL
)
4514 insnbuf
= xtensa_insnbuf_alloc (isa
);
4515 slotbuf
= xtensa_insnbuf_alloc (isa
);
4518 BFD_ASSERT (offset
< content_length
);
4520 if (content_length
< 2)
4523 /* We will hand-code a few of these for a little while.
4524 These have all been specified in the assembler aleady. */
4525 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4526 content_length
- offset
);
4527 fmt
= xtensa_format_decode (isa
, insnbuf
);
4528 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4531 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4534 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4535 if (opcode
== XTENSA_UNDEFINED
)
4537 insn_len
= xtensa_format_length (isa
, fmt
);
4538 if (insn_len
> content_length
)
4541 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4544 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4545 content_length
- offset
);
4553 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4554 "density" instruction to a standard 3-byte instruction. If it is valid,
4555 return the instruction buffer holding the wide instruction. Otherwise,
4556 return 0. The set of valid widenings are specified by a string table
4557 but require some special case operand checks in some cases. */
4559 static xtensa_insnbuf
4560 can_widen_instruction (xtensa_insnbuf slotbuf
,
4562 xtensa_opcode opcode
)
4564 xtensa_isa isa
= xtensa_default_isa
;
4565 xtensa_format o_fmt
;
4568 static xtensa_insnbuf o_insnbuf
= NULL
;
4569 static xtensa_insnbuf o_slotbuf
= NULL
;
4571 if (o_insnbuf
== NULL
)
4573 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4574 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4577 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4579 bool is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4580 bool is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4581 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4583 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4585 uint32 value
, newval
;
4586 int i
, operand_count
, o_operand_count
, check_operand_count
;
4587 xtensa_opcode o_opcode
;
4589 /* Address does not matter in this case. We might need to fix it
4590 to handle branches/jumps. */
4591 bfd_vma self_address
= 0;
4593 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4594 if (o_opcode
== XTENSA_UNDEFINED
)
4596 o_fmt
= get_single_format (o_opcode
);
4597 if (o_fmt
== XTENSA_UNDEFINED
)
4600 if (xtensa_format_length (isa
, fmt
) != 2
4601 || xtensa_format_length (isa
, o_fmt
) != 3)
4604 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4605 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4606 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4607 check_operand_count
= o_operand_count
;
4609 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4614 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4619 uint32 rawval0
, rawval1
;
4621 if (o_operand_count
!= operand_count
+ 1
4622 || xtensa_operand_get_field (isa
, opcode
, 0,
4623 fmt
, 0, slotbuf
, &rawval0
) != 0
4624 || xtensa_operand_get_field (isa
, opcode
, 1,
4625 fmt
, 0, slotbuf
, &rawval1
) != 0
4626 || rawval0
== rawval1
/* it is a nop */)
4630 check_operand_count
--;
4632 for (i
= 0; i
< check_operand_count
; i
++)
4635 if (is_or
&& i
== o_operand_count
- 1)
4637 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4639 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4642 /* PC-relative branches need adjustment, but
4643 the PC-rel operand will always have a relocation. */
4645 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4647 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4648 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4653 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4663 /* Attempt to widen an instruction. If the widening is valid, perform
4664 the action in-place directly into the contents and return TRUE. Otherwise,
4665 the return value is FALSE and the contents are not modified. */
4668 widen_instruction (bfd_byte
*contents
,
4669 bfd_size_type content_length
,
4670 bfd_size_type offset
)
4672 xtensa_opcode opcode
;
4673 bfd_size_type insn_len
;
4674 xtensa_isa isa
= xtensa_default_isa
;
4676 xtensa_insnbuf o_insnbuf
;
4678 static xtensa_insnbuf insnbuf
= NULL
;
4679 static xtensa_insnbuf slotbuf
= NULL
;
4681 if (insnbuf
== NULL
)
4683 insnbuf
= xtensa_insnbuf_alloc (isa
);
4684 slotbuf
= xtensa_insnbuf_alloc (isa
);
4687 BFD_ASSERT (offset
< content_length
);
4689 if (content_length
< 2)
4692 /* We will hand-code a few of these for a little while.
4693 These have all been specified in the assembler aleady. */
4694 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4695 content_length
- offset
);
4696 fmt
= xtensa_format_decode (isa
, insnbuf
);
4697 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4700 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4703 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4704 if (opcode
== XTENSA_UNDEFINED
)
4706 insn_len
= xtensa_format_length (isa
, fmt
);
4707 if (insn_len
> content_length
)
4710 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4713 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4714 content_length
- offset
);
4721 /* Code for transforming CALLs at link-time. */
4723 static bfd_reloc_status_type
4724 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4726 bfd_vma content_length
,
4727 char **error_message
)
4729 static xtensa_insnbuf insnbuf
= NULL
;
4730 static xtensa_insnbuf slotbuf
= NULL
;
4731 xtensa_format core_format
= XTENSA_UNDEFINED
;
4732 xtensa_opcode opcode
;
4733 xtensa_opcode direct_call_opcode
;
4734 xtensa_isa isa
= xtensa_default_isa
;
4735 bfd_byte
*chbuf
= contents
+ address
;
4738 if (insnbuf
== NULL
)
4740 insnbuf
= xtensa_insnbuf_alloc (isa
);
4741 slotbuf
= xtensa_insnbuf_alloc (isa
);
4744 if (content_length
< address
)
4746 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4747 return bfd_reloc_other
;
4750 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4751 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4752 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4754 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4755 return bfd_reloc_other
;
4758 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4759 core_format
= xtensa_format_lookup (isa
, "x24");
4760 opcode
= xtensa_opcode_lookup (isa
, "or");
4761 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4762 for (opn
= 0; opn
< 3; opn
++)
4765 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4766 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4769 xtensa_format_encode (isa
, core_format
, insnbuf
);
4770 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4771 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4773 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4774 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4775 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4777 xtensa_format_encode (isa
, core_format
, insnbuf
);
4778 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4779 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4780 content_length
- address
- 3);
4782 return bfd_reloc_ok
;
4786 static bfd_reloc_status_type
4787 contract_asm_expansion (bfd_byte
*contents
,
4788 bfd_vma content_length
,
4789 Elf_Internal_Rela
*irel
,
4790 char **error_message
)
4792 bfd_reloc_status_type retval
=
4793 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4796 if (retval
!= bfd_reloc_ok
)
4797 return bfd_reloc_dangerous
;
4799 /* Update the irel->r_offset field so that the right immediate and
4800 the right instruction are modified during the relocation. */
4801 irel
->r_offset
+= 3;
4802 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4803 return bfd_reloc_ok
;
4807 static xtensa_opcode
4808 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4810 init_call_opcodes ();
4812 if (opcode
== callx0_op
) return call0_op
;
4813 if (opcode
== callx4_op
) return call4_op
;
4814 if (opcode
== callx8_op
) return call8_op
;
4815 if (opcode
== callx12_op
) return call12_op
;
4817 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4818 return XTENSA_UNDEFINED
;
4822 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4823 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4824 If not, return XTENSA_UNDEFINED. */
4826 #define L32R_TARGET_REG_OPERAND 0
4827 #define CONST16_TARGET_REG_OPERAND 0
4828 #define CALLN_SOURCE_OPERAND 0
4830 static xtensa_opcode
4831 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bool *p_uses_l32r
)
4833 static xtensa_insnbuf insnbuf
= NULL
;
4834 static xtensa_insnbuf slotbuf
= NULL
;
4836 xtensa_opcode opcode
;
4837 xtensa_isa isa
= xtensa_default_isa
;
4838 uint32 regno
, const16_regno
, call_regno
;
4841 if (insnbuf
== NULL
)
4843 insnbuf
= xtensa_insnbuf_alloc (isa
);
4844 slotbuf
= xtensa_insnbuf_alloc (isa
);
4847 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4848 fmt
= xtensa_format_decode (isa
, insnbuf
);
4849 if (fmt
== XTENSA_UNDEFINED
4850 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4851 return XTENSA_UNDEFINED
;
4853 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4854 if (opcode
== XTENSA_UNDEFINED
)
4855 return XTENSA_UNDEFINED
;
4857 if (opcode
== get_l32r_opcode ())
4860 *p_uses_l32r
= true;
4861 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4862 fmt
, 0, slotbuf
, ®no
)
4863 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4865 return XTENSA_UNDEFINED
;
4867 else if (opcode
== get_const16_opcode ())
4870 *p_uses_l32r
= false;
4871 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4872 fmt
, 0, slotbuf
, ®no
)
4873 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4875 return XTENSA_UNDEFINED
;
4877 /* Check that the next instruction is also CONST16. */
4878 offset
+= xtensa_format_length (isa
, fmt
);
4879 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4880 fmt
= xtensa_format_decode (isa
, insnbuf
);
4881 if (fmt
== XTENSA_UNDEFINED
4882 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4883 return XTENSA_UNDEFINED
;
4884 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4885 if (opcode
!= get_const16_opcode ())
4886 return XTENSA_UNDEFINED
;
4888 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4889 fmt
, 0, slotbuf
, &const16_regno
)
4890 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4892 || const16_regno
!= regno
)
4893 return XTENSA_UNDEFINED
;
4896 return XTENSA_UNDEFINED
;
4898 /* Next instruction should be an CALLXn with operand 0 == regno. */
4899 offset
+= xtensa_format_length (isa
, fmt
);
4900 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4901 fmt
= xtensa_format_decode (isa
, insnbuf
);
4902 if (fmt
== XTENSA_UNDEFINED
4903 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4904 return XTENSA_UNDEFINED
;
4905 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4906 if (opcode
== XTENSA_UNDEFINED
4907 || !is_indirect_call_opcode (opcode
))
4908 return XTENSA_UNDEFINED
;
4910 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4911 fmt
, 0, slotbuf
, &call_regno
)
4912 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4914 return XTENSA_UNDEFINED
;
4916 if (call_regno
!= regno
)
4917 return XTENSA_UNDEFINED
;
4923 /* Data structures used during relaxation. */
4925 /* r_reloc: relocation values. */
4927 /* Through the relaxation process, we need to keep track of the values
4928 that will result from evaluating relocations. The standard ELF
4929 relocation structure is not sufficient for this purpose because we're
4930 operating on multiple input files at once, so we need to know which
4931 input file a relocation refers to. The r_reloc structure thus
4932 records both the input file (bfd) and ELF relocation.
4934 For efficiency, an r_reloc also contains a "target_offset" field to
4935 cache the target-section-relative offset value that is represented by
4938 The r_reloc also contains a virtual offset that allows multiple
4939 inserted literals to be placed at the same "address" with
4940 different offsets. */
4942 typedef struct r_reloc_struct r_reloc
;
4944 struct r_reloc_struct
4947 Elf_Internal_Rela rela
;
4948 bfd_vma target_offset
;
4949 bfd_vma virtual_offset
;
4953 /* The r_reloc structure is included by value in literal_value, but not
4954 every literal_value has an associated relocation -- some are simple
4955 constants. In such cases, we set all the fields in the r_reloc
4956 struct to zero. The r_reloc_is_const function should be used to
4957 detect this case. */
4960 r_reloc_is_const (const r_reloc
*r_rel
)
4962 return (r_rel
->abfd
== NULL
);
4967 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4969 bfd_vma target_offset
;
4970 unsigned long r_symndx
;
4972 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4973 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4974 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4975 return (target_offset
+ r_rel
->rela
.r_addend
);
4979 static struct elf_link_hash_entry
*
4980 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4982 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4983 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4988 r_reloc_get_section (const r_reloc
*r_rel
)
4990 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4991 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4996 r_reloc_is_defined (const r_reloc
*r_rel
)
5002 sec
= r_reloc_get_section (r_rel
);
5003 if (sec
== bfd_abs_section_ptr
5004 || sec
== bfd_com_section_ptr
5005 || sec
== bfd_und_section_ptr
)
5012 r_reloc_init (r_reloc
*r_rel
,
5014 Elf_Internal_Rela
*irel
,
5016 bfd_size_type content_length
)
5019 reloc_howto_type
*howto
;
5023 r_rel
->rela
= *irel
;
5025 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
5026 r_rel
->virtual_offset
= 0;
5027 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
5028 howto
= &elf_howto_table
[r_type
];
5029 if (howto
->partial_inplace
)
5031 bfd_vma inplace_val
;
5032 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
5034 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
5035 r_rel
->target_offset
+= inplace_val
;
5039 memset (r_rel
, 0, sizeof (r_reloc
));
5046 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
5048 if (r_reloc_is_defined (r_rel
))
5050 asection
*sec
= r_reloc_get_section (r_rel
);
5051 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
5053 else if (r_reloc_get_hash_entry (r_rel
))
5054 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
5056 fprintf (fp
, " ?? + ");
5058 fprintf (fp
, "%" PRIx64
, (uint64_t) r_rel
->target_offset
);
5059 if (r_rel
->virtual_offset
)
5060 fprintf (fp
, " + %" PRIx64
, (uint64_t) r_rel
->virtual_offset
);
5068 /* source_reloc: relocations that reference literals. */
5070 /* To determine whether literals can be coalesced, we need to first
5071 record all the relocations that reference the literals. The
5072 source_reloc structure below is used for this purpose. The
5073 source_reloc entries are kept in a per-literal-section array, sorted
5074 by offset within the literal section (i.e., target offset).
5076 The source_sec and r_rel.rela.r_offset fields identify the source of
5077 the relocation. The r_rel field records the relocation value, i.e.,
5078 the offset of the literal being referenced. The opnd field is needed
5079 to determine the range of the immediate field to which the relocation
5080 applies, so we can determine whether another literal with the same
5081 value is within range. The is_null field is true when the relocation
5082 is being removed (e.g., when an L32R is being removed due to a CALLX
5083 that is converted to a direct CALL). */
5085 typedef struct source_reloc_struct source_reloc
;
5087 struct source_reloc_struct
5089 asection
*source_sec
;
5091 xtensa_opcode opcode
;
5094 bool is_abs_literal
;
5099 init_source_reloc (source_reloc
*reloc
,
5100 asection
*source_sec
,
5101 const r_reloc
*r_rel
,
5102 xtensa_opcode opcode
,
5104 bool is_abs_literal
)
5106 reloc
->source_sec
= source_sec
;
5107 reloc
->r_rel
= *r_rel
;
5108 reloc
->opcode
= opcode
;
5110 reloc
->is_null
= false;
5111 reloc
->is_abs_literal
= is_abs_literal
;
5115 /* Find the source_reloc for a particular source offset and relocation
5116 type. Note that the array is sorted by _target_ offset, so this is
5117 just a linear search. */
5119 static source_reloc
*
5120 find_source_reloc (source_reloc
*src_relocs
,
5123 Elf_Internal_Rela
*irel
)
5127 for (i
= 0; i
< src_count
; i
++)
5129 if (src_relocs
[i
].source_sec
== sec
5130 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
5131 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
5132 == ELF32_R_TYPE (irel
->r_info
)))
5133 return &src_relocs
[i
];
5141 source_reloc_compare (const void *ap
, const void *bp
)
5143 const source_reloc
*a
= (const source_reloc
*) ap
;
5144 const source_reloc
*b
= (const source_reloc
*) bp
;
5146 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
5147 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5149 /* We don't need to sort on these criteria for correctness,
5150 but enforcing a more strict ordering prevents unstable qsort
5151 from behaving differently with different implementations.
5152 Without the code below we get correct but different results
5153 on Solaris 2.7 and 2.8. We would like to always produce the
5154 same results no matter the host. */
5156 if ((!a
->is_null
) - (!b
->is_null
))
5157 return ((!a
->is_null
) - (!b
->is_null
));
5158 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5162 /* Literal values and value hash tables. */
5164 /* Literals with the same value can be coalesced. The literal_value
5165 structure records the value of a literal: the "r_rel" field holds the
5166 information from the relocation on the literal (if there is one) and
5167 the "value" field holds the contents of the literal word itself.
5169 The value_map structure records a literal value along with the
5170 location of a literal holding that value. The value_map hash table
5171 is indexed by the literal value, so that we can quickly check if a
5172 particular literal value has been seen before and is thus a candidate
5175 typedef struct literal_value_struct literal_value
;
5176 typedef struct value_map_struct value_map
;
5177 typedef struct value_map_hash_table_struct value_map_hash_table
;
5179 struct literal_value_struct
5182 unsigned long value
;
5183 bool is_abs_literal
;
5186 struct value_map_struct
5188 literal_value val
; /* The literal value. */
5189 r_reloc loc
; /* Location of the literal. */
5193 struct value_map_hash_table_struct
5195 unsigned bucket_count
;
5196 value_map
**buckets
;
5204 init_literal_value (literal_value
*lit
,
5205 const r_reloc
*r_rel
,
5206 unsigned long value
,
5207 bool is_abs_literal
)
5209 lit
->r_rel
= *r_rel
;
5211 lit
->is_abs_literal
= is_abs_literal
;
5216 literal_value_equal (const literal_value
*src1
,
5217 const literal_value
*src2
,
5218 bool final_static_link
)
5220 struct elf_link_hash_entry
*h1
, *h2
;
5222 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5225 if (r_reloc_is_const (&src1
->r_rel
))
5226 return (src1
->value
== src2
->value
);
5228 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5229 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5232 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5235 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5238 if (src1
->value
!= src2
->value
)
5241 /* Now check for the same section (if defined) or the same elf_hash
5242 (if undefined or weak). */
5243 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5244 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5245 if (r_reloc_is_defined (&src1
->r_rel
)
5246 && (final_static_link
5247 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5248 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5250 if (r_reloc_get_section (&src1
->r_rel
)
5251 != r_reloc_get_section (&src2
->r_rel
))
5256 /* Require that the hash entries (i.e., symbols) be identical. */
5257 if (h1
!= h2
|| h1
== 0)
5261 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5268 /* Must be power of 2. */
5269 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5271 static value_map_hash_table
*
5272 value_map_hash_table_init (void)
5274 value_map_hash_table
*values
;
5276 values
= (value_map_hash_table
*)
5277 bfd_zmalloc (sizeof (value_map_hash_table
));
5278 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5280 values
->buckets
= (value_map
**)
5281 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5282 if (values
->buckets
== NULL
)
5287 values
->has_last_loc
= false;
5294 value_map_hash_table_delete (value_map_hash_table
*table
)
5296 free (table
->buckets
);
5302 hash_bfd_vma (bfd_vma val
)
5304 return (val
>> 2) + (val
>> 10);
5309 literal_value_hash (const literal_value
*src
)
5313 hash_val
= hash_bfd_vma (src
->value
);
5314 if (!r_reloc_is_const (&src
->r_rel
))
5318 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5319 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5320 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5322 /* Now check for the same section and the same elf_hash. */
5323 if (r_reloc_is_defined (&src
->r_rel
))
5324 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5326 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5327 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5333 /* Check if the specified literal_value has been seen before. */
5336 value_map_get_cached_value (value_map_hash_table
*map
,
5337 const literal_value
*val
,
5338 bool final_static_link
)
5344 idx
= literal_value_hash (val
);
5345 idx
= idx
& (map
->bucket_count
- 1);
5346 bucket
= map
->buckets
[idx
];
5347 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5349 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5356 /* Record a new literal value. It is illegal to call this if VALUE
5357 already has an entry here. */
5360 add_value_map (value_map_hash_table
*map
,
5361 const literal_value
*val
,
5363 bool final_static_link
)
5365 value_map
**bucket_p
;
5368 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5371 bfd_set_error (bfd_error_no_memory
);
5375 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5379 idx
= literal_value_hash (val
);
5380 idx
= idx
& (map
->bucket_count
- 1);
5381 bucket_p
= &map
->buckets
[idx
];
5383 val_e
->next
= *bucket_p
;
5386 /* FIXME: Consider resizing the hash table if we get too many entries. */
5392 /* Lists of text actions (ta_) for narrowing, widening, longcall
5393 conversion, space fill, code & literal removal, etc. */
5395 /* The following text actions are generated:
5397 "ta_remove_insn" remove an instruction or instructions
5398 "ta_remove_longcall" convert longcall to call
5399 "ta_convert_longcall" convert longcall to nop/call
5400 "ta_narrow_insn" narrow a wide instruction
5401 "ta_widen" widen a narrow instruction
5402 "ta_fill" add fill or remove fill
5403 removed < 0 is a fill; branches to the fill address will be
5404 changed to address + fill size (e.g., address - removed)
5405 removed >= 0 branches to the fill address will stay unchanged
5406 "ta_remove_literal" remove a literal; this action is
5407 indicated when a literal is removed
5409 "ta_add_literal" insert a new literal; this action is
5410 indicated when a literal has been moved.
5411 It may use a virtual_offset because
5412 multiple literals can be placed at the
5415 For each of these text actions, we also record the number of bytes
5416 removed by performing the text action. In the case of a "ta_widen"
5417 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5419 typedef struct text_action_struct text_action
;
5420 typedef struct text_action_list_struct text_action_list
;
5421 typedef enum text_action_enum_t text_action_t
;
5423 enum text_action_enum_t
5426 ta_remove_insn
, /* removed = -size */
5427 ta_remove_longcall
, /* removed = -size */
5428 ta_convert_longcall
, /* removed = 0 */
5429 ta_narrow_insn
, /* removed = -1 */
5430 ta_widen_insn
, /* removed = +1 */
5431 ta_fill
, /* removed = +size */
5437 /* Structure for a text action record. */
5438 struct text_action_struct
5440 text_action_t action
;
5441 asection
*sec
; /* Optional */
5443 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5445 literal_value value
; /* Only valid when adding literals. */
5448 struct removal_by_action_entry_struct
5453 int eq_removed_before_fill
;
5455 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5457 struct removal_by_action_map_struct
5460 removal_by_action_entry
*entry
;
5462 typedef struct removal_by_action_map_struct removal_by_action_map
;
5465 /* List of all of the actions taken on a text section. */
5466 struct text_action_list_struct
5470 removal_by_action_map map
;
5474 static text_action
*
5475 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5479 /* It is not necessary to fill at the end of a section. */
5480 if (sec
->size
== offset
)
5486 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5488 return (text_action
*)node
->value
;
5494 compute_removed_action_diff (const text_action
*ta
,
5498 int removable_space
)
5501 int current_removed
= 0;
5504 current_removed
= ta
->removed_bytes
;
5506 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5507 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5509 /* It is not necessary to fill at the end of a section. Clean this up. */
5510 if (sec
->size
== offset
)
5511 new_removed
= removable_space
- 0;
5515 int added
= -removed
- current_removed
;
5516 /* Ignore multiples of the section alignment. */
5517 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5518 new_removed
= (-added
);
5520 /* Modify for removable. */
5521 space
= removable_space
- new_removed
;
5522 new_removed
= (removable_space
5523 - (((1 << sec
->alignment_power
) - 1) & space
));
5525 return (new_removed
- current_removed
);
5530 adjust_fill_action (text_action
*ta
, int fill_diff
)
5532 ta
->removed_bytes
+= fill_diff
;
5537 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5539 text_action
*pa
= (text_action
*)a
;
5540 text_action
*pb
= (text_action
*)b
;
5541 static const int action_priority
[] =
5545 [ta_convert_longcall
] = 2,
5546 [ta_narrow_insn
] = 3,
5547 [ta_remove_insn
] = 4,
5548 [ta_remove_longcall
] = 5,
5549 [ta_remove_literal
] = 6,
5550 [ta_widen_insn
] = 7,
5551 [ta_add_literal
] = 8,
5554 if (pa
->offset
== pb
->offset
)
5556 if (pa
->action
== pb
->action
)
5558 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5561 return pa
->offset
< pb
->offset
? -1 : 1;
5564 static text_action
*
5565 action_first (text_action_list
*action_list
)
5567 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5568 return node
? (text_action
*)node
->value
: NULL
;
5571 static text_action
*
5572 action_next (text_action_list
*action_list
, text_action
*action
)
5574 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5575 (splay_tree_key
)action
);
5576 return node
? (text_action
*)node
->value
: NULL
;
5579 /* Add a modification action to the text. For the case of adding or
5580 removing space, modify any current fill and assume that
5581 "unreachable_space" bytes can be freely contracted. Note that a
5582 negative removed value is a fill. */
5585 text_action_add (text_action_list
*l
,
5586 text_action_t action
,
5594 /* It is not necessary to fill at the end of a section. */
5595 if (action
== ta_fill
&& sec
->size
== offset
)
5598 /* It is not necessary to fill 0 bytes. */
5599 if (action
== ta_fill
&& removed
== 0)
5605 if (action
== ta_fill
)
5607 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5611 ta
= (text_action
*)node
->value
;
5612 ta
->removed_bytes
+= removed
;
5617 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5619 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5620 ta
->action
= action
;
5622 ta
->offset
= offset
;
5623 ta
->removed_bytes
= removed
;
5624 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5630 text_action_add_literal (text_action_list
*l
,
5631 text_action_t action
,
5633 const literal_value
*value
,
5637 asection
*sec
= r_reloc_get_section (loc
);
5638 bfd_vma offset
= loc
->target_offset
;
5639 bfd_vma virtual_offset
= loc
->virtual_offset
;
5641 BFD_ASSERT (action
== ta_add_literal
);
5643 /* Create a new record and fill it up. */
5644 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5645 ta
->action
= action
;
5647 ta
->offset
= offset
;
5648 ta
->virtual_offset
= virtual_offset
;
5650 ta
->removed_bytes
= removed
;
5652 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5653 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5658 /* Find the total offset adjustment for the relaxations specified by
5659 text_actions, beginning from a particular starting action. This is
5660 typically used from offset_with_removed_text to search an entire list of
5661 actions, but it may also be called directly when adjusting adjacent offsets
5662 so that each search may begin where the previous one left off. */
5665 removed_by_actions (text_action_list
*action_list
,
5666 text_action
**p_start_action
,
5673 r
= *p_start_action
;
5676 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5678 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5683 if (r
->offset
> offset
)
5686 if (r
->offset
== offset
5687 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5690 removed
+= r
->removed_bytes
;
5692 r
= action_next (action_list
, r
);
5695 *p_start_action
= r
;
5701 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5703 text_action
*r
= action_first (action_list
);
5705 return offset
- removed_by_actions (action_list
, &r
, offset
, false);
5710 action_list_count (text_action_list
*action_list
)
5712 return action_list
->count
;
5715 typedef struct map_action_fn_context_struct map_action_fn_context
;
5716 struct map_action_fn_context_struct
5719 removal_by_action_map map
;
5724 map_action_fn (splay_tree_node node
, void *p
)
5726 map_action_fn_context
*ctx
= p
;
5727 text_action
*r
= (text_action
*)node
->value
;
5728 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5730 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5736 ++ctx
->map
.n_entries
;
5737 ctx
->eq_complete
= false;
5738 ientry
->offset
= r
->offset
;
5739 ientry
->eq_removed_before_fill
= ctx
->removed
;
5742 if (!ctx
->eq_complete
)
5744 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5746 ientry
->eq_removed
= ctx
->removed
;
5747 ctx
->eq_complete
= true;
5750 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5753 ctx
->removed
+= r
->removed_bytes
;
5754 ientry
->removed
= ctx
->removed
;
5759 map_removal_by_action (text_action_list
*action_list
)
5761 map_action_fn_context ctx
;
5764 ctx
.map
.n_entries
= 0;
5765 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5766 sizeof (removal_by_action_entry
));
5767 ctx
.eq_complete
= false;
5769 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5770 action_list
->map
= ctx
.map
;
5774 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5779 if (!action_list
->map
.entry
)
5780 map_removal_by_action (action_list
);
5782 if (!action_list
->map
.n_entries
)
5786 b
= action_list
->map
.n_entries
;
5790 unsigned c
= (a
+ b
) / 2;
5792 if (action_list
->map
.entry
[c
].offset
<= offset
)
5798 if (action_list
->map
.entry
[a
].offset
< offset
)
5800 return action_list
->map
.entry
[a
].removed
;
5802 else if (action_list
->map
.entry
[a
].offset
== offset
)
5804 return before_fill
?
5805 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5806 action_list
->map
.entry
[a
].eq_removed
;
5815 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5817 int removed
= removed_by_actions_map (action_list
, offset
, false);
5818 return offset
- removed
;
5822 /* The find_insn_action routine will only find non-fill actions. */
5824 static text_action
*
5825 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5827 static const text_action_t action
[] =
5829 ta_convert_longcall
,
5839 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5841 splay_tree_node node
;
5843 a
.action
= action
[i
];
5844 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5846 return (text_action
*)node
->value
;
5855 print_action (FILE *fp
, text_action
*r
)
5857 const char *t
= "unknown";
5860 case ta_remove_insn
:
5861 t
= "remove_insn"; break;
5862 case ta_remove_longcall
:
5863 t
= "remove_longcall"; break;
5864 case ta_convert_longcall
:
5865 t
= "convert_longcall"; break;
5866 case ta_narrow_insn
:
5867 t
= "narrow_insn"; break;
5869 t
= "widen_insn"; break;
5874 case ta_remove_literal
:
5875 t
= "remove_literal"; break;
5876 case ta_add_literal
:
5877 t
= "add_literal"; break;
5880 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5881 r
->sec
->owner
->filename
,
5882 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5886 print_action_list_fn (splay_tree_node node
, void *p
)
5888 text_action
*r
= (text_action
*)node
->value
;
5890 print_action (p
, r
);
5895 print_action_list (FILE *fp
, text_action_list
*action_list
)
5897 fprintf (fp
, "Text Action\n");
5898 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5904 /* Lists of literals being coalesced or removed. */
5906 /* In the usual case, the literal identified by "from" is being
5907 coalesced with another literal identified by "to". If the literal is
5908 unused and is being removed altogether, "to.abfd" will be NULL.
5909 The removed_literal entries are kept on a per-section list, sorted
5910 by the "from" offset field. */
5912 typedef struct removed_literal_struct removed_literal
;
5913 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5914 typedef struct removed_literal_list_struct removed_literal_list
;
5916 struct removed_literal_struct
5920 removed_literal
*next
;
5923 struct removed_literal_map_entry_struct
5926 removed_literal
*literal
;
5929 struct removed_literal_list_struct
5931 removed_literal
*head
;
5932 removed_literal
*tail
;
5935 removed_literal_map_entry
*map
;
5939 /* Record that the literal at "from" is being removed. If "to" is not
5940 NULL, the "from" literal is being coalesced with the "to" literal. */
5943 add_removed_literal (removed_literal_list
*removed_list
,
5944 const r_reloc
*from
,
5947 removed_literal
*r
, *new_r
, *next_r
;
5949 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5951 new_r
->from
= *from
;
5955 new_r
->to
.abfd
= NULL
;
5958 r
= removed_list
->head
;
5961 removed_list
->head
= new_r
;
5962 removed_list
->tail
= new_r
;
5964 /* Special check for common case of append. */
5965 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5967 removed_list
->tail
->next
= new_r
;
5968 removed_list
->tail
= new_r
;
5972 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5978 new_r
->next
= next_r
;
5980 removed_list
->tail
= new_r
;
5985 map_removed_literal (removed_literal_list
*removed_list
)
5989 removed_literal_map_entry
*map
= NULL
;
5990 removed_literal
*r
= removed_list
->head
;
5992 for (i
= 0; r
; ++i
, r
= r
->next
)
5996 n_map
= (n_map
* 2) + 2;
5997 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5999 map
[i
].addr
= r
->from
.target_offset
;
6002 removed_list
->map
= map
;
6003 removed_list
->n_map
= i
;
6007 removed_literal_compare (const void *a
, const void *b
)
6009 const bfd_vma
*key
= a
;
6010 const removed_literal_map_entry
*memb
= b
;
6012 if (*key
== memb
->addr
)
6015 return *key
< memb
->addr
? -1 : 1;
6018 /* Check if the list of removed literals contains an entry for the
6019 given address. Return the entry if found. */
6021 static removed_literal
*
6022 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
6024 removed_literal_map_entry
*p
;
6025 removed_literal
*r
= NULL
;
6027 if (removed_list
->map
== NULL
)
6028 map_removed_literal (removed_list
);
6030 if (removed_list
->map
!= NULL
)
6032 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
6033 sizeof (*removed_list
->map
), removed_literal_compare
);
6036 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
6048 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
6051 r
= removed_list
->head
;
6053 fprintf (fp
, "Removed Literals\n");
6054 for (; r
!= NULL
; r
= r
->next
)
6056 print_r_reloc (fp
, &r
->from
);
6057 fprintf (fp
, " => ");
6058 if (r
->to
.abfd
== NULL
)
6059 fprintf (fp
, "REMOVED");
6061 print_r_reloc (fp
, &r
->to
);
6069 /* Per-section data for relaxation. */
6071 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
6073 struct xtensa_relax_info_struct
6075 bool is_relaxable_literal_section
;
6076 bool is_relaxable_asm_section
;
6077 int visited
; /* Number of times visited. */
6079 source_reloc
*src_relocs
; /* Array[src_count]. */
6081 int src_next
; /* Next src_relocs entry to assign. */
6083 removed_literal_list removed_list
;
6084 text_action_list action_list
;
6086 reloc_bfd_fix
*fix_list
;
6087 reloc_bfd_fix
*fix_array
;
6088 unsigned fix_array_count
;
6090 /* Support for expanding the reloc array that is stored
6091 in the section structure. If the relocations have been
6092 reallocated, the newly allocated relocations will be referenced
6093 here along with the actual size allocated. The relocation
6094 count will always be found in the section structure. */
6095 Elf_Internal_Rela
*allocated_relocs
;
6096 unsigned relocs_count
;
6097 unsigned allocated_relocs_count
;
6100 struct elf_xtensa_section_data
6102 struct bfd_elf_section_data elf
;
6103 xtensa_relax_info relax_info
;
6108 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
6110 if (!sec
->used_by_bfd
)
6112 struct elf_xtensa_section_data
*sdata
;
6113 size_t amt
= sizeof (*sdata
);
6115 sdata
= bfd_zalloc (abfd
, amt
);
6118 sec
->used_by_bfd
= sdata
;
6121 return _bfd_elf_new_section_hook (abfd
, sec
);
6125 static xtensa_relax_info
*
6126 get_xtensa_relax_info (asection
*sec
)
6128 struct elf_xtensa_section_data
*section_data
;
6130 /* No info available if no section or if it is an output section. */
6131 if (!sec
|| sec
== sec
->output_section
)
6134 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
6135 return §ion_data
->relax_info
;
6140 init_xtensa_relax_info (asection
*sec
)
6142 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6144 relax_info
->is_relaxable_literal_section
= false;
6145 relax_info
->is_relaxable_asm_section
= false;
6146 relax_info
->visited
= 0;
6148 relax_info
->src_relocs
= NULL
;
6149 relax_info
->src_count
= 0;
6150 relax_info
->src_next
= 0;
6152 relax_info
->removed_list
.head
= NULL
;
6153 relax_info
->removed_list
.tail
= NULL
;
6155 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6157 relax_info
->action_list
.map
.n_entries
= 0;
6158 relax_info
->action_list
.map
.entry
= NULL
;
6160 relax_info
->fix_list
= NULL
;
6161 relax_info
->fix_array
= NULL
;
6162 relax_info
->fix_array_count
= 0;
6164 relax_info
->allocated_relocs
= NULL
;
6165 relax_info
->relocs_count
= 0;
6166 relax_info
->allocated_relocs_count
= 0;
6170 /* Coalescing literals may require a relocation to refer to a section in
6171 a different input file, but the standard relocation information
6172 cannot express that. Instead, the reloc_bfd_fix structures are used
6173 to "fix" the relocations that refer to sections in other input files.
6174 These structures are kept on per-section lists. The "src_type" field
6175 records the relocation type in case there are multiple relocations on
6176 the same location. FIXME: This is ugly; an alternative might be to
6177 add new symbols with the "owner" field to some other input file. */
6179 struct reloc_bfd_fix_struct
6183 unsigned src_type
; /* Relocation type. */
6185 asection
*target_sec
;
6186 bfd_vma target_offset
;
6189 reloc_bfd_fix
*next
;
6193 static reloc_bfd_fix
*
6194 reloc_bfd_fix_init (asection
*src_sec
,
6197 asection
*target_sec
,
6198 bfd_vma target_offset
,
6203 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6204 fix
->src_sec
= src_sec
;
6205 fix
->src_offset
= src_offset
;
6206 fix
->src_type
= src_type
;
6207 fix
->target_sec
= target_sec
;
6208 fix
->target_offset
= target_offset
;
6209 fix
->translated
= translated
;
6216 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6218 xtensa_relax_info
*relax_info
;
6220 relax_info
= get_xtensa_relax_info (src_sec
);
6221 fix
->next
= relax_info
->fix_list
;
6222 relax_info
->fix_list
= fix
;
6227 fix_compare (const void *ap
, const void *bp
)
6229 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6230 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6232 if (a
->src_offset
!= b
->src_offset
)
6233 return (a
->src_offset
- b
->src_offset
);
6234 return (a
->src_type
- b
->src_type
);
6239 cache_fix_array (asection
*sec
)
6241 unsigned i
, count
= 0;
6243 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6245 if (relax_info
== NULL
)
6247 if (relax_info
->fix_list
== NULL
)
6250 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6253 relax_info
->fix_array
=
6254 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6255 relax_info
->fix_array_count
= count
;
6257 r
= relax_info
->fix_list
;
6258 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6260 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6261 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6264 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6265 sizeof (reloc_bfd_fix
), fix_compare
);
6269 static reloc_bfd_fix
*
6270 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6272 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6276 if (relax_info
== NULL
)
6278 if (relax_info
->fix_list
== NULL
)
6281 if (relax_info
->fix_array
== NULL
)
6282 cache_fix_array (sec
);
6284 key
.src_offset
= offset
;
6285 key
.src_type
= type
;
6286 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6287 sizeof (reloc_bfd_fix
), fix_compare
);
6292 /* Section caching. */
6294 typedef struct section_cache_struct section_cache_t
;
6296 struct section_cache_struct
6300 bfd_byte
*contents
; /* Cache of the section contents. */
6301 bfd_size_type content_length
;
6303 property_table_entry
*ptbl
; /* Cache of the section property table. */
6306 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6307 unsigned reloc_count
;
6312 init_section_cache (section_cache_t
*sec_cache
)
6314 memset (sec_cache
, 0, sizeof (*sec_cache
));
6319 free_section_cache (section_cache_t
*sec_cache
)
6323 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6324 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6325 free (sec_cache
->ptbl
);
6331 section_cache_section (section_cache_t
*sec_cache
,
6333 struct bfd_link_info
*link_info
)
6336 property_table_entry
*prop_table
= NULL
;
6338 bfd_byte
*contents
= NULL
;
6339 Elf_Internal_Rela
*internal_relocs
= NULL
;
6340 bfd_size_type sec_size
;
6344 if (sec
== sec_cache
->sec
)
6348 sec_size
= bfd_get_section_limit (abfd
, sec
);
6350 /* Get the contents. */
6351 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6352 if (contents
== NULL
&& sec_size
!= 0)
6355 /* Get the relocations. */
6356 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6357 link_info
->keep_memory
);
6359 /* Get the entry table. */
6360 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6361 XTENSA_PROP_SEC_NAME
, false);
6365 /* Fill in the new section cache. */
6366 free_section_cache (sec_cache
);
6367 init_section_cache (sec_cache
);
6369 sec_cache
->sec
= sec
;
6370 sec_cache
->contents
= contents
;
6371 sec_cache
->content_length
= sec_size
;
6372 sec_cache
->relocs
= internal_relocs
;
6373 sec_cache
->reloc_count
= sec
->reloc_count
;
6374 sec_cache
->pte_count
= ptblsize
;
6375 sec_cache
->ptbl
= prop_table
;
6380 release_contents (sec
, contents
);
6381 release_internal_relocs (sec
, internal_relocs
);
6387 /* Extended basic blocks. */
6389 /* An ebb_struct represents an Extended Basic Block. Within this
6390 range, we guarantee that all instructions are decodable, the
6391 property table entries are contiguous, and no property table
6392 specifies a segment that cannot have instructions moved. This
6393 structure contains caches of the contents, property table and
6394 relocations for the specified section for easy use. The range is
6395 specified by ranges of indices for the byte offset, property table
6396 offsets and relocation offsets. These must be consistent. */
6398 typedef struct ebb_struct ebb_t
;
6404 bfd_byte
*contents
; /* Cache of the section contents. */
6405 bfd_size_type content_length
;
6407 property_table_entry
*ptbl
; /* Cache of the section property table. */
6410 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6411 unsigned reloc_count
;
6413 bfd_vma start_offset
; /* Offset in section. */
6414 unsigned start_ptbl_idx
; /* Offset in the property table. */
6415 unsigned start_reloc_idx
; /* Offset in the relocations. */
6418 unsigned end_ptbl_idx
;
6419 unsigned end_reloc_idx
;
6421 bool ends_section
; /* Is this the last ebb in a section? */
6423 /* The unreachable property table at the end of this set of blocks;
6424 NULL if the end is not an unreachable block. */
6425 property_table_entry
*ends_unreachable
;
6429 enum ebb_target_enum
6432 EBB_DESIRE_TGT_ALIGN
,
6433 EBB_REQUIRE_TGT_ALIGN
,
6434 EBB_REQUIRE_LOOP_ALIGN
,
6439 /* proposed_action_struct is similar to the text_action_struct except
6440 that is represents a potential transformation, not one that will
6441 occur. We build a list of these for an extended basic block
6442 and use them to compute the actual actions desired. We must be
6443 careful that the entire set of actual actions we perform do not
6444 break any relocations that would fit if the actions were not
6447 typedef struct proposed_action_struct proposed_action
;
6449 struct proposed_action_struct
6451 enum ebb_target_enum align_type
; /* for the target alignment */
6452 bfd_vma alignment_pow
;
6453 text_action_t action
;
6456 bool do_action
; /* If false, then we will not perform the action. */
6460 /* The ebb_constraint_struct keeps a set of proposed actions for an
6461 extended basic block. */
6463 typedef struct ebb_constraint_struct ebb_constraint
;
6465 struct ebb_constraint_struct
6470 /* Bytes of extra space at the beginning if movable. */
6471 int start_extra_space
;
6473 enum ebb_target_enum start_align
;
6477 /* Bytes of extra space at the end if movable. */
6478 int end_extra_space
;
6480 unsigned action_count
;
6481 unsigned action_allocated
;
6483 /* Array of proposed actions. */
6484 proposed_action
*actions
;
6486 /* Action alignments -- one for each proposed action. */
6487 enum ebb_target_enum
*action_aligns
;
6492 init_ebb_constraint (ebb_constraint
*c
)
6494 memset (c
, 0, sizeof (ebb_constraint
));
6499 free_ebb_constraint (ebb_constraint
*c
)
6506 init_ebb (ebb_t
*ebb
,
6509 bfd_size_type content_length
,
6510 property_table_entry
*prop_table
,
6512 Elf_Internal_Rela
*internal_relocs
,
6513 unsigned reloc_count
)
6515 memset (ebb
, 0, sizeof (ebb_t
));
6517 ebb
->contents
= contents
;
6518 ebb
->content_length
= content_length
;
6519 ebb
->ptbl
= prop_table
;
6520 ebb
->pte_count
= ptblsize
;
6521 ebb
->relocs
= internal_relocs
;
6522 ebb
->reloc_count
= reloc_count
;
6523 ebb
->start_offset
= 0;
6524 ebb
->end_offset
= ebb
->content_length
- 1;
6525 ebb
->start_ptbl_idx
= 0;
6526 ebb
->end_ptbl_idx
= ptblsize
;
6527 ebb
->start_reloc_idx
= 0;
6528 ebb
->end_reloc_idx
= reloc_count
;
6532 /* Extend the ebb to all decodable contiguous sections. The algorithm
6533 for building a basic block around an instruction is to push it
6534 forward until we hit the end of a section, an unreachable block or
6535 a block that cannot be transformed. Then we push it backwards
6536 searching for similar conditions. */
6538 static bool extend_ebb_bounds_forward (ebb_t
*);
6539 static bool extend_ebb_bounds_backward (ebb_t
*);
6540 static bfd_size_type insn_block_decodable_len
6541 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6544 extend_ebb_bounds (ebb_t
*ebb
)
6546 if (!extend_ebb_bounds_forward (ebb
))
6548 if (!extend_ebb_bounds_backward (ebb
))
6555 extend_ebb_bounds_forward (ebb_t
*ebb
)
6557 property_table_entry
*the_entry
, *new_entry
;
6559 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6561 /* Stop when (1) we cannot decode an instruction, (2) we are at
6562 the end of the property tables, (3) we hit a non-contiguous property
6563 table entry, (4) we hit a NO_TRANSFORM region. */
6568 bfd_size_type insn_block_len
;
6570 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6572 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6574 entry_end
- ebb
->end_offset
);
6575 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6578 /* xgettext:c-format */
6579 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6580 "possible configuration mismatch"),
6581 ebb
->sec
->owner
, ebb
->sec
,
6582 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6585 ebb
->end_offset
+= insn_block_len
;
6587 if (ebb
->end_offset
== ebb
->sec
->size
)
6588 ebb
->ends_section
= true;
6590 /* Update the reloc counter. */
6591 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6592 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6595 ebb
->end_reloc_idx
++;
6598 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6601 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6602 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6603 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6604 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6607 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6610 the_entry
= new_entry
;
6611 ebb
->end_ptbl_idx
++;
6614 /* Quick check for an unreachable or end of file just at the end. */
6615 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6617 if (ebb
->end_offset
== ebb
->content_length
)
6618 ebb
->ends_section
= true;
6622 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6623 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6624 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6625 ebb
->ends_unreachable
= new_entry
;
6628 /* Any other ending requires exact alignment. */
6634 extend_ebb_bounds_backward (ebb_t
*ebb
)
6636 property_table_entry
*the_entry
, *new_entry
;
6638 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6640 /* Stop when (1) we cannot decode the instructions in the current entry.
6641 (2) we are at the beginning of the property tables, (3) we hit a
6642 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6646 bfd_vma block_begin
;
6647 bfd_size_type insn_block_len
;
6649 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6651 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6653 ebb
->start_offset
- block_begin
);
6654 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6657 /* xgettext:c-format */
6658 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6659 "possible configuration mismatch"),
6660 ebb
->sec
->owner
, ebb
->sec
,
6661 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6664 ebb
->start_offset
-= insn_block_len
;
6666 /* Update the reloc counter. */
6667 while (ebb
->start_reloc_idx
> 0
6668 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6669 >= ebb
->start_offset
))
6671 ebb
->start_reloc_idx
--;
6674 if (ebb
->start_ptbl_idx
== 0)
6677 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6678 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6679 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6680 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6682 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6685 the_entry
= new_entry
;
6686 ebb
->start_ptbl_idx
--;
6692 static bfd_size_type
6693 insn_block_decodable_len (bfd_byte
*contents
,
6694 bfd_size_type content_len
,
6695 bfd_vma block_offset
,
6696 bfd_size_type block_len
)
6698 bfd_vma offset
= block_offset
;
6700 while (offset
< block_offset
+ block_len
)
6702 bfd_size_type insn_len
= 0;
6704 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6706 return (offset
- block_offset
);
6709 return (offset
- block_offset
);
6714 ebb_propose_action (ebb_constraint
*c
,
6715 enum ebb_target_enum align_type
,
6716 bfd_vma alignment_pow
,
6717 text_action_t action
,
6722 proposed_action
*act
;
6724 if (c
->action_allocated
<= c
->action_count
)
6726 unsigned new_allocated
, i
;
6727 proposed_action
*new_actions
;
6729 new_allocated
= (c
->action_count
+ 2) * 2;
6730 new_actions
= (proposed_action
*)
6731 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6733 for (i
= 0; i
< c
->action_count
; i
++)
6734 new_actions
[i
] = c
->actions
[i
];
6736 c
->actions
= new_actions
;
6737 c
->action_allocated
= new_allocated
;
6740 act
= &c
->actions
[c
->action_count
];
6741 act
->align_type
= align_type
;
6742 act
->alignment_pow
= alignment_pow
;
6743 act
->action
= action
;
6744 act
->offset
= offset
;
6745 act
->removed_bytes
= removed_bytes
;
6746 act
->do_action
= do_action
;
6752 /* Access to internal relocations, section contents and symbols. */
6754 /* During relaxation, we need to modify relocations, section contents,
6755 and symbol definitions, and we need to keep the original values from
6756 being reloaded from the input files, i.e., we need to "pin" the
6757 modified values in memory. We also want to continue to observe the
6758 setting of the "keep-memory" flag. The following functions wrap the
6759 standard BFD functions to take care of this for us. */
6761 static Elf_Internal_Rela
*
6762 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bool keep_memory
)
6764 Elf_Internal_Rela
*internal_relocs
;
6766 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6769 internal_relocs
= elf_section_data (sec
)->relocs
;
6770 if (internal_relocs
== NULL
)
6771 internal_relocs
= (_bfd_elf_link_read_relocs
6772 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6773 return internal_relocs
;
6778 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6780 elf_section_data (sec
)->relocs
= internal_relocs
;
6785 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6787 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
6788 free (internal_relocs
);
6793 retrieve_contents (bfd
*abfd
, asection
*sec
, bool keep_memory
)
6796 bfd_size_type sec_size
;
6798 sec_size
= bfd_get_section_limit (abfd
, sec
);
6799 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6801 if (contents
== NULL
&& sec_size
!= 0)
6803 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6809 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6816 pin_contents (asection
*sec
, bfd_byte
*contents
)
6818 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6823 release_contents (asection
*sec
, bfd_byte
*contents
)
6825 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6830 static Elf_Internal_Sym
*
6831 retrieve_local_syms (bfd
*input_bfd
)
6833 Elf_Internal_Shdr
*symtab_hdr
;
6834 Elf_Internal_Sym
*isymbuf
;
6837 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6838 locsymcount
= symtab_hdr
->sh_info
;
6840 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6841 if (isymbuf
== NULL
&& locsymcount
!= 0)
6842 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6845 /* Save the symbols for this input file so they won't be read again. */
6846 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6847 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6853 /* Code for link-time relaxation. */
6855 /* Initialization for relaxation: */
6856 static bool analyze_relocations (struct bfd_link_info
*);
6857 static bool find_relaxable_sections
6858 (bfd
*, asection
*, struct bfd_link_info
*, bool *);
6859 static bool collect_source_relocs
6860 (bfd
*, asection
*, struct bfd_link_info
*);
6861 static bool is_resolvable_asm_expansion
6862 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6864 static Elf_Internal_Rela
*find_associated_l32r_irel
6865 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6866 static bool compute_text_actions
6867 (bfd
*, asection
*, struct bfd_link_info
*);
6868 static bool compute_ebb_proposed_actions (ebb_constraint
*);
6869 static bool compute_ebb_actions (ebb_constraint
*);
6870 typedef struct reloc_range_list_struct reloc_range_list
;
6871 static bool check_section_ebb_pcrels_fit
6872 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6873 reloc_range_list
*, const ebb_constraint
*,
6874 const xtensa_opcode
*);
6875 static bool check_section_ebb_reduces (const ebb_constraint
*);
6876 static void text_action_add_proposed
6877 (text_action_list
*, const ebb_constraint
*, asection
*);
6880 static bool compute_removed_literals
6881 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6882 static Elf_Internal_Rela
*get_irel_at_offset
6883 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6884 static bool is_removable_literal
6885 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6886 property_table_entry
*, int);
6887 static bool remove_dead_literal
6888 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6889 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6890 static bool identify_literal_placement
6891 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6892 value_map_hash_table
*, bool *, Elf_Internal_Rela
*, int,
6893 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6895 static bool relocations_reach (source_reloc
*, int, const r_reloc
*);
6896 static bool coalesce_shared_literal
6897 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6898 static bool move_shared_literal
6899 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6900 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6903 static bool relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6904 static bool translate_section_fixes (asection
*);
6905 static bool translate_reloc_bfd_fix (reloc_bfd_fix
*);
6906 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6907 static void shrink_dynamic_reloc_sections
6908 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6909 static bool move_literal
6910 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6911 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6912 static bool relax_property_section
6913 (bfd
*, asection
*, struct bfd_link_info
*);
6916 static bool relax_section_symbols (bfd
*, asection
*);
6920 elf_xtensa_relax_section (bfd
*abfd
,
6922 struct bfd_link_info
*link_info
,
6925 static value_map_hash_table
*values
= NULL
;
6926 static bool relocations_analyzed
= false;
6927 xtensa_relax_info
*relax_info
;
6929 if (!relocations_analyzed
)
6931 /* Do some overall initialization for relaxation. */
6932 values
= value_map_hash_table_init ();
6935 relaxing_section
= true;
6936 if (!analyze_relocations (link_info
))
6938 relocations_analyzed
= true;
6942 /* Don't mess with linker-created sections. */
6943 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6946 relax_info
= get_xtensa_relax_info (sec
);
6947 BFD_ASSERT (relax_info
!= NULL
);
6949 switch (relax_info
->visited
)
6952 /* Note: It would be nice to fold this pass into
6953 analyze_relocations, but it is important for this step that the
6954 sections be examined in link order. */
6955 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6962 value_map_hash_table_delete (values
);
6964 if (!relax_section (abfd
, sec
, link_info
))
6970 if (!relax_section_symbols (abfd
, sec
))
6975 relax_info
->visited
++;
6980 /* Initialization for relaxation. */
6982 /* This function is called once at the start of relaxation. It scans
6983 all the input sections and marks the ones that are relaxable (i.e.,
6984 literal sections with L32R relocations against them), and then
6985 collects source_reloc information for all the relocations against
6986 those relaxable sections. During this process, it also detects
6987 longcalls, i.e., calls relaxed by the assembler into indirect
6988 calls, that can be optimized back into direct calls. Within each
6989 extended basic block (ebb) containing an optimized longcall, it
6990 computes a set of "text actions" that can be performed to remove
6991 the L32R associated with the longcall while optionally preserving
6992 branch target alignments. */
6995 analyze_relocations (struct bfd_link_info
*link_info
)
6999 bool is_relaxable
= false;
7001 /* Initialize the per-section relaxation info. */
7002 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7003 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7005 init_xtensa_relax_info (sec
);
7008 /* Mark relaxable sections (and count relocations against each one). */
7009 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7010 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7012 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
7016 /* Bail out if there are no relaxable sections. */
7020 /* Allocate space for source_relocs. */
7021 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7022 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7024 xtensa_relax_info
*relax_info
;
7026 relax_info
= get_xtensa_relax_info (sec
);
7027 if (relax_info
->is_relaxable_literal_section
7028 || relax_info
->is_relaxable_asm_section
)
7030 relax_info
->src_relocs
= (source_reloc
*)
7031 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
7034 relax_info
->src_count
= 0;
7037 /* Collect info on relocations against each relaxable section. */
7038 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7039 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7041 if (!collect_source_relocs (abfd
, sec
, link_info
))
7045 /* Compute the text actions. */
7046 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7047 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7049 if (!compute_text_actions (abfd
, sec
, link_info
))
7057 /* Find all the sections that might be relaxed. The motivation for
7058 this pass is that collect_source_relocs() needs to record _all_ the
7059 relocations that target each relaxable section. That is expensive
7060 and unnecessary unless the target section is actually going to be
7061 relaxed. This pass identifies all such sections by checking if
7062 they have L32Rs pointing to them. In the process, the total number
7063 of relocations targeting each section is also counted so that we
7064 know how much space to allocate for source_relocs against each
7065 relaxable literal section. */
7068 find_relaxable_sections (bfd
*abfd
,
7070 struct bfd_link_info
*link_info
,
7071 bool *is_relaxable_p
)
7073 Elf_Internal_Rela
*internal_relocs
;
7077 xtensa_relax_info
*source_relax_info
;
7080 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7081 link_info
->keep_memory
);
7082 if (internal_relocs
== NULL
)
7085 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7086 if (contents
== NULL
&& sec
->size
!= 0)
7092 source_relax_info
= get_xtensa_relax_info (sec
);
7093 for (i
= 0; i
< sec
->reloc_count
; i
++)
7095 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7097 asection
*target_sec
;
7098 xtensa_relax_info
*target_relax_info
;
7100 /* If this section has not already been marked as "relaxable", and
7101 if it contains any ASM_EXPAND relocations (marking expanded
7102 longcalls) that can be optimized into direct calls, then mark
7103 the section as "relaxable". */
7104 if (source_relax_info
7105 && !source_relax_info
->is_relaxable_asm_section
7106 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
7108 bool is_reachable
= false;
7109 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
7110 link_info
, &is_reachable
)
7113 source_relax_info
->is_relaxable_asm_section
= true;
7114 *is_relaxable_p
= true;
7118 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7119 bfd_get_section_limit (abfd
, sec
));
7121 target_sec
= r_reloc_get_section (&r_rel
);
7122 target_relax_info
= get_xtensa_relax_info (target_sec
);
7123 if (!target_relax_info
)
7126 /* Count PC-relative operand relocations against the target section.
7127 Note: The conditions tested here must match the conditions under
7128 which init_source_reloc is called in collect_source_relocs(). */
7129 is_l32r_reloc
= false;
7130 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7132 xtensa_opcode opcode
=
7133 get_relocation_opcode (abfd
, sec
, contents
, irel
);
7134 if (opcode
!= XTENSA_UNDEFINED
)
7136 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
7137 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
7139 target_relax_info
->src_count
++;
7143 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7145 /* Mark the target section as relaxable. */
7146 target_relax_info
->is_relaxable_literal_section
= true;
7147 *is_relaxable_p
= true;
7152 release_contents (sec
, contents
);
7153 release_internal_relocs (sec
, internal_relocs
);
7158 /* Record _all_ the relocations that point to relaxable sections, and
7159 get rid of ASM_EXPAND relocs by either converting them to
7160 ASM_SIMPLIFY or by removing them. */
7163 collect_source_relocs (bfd
*abfd
,
7165 struct bfd_link_info
*link_info
)
7167 Elf_Internal_Rela
*internal_relocs
;
7171 bfd_size_type sec_size
;
7173 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7174 link_info
->keep_memory
);
7175 if (internal_relocs
== NULL
)
7178 sec_size
= bfd_get_section_limit (abfd
, sec
);
7179 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7180 if (contents
== NULL
&& sec_size
!= 0)
7186 /* Record relocations against relaxable literal sections. */
7187 for (i
= 0; i
< sec
->reloc_count
; i
++)
7189 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7191 asection
*target_sec
;
7192 xtensa_relax_info
*target_relax_info
;
7194 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7196 target_sec
= r_reloc_get_section (&r_rel
);
7197 target_relax_info
= get_xtensa_relax_info (target_sec
);
7199 if (target_relax_info
7200 && (target_relax_info
->is_relaxable_literal_section
7201 || target_relax_info
->is_relaxable_asm_section
))
7203 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7205 bool is_abs_literal
= false;
7207 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7209 /* None of the current alternate relocs are PC-relative,
7210 and only PC-relative relocs matter here. However, we
7211 still need to record the opcode for literal
7213 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7214 if (opcode
== get_l32r_opcode ())
7216 is_abs_literal
= true;
7220 opcode
= XTENSA_UNDEFINED
;
7222 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7224 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7225 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7228 if (opcode
!= XTENSA_UNDEFINED
)
7230 int src_next
= target_relax_info
->src_next
++;
7231 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7233 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7239 /* Now get rid of ASM_EXPAND relocations. At this point, the
7240 src_relocs array for the target literal section may still be
7241 incomplete, but it must at least contain the entries for the L32R
7242 relocations associated with ASM_EXPANDs because they were just
7243 added in the preceding loop over the relocations. */
7245 for (i
= 0; i
< sec
->reloc_count
; i
++)
7247 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7250 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7256 Elf_Internal_Rela
*l32r_irel
;
7258 asection
*target_sec
;
7259 xtensa_relax_info
*target_relax_info
;
7261 /* Mark the source_reloc for the L32R so that it will be
7262 removed in compute_removed_literals(), along with the
7263 associated literal. */
7264 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7265 irel
, internal_relocs
);
7266 if (l32r_irel
== NULL
)
7269 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7271 target_sec
= r_reloc_get_section (&r_rel
);
7272 target_relax_info
= get_xtensa_relax_info (target_sec
);
7274 if (target_relax_info
7275 && (target_relax_info
->is_relaxable_literal_section
7276 || target_relax_info
->is_relaxable_asm_section
))
7278 source_reloc
*s_reloc
;
7280 /* Search the source_relocs for the entry corresponding to
7281 the l32r_irel. Note: The src_relocs array is not yet
7282 sorted, but it wouldn't matter anyway because we're
7283 searching by source offset instead of target offset. */
7284 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7285 target_relax_info
->src_next
,
7287 BFD_ASSERT (s_reloc
);
7288 s_reloc
->is_null
= true;
7291 /* Convert this reloc to ASM_SIMPLIFY. */
7292 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7293 R_XTENSA_ASM_SIMPLIFY
);
7294 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7296 pin_internal_relocs (sec
, internal_relocs
);
7300 /* It is resolvable but doesn't reach. We resolve now
7301 by eliminating the relocation -- the call will remain
7302 expanded into L32R/CALLX. */
7303 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7304 pin_internal_relocs (sec
, internal_relocs
);
7309 release_contents (sec
, contents
);
7310 release_internal_relocs (sec
, internal_relocs
);
7315 /* Return TRUE if the asm expansion can be resolved. Generally it can
7316 be resolved on a final link or when a partial link locates it in the
7317 same section as the target. Set "is_reachable" flag if the target of
7318 the call is within the range of a direct call, given the current VMA
7319 for this section and the target section. */
7322 is_resolvable_asm_expansion (bfd
*abfd
,
7325 Elf_Internal_Rela
*irel
,
7326 struct bfd_link_info
*link_info
,
7327 bool *is_reachable_p
)
7329 asection
*target_sec
;
7333 unsigned int first_align
;
7334 unsigned int adjust
;
7335 bfd_vma target_offset
;
7337 xtensa_opcode opcode
, direct_call_opcode
;
7338 bfd_vma self_address
;
7339 bfd_vma dest_address
;
7341 bfd_size_type sec_size
;
7343 *is_reachable_p
= false;
7345 if (contents
== NULL
)
7348 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7351 sec_size
= bfd_get_section_limit (abfd
, sec
);
7352 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7353 sec_size
- irel
->r_offset
, &uses_l32r
);
7354 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7358 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7359 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7362 /* Check and see that the target resolves. */
7363 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7364 if (!r_reloc_is_defined (&r_rel
))
7367 target_sec
= r_reloc_get_section (&r_rel
);
7368 target_offset
= r_rel
.target_offset
;
7370 /* If the target is in a shared library, then it doesn't reach. This
7371 isn't supposed to come up because the compiler should never generate
7372 non-PIC calls on systems that use shared libraries, but the linker
7373 shouldn't crash regardless. */
7374 if (!target_sec
->output_section
)
7377 /* For relocatable sections, we can only simplify when the output
7378 section of the target is the same as the output section of the
7380 if (bfd_link_relocatable (link_info
)
7381 && (target_sec
->output_section
!= sec
->output_section
7382 || is_reloc_sym_weak (abfd
, irel
)))
7385 if (target_sec
->output_section
!= sec
->output_section
)
7387 /* If the two sections are sufficiently far away that relaxation
7388 might take the call out of range, we can't simplify. For
7389 example, a positive displacement call into another memory
7390 could get moved to a lower address due to literal removal,
7391 but the destination won't move, and so the displacment might
7394 If the displacement is negative, assume the destination could
7395 move as far back as the start of the output section. The
7396 self_address will be at least as far into the output section
7397 as it is prior to relaxation.
7399 If the displacement is postive, assume the destination will be in
7400 it's pre-relaxed location (because relaxation only makes sections
7401 smaller). The self_address could go all the way to the beginning
7402 of the output section. */
7404 dest_address
= target_sec
->output_section
->vma
;
7405 self_address
= sec
->output_section
->vma
;
7407 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7408 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7410 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7411 /* Call targets should be four-byte aligned. */
7412 dest_address
= (dest_address
+ 3) & ~3;
7417 self_address
= (sec
->output_section
->vma
7418 + sec
->output_offset
+ irel
->r_offset
+ 3);
7419 dest_address
= (target_sec
->output_section
->vma
7420 + target_sec
->output_offset
+ target_offset
);
7423 /* Adjust addresses with alignments for the worst case to see if call insn
7424 can fit. Don't relax l32r + callx to call if the target can be out of
7425 range due to alignment.
7426 Caller and target addresses are highest and lowest address.
7427 Search all sections between caller and target, looking for max alignment.
7428 The adjustment is max alignment bytes. If the alignment at the lowest
7429 address is less than the adjustment, apply the adjustment to highest
7432 /* Start from lowest address.
7433 Lowest address aligmnet is from input section.
7434 Initial alignment (adjust) is from input section. */
7435 if (dest_address
> self_address
)
7437 s
= sec
->output_section
;
7438 last_vma
= dest_address
;
7439 first_align
= sec
->alignment_power
;
7440 adjust
= target_sec
->alignment_power
;
7444 s
= target_sec
->output_section
;
7445 last_vma
= self_address
;
7446 first_align
= target_sec
->alignment_power
;
7447 adjust
= sec
->alignment_power
;
7452 /* Find the largest alignment in output section list. */
7453 for (; s
&& s
->vma
>= first_vma
&& s
->vma
<= last_vma
; s
= s
->next
)
7455 if (s
->alignment_power
> adjust
)
7456 adjust
= s
->alignment_power
;
7459 if (adjust
> first_align
)
7461 /* Alignment may enlarge the range, adjust highest address. */
7462 adjust
= 1 << adjust
;
7463 if (dest_address
> self_address
)
7465 dest_address
+= adjust
;
7469 self_address
+= adjust
;
7473 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7474 self_address
, dest_address
);
7476 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7477 (dest_address
>> CALL_SEGMENT_BITS
))
7484 static Elf_Internal_Rela
*
7485 find_associated_l32r_irel (bfd
*abfd
,
7488 Elf_Internal_Rela
*other_irel
,
7489 Elf_Internal_Rela
*internal_relocs
)
7493 for (i
= 0; i
< sec
->reloc_count
; i
++)
7495 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7497 if (irel
== other_irel
)
7499 if (irel
->r_offset
!= other_irel
->r_offset
)
7501 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7509 static xtensa_opcode
*
7510 build_reloc_opcodes (bfd
*abfd
,
7513 Elf_Internal_Rela
*internal_relocs
)
7516 xtensa_opcode
*reloc_opcodes
=
7517 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7518 for (i
= 0; i
< sec
->reloc_count
; i
++)
7520 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7521 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7523 return reloc_opcodes
;
7526 struct reloc_range_struct
7529 bool add
; /* TRUE if start of a range, FALSE otherwise. */
7530 /* Original irel index in the array of relocations for a section. */
7531 unsigned irel_index
;
7533 typedef struct reloc_range_struct reloc_range
;
7535 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7536 struct reloc_range_list_entry_struct
7538 reloc_range_list_entry
*next
;
7539 reloc_range_list_entry
*prev
;
7540 Elf_Internal_Rela
*irel
;
7541 xtensa_opcode opcode
;
7545 struct reloc_range_list_struct
7547 /* The rest of the structure is only meaningful when ok is TRUE. */
7550 unsigned n_range
; /* Number of range markers. */
7551 reloc_range
*range
; /* Sorted range markers. */
7553 unsigned first
; /* Index of a first range element in the list. */
7554 unsigned last
; /* One past index of a last range element in the list. */
7556 unsigned n_list
; /* Number of list elements. */
7557 reloc_range_list_entry
*reloc
; /* */
7558 reloc_range_list_entry list_root
;
7562 reloc_range_compare (const void *a
, const void *b
)
7564 const reloc_range
*ra
= a
;
7565 const reloc_range
*rb
= b
;
7567 if (ra
->addr
!= rb
->addr
)
7568 return ra
->addr
< rb
->addr
? -1 : 1;
7569 if (ra
->add
!= rb
->add
)
7570 return ra
->add
? -1 : 1;
7575 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7577 Elf_Internal_Rela
*internal_relocs
,
7578 xtensa_opcode
*reloc_opcodes
,
7579 reloc_range_list
*list
)
7584 reloc_range
*ranges
= NULL
;
7585 reloc_range_list_entry
*reloc
=
7586 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7588 memset (list
, 0, sizeof (*list
));
7591 for (i
= 0; i
< sec
->reloc_count
; i
++)
7593 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7594 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7595 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7598 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7599 || r_type
== R_XTENSA_32_PCREL
7600 || !howto
->pc_relative
)
7603 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7604 bfd_get_section_limit (abfd
, sec
));
7606 if (r_reloc_get_section (&r_rel
) != sec
)
7611 max_n
= (max_n
+ 2) * 2;
7612 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7615 ranges
[n
].addr
= irel
->r_offset
;
7616 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7618 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7619 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7621 ranges
[n
].irel_index
= i
;
7622 ranges
[n
+ 1].irel_index
= i
;
7626 reloc
[i
].irel
= irel
;
7628 /* Every relocation won't possibly be checked in the optimized version of
7629 check_section_ebb_pcrels_fit, so this needs to be done here. */
7630 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7632 /* None of the current alternate relocs are PC-relative,
7633 and only PC-relative relocs matter here. */
7637 xtensa_opcode opcode
;
7641 opcode
= reloc_opcodes
[i
];
7643 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7645 if (opcode
== XTENSA_UNDEFINED
)
7651 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7652 if (opnum
== XTENSA_UNDEFINED
)
7658 /* Record relocation opcode and opnum as we've calculated them
7659 anyway and they won't change. */
7660 reloc
[i
].opcode
= opcode
;
7661 reloc
[i
].opnum
= opnum
;
7667 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7668 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7671 list
->range
= ranges
;
7672 list
->reloc
= reloc
;
7673 list
->list_root
.prev
= &list
->list_root
;
7674 list
->list_root
.next
= &list
->list_root
;
7683 static void reloc_range_list_append (reloc_range_list
*list
,
7684 unsigned irel_index
)
7686 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7688 entry
->prev
= list
->list_root
.prev
;
7689 entry
->next
= &list
->list_root
;
7690 entry
->prev
->next
= entry
;
7691 entry
->next
->prev
= entry
;
7695 static void reloc_range_list_remove (reloc_range_list
*list
,
7696 unsigned irel_index
)
7698 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7700 entry
->next
->prev
= entry
->prev
;
7701 entry
->prev
->next
= entry
->next
;
7705 /* Update relocation list object so that it lists all relocations that cross
7706 [first; last] range. Range bounds should not decrease with successive
7708 static void reloc_range_list_update_range (reloc_range_list
*list
,
7709 bfd_vma first
, bfd_vma last
)
7711 /* This should not happen: EBBs are iterated from lower addresses to higher.
7712 But even if that happens there's no need to break: just flush current list
7713 and start from scratch. */
7714 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7715 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7720 list
->list_root
.next
= &list
->list_root
;
7721 list
->list_root
.prev
= &list
->list_root
;
7722 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7725 for (; list
->last
< list
->n_range
&&
7726 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7727 if (list
->range
[list
->last
].add
)
7728 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7730 for (; list
->first
< list
->n_range
&&
7731 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7732 if (!list
->range
[list
->first
].add
)
7733 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7736 static void free_reloc_range_list (reloc_range_list
*list
)
7742 /* The compute_text_actions function will build a list of potential
7743 transformation actions for code in the extended basic block of each
7744 longcall that is optimized to a direct call. From this list we
7745 generate a set of actions to actually perform that optimizes for
7746 space and, if not using size_opt, maintains branch target
7749 These actions to be performed are placed on a per-section list.
7750 The actual changes are performed by relax_section() in the second
7754 compute_text_actions (bfd
*abfd
,
7756 struct bfd_link_info
*link_info
)
7758 xtensa_opcode
*reloc_opcodes
= NULL
;
7759 xtensa_relax_info
*relax_info
;
7761 Elf_Internal_Rela
*internal_relocs
;
7764 property_table_entry
*prop_table
= 0;
7766 bfd_size_type sec_size
;
7767 reloc_range_list relevant_relocs
;
7769 relax_info
= get_xtensa_relax_info (sec
);
7770 BFD_ASSERT (relax_info
);
7771 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7773 /* Do nothing if the section contains no optimized longcalls. */
7774 if (!relax_info
->is_relaxable_asm_section
)
7777 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7778 link_info
->keep_memory
);
7780 if (internal_relocs
)
7781 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7782 internal_reloc_compare
);
7784 sec_size
= bfd_get_section_limit (abfd
, sec
);
7785 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7786 if (contents
== NULL
&& sec_size
!= 0)
7792 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7793 XTENSA_PROP_SEC_NAME
, false);
7800 /* Precompute the opcode for each relocation. */
7801 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7803 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7806 for (i
= 0; i
< sec
->reloc_count
; i
++)
7808 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7810 property_table_entry
*the_entry
;
7813 ebb_constraint ebb_table
;
7814 bfd_size_type simplify_size
;
7816 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7818 r_offset
= irel
->r_offset
;
7820 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7821 if (simplify_size
== 0)
7824 /* xgettext:c-format */
7825 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7826 "XTENSA_ASM_SIMPLIFY relocation; "
7827 "possible configuration mismatch"),
7828 sec
->owner
, sec
, (uint64_t) r_offset
);
7832 /* If the instruction table is not around, then don't do this
7834 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7835 sec
->vma
+ irel
->r_offset
);
7836 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7838 text_action_add (&relax_info
->action_list
,
7839 ta_convert_longcall
, sec
, r_offset
,
7844 /* If the next longcall happens to be at the same address as an
7845 unreachable section of size 0, then skip forward. */
7846 ptbl_idx
= the_entry
- prop_table
;
7847 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7848 && the_entry
->size
== 0
7849 && ptbl_idx
+ 1 < ptblsize
7850 && (prop_table
[ptbl_idx
+ 1].address
7851 == prop_table
[ptbl_idx
].address
))
7857 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7858 /* NO_REORDER is OK */
7861 init_ebb_constraint (&ebb_table
);
7862 ebb
= &ebb_table
.ebb
;
7863 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7864 internal_relocs
, sec
->reloc_count
);
7865 ebb
->start_offset
= r_offset
+ simplify_size
;
7866 ebb
->end_offset
= r_offset
+ simplify_size
;
7867 ebb
->start_ptbl_idx
= ptbl_idx
;
7868 ebb
->end_ptbl_idx
= ptbl_idx
;
7869 ebb
->start_reloc_idx
= i
;
7870 ebb
->end_reloc_idx
= i
;
7872 if (!extend_ebb_bounds (ebb
)
7873 || !compute_ebb_proposed_actions (&ebb_table
)
7874 || !compute_ebb_actions (&ebb_table
)
7875 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7878 &ebb_table
, reloc_opcodes
)
7879 || !check_section_ebb_reduces (&ebb_table
))
7881 /* If anything goes wrong or we get unlucky and something does
7882 not fit, with our plan because of expansion between
7883 critical branches, just convert to a NOP. */
7885 text_action_add (&relax_info
->action_list
,
7886 ta_convert_longcall
, sec
, r_offset
, 0);
7887 i
= ebb_table
.ebb
.end_reloc_idx
;
7888 free_ebb_constraint (&ebb_table
);
7892 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7894 /* Update the index so we do not go looking at the relocations
7895 we have already processed. */
7896 i
= ebb_table
.ebb
.end_reloc_idx
;
7897 free_ebb_constraint (&ebb_table
);
7900 free_reloc_range_list (&relevant_relocs
);
7903 if (action_list_count (&relax_info
->action_list
))
7904 print_action_list (stderr
, &relax_info
->action_list
);
7908 release_contents (sec
, contents
);
7909 release_internal_relocs (sec
, internal_relocs
);
7911 free (reloc_opcodes
);
7917 /* Do not widen an instruction if it is preceeded by a
7918 loop opcode. It might cause misalignment. */
7921 prev_instr_is_a_loop (bfd_byte
*contents
,
7922 bfd_size_type content_length
,
7923 bfd_size_type offset
)
7925 xtensa_opcode prev_opcode
;
7929 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7930 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7934 /* Find all of the possible actions for an extended basic block. */
7937 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7939 const ebb_t
*ebb
= &ebb_table
->ebb
;
7940 unsigned rel_idx
= ebb
->start_reloc_idx
;
7941 property_table_entry
*entry
, *start_entry
, *end_entry
;
7943 xtensa_isa isa
= xtensa_default_isa
;
7945 static xtensa_insnbuf insnbuf
= NULL
;
7946 static xtensa_insnbuf slotbuf
= NULL
;
7948 if (insnbuf
== NULL
)
7950 insnbuf
= xtensa_insnbuf_alloc (isa
);
7951 slotbuf
= xtensa_insnbuf_alloc (isa
);
7954 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7955 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7957 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7959 bfd_vma start_offset
, end_offset
;
7960 bfd_size_type insn_len
;
7962 start_offset
= entry
->address
- ebb
->sec
->vma
;
7963 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7965 if (entry
== start_entry
)
7966 start_offset
= ebb
->start_offset
;
7967 if (entry
== end_entry
)
7968 end_offset
= ebb
->end_offset
;
7969 offset
= start_offset
;
7971 if (offset
== entry
->address
- ebb
->sec
->vma
7972 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7974 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7975 BFD_ASSERT (offset
!= end_offset
);
7976 if (offset
== end_offset
)
7979 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7984 if (check_branch_target_aligned_address (offset
, insn_len
))
7985 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7987 ebb_propose_action (ebb_table
, align_type
, 0,
7988 ta_none
, offset
, 0, true);
7991 while (offset
!= end_offset
)
7993 Elf_Internal_Rela
*irel
;
7994 xtensa_opcode opcode
;
7996 while (rel_idx
< ebb
->end_reloc_idx
7997 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7998 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7999 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
8000 != R_XTENSA_ASM_SIMPLIFY
))))
8003 /* Check for longcall. */
8004 irel
= &ebb
->relocs
[rel_idx
];
8005 if (irel
->r_offset
== offset
8006 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
8008 bfd_size_type simplify_size
;
8010 simplify_size
= get_asm_simplify_size (ebb
->contents
,
8011 ebb
->content_length
,
8013 if (simplify_size
== 0)
8016 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8017 ta_convert_longcall
, offset
, 0, true);
8019 offset
+= simplify_size
;
8023 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
8025 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
8026 ebb
->content_length
- offset
);
8027 fmt
= xtensa_format_decode (isa
, insnbuf
);
8028 if (fmt
== XTENSA_UNDEFINED
)
8030 insn_len
= xtensa_format_length (isa
, fmt
);
8031 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
8034 if (xtensa_format_num_slots (isa
, fmt
) != 1)
8040 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
8041 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
8042 if (opcode
== XTENSA_UNDEFINED
)
8045 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
8046 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8047 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
8049 /* Add an instruction narrow action. */
8050 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8051 ta_narrow_insn
, offset
, 0, false);
8053 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8054 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
8055 && ! prev_instr_is_a_loop (ebb
->contents
,
8056 ebb
->content_length
, offset
))
8058 /* Add an instruction widen action. */
8059 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8060 ta_widen_insn
, offset
, 0, false);
8062 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
8064 /* Check for branch targets. */
8065 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
8066 ta_none
, offset
, 0, true);
8073 if (ebb
->ends_unreachable
)
8075 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8076 ta_fill
, ebb
->end_offset
, 0, true);
8083 /* xgettext:c-format */
8084 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
8085 "possible configuration mismatch"),
8086 ebb
->sec
->owner
, ebb
->sec
, (uint64_t) offset
);
8091 /* After all of the information has collected about the
8092 transformations possible in an EBB, compute the appropriate actions
8093 here in compute_ebb_actions. We still must check later to make
8094 sure that the actions do not break any relocations. The algorithm
8095 used here is pretty greedy. Basically, it removes as many no-ops
8096 as possible so that the end of the EBB has the same alignment
8097 characteristics as the original. First, it uses narrowing, then
8098 fill space at the end of the EBB, and finally widenings. If that
8099 does not work, it tries again with one fewer no-op removed. The
8100 optimization will only be performed if all of the branch targets
8101 that were aligned before transformation are also aligned after the
8104 When the size_opt flag is set, ignore the branch target alignments,
8105 narrow all wide instructions, and remove all no-ops unless the end
8106 of the EBB prevents it. */
8109 compute_ebb_actions (ebb_constraint
*ebb_table
)
8113 int removed_bytes
= 0;
8114 ebb_t
*ebb
= &ebb_table
->ebb
;
8115 unsigned seg_idx_start
= 0;
8116 unsigned seg_idx_end
= 0;
8118 /* We perform this like the assembler relaxation algorithm: Start by
8119 assuming all instructions are narrow and all no-ops removed; then
8122 /* For each segment of this that has a solid constraint, check to
8123 see if there are any combinations that will keep the constraint.
8125 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
8127 bool requires_text_end_align
= false;
8128 unsigned longcall_count
= 0;
8129 unsigned longcall_convert_count
= 0;
8130 unsigned narrowable_count
= 0;
8131 unsigned narrowable_convert_count
= 0;
8132 unsigned widenable_count
= 0;
8133 unsigned widenable_convert_count
= 0;
8135 proposed_action
*action
= NULL
;
8136 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
8138 seg_idx_start
= seg_idx_end
;
8140 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
8142 action
= &ebb_table
->actions
[i
];
8143 if (action
->action
== ta_convert_longcall
)
8145 if (action
->action
== ta_narrow_insn
)
8147 if (action
->action
== ta_widen_insn
)
8149 if (action
->action
== ta_fill
)
8151 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8153 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
8154 && !elf32xtensa_size_opt
)
8159 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
8160 requires_text_end_align
= true;
8162 if (elf32xtensa_size_opt
&& !requires_text_end_align
8163 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
8164 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
8166 longcall_convert_count
= longcall_count
;
8167 narrowable_convert_count
= narrowable_count
;
8168 widenable_convert_count
= 0;
8172 /* There is a constraint. Convert the max number of longcalls. */
8173 narrowable_convert_count
= 0;
8174 longcall_convert_count
= 0;
8175 widenable_convert_count
= 0;
8177 for (j
= 0; j
< longcall_count
; j
++)
8179 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
8180 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
8181 unsigned desire_widen
= removed
;
8182 if (desire_narrow
<= narrowable_count
)
8184 narrowable_convert_count
= desire_narrow
;
8185 narrowable_convert_count
+=
8186 (align
* ((narrowable_count
- narrowable_convert_count
)
8188 longcall_convert_count
= (longcall_count
- j
);
8189 widenable_convert_count
= 0;
8192 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
8194 narrowable_convert_count
= 0;
8195 longcall_convert_count
= longcall_count
- j
;
8196 widenable_convert_count
= desire_widen
;
8202 /* Now the number of conversions are saved. Do them. */
8203 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
8205 action
= &ebb_table
->actions
[i
];
8206 switch (action
->action
)
8208 case ta_convert_longcall
:
8209 if (longcall_convert_count
!= 0)
8211 action
->action
= ta_remove_longcall
;
8212 action
->do_action
= true;
8213 action
->removed_bytes
+= 3;
8214 longcall_convert_count
--;
8217 case ta_narrow_insn
:
8218 if (narrowable_convert_count
!= 0)
8220 action
->do_action
= true;
8221 action
->removed_bytes
+= 1;
8222 narrowable_convert_count
--;
8226 if (widenable_convert_count
!= 0)
8228 action
->do_action
= true;
8229 action
->removed_bytes
-= 1;
8230 widenable_convert_count
--;
8239 /* Now we move on to some local opts. Try to remove each of the
8240 remaining longcalls. */
8242 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8245 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8247 int old_removed_bytes
= removed_bytes
;
8248 proposed_action
*action
= &ebb_table
->actions
[i
];
8250 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8252 bool bad_alignment
= false;
8254 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8256 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8257 bfd_vma offset
= new_action
->offset
;
8258 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8260 if (!check_branch_target_aligned
8261 (ebb_table
->ebb
.contents
,
8262 ebb_table
->ebb
.content_length
,
8263 offset
, offset
- removed_bytes
))
8265 bad_alignment
= true;
8269 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8271 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8272 ebb_table
->ebb
.content_length
,
8274 offset
- removed_bytes
))
8276 bad_alignment
= true;
8280 if (new_action
->action
== ta_narrow_insn
8281 && !new_action
->do_action
8282 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8284 /* Narrow an instruction and we are done. */
8285 new_action
->do_action
= true;
8286 new_action
->removed_bytes
+= 1;
8287 bad_alignment
= false;
8290 if (new_action
->action
== ta_widen_insn
8291 && new_action
->do_action
8292 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8294 /* Narrow an instruction and we are done. */
8295 new_action
->do_action
= false;
8296 new_action
->removed_bytes
+= 1;
8297 bad_alignment
= false;
8300 if (new_action
->do_action
)
8301 removed_bytes
+= new_action
->removed_bytes
;
8305 action
->removed_bytes
+= 3;
8306 action
->action
= ta_remove_longcall
;
8307 action
->do_action
= true;
8310 removed_bytes
= old_removed_bytes
;
8311 if (action
->do_action
)
8312 removed_bytes
+= action
->removed_bytes
;
8317 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8319 proposed_action
*action
= &ebb_table
->actions
[i
];
8320 if (action
->do_action
)
8321 removed_bytes
+= action
->removed_bytes
;
8324 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8325 && ebb
->ends_unreachable
)
8327 proposed_action
*action
;
8331 BFD_ASSERT (ebb_table
->action_count
!= 0);
8332 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8333 BFD_ASSERT (action
->action
== ta_fill
);
8334 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8336 extra_space
= xtensa_compute_fill_extra_space (ebb
->ends_unreachable
);
8337 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8338 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8340 action
->removed_bytes
= extra_space
- br
;
8346 /* The xlate_map is a sorted array of address mappings designed to
8347 answer the offset_with_removed_text() query with a binary search instead
8348 of a linear search through the section's action_list. */
8350 typedef struct xlate_map_entry xlate_map_entry_t
;
8351 typedef struct xlate_map xlate_map_t
;
8353 struct xlate_map_entry
8355 bfd_vma orig_address
;
8356 bfd_vma new_address
;
8362 unsigned entry_count
;
8363 xlate_map_entry_t
*entry
;
8368 xlate_compare (const void *a_v
, const void *b_v
)
8370 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8371 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8372 if (a
->orig_address
< b
->orig_address
)
8374 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8381 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8382 text_action_list
*action_list
,
8386 xlate_map_entry_t
*e
;
8387 struct xlate_map_entry se
;
8390 return offset_with_removed_text (action_list
, offset
);
8392 if (map
->entry_count
== 0)
8395 se
.orig_address
= offset
;
8396 r
= bsearch (&se
, map
->entry
, map
->entry_count
,
8397 sizeof (xlate_map_entry_t
), &xlate_compare
);
8398 e
= (xlate_map_entry_t
*) r
;
8400 /* There could be a jump past the end of the section,
8401 allow it using the last xlate map entry to translate its address. */
8404 e
= map
->entry
+ map
->entry_count
- 1;
8405 if (xlate_compare (&se
, e
) <= 0)
8408 BFD_ASSERT (e
!= NULL
);
8411 return e
->new_address
- e
->orig_address
+ offset
;
8414 typedef struct xlate_map_context_struct xlate_map_context
;
8415 struct xlate_map_context_struct
8418 xlate_map_entry_t
*current_entry
;
8423 xlate_map_fn (splay_tree_node node
, void *p
)
8425 text_action
*r
= (text_action
*)node
->value
;
8426 xlate_map_context
*ctx
= p
;
8427 unsigned orig_size
= 0;
8432 case ta_remove_insn
:
8433 case ta_convert_longcall
:
8434 case ta_remove_literal
:
8435 case ta_add_literal
:
8437 case ta_remove_longcall
:
8440 case ta_narrow_insn
:
8449 ctx
->current_entry
->size
=
8450 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8451 if (ctx
->current_entry
->size
!= 0)
8453 ctx
->current_entry
++;
8454 ctx
->map
->entry_count
++;
8456 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8457 ctx
->removed
+= r
->removed_bytes
;
8458 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8459 ctx
->current_entry
->size
= 0;
8463 /* Build a binary searchable offset translation map from a section's
8466 static xlate_map_t
*
8467 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8469 text_action_list
*action_list
= &relax_info
->action_list
;
8470 unsigned num_actions
= 0;
8471 xlate_map_context ctx
;
8473 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8475 if (ctx
.map
== NULL
)
8478 num_actions
= action_list_count (action_list
);
8479 ctx
.map
->entry
= (xlate_map_entry_t
*)
8480 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8481 if (ctx
.map
->entry
== NULL
)
8486 ctx
.map
->entry_count
= 0;
8489 ctx
.current_entry
= &ctx
.map
->entry
[0];
8491 ctx
.current_entry
->orig_address
= 0;
8492 ctx
.current_entry
->new_address
= 0;
8493 ctx
.current_entry
->size
= 0;
8495 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8497 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8498 - ctx
.current_entry
->orig_address
);
8499 if (ctx
.current_entry
->size
!= 0)
8500 ctx
.map
->entry_count
++;
8506 /* Free an offset translation map. */
8509 free_xlate_map (xlate_map_t
*map
)
8519 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8520 relocations in a section will fit if a proposed set of actions
8524 check_section_ebb_pcrels_fit (bfd
*abfd
,
8527 Elf_Internal_Rela
*internal_relocs
,
8528 reloc_range_list
*relevant_relocs
,
8529 const ebb_constraint
*constraint
,
8530 const xtensa_opcode
*reloc_opcodes
)
8533 unsigned n
= sec
->reloc_count
;
8534 Elf_Internal_Rela
*irel
;
8535 xlate_map_t
*xmap
= NULL
;
8537 xtensa_relax_info
*relax_info
;
8538 reloc_range_list_entry
*entry
= NULL
;
8540 relax_info
= get_xtensa_relax_info (sec
);
8542 if (relax_info
&& sec
->reloc_count
> 100)
8544 xmap
= build_xlate_map (sec
, relax_info
);
8545 /* NULL indicates out of memory, but the slow version
8546 can still be used. */
8549 if (relevant_relocs
&& constraint
->action_count
)
8551 if (!relevant_relocs
->ok
)
8558 bfd_vma min_offset
, max_offset
;
8559 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8561 for (i
= 1; i
< constraint
->action_count
; ++i
)
8563 proposed_action
*action
= &constraint
->actions
[i
];
8564 bfd_vma offset
= action
->offset
;
8566 if (offset
< min_offset
)
8567 min_offset
= offset
;
8568 if (offset
> max_offset
)
8569 max_offset
= offset
;
8571 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8573 n
= relevant_relocs
->n_list
;
8574 entry
= &relevant_relocs
->list_root
;
8579 relevant_relocs
= NULL
;
8582 for (i
= 0; i
< n
; i
++)
8585 bfd_vma orig_self_offset
, orig_target_offset
;
8586 bfd_vma self_offset
, target_offset
;
8588 reloc_howto_type
*howto
;
8589 int self_removed_bytes
, target_removed_bytes
;
8591 if (relevant_relocs
)
8593 entry
= entry
->next
;
8598 irel
= internal_relocs
+ i
;
8600 r_type
= ELF32_R_TYPE (irel
->r_info
);
8602 howto
= &elf_howto_table
[r_type
];
8603 /* We maintain the required invariant: PC-relative relocations
8604 that fit before linking must fit after linking. Thus we only
8605 need to deal with relocations to the same section that are
8607 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8608 || r_type
== R_XTENSA_32_PCREL
8609 || !howto
->pc_relative
)
8612 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8613 bfd_get_section_limit (abfd
, sec
));
8615 if (r_reloc_get_section (&r_rel
) != sec
)
8618 orig_self_offset
= irel
->r_offset
;
8619 orig_target_offset
= r_rel
.target_offset
;
8621 self_offset
= orig_self_offset
;
8622 target_offset
= orig_target_offset
;
8627 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8630 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8631 orig_target_offset
);
8634 self_removed_bytes
= 0;
8635 target_removed_bytes
= 0;
8637 for (j
= 0; j
< constraint
->action_count
; ++j
)
8639 proposed_action
*action
= &constraint
->actions
[j
];
8640 bfd_vma offset
= action
->offset
;
8641 int removed_bytes
= action
->removed_bytes
;
8642 if (offset
< orig_self_offset
8643 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8644 && action
->removed_bytes
< 0))
8645 self_removed_bytes
+= removed_bytes
;
8646 if (offset
< orig_target_offset
8647 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8648 && action
->removed_bytes
< 0))
8649 target_removed_bytes
+= removed_bytes
;
8651 self_offset
-= self_removed_bytes
;
8652 target_offset
-= target_removed_bytes
;
8654 /* Try to encode it. Get the operand and check. */
8655 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8657 /* None of the current alternate relocs are PC-relative,
8658 and only PC-relative relocs matter here. */
8662 xtensa_opcode opcode
;
8665 if (relevant_relocs
)
8667 opcode
= entry
->opcode
;
8668 opnum
= entry
->opnum
;
8673 opcode
= reloc_opcodes
[relevant_relocs
?
8674 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8676 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8677 if (opcode
== XTENSA_UNDEFINED
)
8683 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8684 if (opnum
== XTENSA_UNDEFINED
)
8691 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8699 free_xlate_map (xmap
);
8706 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8711 for (i
= 0; i
< constraint
->action_count
; i
++)
8713 const proposed_action
*action
= &constraint
->actions
[i
];
8714 if (action
->do_action
)
8715 removed
+= action
->removed_bytes
;
8725 text_action_add_proposed (text_action_list
*l
,
8726 const ebb_constraint
*ebb_table
,
8731 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8733 proposed_action
*action
= &ebb_table
->actions
[i
];
8735 if (!action
->do_action
)
8737 switch (action
->action
)
8739 case ta_remove_insn
:
8740 case ta_remove_longcall
:
8741 case ta_convert_longcall
:
8742 case ta_narrow_insn
:
8745 case ta_remove_literal
:
8746 text_action_add (l
, action
->action
, sec
, action
->offset
,
8747 action
->removed_bytes
);
8760 xtensa_compute_fill_extra_space (property_table_entry
*entry
)
8762 int fill_extra_space
;
8767 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8770 fill_extra_space
= entry
->size
;
8771 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8773 /* Fill bytes for alignment:
8774 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8775 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8776 int nsm
= (1 << pow
) - 1;
8777 bfd_vma addr
= entry
->address
+ entry
->size
;
8778 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8779 fill_extra_space
+= align_fill
;
8781 return fill_extra_space
;
8785 /* First relaxation pass. */
8787 /* If the section contains relaxable literals, check each literal to
8788 see if it has the same value as another literal that has already
8789 been seen, either in the current section or a previous one. If so,
8790 add an entry to the per-section list of removed literals. The
8791 actual changes are deferred until the next pass. */
8794 compute_removed_literals (bfd
*abfd
,
8796 struct bfd_link_info
*link_info
,
8797 value_map_hash_table
*values
)
8799 xtensa_relax_info
*relax_info
;
8801 Elf_Internal_Rela
*internal_relocs
;
8802 source_reloc
*src_relocs
, *rel
;
8804 property_table_entry
*prop_table
= NULL
;
8807 bool last_loc_is_prev
= false;
8808 bfd_vma last_target_offset
= 0;
8809 section_cache_t target_sec_cache
;
8810 bfd_size_type sec_size
;
8812 init_section_cache (&target_sec_cache
);
8814 /* Do nothing if it is not a relaxable literal section. */
8815 relax_info
= get_xtensa_relax_info (sec
);
8816 BFD_ASSERT (relax_info
);
8817 if (!relax_info
->is_relaxable_literal_section
)
8820 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8821 link_info
->keep_memory
);
8823 sec_size
= bfd_get_section_limit (abfd
, sec
);
8824 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8825 if (contents
== NULL
&& sec_size
!= 0)
8831 /* Sort the source_relocs by target offset. */
8832 src_relocs
= relax_info
->src_relocs
;
8833 qsort (src_relocs
, relax_info
->src_count
,
8834 sizeof (source_reloc
), source_reloc_compare
);
8835 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8836 internal_reloc_compare
);
8838 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8839 XTENSA_PROP_SEC_NAME
, false);
8847 for (i
= 0; i
< relax_info
->src_count
; i
++)
8849 Elf_Internal_Rela
*irel
= NULL
;
8851 rel
= &src_relocs
[i
];
8852 if (get_l32r_opcode () != rel
->opcode
)
8854 irel
= get_irel_at_offset (sec
, internal_relocs
,
8855 rel
->r_rel
.target_offset
);
8857 /* If the relocation on this is not a simple R_XTENSA_32 or
8858 R_XTENSA_PLT then do not consider it. This may happen when
8859 the difference of two symbols is used in a literal. */
8860 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8861 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8864 /* If the target_offset for this relocation is the same as the
8865 previous relocation, then we've already considered whether the
8866 literal can be coalesced. Skip to the next one.... */
8867 if (i
!= 0 && prev_i
!= -1
8868 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8872 if (last_loc_is_prev
&&
8873 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8874 last_loc_is_prev
= false;
8876 /* Check if the relocation was from an L32R that is being removed
8877 because a CALLX was converted to a direct CALL, and check if
8878 there are no other relocations to the literal. */
8879 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8880 sec
, prop_table
, ptblsize
))
8882 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8883 irel
, rel
, prop_table
, ptblsize
))
8888 last_target_offset
= rel
->r_rel
.target_offset
;
8892 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8894 &last_loc_is_prev
, irel
,
8895 relax_info
->src_count
- i
, rel
,
8896 prop_table
, ptblsize
,
8897 &target_sec_cache
, rel
->is_abs_literal
))
8902 last_target_offset
= rel
->r_rel
.target_offset
;
8906 print_removed_literals (stderr
, &relax_info
->removed_list
);
8907 print_action_list (stderr
, &relax_info
->action_list
);
8912 free_section_cache (&target_sec_cache
);
8914 release_contents (sec
, contents
);
8915 release_internal_relocs (sec
, internal_relocs
);
8920 static Elf_Internal_Rela
*
8921 get_irel_at_offset (asection
*sec
,
8922 Elf_Internal_Rela
*internal_relocs
,
8926 Elf_Internal_Rela
*irel
;
8928 Elf_Internal_Rela key
;
8930 if (!internal_relocs
)
8933 key
.r_offset
= offset
;
8934 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8935 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8939 /* bsearch does not guarantee which will be returned if there are
8940 multiple matches. We need the first that is not an alignment. */
8941 i
= irel
- internal_relocs
;
8944 if (internal_relocs
[i
-1].r_offset
!= offset
)
8948 for ( ; i
< sec
->reloc_count
; i
++)
8950 irel
= &internal_relocs
[i
];
8951 r_type
= ELF32_R_TYPE (irel
->r_info
);
8952 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8961 is_removable_literal (const source_reloc
*rel
,
8963 const source_reloc
*src_relocs
,
8966 property_table_entry
*prop_table
,
8969 const source_reloc
*curr_rel
;
8970 property_table_entry
*entry
;
8975 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8976 sec
->vma
+ rel
->r_rel
.target_offset
);
8977 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8980 for (++i
; i
< src_count
; ++i
)
8982 curr_rel
= &src_relocs
[i
];
8983 /* If all others have the same target offset.... */
8984 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8987 if (!curr_rel
->is_null
8988 && !xtensa_is_property_section (curr_rel
->source_sec
)
8989 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8997 remove_dead_literal (bfd
*abfd
,
8999 struct bfd_link_info
*link_info
,
9000 Elf_Internal_Rela
*internal_relocs
,
9001 Elf_Internal_Rela
*irel
,
9003 property_table_entry
*prop_table
,
9006 property_table_entry
*entry
;
9007 xtensa_relax_info
*relax_info
;
9009 relax_info
= get_xtensa_relax_info (sec
);
9013 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9014 sec
->vma
+ rel
->r_rel
.target_offset
);
9016 /* Mark the unused literal so that it will be removed. */
9017 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
9019 text_action_add (&relax_info
->action_list
,
9020 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9022 /* If the section is 4-byte aligned, do not add fill. */
9023 if (sec
->alignment_power
> 2)
9025 int fill_extra_space
;
9026 bfd_vma entry_sec_offset
;
9028 property_table_entry
*the_add_entry
;
9032 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9034 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9036 /* If the literal range is at the end of the section,
9038 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9040 fill_extra_space
= xtensa_compute_fill_extra_space (the_add_entry
);
9042 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9043 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9044 -4, fill_extra_space
);
9046 adjust_fill_action (fa
, removed_diff
);
9048 text_action_add (&relax_info
->action_list
,
9049 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9052 /* Zero out the relocation on this literal location. */
9055 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9056 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9058 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9059 pin_internal_relocs (sec
, internal_relocs
);
9062 /* Do not modify "last_loc_is_prev". */
9068 identify_literal_placement (bfd
*abfd
,
9071 struct bfd_link_info
*link_info
,
9072 value_map_hash_table
*values
,
9073 bool *last_loc_is_prev_p
,
9074 Elf_Internal_Rela
*irel
,
9075 int remaining_src_rels
,
9077 property_table_entry
*prop_table
,
9079 section_cache_t
*target_sec_cache
,
9080 bool is_abs_literal
)
9084 xtensa_relax_info
*relax_info
;
9085 bool literal_placed
= false;
9087 unsigned long value
;
9088 bool final_static_link
;
9089 bfd_size_type sec_size
;
9091 relax_info
= get_xtensa_relax_info (sec
);
9095 sec_size
= bfd_get_section_limit (abfd
, sec
);
9098 (!bfd_link_relocatable (link_info
)
9099 && !elf_hash_table (link_info
)->dynamic_sections_created
);
9101 /* The placement algorithm first checks to see if the literal is
9102 already in the value map. If so and the value map is reachable
9103 from all uses, then the literal is moved to that location. If
9104 not, then we identify the last location where a fresh literal was
9105 placed. If the literal can be safely moved there, then we do so.
9106 If not, then we assume that the literal is not to move and leave
9107 the literal where it is, marking it as the last literal
9110 /* Find the literal value. */
9112 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9115 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
9116 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
9118 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
9120 /* Check if we've seen another literal with the same value that
9121 is in the same output section. */
9122 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
9125 && (r_reloc_get_section (&val_map
->loc
)->output_section
9126 == sec
->output_section
)
9127 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
9128 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
9130 /* No change to last_loc_is_prev. */
9131 literal_placed
= true;
9134 /* For relocatable links, do not try to move literals. To do it
9135 correctly might increase the number of relocations in an input
9136 section making the default relocatable linking fail. */
9137 if (!bfd_link_relocatable (link_info
) && !literal_placed
9138 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
9140 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
9141 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
9143 /* Increment the virtual offset. */
9144 r_reloc try_loc
= values
->last_loc
;
9145 try_loc
.virtual_offset
+= 4;
9147 /* There is a last loc that was in the same output section. */
9148 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
9149 && move_shared_literal (sec
, link_info
, rel
,
9150 prop_table
, ptblsize
,
9151 &try_loc
, &val
, target_sec_cache
))
9153 values
->last_loc
.virtual_offset
+= 4;
9154 literal_placed
= true;
9156 val_map
= add_value_map (values
, &val
, &try_loc
,
9159 val_map
->loc
= try_loc
;
9164 if (!literal_placed
)
9166 /* Nothing worked, leave the literal alone but update the last loc. */
9167 values
->has_last_loc
= true;
9168 values
->last_loc
= rel
->r_rel
;
9170 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
9172 val_map
->loc
= rel
->r_rel
;
9173 *last_loc_is_prev_p
= true;
9180 /* Check if the original relocations (presumably on L32R instructions)
9181 identified by reloc[0..N] can be changed to reference the literal
9182 identified by r_rel. If r_rel is out of range for any of the
9183 original relocations, then we don't want to coalesce the original
9184 literal with the one at r_rel. We only check reloc[0..N], where the
9185 offsets are all the same as for reloc[0] (i.e., they're all
9186 referencing the same literal) and where N is also bounded by the
9187 number of remaining entries in the "reloc" array. The "reloc" array
9188 is sorted by target offset so we know all the entries for the same
9189 literal will be contiguous. */
9192 relocations_reach (source_reloc
*reloc
,
9193 int remaining_relocs
,
9194 const r_reloc
*r_rel
)
9196 bfd_vma from_offset
, source_address
, dest_address
;
9200 if (!r_reloc_is_defined (r_rel
))
9203 sec
= r_reloc_get_section (r_rel
);
9204 from_offset
= reloc
[0].r_rel
.target_offset
;
9206 for (i
= 0; i
< remaining_relocs
; i
++)
9208 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9211 /* Ignore relocations that have been removed. */
9212 if (reloc
[i
].is_null
)
9215 /* The original and new output section for these must be the same
9216 in order to coalesce. */
9217 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9218 != sec
->output_section
)
9221 /* Absolute literals in the same output section can always be
9223 if (reloc
[i
].is_abs_literal
)
9226 /* A literal with no PC-relative relocations can be moved anywhere. */
9227 if (reloc
[i
].opnd
!= -1)
9229 /* Otherwise, check to see that it fits. */
9230 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9231 + reloc
[i
].source_sec
->output_offset
9232 + reloc
[i
].r_rel
.rela
.r_offset
);
9233 dest_address
= (sec
->output_section
->vma
9234 + sec
->output_offset
9235 + r_rel
->target_offset
);
9237 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9238 source_address
, dest_address
))
9247 /* Move a literal to another literal location because it is
9248 the same as the other literal value. */
9251 coalesce_shared_literal (asection
*sec
,
9253 property_table_entry
*prop_table
,
9257 property_table_entry
*entry
;
9259 property_table_entry
*the_add_entry
;
9261 xtensa_relax_info
*relax_info
;
9263 relax_info
= get_xtensa_relax_info (sec
);
9267 entry
= elf_xtensa_find_property_entry
9268 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9269 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9272 /* Mark that the literal will be coalesced. */
9273 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9275 text_action_add (&relax_info
->action_list
,
9276 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9278 /* If the section is 4-byte aligned, do not add fill. */
9279 if (sec
->alignment_power
> 2)
9281 int fill_extra_space
;
9282 bfd_vma entry_sec_offset
;
9285 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9287 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9289 /* If the literal range is at the end of the section,
9291 fill_extra_space
= 0;
9292 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9294 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9295 fill_extra_space
= the_add_entry
->size
;
9297 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9298 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9299 -4, fill_extra_space
);
9301 adjust_fill_action (fa
, removed_diff
);
9303 text_action_add (&relax_info
->action_list
,
9304 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9311 /* Move a literal to another location. This may actually increase the
9312 total amount of space used because of alignments so we need to do
9313 this carefully. Also, it may make a branch go out of range. */
9316 move_shared_literal (asection
*sec
,
9317 struct bfd_link_info
*link_info
,
9319 property_table_entry
*prop_table
,
9321 const r_reloc
*target_loc
,
9322 const literal_value
*lit_value
,
9323 section_cache_t
*target_sec_cache
)
9325 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9326 text_action
*fa
, *target_fa
;
9328 xtensa_relax_info
*relax_info
, *target_relax_info
;
9329 asection
*target_sec
;
9331 ebb_constraint ebb_table
;
9334 /* If this routine always returns FALSE, the literals that cannot be
9335 coalesced will not be moved. */
9336 if (elf32xtensa_no_literal_movement
)
9339 relax_info
= get_xtensa_relax_info (sec
);
9343 target_sec
= r_reloc_get_section (target_loc
);
9344 target_relax_info
= get_xtensa_relax_info (target_sec
);
9346 /* Literals to undefined sections may not be moved because they
9347 must report an error. */
9348 if (bfd_is_und_section (target_sec
))
9351 src_entry
= elf_xtensa_find_property_entry
9352 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9354 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9357 target_entry
= elf_xtensa_find_property_entry
9358 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9359 target_sec
->vma
+ target_loc
->target_offset
);
9364 /* Make sure that we have not broken any branches. */
9367 init_ebb_constraint (&ebb_table
);
9368 ebb
= &ebb_table
.ebb
;
9369 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9370 target_sec_cache
->content_length
,
9371 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9372 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9374 /* Propose to add 4 bytes + worst-case alignment size increase to
9376 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9377 ta_fill
, target_loc
->target_offset
,
9378 -4 - (1 << target_sec
->alignment_power
), true);
9380 /* Check all of the PC-relative relocations to make sure they still fit. */
9381 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9382 target_sec_cache
->contents
,
9383 target_sec_cache
->relocs
, NULL
,
9389 text_action_add_literal (&target_relax_info
->action_list
,
9390 ta_add_literal
, target_loc
, lit_value
, -4);
9392 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9394 /* May need to add or remove some fill to maintain alignment. */
9395 int fill_extra_space
;
9396 bfd_vma entry_sec_offset
;
9399 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9401 /* If the literal range is at the end of the section,
9403 fill_extra_space
= 0;
9405 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9406 target_sec_cache
->pte_count
,
9408 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9409 fill_extra_space
= the_add_entry
->size
;
9411 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9412 target_sec
, entry_sec_offset
);
9413 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9414 entry_sec_offset
, 4,
9417 adjust_fill_action (target_fa
, removed_diff
);
9419 text_action_add (&target_relax_info
->action_list
,
9420 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9423 /* Mark that the literal will be moved to the new location. */
9424 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9426 /* Remove the literal. */
9427 text_action_add (&relax_info
->action_list
,
9428 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9430 /* If the section is 4-byte aligned, do not add fill. */
9431 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9433 int fill_extra_space
;
9434 bfd_vma entry_sec_offset
;
9437 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9439 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9441 /* If the literal range is at the end of the section,
9443 fill_extra_space
= 0;
9444 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9446 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9447 fill_extra_space
= the_add_entry
->size
;
9449 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9450 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9451 -4, fill_extra_space
);
9453 adjust_fill_action (fa
, removed_diff
);
9455 text_action_add (&relax_info
->action_list
,
9456 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9463 /* Second relaxation pass. */
9466 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9468 bfd_size_type
*final_size
= p
;
9469 text_action
*action
= (text_action
*)node
->value
;
9471 *final_size
-= action
->removed_bytes
;
9475 /* Modify all of the relocations to point to the right spot, and if this
9476 is a relaxable section, delete the unwanted literals and fix the
9480 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9482 Elf_Internal_Rela
*internal_relocs
;
9483 xtensa_relax_info
*relax_info
;
9488 bool virtual_action
;
9489 bfd_size_type sec_size
;
9491 sec_size
= bfd_get_section_limit (abfd
, sec
);
9492 relax_info
= get_xtensa_relax_info (sec
);
9493 BFD_ASSERT (relax_info
);
9495 /* First translate any of the fixes that have been added already. */
9496 translate_section_fixes (sec
);
9498 /* Handle property sections (e.g., literal tables) specially. */
9499 if (xtensa_is_property_section (sec
))
9501 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9502 return relax_property_section (abfd
, sec
, link_info
);
9505 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9506 link_info
->keep_memory
);
9507 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9510 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9511 if (contents
== NULL
&& sec_size
!= 0)
9517 if (internal_relocs
)
9519 for (i
= 0; i
< sec
->reloc_count
; i
++)
9521 Elf_Internal_Rela
*irel
;
9522 xtensa_relax_info
*target_relax_info
;
9523 bfd_vma source_offset
, old_source_offset
;
9526 asection
*target_sec
;
9528 /* Locally change the source address.
9529 Translate the target to the new target address.
9530 If it points to this section and has been removed,
9534 irel
= &internal_relocs
[i
];
9535 source_offset
= irel
->r_offset
;
9536 old_source_offset
= source_offset
;
9538 r_type
= ELF32_R_TYPE (irel
->r_info
);
9539 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9540 bfd_get_section_limit (abfd
, sec
));
9542 /* If this section could have changed then we may need to
9543 change the relocation's offset. */
9545 if (relax_info
->is_relaxable_literal_section
9546 || relax_info
->is_relaxable_asm_section
)
9548 pin_internal_relocs (sec
, internal_relocs
);
9550 if (r_type
!= R_XTENSA_NONE
9551 && find_removed_literal (&relax_info
->removed_list
,
9554 /* Remove this relocation. */
9555 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9556 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9557 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9558 irel
->r_offset
= offset_with_removed_text_map
9559 (&relax_info
->action_list
, irel
->r_offset
);
9563 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9565 text_action
*action
=
9566 find_insn_action (&relax_info
->action_list
,
9568 if (action
&& (action
->action
== ta_convert_longcall
9569 || action
->action
== ta_remove_longcall
))
9571 bfd_reloc_status_type retval
;
9572 char *error_message
= NULL
;
9574 retval
= contract_asm_expansion (contents
, sec_size
,
9575 irel
, &error_message
);
9576 if (retval
!= bfd_reloc_ok
)
9578 (*link_info
->callbacks
->reloc_dangerous
)
9579 (link_info
, error_message
, abfd
, sec
,
9583 /* Update the action so that the code that moves
9584 the contents will do the right thing. */
9585 /* ta_remove_longcall and ta_remove_insn actions are
9586 grouped together in the tree as well as
9587 ta_convert_longcall and ta_none, so that changes below
9588 can be done w/o removing and reinserting action into
9591 if (action
->action
== ta_remove_longcall
)
9592 action
->action
= ta_remove_insn
;
9594 action
->action
= ta_none
;
9595 /* Refresh the info in the r_rel. */
9596 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9597 r_type
= ELF32_R_TYPE (irel
->r_info
);
9601 source_offset
= offset_with_removed_text_map
9602 (&relax_info
->action_list
, irel
->r_offset
);
9603 irel
->r_offset
= source_offset
;
9606 /* If the target section could have changed then
9607 we may need to change the relocation's target offset. */
9609 target_sec
= r_reloc_get_section (&r_rel
);
9611 /* For a reference to a discarded section from a DWARF section,
9612 i.e., where action_discarded is PRETEND, the symbol will
9613 eventually be modified to refer to the kept section (at least if
9614 the kept and discarded sections are the same size). Anticipate
9615 that here and adjust things accordingly. */
9616 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9617 && elf_xtensa_action_discarded (sec
) == PRETEND
9618 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9619 && target_sec
!= NULL
9620 && discarded_section (target_sec
))
9622 /* It would be natural to call _bfd_elf_check_kept_section
9623 here, but it's not exported from elflink.c. It's also a
9624 fairly expensive check. Adjusting the relocations to the
9625 discarded section is fairly harmless; it will only adjust
9626 some addends and difference values. If it turns out that
9627 _bfd_elf_check_kept_section fails later, it won't matter,
9628 so just compare the section names to find the right group
9630 asection
*kept
= target_sec
->kept_section
;
9633 if ((kept
->flags
& SEC_GROUP
) != 0)
9635 asection
*first
= elf_next_in_group (kept
);
9636 asection
*s
= first
;
9641 if (strcmp (s
->name
, target_sec
->name
) == 0)
9646 s
= elf_next_in_group (s
);
9653 && ((target_sec
->rawsize
!= 0
9654 ? target_sec
->rawsize
: target_sec
->size
)
9655 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9659 target_relax_info
= get_xtensa_relax_info (target_sec
);
9660 if (target_relax_info
9661 && (target_relax_info
->is_relaxable_literal_section
9662 || target_relax_info
->is_relaxable_asm_section
))
9665 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9667 if (r_type
== R_XTENSA_DIFF8
9668 || r_type
== R_XTENSA_DIFF16
9669 || r_type
== R_XTENSA_DIFF32
9670 || r_type
== R_XTENSA_PDIFF8
9671 || r_type
== R_XTENSA_PDIFF16
9672 || r_type
== R_XTENSA_PDIFF32
9673 || r_type
== R_XTENSA_NDIFF8
9674 || r_type
== R_XTENSA_NDIFF16
9675 || r_type
== R_XTENSA_NDIFF32
)
9677 bfd_signed_vma diff_value
= 0;
9678 bfd_vma new_end_offset
, diff_mask
= 0;
9680 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9682 (*link_info
->callbacks
->reloc_dangerous
)
9683 (link_info
, _("invalid relocation address"),
9684 abfd
, sec
, old_source_offset
);
9690 case R_XTENSA_DIFF8
:
9693 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9695 case R_XTENSA_DIFF16
:
9698 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9700 case R_XTENSA_DIFF32
:
9701 diff_mask
= 0x7fffffff;
9703 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9705 case R_XTENSA_PDIFF8
:
9706 case R_XTENSA_NDIFF8
:
9709 bfd_get_8 (abfd
, &contents
[old_source_offset
]);
9711 case R_XTENSA_PDIFF16
:
9712 case R_XTENSA_NDIFF16
:
9715 bfd_get_16 (abfd
, &contents
[old_source_offset
]);
9717 case R_XTENSA_PDIFF32
:
9718 case R_XTENSA_NDIFF32
:
9719 diff_mask
= 0xffffffff;
9721 bfd_get_32 (abfd
, &contents
[old_source_offset
]);
9725 if (r_type
>= R_XTENSA_NDIFF8
9726 && r_type
<= R_XTENSA_NDIFF32
9728 diff_value
|= ~diff_mask
;
9730 new_end_offset
= offset_with_removed_text_map
9731 (&target_relax_info
->action_list
,
9732 r_rel
.target_offset
+ diff_value
);
9733 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9737 case R_XTENSA_DIFF8
:
9738 bfd_put_signed_8 (abfd
, diff_value
,
9739 &contents
[old_source_offset
]);
9741 case R_XTENSA_DIFF16
:
9742 bfd_put_signed_16 (abfd
, diff_value
,
9743 &contents
[old_source_offset
]);
9745 case R_XTENSA_DIFF32
:
9746 bfd_put_signed_32 (abfd
, diff_value
,
9747 &contents
[old_source_offset
]);
9749 case R_XTENSA_PDIFF8
:
9750 case R_XTENSA_NDIFF8
:
9751 bfd_put_8 (abfd
, diff_value
,
9752 &contents
[old_source_offset
]);
9754 case R_XTENSA_PDIFF16
:
9755 case R_XTENSA_NDIFF16
:
9756 bfd_put_16 (abfd
, diff_value
,
9757 &contents
[old_source_offset
]);
9759 case R_XTENSA_PDIFF32
:
9760 case R_XTENSA_NDIFF32
:
9761 bfd_put_32 (abfd
, diff_value
,
9762 &contents
[old_source_offset
]);
9766 /* Check for overflow. Sign bits must be all zeroes or
9767 all ones. When sign bits are all ones diff_value
9769 if (((diff_value
& ~diff_mask
) != 0
9770 && (diff_value
& ~diff_mask
) != ~diff_mask
)
9771 || (diff_value
&& (bfd_vma
) diff_value
== ~diff_mask
))
9773 (*link_info
->callbacks
->reloc_dangerous
)
9774 (link_info
, _("overflow after relaxation"),
9775 abfd
, sec
, old_source_offset
);
9779 pin_contents (sec
, contents
);
9782 /* If the relocation still references a section in the same
9783 input file, modify the relocation directly instead of
9784 adding a "fix" record. */
9785 if (target_sec
->owner
== abfd
)
9787 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9788 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9789 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9790 pin_internal_relocs (sec
, internal_relocs
);
9794 bfd_vma addend_displacement
;
9797 addend_displacement
=
9798 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9799 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9801 addend_displacement
, true);
9808 if ((relax_info
->is_relaxable_literal_section
9809 || relax_info
->is_relaxable_asm_section
)
9810 && action_list_count (&relax_info
->action_list
))
9812 /* Walk through the planned actions and build up a table
9813 of move, copy and fill records. Use the move, copy and
9814 fill records to perform the actions once. */
9816 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9817 bfd_byte
*scratch
= NULL
;
9818 bfd_byte
*dup_contents
= NULL
;
9819 bfd_size_type orig_size
= sec
->size
;
9820 bfd_vma orig_dot
= 0;
9821 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9822 orig dot in physical memory. */
9823 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9824 bfd_vma dup_dot
= 0;
9826 text_action
*action
;
9828 final_size
= sec
->size
;
9830 splay_tree_foreach (relax_info
->action_list
.tree
,
9831 action_remove_bytes_fn
, &final_size
);
9832 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9833 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9835 /* The dot is the current fill location. */
9837 print_action_list (stderr
, &relax_info
->action_list
);
9840 for (action
= action_first (&relax_info
->action_list
); action
;
9841 action
= action_next (&relax_info
->action_list
, action
))
9843 virtual_action
= false;
9844 if (action
->offset
> orig_dot
)
9846 orig_dot
+= orig_dot_copied
;
9847 orig_dot_copied
= 0;
9849 /* Out of the virtual world. */
9852 if (action
->offset
> orig_dot
)
9854 copy_size
= action
->offset
- orig_dot
;
9855 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9856 orig_dot
+= copy_size
;
9857 dup_dot
+= copy_size
;
9858 BFD_ASSERT (action
->offset
== orig_dot
);
9860 else if (action
->offset
< orig_dot
)
9862 if (action
->action
== ta_fill
9863 && action
->offset
- action
->removed_bytes
== orig_dot
)
9865 /* This is OK because the fill only effects the dup_dot. */
9867 else if (action
->action
== ta_add_literal
)
9869 /* TBD. Might need to handle this. */
9872 if (action
->offset
== orig_dot
)
9874 if (action
->virtual_offset
> orig_dot_vo
)
9876 if (orig_dot_vo
== 0)
9878 /* Need to copy virtual_offset bytes. Probably four. */
9879 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9880 memmove (&dup_contents
[dup_dot
],
9881 &contents
[orig_dot
], copy_size
);
9882 orig_dot_copied
= copy_size
;
9883 dup_dot
+= copy_size
;
9885 virtual_action
= true;
9888 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9890 switch (action
->action
)
9892 case ta_remove_literal
:
9893 case ta_remove_insn
:
9894 BFD_ASSERT (action
->removed_bytes
>= 0);
9895 orig_dot
+= action
->removed_bytes
;
9898 case ta_narrow_insn
:
9901 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9902 BFD_ASSERT (action
->removed_bytes
== 1);
9903 rv
= narrow_instruction (scratch
, final_size
, 0);
9905 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9906 orig_dot
+= orig_insn_size
;
9907 dup_dot
+= copy_size
;
9911 if (action
->removed_bytes
>= 0)
9912 orig_dot
+= action
->removed_bytes
;
9915 /* Already zeroed in dup_contents. Just bump the
9917 dup_dot
+= (-action
->removed_bytes
);
9922 BFD_ASSERT (action
->removed_bytes
== 0);
9925 case ta_convert_longcall
:
9926 case ta_remove_longcall
:
9927 /* These will be removed or converted before we get here. */
9934 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9935 BFD_ASSERT (action
->removed_bytes
== -1);
9936 rv
= widen_instruction (scratch
, final_size
, 0);
9938 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9939 orig_dot
+= orig_insn_size
;
9940 dup_dot
+= copy_size
;
9943 case ta_add_literal
:
9946 BFD_ASSERT (action
->removed_bytes
== -4);
9947 /* TBD -- place the literal value here and insert
9949 memset (&dup_contents
[dup_dot
], 0, 4);
9950 pin_internal_relocs (sec
, internal_relocs
);
9951 pin_contents (sec
, contents
);
9953 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9954 relax_info
, &internal_relocs
, &action
->value
))
9958 orig_dot_vo
+= copy_size
;
9960 orig_dot
+= orig_insn_size
;
9961 dup_dot
+= copy_size
;
9965 /* Not implemented yet. */
9970 BFD_ASSERT (dup_dot
<= final_size
);
9971 BFD_ASSERT (orig_dot
<= orig_size
);
9974 orig_dot
+= orig_dot_copied
;
9975 orig_dot_copied
= 0;
9977 if (orig_dot
!= orig_size
)
9979 copy_size
= orig_size
- orig_dot
;
9980 BFD_ASSERT (orig_size
> orig_dot
);
9981 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9982 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9983 orig_dot
+= copy_size
;
9984 dup_dot
+= copy_size
;
9986 BFD_ASSERT (orig_size
== orig_dot
);
9987 BFD_ASSERT (final_size
== dup_dot
);
9989 /* Move the dup_contents back. */
9990 if (final_size
> orig_size
)
9992 /* Contents need to be reallocated. Swap the dup_contents into
9994 sec
->contents
= dup_contents
;
9996 contents
= dup_contents
;
9997 pin_contents (sec
, contents
);
10001 BFD_ASSERT (final_size
<= orig_size
);
10002 memset (contents
, 0, orig_size
);
10003 memcpy (contents
, dup_contents
, final_size
);
10004 free (dup_contents
);
10007 pin_contents (sec
, contents
);
10009 if (sec
->rawsize
== 0)
10010 sec
->rawsize
= sec
->size
;
10011 sec
->size
= final_size
;
10015 release_internal_relocs (sec
, internal_relocs
);
10016 release_contents (sec
, contents
);
10022 translate_section_fixes (asection
*sec
)
10024 xtensa_relax_info
*relax_info
;
10027 relax_info
= get_xtensa_relax_info (sec
);
10031 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
10032 if (!translate_reloc_bfd_fix (r
))
10039 /* Translate a fix given the mapping in the relax info for the target
10040 section. If it has already been translated, no work is required. */
10043 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
10045 reloc_bfd_fix new_fix
;
10047 xtensa_relax_info
*relax_info
;
10048 removed_literal
*removed
;
10049 bfd_vma new_offset
, target_offset
;
10051 if (fix
->translated
)
10054 sec
= fix
->target_sec
;
10055 target_offset
= fix
->target_offset
;
10057 relax_info
= get_xtensa_relax_info (sec
);
10060 fix
->translated
= true;
10066 /* The fix does not need to be translated if the section cannot change. */
10067 if (!relax_info
->is_relaxable_literal_section
10068 && !relax_info
->is_relaxable_asm_section
)
10070 fix
->translated
= true;
10074 /* If the literal has been moved and this relocation was on an
10075 opcode, then the relocation should move to the new literal
10076 location. Otherwise, the relocation should move within the
10080 if (is_operand_relocation (fix
->src_type
))
10082 /* Check if the original relocation is against a literal being
10084 removed
= find_removed_literal (&relax_info
->removed_list
,
10092 /* The fact that there is still a relocation to this literal indicates
10093 that the literal is being coalesced, not simply removed. */
10094 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10096 /* This was moved to some other address (possibly another section). */
10097 new_sec
= r_reloc_get_section (&removed
->to
);
10098 if (new_sec
!= sec
)
10101 relax_info
= get_xtensa_relax_info (sec
);
10103 (!relax_info
->is_relaxable_literal_section
10104 && !relax_info
->is_relaxable_asm_section
))
10106 target_offset
= removed
->to
.target_offset
;
10107 new_fix
.target_sec
= new_sec
;
10108 new_fix
.target_offset
= target_offset
;
10109 new_fix
.translated
= true;
10114 target_offset
= removed
->to
.target_offset
;
10115 new_fix
.target_sec
= new_sec
;
10118 /* The target address may have been moved within its section. */
10119 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
10122 new_fix
.target_offset
= new_offset
;
10123 new_fix
.target_offset
= new_offset
;
10124 new_fix
.translated
= true;
10130 /* Fix up a relocation to take account of removed literals. */
10133 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
10135 xtensa_relax_info
*relax_info
;
10136 removed_literal
*removed
;
10137 bfd_vma target_offset
, base_offset
;
10139 *new_rel
= *orig_rel
;
10141 if (!r_reloc_is_defined (orig_rel
))
10144 relax_info
= get_xtensa_relax_info (sec
);
10145 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
10146 || relax_info
->is_relaxable_asm_section
));
10148 target_offset
= orig_rel
->target_offset
;
10151 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
10153 /* Check if the original relocation is against a literal being
10155 removed
= find_removed_literal (&relax_info
->removed_list
,
10158 if (removed
&& removed
->to
.abfd
)
10162 /* The fact that there is still a relocation to this literal indicates
10163 that the literal is being coalesced, not simply removed. */
10164 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10166 /* This was moved to some other address
10167 (possibly in another section). */
10168 *new_rel
= removed
->to
;
10169 new_sec
= r_reloc_get_section (new_rel
);
10170 if (new_sec
!= sec
)
10173 relax_info
= get_xtensa_relax_info (sec
);
10175 || (!relax_info
->is_relaxable_literal_section
10176 && !relax_info
->is_relaxable_asm_section
))
10179 target_offset
= new_rel
->target_offset
;
10182 /* Find the base offset of the reloc symbol, excluding any addend from the
10183 reloc or from the section contents (for a partial_inplace reloc). Then
10184 find the adjusted values of the offsets due to relaxation. The base
10185 offset is needed to determine the change to the reloc's addend; the reloc
10186 addend should not be adjusted due to relaxations located before the base
10189 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
10190 if (base_offset
<= target_offset
)
10192 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
10193 base_offset
, false);
10194 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10195 target_offset
, false) -
10198 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
10199 new_rel
->rela
.r_addend
-= addend_removed
;
10203 /* Handle a negative addend. The base offset comes first. */
10204 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
10205 target_offset
, false);
10206 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10207 base_offset
, false) -
10210 new_rel
->target_offset
= target_offset
- tgt_removed
;
10211 new_rel
->rela
.r_addend
+= addend_removed
;
10218 /* For dynamic links, there may be a dynamic relocation for each
10219 literal. The number of dynamic relocations must be computed in
10220 size_dynamic_sections, which occurs before relaxation. When a
10221 literal is removed, this function checks if there is a corresponding
10222 dynamic relocation and shrinks the size of the appropriate dynamic
10223 relocation section accordingly. At this point, the contents of the
10224 dynamic relocation sections have not yet been filled in, so there's
10225 nothing else that needs to be done. */
10228 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
10230 asection
*input_section
,
10231 Elf_Internal_Rela
*rel
)
10233 struct elf_xtensa_link_hash_table
*htab
;
10234 Elf_Internal_Shdr
*symtab_hdr
;
10235 struct elf_link_hash_entry
**sym_hashes
;
10236 unsigned long r_symndx
;
10238 struct elf_link_hash_entry
*h
;
10239 bool dynamic_symbol
;
10241 htab
= elf_xtensa_hash_table (info
);
10245 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10246 sym_hashes
= elf_sym_hashes (abfd
);
10248 r_type
= ELF32_R_TYPE (rel
->r_info
);
10249 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10251 if (r_symndx
< symtab_hdr
->sh_info
)
10254 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10256 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10258 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10259 && (input_section
->flags
& SEC_ALLOC
) != 0
10261 || (bfd_link_pic (info
)
10262 && (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
))))
10265 bool is_plt
= false;
10267 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10269 srel
= htab
->elf
.srelplt
;
10273 srel
= htab
->elf
.srelgot
;
10275 /* Reduce size of the .rela.* section by one reloc. */
10276 BFD_ASSERT (srel
!= NULL
);
10277 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10278 srel
->size
-= sizeof (Elf32_External_Rela
);
10282 asection
*splt
, *sgotplt
, *srelgot
;
10283 int reloc_index
, chunk
;
10285 /* Find the PLT reloc index of the entry being removed. This
10286 is computed from the size of ".rela.plt". It is needed to
10287 figure out which PLT chunk to resize. Usually "last index
10288 = size - 1" since the index starts at zero, but in this
10289 context, the size has just been decremented so there's no
10290 need to subtract one. */
10291 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10293 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10294 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10295 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10296 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10298 /* Check if an entire PLT chunk has just been eliminated. */
10299 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10301 /* The two magic GOT entries for that chunk can go away. */
10302 srelgot
= htab
->elf
.srelgot
;
10303 BFD_ASSERT (srelgot
!= NULL
);
10304 srelgot
->reloc_count
-= 2;
10305 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10306 sgotplt
->size
-= 8;
10308 /* There should be only one entry left (and it will be
10310 BFD_ASSERT (sgotplt
->size
== 4);
10311 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10314 BFD_ASSERT (sgotplt
->size
>= 4);
10315 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10317 sgotplt
->size
-= 4;
10318 splt
->size
-= PLT_ENTRY_SIZE
;
10324 /* Take an r_rel and move it to another section. This usually
10325 requires extending the interal_relocation array and pinning it. If
10326 the original r_rel is from the same BFD, we can complete this here.
10327 Otherwise, we add a fix record to let the final link fix the
10328 appropriate address. Contents and internal relocations for the
10329 section must be pinned after calling this routine. */
10332 move_literal (bfd
*abfd
,
10333 struct bfd_link_info
*link_info
,
10336 bfd_byte
*contents
,
10337 xtensa_relax_info
*relax_info
,
10338 Elf_Internal_Rela
**internal_relocs_p
,
10339 const literal_value
*lit
)
10341 Elf_Internal_Rela
*new_relocs
= NULL
;
10342 size_t new_relocs_count
= 0;
10343 Elf_Internal_Rela this_rela
;
10344 const r_reloc
*r_rel
;
10346 r_rel
= &lit
->r_rel
;
10347 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10349 if (r_reloc_is_const (r_rel
))
10350 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10355 reloc_bfd_fix
*fix
;
10356 unsigned insert_at
;
10358 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10360 /* This is the difficult case. We have to create a fix up. */
10361 this_rela
.r_offset
= offset
;
10362 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10363 this_rela
.r_addend
=
10364 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10365 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10367 /* Currently, we cannot move relocations during a relocatable link. */
10368 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10369 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10370 r_reloc_get_section (r_rel
),
10371 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10373 /* We also need to mark that relocations are needed here. */
10374 sec
->flags
|= SEC_RELOC
;
10376 translate_reloc_bfd_fix (fix
);
10377 /* This fix has not yet been translated. */
10378 add_fix (sec
, fix
);
10380 /* Add the relocation. If we have already allocated our own
10381 space for the relocations and we have room for more, then use
10382 it. Otherwise, allocate new space and move the literals. */
10383 insert_at
= sec
->reloc_count
;
10384 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10386 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10393 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10394 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10396 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10397 || sec
->reloc_count
== relax_info
->relocs_count
);
10399 if (relax_info
->allocated_relocs_count
== 0)
10400 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10402 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10404 new_relocs
= (Elf_Internal_Rela
*)
10405 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10409 /* We could handle this more quickly by finding the split point. */
10410 if (insert_at
!= 0)
10411 memcpy (new_relocs
, *internal_relocs_p
,
10412 insert_at
* sizeof (Elf_Internal_Rela
));
10414 new_relocs
[insert_at
] = this_rela
;
10416 if (insert_at
!= sec
->reloc_count
)
10417 memcpy (new_relocs
+ insert_at
+ 1,
10418 (*internal_relocs_p
) + insert_at
,
10419 (sec
->reloc_count
- insert_at
)
10420 * sizeof (Elf_Internal_Rela
));
10422 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10424 /* The first time we re-allocate, we can only free the
10425 old relocs if they were allocated with bfd_malloc.
10426 This is not true when keep_memory is in effect. */
10427 if (!link_info
->keep_memory
)
10428 free (*internal_relocs_p
);
10431 free (*internal_relocs_p
);
10432 relax_info
->allocated_relocs
= new_relocs
;
10433 relax_info
->allocated_relocs_count
= new_relocs_count
;
10434 elf_section_data (sec
)->relocs
= new_relocs
;
10435 sec
->reloc_count
++;
10436 relax_info
->relocs_count
= sec
->reloc_count
;
10437 *internal_relocs_p
= new_relocs
;
10441 if (insert_at
!= sec
->reloc_count
)
10444 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10445 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10447 (*internal_relocs_p
)[insert_at
] = this_rela
;
10448 sec
->reloc_count
++;
10449 if (relax_info
->allocated_relocs
)
10450 relax_info
->relocs_count
= sec
->reloc_count
;
10457 /* This is similar to relax_section except that when a target is moved,
10458 we shift addresses up. We also need to modify the size. This
10459 algorithm does NOT allow for relocations into the middle of the
10460 property sections. */
10463 relax_property_section (bfd
*abfd
,
10465 struct bfd_link_info
*link_info
)
10467 Elf_Internal_Rela
*internal_relocs
;
10468 bfd_byte
*contents
;
10471 bool is_full_prop_section
;
10472 size_t last_zfill_target_offset
= 0;
10473 asection
*last_zfill_target_sec
= NULL
;
10474 bfd_size_type sec_size
;
10475 bfd_size_type entry_size
;
10477 sec_size
= bfd_get_section_limit (abfd
, sec
);
10478 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10479 link_info
->keep_memory
);
10480 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10481 if (contents
== NULL
&& sec_size
!= 0)
10487 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10488 if (is_full_prop_section
)
10493 if (internal_relocs
)
10495 for (i
= 0; i
< sec
->reloc_count
; i
++)
10497 Elf_Internal_Rela
*irel
;
10498 xtensa_relax_info
*target_relax_info
;
10500 asection
*target_sec
;
10502 bfd_byte
*size_p
, *flags_p
;
10504 /* Locally change the source address.
10505 Translate the target to the new target address.
10506 If it points to this section and has been removed, MOVE IT.
10507 Also, don't forget to modify the associated SIZE at
10510 irel
= &internal_relocs
[i
];
10511 r_type
= ELF32_R_TYPE (irel
->r_info
);
10512 if (r_type
== R_XTENSA_NONE
)
10515 /* Find the literal value. */
10516 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10517 size_p
= &contents
[irel
->r_offset
+ 4];
10519 if (is_full_prop_section
)
10520 flags_p
= &contents
[irel
->r_offset
+ 8];
10521 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10523 target_sec
= r_reloc_get_section (&val
.r_rel
);
10524 target_relax_info
= get_xtensa_relax_info (target_sec
);
10526 if (target_relax_info
10527 && (target_relax_info
->is_relaxable_literal_section
10528 || target_relax_info
->is_relaxable_asm_section
))
10530 /* Translate the relocation's destination. */
10531 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10532 bfd_vma new_offset
;
10533 long old_size
, new_size
;
10534 int removed_by_old_offset
=
10535 removed_by_actions_map (&target_relax_info
->action_list
,
10536 old_offset
, false);
10537 new_offset
= old_offset
- removed_by_old_offset
;
10539 /* Assert that we are not out of bounds. */
10540 old_size
= bfd_get_32 (abfd
, size_p
);
10541 new_size
= old_size
;
10545 /* Only the first zero-sized unreachable entry is
10546 allowed to expand. In this case the new offset
10547 should be the offset before the fill and the new
10548 size is the expansion size. For other zero-sized
10549 entries the resulting size should be zero with an
10550 offset before or after the fill address depending
10551 on whether the expanding unreachable entry
10553 if (last_zfill_target_sec
== 0
10554 || last_zfill_target_sec
!= target_sec
10555 || last_zfill_target_offset
!= old_offset
)
10557 bfd_vma new_end_offset
= new_offset
;
10559 /* Recompute the new_offset, but this time don't
10560 include any fill inserted by relaxation. */
10561 removed_by_old_offset
=
10562 removed_by_actions_map (&target_relax_info
->action_list
,
10564 new_offset
= old_offset
- removed_by_old_offset
;
10566 /* If it is not unreachable and we have not yet
10567 seen an unreachable at this address, place it
10568 before the fill address. */
10569 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10570 & XTENSA_PROP_UNREACHABLE
) != 0)
10572 new_size
= new_end_offset
- new_offset
;
10574 last_zfill_target_sec
= target_sec
;
10575 last_zfill_target_offset
= old_offset
;
10581 int removed_by_old_offset_size
=
10582 removed_by_actions_map (&target_relax_info
->action_list
,
10583 old_offset
+ old_size
, true);
10584 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10587 if (new_size
!= old_size
)
10589 bfd_put_32 (abfd
, new_size
, size_p
);
10590 pin_contents (sec
, contents
);
10593 if (new_offset
!= old_offset
)
10595 bfd_vma diff
= new_offset
- old_offset
;
10596 irel
->r_addend
+= diff
;
10597 pin_internal_relocs (sec
, internal_relocs
);
10603 /* Combine adjacent property table entries. This is also done in
10604 finish_dynamic_sections() but at that point it's too late to
10605 reclaim the space in the output section, so we do this twice. */
10607 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10608 || xtensa_is_littable_section (sec
)))
10610 Elf_Internal_Rela
*last_irel
= NULL
;
10611 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10612 int removed_bytes
= 0;
10614 flagword predef_flags
;
10616 predef_flags
= xtensa_get_property_predef_flags (sec
);
10618 /* Walk over memory and relocations at the same time.
10619 This REQUIRES that the internal_relocs be sorted by offset. */
10620 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10621 internal_reloc_compare
);
10623 pin_internal_relocs (sec
, internal_relocs
);
10624 pin_contents (sec
, contents
);
10626 next_rel
= internal_relocs
;
10627 rel_end
= internal_relocs
+ sec
->reloc_count
;
10629 BFD_ASSERT (sec
->size
% entry_size
== 0);
10631 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10633 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10634 bfd_vma bytes_to_remove
, size
, actual_offset
;
10635 bool remove_this_rel
;
10638 /* Find the first relocation for the entry at the current offset.
10639 Adjust the offsets of any extra relocations for the previous
10644 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10646 if ((irel
->r_offset
== offset
10647 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10648 || irel
->r_offset
> offset
)
10653 irel
->r_offset
-= removed_bytes
;
10657 /* Find the next relocation (if there are any left). */
10661 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10663 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10671 /* Check if there are relocations on the current entry. There
10672 should usually be a relocation on the offset field. If there
10673 are relocations on the size or flags, then we can't optimize
10674 this entry. Also, find the next relocation to examine on the
10678 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10680 next_rel
= offset_rel
;
10681 /* There are no relocations on the current entry, but we
10682 might still be able to remove it if the size is zero. */
10685 else if (offset_rel
->r_offset
> offset
10687 && extra_rel
->r_offset
< offset
+ entry_size
))
10689 /* There is a relocation on the size or flags, so we can't
10690 do anything with this entry. Continue with the next. */
10691 next_rel
= offset_rel
;
10696 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10697 offset_rel
->r_offset
-= removed_bytes
;
10698 next_rel
= offset_rel
+ 1;
10704 remove_this_rel
= false;
10705 bytes_to_remove
= 0;
10706 actual_offset
= offset
- removed_bytes
;
10707 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10709 if (is_full_prop_section
)
10710 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10712 flags
= predef_flags
;
10715 && (flags
& XTENSA_PROP_ALIGN
) == 0
10716 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10718 /* Always remove entries with zero size and no alignment. */
10719 bytes_to_remove
= entry_size
;
10721 remove_this_rel
= true;
10723 else if (offset_rel
10724 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10728 flagword old_flags
;
10730 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10731 bfd_vma old_address
=
10732 (last_irel
->r_addend
10733 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10734 bfd_vma new_address
=
10735 (offset_rel
->r_addend
10736 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10737 if (is_full_prop_section
)
10738 old_flags
= bfd_get_32
10739 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10741 old_flags
= predef_flags
;
10743 if ((ELF32_R_SYM (offset_rel
->r_info
)
10744 == ELF32_R_SYM (last_irel
->r_info
))
10745 && old_address
+ old_size
== new_address
10746 && old_flags
== flags
10747 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10748 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10750 /* Fix the old size. */
10751 bfd_put_32 (abfd
, old_size
+ size
,
10752 &contents
[last_irel
->r_offset
+ 4]);
10753 bytes_to_remove
= entry_size
;
10754 remove_this_rel
= true;
10757 last_irel
= offset_rel
;
10760 last_irel
= offset_rel
;
10763 if (remove_this_rel
)
10765 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10766 offset_rel
->r_offset
= 0;
10769 if (bytes_to_remove
!= 0)
10771 removed_bytes
+= bytes_to_remove
;
10772 if (offset
+ bytes_to_remove
< sec
->size
)
10773 memmove (&contents
[actual_offset
],
10774 &contents
[actual_offset
+ bytes_to_remove
],
10775 sec
->size
- offset
- bytes_to_remove
);
10781 /* Fix up any extra relocations on the last entry. */
10782 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10783 irel
->r_offset
-= removed_bytes
;
10785 /* Clear the removed bytes. */
10786 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10788 if (sec
->rawsize
== 0)
10789 sec
->rawsize
= sec
->size
;
10790 sec
->size
-= removed_bytes
;
10792 if (xtensa_is_littable_section (sec
))
10794 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10796 sgotloc
->size
-= removed_bytes
;
10802 release_internal_relocs (sec
, internal_relocs
);
10803 release_contents (sec
, contents
);
10808 /* Third relaxation pass. */
10810 /* Change symbol values to account for removed literals. */
10813 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10815 xtensa_relax_info
*relax_info
;
10816 unsigned int sec_shndx
;
10817 Elf_Internal_Shdr
*symtab_hdr
;
10818 Elf_Internal_Sym
*isymbuf
;
10819 unsigned i
, num_syms
, num_locals
;
10821 relax_info
= get_xtensa_relax_info (sec
);
10822 BFD_ASSERT (relax_info
);
10824 if (!relax_info
->is_relaxable_literal_section
10825 && !relax_info
->is_relaxable_asm_section
)
10828 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10830 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10831 isymbuf
= retrieve_local_syms (abfd
);
10833 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10834 num_locals
= symtab_hdr
->sh_info
;
10836 /* Adjust the local symbols defined in this section. */
10837 for (i
= 0; i
< num_locals
; i
++)
10839 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10841 if (isym
->st_shndx
== sec_shndx
)
10843 bfd_vma orig_addr
= isym
->st_value
;
10844 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10847 isym
->st_value
-= removed
;
10848 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10850 removed_by_actions_map (&relax_info
->action_list
,
10851 orig_addr
+ isym
->st_size
, false) -
10856 /* Now adjust the global symbols defined in this section. */
10857 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10859 struct elf_link_hash_entry
*sym_hash
;
10861 sym_hash
= elf_sym_hashes (abfd
)[i
];
10863 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10864 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10866 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10867 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10868 && sym_hash
->root
.u
.def
.section
== sec
)
10870 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10871 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10874 sym_hash
->root
.u
.def
.value
-= removed
;
10876 if (sym_hash
->type
== STT_FUNC
)
10878 removed_by_actions_map (&relax_info
->action_list
,
10879 orig_addr
+ sym_hash
->size
, false) -
10888 /* "Fix" handling functions, called while performing relocations. */
10891 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10893 asection
*input_section
,
10894 bfd_byte
*contents
)
10897 asection
*sec
, *old_sec
;
10898 bfd_vma old_offset
;
10899 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10900 reloc_bfd_fix
*fix
;
10902 if (r_type
== R_XTENSA_NONE
)
10905 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10909 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10910 bfd_get_section_limit (input_bfd
, input_section
));
10911 old_sec
= r_reloc_get_section (&r_rel
);
10912 old_offset
= r_rel
.target_offset
;
10914 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10916 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10919 /* xgettext:c-format */
10920 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10921 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10922 elf_howto_table
[r_type
].name
);
10925 /* Leave it be. Resolution will happen in a later stage. */
10929 sec
= fix
->target_sec
;
10930 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10931 - (old_sec
->output_offset
+ old_offset
));
10938 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10940 asection
*input_section
,
10941 bfd_byte
*contents
,
10942 bfd_vma
*relocationp
)
10945 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10946 reloc_bfd_fix
*fix
;
10947 bfd_vma fixup_diff
;
10949 if (r_type
== R_XTENSA_NONE
)
10952 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10956 sec
= fix
->target_sec
;
10958 fixup_diff
= rel
->r_addend
;
10959 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10961 bfd_vma inplace_val
;
10962 BFD_ASSERT (fix
->src_offset
10963 < bfd_get_section_limit (input_bfd
, input_section
));
10964 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10965 fixup_diff
+= inplace_val
;
10968 *relocationp
= (sec
->output_section
->vma
10969 + sec
->output_offset
10970 + fix
->target_offset
- fixup_diff
);
10974 /* Miscellaneous utility functions.... */
10977 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10983 return elf_hash_table (info
)->splt
;
10985 dynobj
= elf_hash_table (info
)->dynobj
;
10986 sprintf (plt_name
, ".plt.%u", chunk
);
10987 return bfd_get_linker_section (dynobj
, plt_name
);
10992 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10998 return elf_hash_table (info
)->sgotplt
;
11000 dynobj
= elf_hash_table (info
)->dynobj
;
11001 sprintf (got_name
, ".got.plt.%u", chunk
);
11002 return bfd_get_linker_section (dynobj
, got_name
);
11006 /* Get the input section for a given symbol index.
11008 . a section symbol, return the section;
11009 . a common symbol, return the common section;
11010 . an undefined symbol, return the undefined section;
11011 . an indirect symbol, follow the links;
11012 . an absolute value, return the absolute section. */
11015 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
11017 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11018 asection
*target_sec
= NULL
;
11019 if (r_symndx
< symtab_hdr
->sh_info
)
11021 Elf_Internal_Sym
*isymbuf
;
11022 unsigned int section_index
;
11024 isymbuf
= retrieve_local_syms (abfd
);
11025 section_index
= isymbuf
[r_symndx
].st_shndx
;
11027 if (section_index
== SHN_UNDEF
)
11028 target_sec
= bfd_und_section_ptr
;
11029 else if (section_index
== SHN_ABS
)
11030 target_sec
= bfd_abs_section_ptr
;
11031 else if (section_index
== SHN_COMMON
)
11032 target_sec
= bfd_com_section_ptr
;
11034 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
11038 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11039 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
11041 while (h
->root
.type
== bfd_link_hash_indirect
11042 || h
->root
.type
== bfd_link_hash_warning
)
11043 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11045 switch (h
->root
.type
)
11047 case bfd_link_hash_defined
:
11048 case bfd_link_hash_defweak
:
11049 target_sec
= h
->root
.u
.def
.section
;
11051 case bfd_link_hash_common
:
11052 target_sec
= bfd_com_section_ptr
;
11054 case bfd_link_hash_undefined
:
11055 case bfd_link_hash_undefweak
:
11056 target_sec
= bfd_und_section_ptr
;
11058 default: /* New indirect warning. */
11059 target_sec
= bfd_und_section_ptr
;
11067 static struct elf_link_hash_entry
*
11068 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
11070 unsigned long indx
;
11071 struct elf_link_hash_entry
*h
;
11072 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11074 if (r_symndx
< symtab_hdr
->sh_info
)
11077 indx
= r_symndx
- symtab_hdr
->sh_info
;
11078 h
= elf_sym_hashes (abfd
)[indx
];
11079 while (h
->root
.type
== bfd_link_hash_indirect
11080 || h
->root
.type
== bfd_link_hash_warning
)
11081 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11086 /* Get the section-relative offset for a symbol number. */
11089 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
11091 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11092 bfd_vma offset
= 0;
11094 if (r_symndx
< symtab_hdr
->sh_info
)
11096 Elf_Internal_Sym
*isymbuf
;
11097 isymbuf
= retrieve_local_syms (abfd
);
11098 offset
= isymbuf
[r_symndx
].st_value
;
11102 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11103 struct elf_link_hash_entry
*h
=
11104 elf_sym_hashes (abfd
)[indx
];
11106 while (h
->root
.type
== bfd_link_hash_indirect
11107 || h
->root
.type
== bfd_link_hash_warning
)
11108 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11109 if (h
->root
.type
== bfd_link_hash_defined
11110 || h
->root
.type
== bfd_link_hash_defweak
)
11111 offset
= h
->root
.u
.def
.value
;
11118 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
11120 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
11121 struct elf_link_hash_entry
*h
;
11123 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
11124 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
11131 pcrel_reloc_fits (xtensa_opcode opc
,
11133 bfd_vma self_address
,
11134 bfd_vma dest_address
)
11136 xtensa_isa isa
= xtensa_default_isa
;
11137 uint32 valp
= dest_address
;
11138 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
11139 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
11146 xtensa_is_property_section (asection
*sec
)
11148 if (xtensa_is_insntable_section (sec
)
11149 || xtensa_is_littable_section (sec
)
11150 || xtensa_is_proptable_section (sec
))
11158 xtensa_is_insntable_section (asection
*sec
)
11160 if (startswith (sec
->name
, XTENSA_INSN_SEC_NAME
)
11161 || startswith (sec
->name
, ".gnu.linkonce.x."))
11169 xtensa_is_littable_section (asection
*sec
)
11171 if (startswith (sec
->name
, XTENSA_LIT_SEC_NAME
)
11172 || startswith (sec
->name
, ".gnu.linkonce.p."))
11180 xtensa_is_proptable_section (asection
*sec
)
11182 if (startswith (sec
->name
, XTENSA_PROP_SEC_NAME
)
11183 || startswith (sec
->name
, ".gnu.linkonce.prop."))
11191 internal_reloc_compare (const void *ap
, const void *bp
)
11193 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11194 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11196 if (a
->r_offset
!= b
->r_offset
)
11197 return (a
->r_offset
- b
->r_offset
);
11199 /* We don't need to sort on these criteria for correctness,
11200 but enforcing a more strict ordering prevents unstable qsort
11201 from behaving differently with different implementations.
11202 Without the code below we get correct but different results
11203 on Solaris 2.7 and 2.8. We would like to always produce the
11204 same results no matter the host. */
11206 if (a
->r_info
!= b
->r_info
)
11207 return (a
->r_info
- b
->r_info
);
11209 return (a
->r_addend
- b
->r_addend
);
11214 internal_reloc_matches (const void *ap
, const void *bp
)
11216 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11217 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11219 /* Check if one entry overlaps with the other; this shouldn't happen
11220 except when searching for a match. */
11221 return (a
->r_offset
- b
->r_offset
);
11225 /* Predicate function used to look up a section in a particular group. */
11228 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
11230 const char *gname
= inf
;
11231 const char *group_name
= elf_group_name (sec
);
11233 return (group_name
== gname
11234 || (group_name
!= NULL
11236 && strcmp (group_name
, gname
) == 0));
11241 xtensa_add_names (const char *base
, const char *suffix
)
11245 size_t base_len
= strlen (base
);
11246 size_t suffix_len
= strlen (suffix
);
11247 char *str
= bfd_malloc (base_len
+ suffix_len
+ 1);
11249 memcpy (str
, base
, base_len
);
11250 memcpy (str
+ base_len
, suffix
, suffix_len
+ 1);
11255 return strdup (base
);
11259 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11262 xtensa_property_section_name (asection
*sec
, const char *base_name
,
11263 bool separate_sections
)
11265 const char *suffix
, *group_name
;
11266 char *prop_sec_name
;
11268 group_name
= elf_group_name (sec
);
11271 suffix
= strrchr (sec
->name
, '.');
11272 if (suffix
== sec
->name
)
11274 prop_sec_name
= xtensa_add_names (base_name
, suffix
);
11276 else if (startswith (sec
->name
, ".gnu.linkonce."))
11278 char *linkonce_kind
= 0;
11280 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11281 linkonce_kind
= "x.";
11282 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11283 linkonce_kind
= "p.";
11284 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11285 linkonce_kind
= "prop.";
11289 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11290 + strlen (linkonce_kind
) + 1);
11291 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11292 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11294 suffix
= sec
->name
+ linkonce_len
;
11295 /* For backward compatibility, replace "t." instead of inserting
11296 the new linkonce_kind (but not for "prop" sections). */
11297 if (startswith (suffix
, "t.") && linkonce_kind
[1] == '.')
11299 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11303 prop_sec_name
= xtensa_add_names (base_name
,
11304 separate_sections
? sec
->name
: NULL
);
11307 return prop_sec_name
;
11312 xtensa_get_separate_property_section (asection
*sec
, const char *base_name
,
11313 bool separate_section
)
11315 char *prop_sec_name
;
11316 asection
*prop_sec
;
11318 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11320 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11321 match_section_group
,
11322 (void *) elf_group_name (sec
));
11323 free (prop_sec_name
);
11328 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11330 asection
*prop_sec
;
11332 /* Try individual property section first. */
11333 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, true);
11335 /* Refer to a common property section if individual is not present. */
11337 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, false);
11344 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11346 char *prop_sec_name
;
11347 asection
*prop_sec
;
11349 /* Check if the section already exists. */
11350 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11351 elf32xtensa_separate_props
);
11352 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11353 match_section_group
,
11354 (void *) elf_group_name (sec
));
11355 /* If not, create it. */
11358 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11359 flags
|= (bfd_section_flags (sec
)
11360 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11362 prop_sec
= bfd_make_section_anyway_with_flags
11363 (sec
->owner
, strdup (prop_sec_name
), flags
);
11367 elf_group_name (prop_sec
) = elf_group_name (sec
);
11370 free (prop_sec_name
);
11376 xtensa_get_property_predef_flags (asection
*sec
)
11378 if (xtensa_is_insntable_section (sec
))
11379 return (XTENSA_PROP_INSN
11380 | XTENSA_PROP_NO_TRANSFORM
11381 | XTENSA_PROP_INSN_NO_REORDER
);
11383 if (xtensa_is_littable_section (sec
))
11384 return (XTENSA_PROP_LITERAL
11385 | XTENSA_PROP_NO_TRANSFORM
11386 | XTENSA_PROP_INSN_NO_REORDER
);
11392 /* Other functions called directly by the linker. */
11395 xtensa_callback_required_dependence (bfd
*abfd
,
11397 struct bfd_link_info
*link_info
,
11398 deps_callback_t callback
,
11401 Elf_Internal_Rela
*internal_relocs
;
11402 bfd_byte
*contents
;
11405 bfd_size_type sec_size
;
11407 sec_size
= bfd_get_section_limit (abfd
, sec
);
11409 /* ".plt*" sections have no explicit relocations but they contain L32R
11410 instructions that reference the corresponding ".got.plt*" sections. */
11411 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11412 && startswith (sec
->name
, ".plt"))
11416 /* Find the corresponding ".got.plt*" section. */
11417 if (sec
->name
[4] == '\0')
11418 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11424 BFD_ASSERT (sec
->name
[4] == '.');
11425 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11427 sprintf (got_name
, ".got.plt.%u", chunk
);
11428 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11430 BFD_ASSERT (sgotplt
);
11432 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11433 section referencing a literal at the very beginning of
11434 ".got.plt". This is very close to the real dependence, anyway. */
11435 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11438 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11439 when building uclibc, which runs "ld -b binary /dev/null". */
11440 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11443 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11444 link_info
->keep_memory
);
11445 if (internal_relocs
== NULL
11446 || sec
->reloc_count
== 0)
11449 /* Cache the contents for the duration of this scan. */
11450 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11451 if (contents
== NULL
&& sec_size
!= 0)
11457 if (!xtensa_default_isa
)
11458 xtensa_default_isa
= xtensa_isa_init (0, 0);
11460 for (i
= 0; i
< sec
->reloc_count
; i
++)
11462 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11463 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11466 asection
*target_sec
;
11467 bfd_vma target_offset
;
11469 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11472 /* L32Rs must be local to the input file. */
11473 if (r_reloc_is_defined (&l32r_rel
))
11475 target_sec
= r_reloc_get_section (&l32r_rel
);
11476 target_offset
= l32r_rel
.target_offset
;
11478 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11484 release_internal_relocs (sec
, internal_relocs
);
11485 release_contents (sec
, contents
);
11489 /* The default literal sections should always be marked as "code" (i.e.,
11490 SHF_EXECINSTR). This is particularly important for the Linux kernel
11491 module loader so that the literals are not placed after the text. */
11492 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11494 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11495 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11496 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11497 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11498 { NULL
, 0, 0, 0, 0 }
11501 #define ELF_TARGET_ID XTENSA_ELF_DATA
11503 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11504 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11505 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11506 #define TARGET_BIG_NAME "elf32-xtensa-be"
11507 #define ELF_ARCH bfd_arch_xtensa
11509 #define ELF_MACHINE_CODE EM_XTENSA
11510 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11512 #define ELF_MAXPAGESIZE 0x1000
11513 #endif /* ELF_ARCH */
11515 #define elf_backend_can_gc_sections 1
11516 #define elf_backend_can_refcount 1
11517 #define elf_backend_plt_readonly 1
11518 #define elf_backend_got_header_size 4
11519 #define elf_backend_want_dynbss 0
11520 #define elf_backend_want_got_plt 1
11521 #define elf_backend_dtrel_excludes_plt 1
11523 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11525 #define bfd_elf32_mkobject elf_xtensa_mkobject
11527 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11528 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11529 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11530 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11531 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11532 #define bfd_elf32_bfd_reloc_name_lookup \
11533 elf_xtensa_reloc_name_lookup
11534 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11535 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11537 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11538 #define elf_backend_check_relocs elf_xtensa_check_relocs
11539 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11540 #define elf_backend_discard_info elf_xtensa_discard_info
11541 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11542 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11543 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11544 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11545 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11546 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11547 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11548 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11549 #define elf_backend_object_p elf_xtensa_object_p
11550 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11551 #define elf_backend_relocate_section elf_xtensa_relocate_section
11552 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11553 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11554 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11555 #define elf_backend_special_sections elf_xtensa_special_sections
11556 #define elf_backend_action_discarded elf_xtensa_action_discarded
11557 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11559 #include "elf32-target.h"