1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright (C) 2003-2020 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 bfd_boolean
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 bfd_boolean 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 bfd_boolean
is_indirect_call_opcode (xtensa_opcode
);
70 static bfd_boolean
is_direct_call_opcode (xtensa_opcode
);
71 static bfd_boolean
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 bfd_boolean is_l32r_relocation
80 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
81 static bfd_boolean
is_alt_relocation (int);
82 static bfd_boolean
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 bfd_boolean check_branch_target_aligned
90 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
91 static bfd_boolean check_loop_aligned
92 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
93 static bfd_boolean
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, bfd_boolean
*);
106 /* Access to internal relocations, section contents and symbols. */
108 static Elf_Internal_Rela
*retrieve_internal_relocs
109 (bfd
*, asection
*, bfd_boolean
);
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
*, bfd_boolean
);
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 bfd_boolean
is_reloc_sym_weak (bfd
*, Elf_Internal_Rela
*);
126 static bfd_boolean
pcrel_reloc_fits (xtensa_opcode
, int, bfd_vma
, bfd_vma
);
127 static bfd_boolean
xtensa_is_property_section (asection
*);
128 static bfd_boolean
xtensa_is_insntable_section (asection
*);
129 static bfd_boolean
xtensa_is_littable_section (asection
*);
130 static bfd_boolean
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 bfd_boolean 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 bfd_boolean 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 bfd_boolean elf32xtensa_separate_props
= FALSE
;
183 /* Xtensa ABI. It affects PLT entry code. */
185 int elf32xtensa_abi
= XTHAL_ABI_UNDEFINED
;
187 /* Rename one of the generic section flags to better document how it
189 /* Whether relocations have been processed. */
190 #define reloc_done sec_flg0
192 static reloc_howto_type elf_howto_table
[] =
194 HOWTO (R_XTENSA_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
195 bfd_elf_xtensa_reloc
, "R_XTENSA_NONE",
197 HOWTO (R_XTENSA_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
198 bfd_elf_xtensa_reloc
, "R_XTENSA_32",
199 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
201 /* Replace a 32-bit value with a value from the runtime linker (only
202 used by linker-generated stub functions). The r_addend value is
203 special: 1 means to substitute a pointer to the runtime linker's
204 dynamic resolver function; 2 means to substitute the link map for
205 the shared object. */
206 HOWTO (R_XTENSA_RTLD
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
207 NULL
, "R_XTENSA_RTLD", FALSE
, 0, 0, FALSE
),
209 HOWTO (R_XTENSA_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
210 bfd_elf_generic_reloc
, "R_XTENSA_GLOB_DAT",
211 FALSE
, 0, 0xffffffff, FALSE
),
212 HOWTO (R_XTENSA_JMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
213 bfd_elf_generic_reloc
, "R_XTENSA_JMP_SLOT",
214 FALSE
, 0, 0xffffffff, FALSE
),
215 HOWTO (R_XTENSA_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
216 bfd_elf_generic_reloc
, "R_XTENSA_RELATIVE",
217 FALSE
, 0, 0xffffffff, FALSE
),
218 HOWTO (R_XTENSA_PLT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
219 bfd_elf_xtensa_reloc
, "R_XTENSA_PLT",
220 FALSE
, 0, 0xffffffff, FALSE
),
224 /* Old relocations for backward compatibility. */
225 HOWTO (R_XTENSA_OP0
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
226 bfd_elf_xtensa_reloc
, "R_XTENSA_OP0", FALSE
, 0, 0, TRUE
),
227 HOWTO (R_XTENSA_OP1
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
228 bfd_elf_xtensa_reloc
, "R_XTENSA_OP1", FALSE
, 0, 0, TRUE
),
229 HOWTO (R_XTENSA_OP2
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
230 bfd_elf_xtensa_reloc
, "R_XTENSA_OP2", FALSE
, 0, 0, TRUE
),
232 /* Assembly auto-expansion. */
233 HOWTO (R_XTENSA_ASM_EXPAND
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
234 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_EXPAND", FALSE
, 0, 0, TRUE
),
235 /* Relax assembly auto-expansion. */
236 HOWTO (R_XTENSA_ASM_SIMPLIFY
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
237 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_SIMPLIFY", FALSE
, 0, 0, TRUE
),
241 HOWTO (R_XTENSA_32_PCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
242 bfd_elf_xtensa_reloc
, "R_XTENSA_32_PCREL",
243 FALSE
, 0, 0xffffffff, TRUE
),
245 /* GNU extension to record C++ vtable hierarchy. */
246 HOWTO (R_XTENSA_GNU_VTINHERIT
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
247 NULL
, "R_XTENSA_GNU_VTINHERIT",
249 /* GNU extension to record C++ vtable member usage. */
250 HOWTO (R_XTENSA_GNU_VTENTRY
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
251 _bfd_elf_rel_vtable_reloc_fn
, "R_XTENSA_GNU_VTENTRY",
254 /* Relocations for supporting difference of symbols. */
255 HOWTO (R_XTENSA_DIFF8
, 0, 0, 8, FALSE
, 0, complain_overflow_signed
,
256 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF8", FALSE
, 0, 0xff, FALSE
),
257 HOWTO (R_XTENSA_DIFF16
, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,
258 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF16", FALSE
, 0, 0xffff, FALSE
),
259 HOWTO (R_XTENSA_DIFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
260 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF32", FALSE
, 0, 0xffffffff, FALSE
),
262 /* General immediate operand relocations. */
263 HOWTO (R_XTENSA_SLOT0_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
264 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_OP", FALSE
, 0, 0, TRUE
),
265 HOWTO (R_XTENSA_SLOT1_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
266 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_OP", FALSE
, 0, 0, TRUE
),
267 HOWTO (R_XTENSA_SLOT2_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
268 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_OP", FALSE
, 0, 0, TRUE
),
269 HOWTO (R_XTENSA_SLOT3_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
270 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_OP", FALSE
, 0, 0, TRUE
),
271 HOWTO (R_XTENSA_SLOT4_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
272 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_OP", FALSE
, 0, 0, TRUE
),
273 HOWTO (R_XTENSA_SLOT5_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
274 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_OP", FALSE
, 0, 0, TRUE
),
275 HOWTO (R_XTENSA_SLOT6_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
276 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_OP", FALSE
, 0, 0, TRUE
),
277 HOWTO (R_XTENSA_SLOT7_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
278 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_OP", FALSE
, 0, 0, TRUE
),
279 HOWTO (R_XTENSA_SLOT8_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
280 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_OP", FALSE
, 0, 0, TRUE
),
281 HOWTO (R_XTENSA_SLOT9_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
282 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_OP", FALSE
, 0, 0, TRUE
),
283 HOWTO (R_XTENSA_SLOT10_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
284 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_OP", FALSE
, 0, 0, TRUE
),
285 HOWTO (R_XTENSA_SLOT11_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
286 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_OP", FALSE
, 0, 0, TRUE
),
287 HOWTO (R_XTENSA_SLOT12_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
288 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_OP", FALSE
, 0, 0, TRUE
),
289 HOWTO (R_XTENSA_SLOT13_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
290 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_OP", FALSE
, 0, 0, TRUE
),
291 HOWTO (R_XTENSA_SLOT14_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
292 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_OP", FALSE
, 0, 0, TRUE
),
294 /* "Alternate" relocations. The meaning of these is opcode-specific. */
295 HOWTO (R_XTENSA_SLOT0_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
296 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_ALT", FALSE
, 0, 0, TRUE
),
297 HOWTO (R_XTENSA_SLOT1_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
298 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_ALT", FALSE
, 0, 0, TRUE
),
299 HOWTO (R_XTENSA_SLOT2_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
300 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_ALT", FALSE
, 0, 0, TRUE
),
301 HOWTO (R_XTENSA_SLOT3_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
302 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_ALT", FALSE
, 0, 0, TRUE
),
303 HOWTO (R_XTENSA_SLOT4_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
304 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_ALT", FALSE
, 0, 0, TRUE
),
305 HOWTO (R_XTENSA_SLOT5_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
306 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_ALT", FALSE
, 0, 0, TRUE
),
307 HOWTO (R_XTENSA_SLOT6_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
308 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_ALT", FALSE
, 0, 0, TRUE
),
309 HOWTO (R_XTENSA_SLOT7_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
310 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_ALT", FALSE
, 0, 0, TRUE
),
311 HOWTO (R_XTENSA_SLOT8_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
312 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_ALT", FALSE
, 0, 0, TRUE
),
313 HOWTO (R_XTENSA_SLOT9_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
314 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_ALT", FALSE
, 0, 0, TRUE
),
315 HOWTO (R_XTENSA_SLOT10_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
316 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_ALT", FALSE
, 0, 0, TRUE
),
317 HOWTO (R_XTENSA_SLOT11_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
318 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_ALT", FALSE
, 0, 0, TRUE
),
319 HOWTO (R_XTENSA_SLOT12_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
320 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_ALT", FALSE
, 0, 0, TRUE
),
321 HOWTO (R_XTENSA_SLOT13_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
322 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_ALT", FALSE
, 0, 0, TRUE
),
323 HOWTO (R_XTENSA_SLOT14_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
324 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_ALT", FALSE
, 0, 0, TRUE
),
326 /* TLS relocations. */
327 HOWTO (R_XTENSA_TLSDESC_FN
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
328 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_FN",
329 FALSE
, 0, 0xffffffff, FALSE
),
330 HOWTO (R_XTENSA_TLSDESC_ARG
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
331 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_ARG",
332 FALSE
, 0, 0xffffffff, FALSE
),
333 HOWTO (R_XTENSA_TLS_DTPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
334 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_DTPOFF",
335 FALSE
, 0, 0xffffffff, FALSE
),
336 HOWTO (R_XTENSA_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
337 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_TPOFF",
338 FALSE
, 0, 0xffffffff, FALSE
),
339 HOWTO (R_XTENSA_TLS_FUNC
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
340 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_FUNC",
342 HOWTO (R_XTENSA_TLS_ARG
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
343 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_ARG",
345 HOWTO (R_XTENSA_TLS_CALL
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
346 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_CALL",
349 HOWTO (R_XTENSA_PDIFF8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
350 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF8", FALSE
, 0, 0xff, FALSE
),
351 HOWTO (R_XTENSA_PDIFF16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
352 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF16", FALSE
, 0, 0xffff, FALSE
),
353 HOWTO (R_XTENSA_PDIFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
354 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF32", FALSE
, 0, 0xffffffff, FALSE
),
356 HOWTO (R_XTENSA_NDIFF8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
357 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF8", FALSE
, 0, 0xff, FALSE
),
358 HOWTO (R_XTENSA_NDIFF16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
359 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF16", FALSE
, 0, 0xffff, FALSE
),
360 HOWTO (R_XTENSA_NDIFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
361 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF32", FALSE
, 0, 0xffffffff, FALSE
),
366 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
371 static reloc_howto_type
*
372 elf_xtensa_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
373 bfd_reloc_code_real_type code
)
378 TRACE ("BFD_RELOC_NONE");
379 return &elf_howto_table
[(unsigned) R_XTENSA_NONE
];
382 TRACE ("BFD_RELOC_32");
383 return &elf_howto_table
[(unsigned) R_XTENSA_32
];
385 case BFD_RELOC_32_PCREL
:
386 TRACE ("BFD_RELOC_32_PCREL");
387 return &elf_howto_table
[(unsigned) R_XTENSA_32_PCREL
];
389 case BFD_RELOC_XTENSA_DIFF8
:
390 TRACE ("BFD_RELOC_XTENSA_DIFF8");
391 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF8
];
393 case BFD_RELOC_XTENSA_DIFF16
:
394 TRACE ("BFD_RELOC_XTENSA_DIFF16");
395 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF16
];
397 case BFD_RELOC_XTENSA_DIFF32
:
398 TRACE ("BFD_RELOC_XTENSA_DIFF32");
399 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF32
];
401 case BFD_RELOC_XTENSA_PDIFF8
:
402 TRACE ("BFD_RELOC_XTENSA_PDIFF8");
403 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF8
];
405 case BFD_RELOC_XTENSA_PDIFF16
:
406 TRACE ("BFD_RELOC_XTENSA_PDIFF16");
407 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF16
];
409 case BFD_RELOC_XTENSA_PDIFF32
:
410 TRACE ("BFD_RELOC_XTENSA_PDIFF32");
411 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF32
];
413 case BFD_RELOC_XTENSA_NDIFF8
:
414 TRACE ("BFD_RELOC_XTENSA_NDIFF8");
415 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF8
];
417 case BFD_RELOC_XTENSA_NDIFF16
:
418 TRACE ("BFD_RELOC_XTENSA_NDIFF16");
419 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF16
];
421 case BFD_RELOC_XTENSA_NDIFF32
:
422 TRACE ("BFD_RELOC_XTENSA_NDIFF32");
423 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF32
];
425 case BFD_RELOC_XTENSA_RTLD
:
426 TRACE ("BFD_RELOC_XTENSA_RTLD");
427 return &elf_howto_table
[(unsigned) R_XTENSA_RTLD
];
429 case BFD_RELOC_XTENSA_GLOB_DAT
:
430 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
431 return &elf_howto_table
[(unsigned) R_XTENSA_GLOB_DAT
];
433 case BFD_RELOC_XTENSA_JMP_SLOT
:
434 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
435 return &elf_howto_table
[(unsigned) R_XTENSA_JMP_SLOT
];
437 case BFD_RELOC_XTENSA_RELATIVE
:
438 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
439 return &elf_howto_table
[(unsigned) R_XTENSA_RELATIVE
];
441 case BFD_RELOC_XTENSA_PLT
:
442 TRACE ("BFD_RELOC_XTENSA_PLT");
443 return &elf_howto_table
[(unsigned) R_XTENSA_PLT
];
445 case BFD_RELOC_XTENSA_OP0
:
446 TRACE ("BFD_RELOC_XTENSA_OP0");
447 return &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
449 case BFD_RELOC_XTENSA_OP1
:
450 TRACE ("BFD_RELOC_XTENSA_OP1");
451 return &elf_howto_table
[(unsigned) R_XTENSA_OP1
];
453 case BFD_RELOC_XTENSA_OP2
:
454 TRACE ("BFD_RELOC_XTENSA_OP2");
455 return &elf_howto_table
[(unsigned) R_XTENSA_OP2
];
457 case BFD_RELOC_XTENSA_ASM_EXPAND
:
458 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
459 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_EXPAND
];
461 case BFD_RELOC_XTENSA_ASM_SIMPLIFY
:
462 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
463 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_SIMPLIFY
];
465 case BFD_RELOC_VTABLE_INHERIT
:
466 TRACE ("BFD_RELOC_VTABLE_INHERIT");
467 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTINHERIT
];
469 case BFD_RELOC_VTABLE_ENTRY
:
470 TRACE ("BFD_RELOC_VTABLE_ENTRY");
471 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTENTRY
];
473 case BFD_RELOC_XTENSA_TLSDESC_FN
:
474 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
475 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_FN
];
477 case BFD_RELOC_XTENSA_TLSDESC_ARG
:
478 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
479 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_ARG
];
481 case BFD_RELOC_XTENSA_TLS_DTPOFF
:
482 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
483 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_DTPOFF
];
485 case BFD_RELOC_XTENSA_TLS_TPOFF
:
486 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
487 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_TPOFF
];
489 case BFD_RELOC_XTENSA_TLS_FUNC
:
490 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
491 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_FUNC
];
493 case BFD_RELOC_XTENSA_TLS_ARG
:
494 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
495 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_ARG
];
497 case BFD_RELOC_XTENSA_TLS_CALL
:
498 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
499 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_CALL
];
502 if (code
>= BFD_RELOC_XTENSA_SLOT0_OP
503 && code
<= BFD_RELOC_XTENSA_SLOT14_OP
)
505 unsigned n
= (R_XTENSA_SLOT0_OP
+
506 (code
- BFD_RELOC_XTENSA_SLOT0_OP
));
507 return &elf_howto_table
[n
];
510 if (code
>= BFD_RELOC_XTENSA_SLOT0_ALT
511 && code
<= BFD_RELOC_XTENSA_SLOT14_ALT
)
513 unsigned n
= (R_XTENSA_SLOT0_ALT
+
514 (code
- BFD_RELOC_XTENSA_SLOT0_ALT
));
515 return &elf_howto_table
[n
];
521 /* xgettext:c-format */
522 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
, (int) code
);
523 bfd_set_error (bfd_error_bad_value
);
528 static reloc_howto_type
*
529 elf_xtensa_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
534 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
535 if (elf_howto_table
[i
].name
!= NULL
536 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
537 return &elf_howto_table
[i
];
543 /* Given an ELF "rela" relocation, find the corresponding howto and record
544 it in the BFD internal arelent representation of the relocation. */
547 elf_xtensa_info_to_howto_rela (bfd
*abfd
,
549 Elf_Internal_Rela
*dst
)
551 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
553 if (r_type
>= (unsigned int) R_XTENSA_max
)
555 /* xgettext:c-format */
556 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
558 bfd_set_error (bfd_error_bad_value
);
561 cache_ptr
->howto
= &elf_howto_table
[r_type
];
566 /* Functions for the Xtensa ELF linker. */
568 /* The name of the dynamic interpreter. This is put in the .interp
571 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
573 /* The size in bytes of an entry in the procedure linkage table.
574 (This does _not_ include the space for the literals associated with
577 #define PLT_ENTRY_SIZE 16
579 /* For _really_ large PLTs, we may need to alternate between literals
580 and code to keep the literals within the 256K range of the L32R
581 instructions in the code. It's unlikely that anyone would ever need
582 such a big PLT, but an arbitrary limit on the PLT size would be bad.
583 Thus, we split the PLT into chunks. Since there's very little
584 overhead (2 extra literals) for each chunk, the chunk size is kept
585 small so that the code for handling multiple chunks get used and
586 tested regularly. With 254 entries, there are 1K of literals for
587 each chunk, and that seems like a nice round number. */
589 #define PLT_ENTRIES_PER_CHUNK 254
591 /* PLT entries are actually used as stub functions for lazy symbol
592 resolution. Once the symbol is resolved, the stub function is never
593 invoked. Note: the 32-byte frame size used here cannot be changed
594 without a corresponding change in the runtime linker. */
596 static const bfd_byte elf_xtensa_be_plt_entry
[][PLT_ENTRY_SIZE
] =
599 0x6c, 0x10, 0x04, /* entry sp, 32 */
600 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
601 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
602 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
603 0x0a, 0x80, 0x00, /* jx a8 */
607 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
608 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
609 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
610 0x0a, 0x80, 0x00, /* jx a8 */
615 static const bfd_byte elf_xtensa_le_plt_entry
[][PLT_ENTRY_SIZE
] =
618 0x36, 0x41, 0x00, /* entry sp, 32 */
619 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
620 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
621 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
622 0xa0, 0x08, 0x00, /* jx a8 */
626 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
627 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
628 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
629 0xa0, 0x08, 0x00, /* jx a8 */
634 /* The size of the thread control block. */
637 struct elf_xtensa_link_hash_entry
639 struct elf_link_hash_entry elf
;
641 bfd_signed_vma tlsfunc_refcount
;
643 #define GOT_UNKNOWN 0
645 #define GOT_TLS_GD 2 /* global or local dynamic */
646 #define GOT_TLS_IE 4 /* initial or local exec */
647 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
648 unsigned char tls_type
;
651 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
653 struct elf_xtensa_obj_tdata
655 struct elf_obj_tdata root
;
657 /* tls_type for each local got entry. */
658 char *local_got_tls_type
;
660 bfd_signed_vma
*local_tlsfunc_refcounts
;
663 #define elf_xtensa_tdata(abfd) \
664 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
666 #define elf_xtensa_local_got_tls_type(abfd) \
667 (elf_xtensa_tdata (abfd)->local_got_tls_type)
669 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
670 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
672 #define is_xtensa_elf(bfd) \
673 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
674 && elf_tdata (bfd) != NULL \
675 && elf_object_id (bfd) == XTENSA_ELF_DATA)
678 elf_xtensa_mkobject (bfd
*abfd
)
680 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_xtensa_obj_tdata
),
684 /* Xtensa ELF linker hash table. */
686 struct elf_xtensa_link_hash_table
688 struct elf_link_hash_table elf
;
690 /* Short-cuts to get to dynamic linker sections. */
692 asection
*spltlittbl
;
694 /* Total count of PLT relocations seen during check_relocs.
695 The actual PLT code must be split into multiple sections and all
696 the sections have to be created before size_dynamic_sections,
697 where we figure out the exact number of PLT entries that will be
698 needed. It is OK if this count is an overestimate, e.g., some
699 relocations may be removed by GC. */
702 struct elf_xtensa_link_hash_entry
*tlsbase
;
705 /* Get the Xtensa ELF linker hash table from a link_info structure. */
707 #define elf_xtensa_hash_table(p) \
708 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
709 == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
711 /* Create an entry in an Xtensa ELF linker hash table. */
713 static struct bfd_hash_entry
*
714 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
715 struct bfd_hash_table
*table
,
718 /* Allocate the structure if it has not already been allocated by a
722 entry
= bfd_hash_allocate (table
,
723 sizeof (struct elf_xtensa_link_hash_entry
));
728 /* Call the allocation method of the superclass. */
729 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
732 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (entry
);
733 eh
->tlsfunc_refcount
= 0;
734 eh
->tls_type
= GOT_UNKNOWN
;
740 /* Create an Xtensa ELF linker hash table. */
742 static struct bfd_link_hash_table
*
743 elf_xtensa_link_hash_table_create (bfd
*abfd
)
745 struct elf_link_hash_entry
*tlsbase
;
746 struct elf_xtensa_link_hash_table
*ret
;
747 size_t amt
= sizeof (struct elf_xtensa_link_hash_table
);
749 ret
= bfd_zmalloc (amt
);
753 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
754 elf_xtensa_link_hash_newfunc
,
755 sizeof (struct elf_xtensa_link_hash_entry
),
762 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
764 tlsbase
= elf_link_hash_lookup (&ret
->elf
, "_TLS_MODULE_BASE_",
766 tlsbase
->root
.type
= bfd_link_hash_new
;
767 tlsbase
->root
.u
.undef
.abfd
= NULL
;
768 tlsbase
->non_elf
= 0;
769 ret
->elf
.dt_pltgot_required
= TRUE
;
770 ret
->tlsbase
= elf_xtensa_hash_entry (tlsbase
);
771 ret
->tlsbase
->tls_type
= GOT_UNKNOWN
;
773 return &ret
->elf
.root
;
776 /* Copy the extra info we tack onto an elf_link_hash_entry. */
779 elf_xtensa_copy_indirect_symbol (struct bfd_link_info
*info
,
780 struct elf_link_hash_entry
*dir
,
781 struct elf_link_hash_entry
*ind
)
783 struct elf_xtensa_link_hash_entry
*edir
, *eind
;
785 edir
= elf_xtensa_hash_entry (dir
);
786 eind
= elf_xtensa_hash_entry (ind
);
788 if (ind
->root
.type
== bfd_link_hash_indirect
)
790 edir
->tlsfunc_refcount
+= eind
->tlsfunc_refcount
;
791 eind
->tlsfunc_refcount
= 0;
793 if (dir
->got
.refcount
<= 0)
795 edir
->tls_type
= eind
->tls_type
;
796 eind
->tls_type
= GOT_UNKNOWN
;
800 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
803 static inline bfd_boolean
804 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
805 struct bfd_link_info
*info
)
807 /* Check if we should do dynamic things to this symbol. The
808 "ignore_protected" argument need not be set, because Xtensa code
809 does not require special handling of STV_PROTECTED to make function
810 pointer comparisons work properly. The PLT addresses are never
811 used for function pointers. */
813 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
818 property_table_compare (const void *ap
, const void *bp
)
820 const property_table_entry
*a
= (const property_table_entry
*) ap
;
821 const property_table_entry
*b
= (const property_table_entry
*) bp
;
823 if (a
->address
== b
->address
)
825 if (a
->size
!= b
->size
)
826 return (a
->size
- b
->size
);
828 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
829 return ((b
->flags
& XTENSA_PROP_ALIGN
)
830 - (a
->flags
& XTENSA_PROP_ALIGN
));
832 if ((a
->flags
& XTENSA_PROP_ALIGN
)
833 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
834 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
835 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
836 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
838 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
839 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
840 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
841 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
843 return (a
->flags
- b
->flags
);
846 return (a
->address
- b
->address
);
851 property_table_matches (const void *ap
, const void *bp
)
853 const property_table_entry
*a
= (const property_table_entry
*) ap
;
854 const property_table_entry
*b
= (const property_table_entry
*) bp
;
856 /* Check if one entry overlaps with the other. */
857 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
858 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
861 return (a
->address
- b
->address
);
865 /* Get the literal table or property table entries for the given
866 section. Sets TABLE_P and returns the number of entries. On
867 error, returns a negative value. */
870 xtensa_read_table_entries (bfd
*abfd
,
872 property_table_entry
**table_p
,
873 const char *sec_name
,
874 bfd_boolean output_addr
)
876 asection
*table_section
;
877 bfd_size_type table_size
= 0;
878 bfd_byte
*table_data
;
879 property_table_entry
*blocks
;
880 int blk
, block_count
;
881 bfd_size_type num_records
;
882 Elf_Internal_Rela
*internal_relocs
, *irel
, *rel_end
;
883 bfd_vma section_addr
, off
;
884 flagword predef_flags
;
885 bfd_size_type table_entry_size
, section_limit
;
888 || !(section
->flags
& SEC_ALLOC
)
889 || (section
->flags
& SEC_DEBUGGING
))
895 table_section
= xtensa_get_property_section (section
, sec_name
);
897 table_size
= table_section
->size
;
905 predef_flags
= xtensa_get_property_predef_flags (table_section
);
906 table_entry_size
= 12;
908 table_entry_size
-= 4;
910 num_records
= table_size
/ table_entry_size
;
911 table_data
= retrieve_contents (abfd
, table_section
, TRUE
);
912 blocks
= (property_table_entry
*)
913 bfd_malloc (num_records
* sizeof (property_table_entry
));
917 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
919 section_addr
= section
->vma
;
921 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, TRUE
);
922 if (internal_relocs
&& !table_section
->reloc_done
)
924 qsort (internal_relocs
, table_section
->reloc_count
,
925 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
926 irel
= internal_relocs
;
931 section_limit
= bfd_get_section_limit (abfd
, section
);
932 rel_end
= internal_relocs
+ table_section
->reloc_count
;
934 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
936 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
938 /* Skip any relocations before the current offset. This should help
939 avoid confusion caused by unexpected relocations for the preceding
942 (irel
->r_offset
< off
943 || (irel
->r_offset
== off
944 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
951 if (irel
&& irel
->r_offset
== off
)
954 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
955 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
957 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
960 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
961 BFD_ASSERT (sym_off
== 0);
962 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
966 if (address
< section_addr
967 || address
>= section_addr
+ section_limit
)
971 blocks
[block_count
].address
= address
;
972 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
974 blocks
[block_count
].flags
= predef_flags
;
976 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
980 release_contents (table_section
, table_data
);
981 release_internal_relocs (table_section
, internal_relocs
);
985 /* Now sort them into address order for easy reference. */
986 qsort (blocks
, block_count
, sizeof (property_table_entry
),
987 property_table_compare
);
989 /* Check that the table contents are valid. Problems may occur,
990 for example, if an unrelocated object file is stripped. */
991 for (blk
= 1; blk
< block_count
; blk
++)
993 /* The only circumstance where two entries may legitimately
994 have the same address is when one of them is a zero-size
995 placeholder to mark a place where fill can be inserted.
996 The zero-size entry should come first. */
997 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
998 blocks
[blk
- 1].size
!= 0)
1000 /* xgettext:c-format */
1001 _bfd_error_handler (_("%pB(%pA): invalid property table"),
1003 bfd_set_error (bfd_error_bad_value
);
1015 static property_table_entry
*
1016 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
1017 int property_table_size
,
1020 property_table_entry entry
;
1021 property_table_entry
*rv
;
1023 if (property_table_size
== 0)
1026 entry
.address
= addr
;
1030 rv
= bsearch (&entry
, property_table
, property_table_size
,
1031 sizeof (property_table_entry
), property_table_matches
);
1037 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
1041 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
1048 /* Look through the relocs for a section during the first phase, and
1049 calculate needed space in the dynamic reloc sections. */
1052 elf_xtensa_check_relocs (bfd
*abfd
,
1053 struct bfd_link_info
*info
,
1055 const Elf_Internal_Rela
*relocs
)
1057 struct elf_xtensa_link_hash_table
*htab
;
1058 Elf_Internal_Shdr
*symtab_hdr
;
1059 struct elf_link_hash_entry
**sym_hashes
;
1060 const Elf_Internal_Rela
*rel
;
1061 const Elf_Internal_Rela
*rel_end
;
1063 if (bfd_link_relocatable (info
))
1066 BFD_ASSERT (is_xtensa_elf (abfd
));
1068 htab
= elf_xtensa_hash_table (info
);
1072 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1073 sym_hashes
= elf_sym_hashes (abfd
);
1075 rel_end
= relocs
+ sec
->reloc_count
;
1076 for (rel
= relocs
; rel
< rel_end
; rel
++)
1078 unsigned int r_type
;
1080 struct elf_link_hash_entry
*h
= NULL
;
1081 struct elf_xtensa_link_hash_entry
*eh
;
1082 int tls_type
, old_tls_type
;
1083 bfd_boolean is_got
= FALSE
;
1084 bfd_boolean is_plt
= FALSE
;
1085 bfd_boolean is_tlsfunc
= FALSE
;
1087 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1088 r_type
= ELF32_R_TYPE (rel
->r_info
);
1090 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1092 /* xgettext:c-format */
1093 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1098 if (r_symndx
>= symtab_hdr
->sh_info
)
1100 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1101 while (h
->root
.type
== bfd_link_hash_indirect
1102 || h
->root
.type
== bfd_link_hash_warning
)
1103 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1105 eh
= elf_xtensa_hash_entry (h
);
1109 case R_XTENSA_TLSDESC_FN
:
1110 if (bfd_link_pic (info
))
1112 tls_type
= GOT_TLS_GD
;
1117 tls_type
= GOT_TLS_IE
;
1120 case R_XTENSA_TLSDESC_ARG
:
1121 if (bfd_link_pic (info
))
1123 tls_type
= GOT_TLS_GD
;
1128 tls_type
= GOT_TLS_IE
;
1129 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1134 case R_XTENSA_TLS_DTPOFF
:
1135 if (bfd_link_pic (info
))
1136 tls_type
= GOT_TLS_GD
;
1138 tls_type
= GOT_TLS_IE
;
1141 case R_XTENSA_TLS_TPOFF
:
1142 tls_type
= GOT_TLS_IE
;
1143 if (bfd_link_pic (info
))
1144 info
->flags
|= DF_STATIC_TLS
;
1145 if (bfd_link_pic (info
) || h
)
1150 tls_type
= GOT_NORMAL
;
1155 tls_type
= GOT_NORMAL
;
1159 case R_XTENSA_GNU_VTINHERIT
:
1160 /* This relocation describes the C++ object vtable hierarchy.
1161 Reconstruct it for later use during GC. */
1162 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1166 case R_XTENSA_GNU_VTENTRY
:
1167 /* This relocation describes which C++ vtable entries are actually
1168 used. Record for later use during GC. */
1169 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1174 /* Nothing to do for any other relocations. */
1182 if (h
->plt
.refcount
<= 0)
1185 h
->plt
.refcount
= 1;
1188 h
->plt
.refcount
+= 1;
1190 /* Keep track of the total PLT relocation count even if we
1191 don't yet know whether the dynamic sections will be
1193 htab
->plt_reloc_count
+= 1;
1195 if (elf_hash_table (info
)->dynamic_sections_created
)
1197 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1203 if (h
->got
.refcount
<= 0)
1204 h
->got
.refcount
= 1;
1206 h
->got
.refcount
+= 1;
1210 eh
->tlsfunc_refcount
+= 1;
1212 old_tls_type
= eh
->tls_type
;
1216 /* Allocate storage the first time. */
1217 if (elf_local_got_refcounts (abfd
) == NULL
)
1219 bfd_size_type size
= symtab_hdr
->sh_info
;
1222 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1225 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1227 mem
= bfd_zalloc (abfd
, size
);
1230 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1232 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1235 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1236 = (bfd_signed_vma
*) mem
;
1239 /* This is a global offset table entry for a local symbol. */
1240 if (is_got
|| is_plt
)
1241 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1244 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1246 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1249 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1250 tls_type
|= old_tls_type
;
1251 /* If a TLS symbol is accessed using IE at least once,
1252 there is no point to use a dynamic model for it. */
1253 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1254 && ((old_tls_type
& GOT_TLS_GD
) == 0
1255 || (tls_type
& GOT_TLS_IE
) == 0))
1257 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1258 tls_type
= old_tls_type
;
1259 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1260 tls_type
|= old_tls_type
;
1264 /* xgettext:c-format */
1265 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1267 h
? h
->root
.root
.string
: "<local>");
1272 if (old_tls_type
!= tls_type
)
1275 eh
->tls_type
= tls_type
;
1277 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1286 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1287 struct elf_link_hash_entry
*h
)
1289 if (bfd_link_pic (info
))
1291 if (h
->plt
.refcount
> 0)
1293 /* For shared objects, there's no need for PLT entries for local
1294 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1295 if (h
->got
.refcount
< 0)
1296 h
->got
.refcount
= 0;
1297 h
->got
.refcount
+= h
->plt
.refcount
;
1298 h
->plt
.refcount
= 0;
1303 /* Don't need any dynamic relocations at all. */
1304 h
->plt
.refcount
= 0;
1305 h
->got
.refcount
= 0;
1311 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1312 struct elf_link_hash_entry
*h
,
1313 bfd_boolean force_local
)
1315 /* For a shared link, move the plt refcount to the got refcount to leave
1316 space for RELATIVE relocs. */
1317 elf_xtensa_make_sym_local (info
, h
);
1319 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1323 /* Return the section that should be marked against GC for a given
1327 elf_xtensa_gc_mark_hook (asection
*sec
,
1328 struct bfd_link_info
*info
,
1329 Elf_Internal_Rela
*rel
,
1330 struct elf_link_hash_entry
*h
,
1331 Elf_Internal_Sym
*sym
)
1333 /* Property sections are marked "KEEP" in the linker scripts, but they
1334 should not cause other sections to be marked. (This approach relies
1335 on elf_xtensa_discard_info to remove property table entries that
1336 describe discarded sections. Alternatively, it might be more
1337 efficient to avoid using "KEEP" in the linker scripts and instead use
1338 the gc_mark_extra_sections hook to mark only the property sections
1339 that describe marked sections. That alternative does not work well
1340 with the current property table sections, which do not correspond
1341 one-to-one with the sections they describe, but that should be fixed
1343 if (xtensa_is_property_section (sec
))
1347 switch (ELF32_R_TYPE (rel
->r_info
))
1349 case R_XTENSA_GNU_VTINHERIT
:
1350 case R_XTENSA_GNU_VTENTRY
:
1354 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1358 /* Create all the dynamic sections. */
1361 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1363 struct elf_xtensa_link_hash_table
*htab
;
1364 flagword flags
, noalloc_flags
;
1366 htab
= elf_xtensa_hash_table (info
);
1370 /* First do all the standard stuff. */
1371 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1374 /* Create any extra PLT sections in case check_relocs has already
1375 been called on all the non-dynamic input files. */
1376 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1379 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1380 | SEC_LINKER_CREATED
| SEC_READONLY
);
1381 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1383 /* Mark the ".got.plt" section READONLY. */
1384 if (htab
->elf
.sgotplt
== NULL
1385 || !bfd_set_section_flags (htab
->elf
.sgotplt
, flags
))
1388 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1389 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1391 if (htab
->sgotloc
== NULL
1392 || !bfd_set_section_alignment (htab
->sgotloc
, 2))
1395 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1396 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1398 if (htab
->spltlittbl
== NULL
1399 || !bfd_set_section_alignment (htab
->spltlittbl
, 2))
1407 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1409 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1412 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1413 ".got.plt" sections. */
1414 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1420 /* Stop when we find a section has already been created. */
1421 if (elf_xtensa_get_plt_section (info
, chunk
))
1424 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1425 | SEC_LINKER_CREATED
| SEC_READONLY
);
1427 sname
= (char *) bfd_malloc (10);
1428 sprintf (sname
, ".plt.%u", chunk
);
1429 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1431 || !bfd_set_section_alignment (s
, 2))
1434 sname
= (char *) bfd_malloc (14);
1435 sprintf (sname
, ".got.plt.%u", chunk
);
1436 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1438 || !bfd_set_section_alignment (s
, 2))
1446 /* Adjust a symbol defined by a dynamic object and referenced by a
1447 regular object. The current definition is in some section of the
1448 dynamic object, but we're not including those sections. We have to
1449 change the definition to something the rest of the link can
1453 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1454 struct elf_link_hash_entry
*h
)
1456 /* If this is a weak symbol, and there is a real definition, the
1457 processor independent code will have arranged for us to see the
1458 real definition first, and we can just use the same value. */
1459 if (h
->is_weakalias
)
1461 struct elf_link_hash_entry
*def
= weakdef (h
);
1462 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1463 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1464 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1468 /* This is a reference to a symbol defined by a dynamic object. The
1469 reference must go through the GOT, so there's no need for COPY relocs,
1477 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1479 struct bfd_link_info
*info
;
1480 struct elf_xtensa_link_hash_table
*htab
;
1481 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1483 if (h
->root
.type
== bfd_link_hash_indirect
)
1486 info
= (struct bfd_link_info
*) arg
;
1487 htab
= elf_xtensa_hash_table (info
);
1491 /* If we saw any use of an IE model for this symbol, we can then optimize
1492 away GOT entries for any TLSDESC_FN relocs. */
1493 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1495 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1496 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1499 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1500 elf_xtensa_make_sym_local (info
, h
);
1502 if (! elf_xtensa_dynamic_symbol_p (h
, info
)
1503 && h
->root
.type
== bfd_link_hash_undefweak
)
1506 if (h
->plt
.refcount
> 0)
1507 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1509 if (h
->got
.refcount
> 0)
1510 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1517 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1519 struct elf_xtensa_link_hash_table
*htab
;
1522 htab
= elf_xtensa_hash_table (info
);
1526 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1528 bfd_signed_vma
*local_got_refcounts
;
1529 bfd_size_type j
, cnt
;
1530 Elf_Internal_Shdr
*symtab_hdr
;
1532 local_got_refcounts
= elf_local_got_refcounts (i
);
1533 if (!local_got_refcounts
)
1536 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1537 cnt
= symtab_hdr
->sh_info
;
1539 for (j
= 0; j
< cnt
; ++j
)
1541 /* If we saw any use of an IE model for this symbol, we can
1542 then optimize away GOT entries for any TLSDESC_FN relocs. */
1543 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1545 bfd_signed_vma
*tlsfunc_refcount
1546 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1547 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1548 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1551 if (local_got_refcounts
[j
] > 0)
1552 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1553 * sizeof (Elf32_External_Rela
));
1559 /* Set the sizes of the dynamic sections. */
1562 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1563 struct bfd_link_info
*info
)
1565 struct elf_xtensa_link_hash_table
*htab
;
1567 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1568 bfd_boolean relplt
, relgot
;
1569 int plt_entries
, plt_chunks
, chunk
;
1574 htab
= elf_xtensa_hash_table (info
);
1578 dynobj
= elf_hash_table (info
)->dynobj
;
1581 srelgot
= htab
->elf
.srelgot
;
1582 srelplt
= htab
->elf
.srelplt
;
1584 if (elf_hash_table (info
)->dynamic_sections_created
)
1586 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1587 && htab
->elf
.srelplt
!= NULL
1588 && htab
->elf
.sgot
!= NULL
1589 && htab
->spltlittbl
!= NULL
1590 && htab
->sgotloc
!= NULL
);
1592 /* Set the contents of the .interp section to the interpreter. */
1593 if (bfd_link_executable (info
) && !info
->nointerp
)
1595 s
= bfd_get_linker_section (dynobj
, ".interp");
1598 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1599 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1602 /* Allocate room for one word in ".got". */
1603 htab
->elf
.sgot
->size
= 4;
1605 /* Allocate space in ".rela.got" for literals that reference global
1606 symbols and space in ".rela.plt" for literals that have PLT
1608 elf_link_hash_traverse (elf_hash_table (info
),
1609 elf_xtensa_allocate_dynrelocs
,
1612 /* If we are generating a shared object, we also need space in
1613 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1614 reference local symbols. */
1615 if (bfd_link_pic (info
))
1616 elf_xtensa_allocate_local_got_size (info
);
1618 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1619 each PLT entry, we need the PLT code plus a 4-byte literal.
1620 For each chunk of ".plt", we also need two more 4-byte
1621 literals, two corresponding entries in ".rela.got", and an
1622 8-byte entry in ".xt.lit.plt". */
1623 spltlittbl
= htab
->spltlittbl
;
1624 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1626 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1628 /* Iterate over all the PLT chunks, including any extra sections
1629 created earlier because the initial count of PLT relocations
1630 was an overestimate. */
1632 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1637 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1638 BFD_ASSERT (sgotplt
!= NULL
);
1640 if (chunk
< plt_chunks
- 1)
1641 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1642 else if (chunk
== plt_chunks
- 1)
1643 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1647 if (chunk_entries
!= 0)
1649 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1650 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1651 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1652 spltlittbl
->size
+= 8;
1661 /* Allocate space in ".got.loc" to match the total size of all the
1663 sgotloc
= htab
->sgotloc
;
1664 sgotloc
->size
= spltlittbl
->size
;
1665 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1667 if (abfd
->flags
& DYNAMIC
)
1669 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1671 if (! discarded_section (s
)
1672 && xtensa_is_littable_section (s
)
1674 sgotloc
->size
+= s
->size
;
1679 /* Allocate memory for dynamic sections. */
1682 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1686 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1689 /* It's OK to base decisions on the section name, because none
1690 of the dynobj section names depend upon the input files. */
1691 name
= bfd_section_name (s
);
1693 if (CONST_STRNEQ (name
, ".rela"))
1697 if (strcmp (name
, ".rela.plt") == 0)
1699 else if (strcmp (name
, ".rela.got") == 0)
1702 /* We use the reloc_count field as a counter if we need
1703 to copy relocs into the output file. */
1707 else if (! CONST_STRNEQ (name
, ".plt.")
1708 && ! CONST_STRNEQ (name
, ".got.plt.")
1709 && strcmp (name
, ".got") != 0
1710 && strcmp (name
, ".plt") != 0
1711 && strcmp (name
, ".got.plt") != 0
1712 && strcmp (name
, ".xt.lit.plt") != 0
1713 && strcmp (name
, ".got.loc") != 0)
1715 /* It's not one of our sections, so don't allocate space. */
1721 /* If we don't need this section, strip it from the output
1722 file. We must create the ".plt*" and ".got.plt*"
1723 sections in create_dynamic_sections and/or check_relocs
1724 based on a conservative estimate of the PLT relocation
1725 count, because the sections must be created before the
1726 linker maps input sections to output sections. The
1727 linker does that before size_dynamic_sections, where we
1728 compute the exact size of the PLT, so there may be more
1729 of these sections than are actually needed. */
1730 s
->flags
|= SEC_EXCLUDE
;
1732 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1734 /* Allocate memory for the section contents. */
1735 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1736 if (s
->contents
== NULL
)
1741 if (elf_hash_table (info
)->dynamic_sections_created
)
1743 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1744 known until finish_dynamic_sections, but we need to get the relocs
1745 in place before they are sorted. */
1746 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1748 Elf_Internal_Rela irela
;
1752 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1755 loc
= (srelgot
->contents
1756 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1757 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1758 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1759 loc
+ sizeof (Elf32_External_Rela
));
1760 srelgot
->reloc_count
+= 2;
1763 /* Add some entries to the .dynamic section. We fill in the
1764 values later, in elf_xtensa_finish_dynamic_sections, but we
1765 must add the entries now so that we get the correct size for
1766 the .dynamic section. The DT_DEBUG entry is filled in by the
1767 dynamic linker and used by the debugger. */
1768 #define add_dynamic_entry(TAG, VAL) \
1769 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1771 if (!_bfd_elf_add_dynamic_tags (output_bfd
, info
,
1775 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1776 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1779 #undef add_dynamic_entry
1785 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1786 struct bfd_link_info
*info
)
1788 struct elf_xtensa_link_hash_table
*htab
;
1791 htab
= elf_xtensa_hash_table (info
);
1795 tls_sec
= htab
->elf
.tls_sec
;
1797 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1799 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1800 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1801 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1803 tlsbase
->type
= STT_TLS
;
1804 if (!(_bfd_generic_link_add_one_symbol
1805 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1806 tls_sec
, 0, NULL
, FALSE
,
1807 bed
->collect
, &bh
)))
1809 tlsbase
->def_regular
= 1;
1810 tlsbase
->other
= STV_HIDDEN
;
1811 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1818 /* Return the base VMA address which should be subtracted from real addresses
1819 when resolving @dtpoff relocation.
1820 This is PT_TLS segment p_vaddr. */
1823 dtpoff_base (struct bfd_link_info
*info
)
1825 /* If tls_sec is NULL, we should have signalled an error already. */
1826 if (elf_hash_table (info
)->tls_sec
== NULL
)
1828 return elf_hash_table (info
)->tls_sec
->vma
;
1831 /* Return the relocation value for @tpoff relocation
1832 if STT_TLS virtual address is ADDRESS. */
1835 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1837 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1840 /* If tls_sec is NULL, we should have signalled an error already. */
1841 if (htab
->tls_sec
== NULL
)
1843 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1844 return address
- htab
->tls_sec
->vma
+ base
;
1847 /* Perform the specified relocation. The instruction at (contents + address)
1848 is modified to set one operand to represent the value in "relocation". The
1849 operand position is determined by the relocation type recorded in the
1852 #define CALL_SEGMENT_BITS (30)
1853 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1855 static bfd_reloc_status_type
1856 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1858 asection
*input_section
,
1862 bfd_boolean is_weak_undef
,
1863 char **error_message
)
1866 xtensa_opcode opcode
;
1867 xtensa_isa isa
= xtensa_default_isa
;
1868 static xtensa_insnbuf ibuff
= NULL
;
1869 static xtensa_insnbuf sbuff
= NULL
;
1870 bfd_vma self_address
;
1871 bfd_size_type input_size
;
1877 ibuff
= xtensa_insnbuf_alloc (isa
);
1878 sbuff
= xtensa_insnbuf_alloc (isa
);
1881 input_size
= bfd_get_section_limit (abfd
, input_section
);
1883 /* Calculate the PC address for this instruction. */
1884 self_address
= (input_section
->output_section
->vma
1885 + input_section
->output_offset
1888 switch (howto
->type
)
1891 case R_XTENSA_DIFF8
:
1892 case R_XTENSA_DIFF16
:
1893 case R_XTENSA_DIFF32
:
1894 case R_XTENSA_PDIFF8
:
1895 case R_XTENSA_PDIFF16
:
1896 case R_XTENSA_PDIFF32
:
1897 case R_XTENSA_NDIFF8
:
1898 case R_XTENSA_NDIFF16
:
1899 case R_XTENSA_NDIFF32
:
1900 case R_XTENSA_TLS_FUNC
:
1901 case R_XTENSA_TLS_ARG
:
1902 case R_XTENSA_TLS_CALL
:
1903 return bfd_reloc_ok
;
1905 case R_XTENSA_ASM_EXPAND
:
1908 /* Check for windowed CALL across a 1GB boundary. */
1909 opcode
= get_expanded_call_opcode (contents
+ address
,
1910 input_size
- address
, 0);
1911 if (is_windowed_call_opcode (opcode
))
1913 if ((self_address
>> CALL_SEGMENT_BITS
)
1914 != (relocation
>> CALL_SEGMENT_BITS
))
1916 *error_message
= "windowed longcall crosses 1GB boundary; "
1918 return bfd_reloc_dangerous
;
1922 return bfd_reloc_ok
;
1924 case R_XTENSA_ASM_SIMPLIFY
:
1926 /* Convert the L32R/CALLX to CALL. */
1927 bfd_reloc_status_type retval
=
1928 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1930 if (retval
!= bfd_reloc_ok
)
1931 return bfd_reloc_dangerous
;
1933 /* The CALL needs to be relocated. Continue below for that part. */
1936 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1943 x
= bfd_get_32 (abfd
, contents
+ address
);
1945 bfd_put_32 (abfd
, x
, contents
+ address
);
1947 return bfd_reloc_ok
;
1949 case R_XTENSA_32_PCREL
:
1950 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1951 return bfd_reloc_ok
;
1954 case R_XTENSA_TLSDESC_FN
:
1955 case R_XTENSA_TLSDESC_ARG
:
1956 case R_XTENSA_TLS_DTPOFF
:
1957 case R_XTENSA_TLS_TPOFF
:
1958 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1959 return bfd_reloc_ok
;
1962 /* Only instruction slot-specific relocations handled below.... */
1963 slot
= get_relocation_slot (howto
->type
);
1964 if (slot
== XTENSA_UNDEFINED
)
1966 *error_message
= "unexpected relocation";
1967 return bfd_reloc_dangerous
;
1970 /* Read the instruction into a buffer and decode the opcode. */
1971 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1972 input_size
- address
);
1973 fmt
= xtensa_format_decode (isa
, ibuff
);
1974 if (fmt
== XTENSA_UNDEFINED
)
1976 *error_message
= "cannot decode instruction format";
1977 return bfd_reloc_dangerous
;
1980 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1982 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1983 if (opcode
== XTENSA_UNDEFINED
)
1985 *error_message
= "cannot decode instruction opcode";
1986 return bfd_reloc_dangerous
;
1989 /* Check for opcode-specific "alternate" relocations. */
1990 if (is_alt_relocation (howto
->type
))
1992 if (opcode
== get_l32r_opcode ())
1994 /* Handle the special-case of non-PC-relative L32R instructions. */
1995 bfd
*output_bfd
= input_section
->output_section
->owner
;
1996 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
1999 *error_message
= "relocation references missing .lit4 section";
2000 return bfd_reloc_dangerous
;
2002 self_address
= ((lit4_sec
->vma
& ~0xfff)
2003 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2004 newval
= relocation
;
2007 else if (opcode
== get_const16_opcode ())
2009 /* ALT used for high 16 bits.
2010 Ignore 32-bit overflow. */
2011 newval
= (relocation
>> 16) & 0xffff;
2016 /* No other "alternate" relocations currently defined. */
2017 *error_message
= "unexpected relocation";
2018 return bfd_reloc_dangerous
;
2021 else /* Not an "alternate" relocation.... */
2023 if (opcode
== get_const16_opcode ())
2025 newval
= relocation
& 0xffff;
2030 /* ...normal PC-relative relocation.... */
2032 /* Determine which operand is being relocated. */
2033 opnd
= get_relocation_opnd (opcode
, howto
->type
);
2034 if (opnd
== XTENSA_UNDEFINED
)
2036 *error_message
= "unexpected relocation";
2037 return bfd_reloc_dangerous
;
2040 if (!howto
->pc_relative
)
2042 *error_message
= "expected PC-relative relocation";
2043 return bfd_reloc_dangerous
;
2046 newval
= relocation
;
2050 /* Apply the relocation. */
2051 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
2052 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
2053 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2056 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2059 msg
= "cannot encode";
2060 if (is_direct_call_opcode (opcode
))
2062 if ((relocation
& 0x3) != 0)
2063 msg
= "misaligned call target";
2065 msg
= "call target out of range";
2067 else if (opcode
== get_l32r_opcode ())
2069 if ((relocation
& 0x3) != 0)
2070 msg
= "misaligned literal target";
2071 else if (is_alt_relocation (howto
->type
))
2072 msg
= "literal target out of range (too many literals)";
2073 else if (self_address
> relocation
)
2074 msg
= "literal target out of range (try using text-section-literals)";
2076 msg
= "literal placed after use";
2079 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2080 return bfd_reloc_dangerous
;
2083 /* Check for calls across 1GB boundaries. */
2084 if (is_direct_call_opcode (opcode
)
2085 && is_windowed_call_opcode (opcode
))
2087 if ((self_address
>> CALL_SEGMENT_BITS
)
2088 != (relocation
>> CALL_SEGMENT_BITS
))
2091 "windowed call crosses 1GB boundary; return may fail";
2092 return bfd_reloc_dangerous
;
2096 /* Write the modified instruction back out of the buffer. */
2097 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2098 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2099 input_size
- address
);
2100 return bfd_reloc_ok
;
2105 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2107 /* To reduce the size of the memory leak,
2108 we only use a single message buffer. */
2109 static bfd_size_type alloc_size
= 0;
2110 static char *message
= NULL
;
2111 bfd_size_type orig_len
, len
= 0;
2112 bfd_boolean is_append
;
2115 va_start (ap
, arglen
);
2117 is_append
= (origmsg
== message
);
2119 orig_len
= strlen (origmsg
);
2120 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2121 if (len
> alloc_size
)
2123 message
= (char *) bfd_realloc_or_free (message
, len
);
2126 if (message
!= NULL
)
2129 memcpy (message
, origmsg
, orig_len
);
2130 vsprintf (message
+ orig_len
, fmt
, ap
);
2137 /* This function is registered as the "special_function" in the
2138 Xtensa howto for handling simplify operations.
2139 bfd_perform_relocation / bfd_install_relocation use it to
2140 perform (install) the specified relocation. Since this replaces the code
2141 in bfd_perform_relocation, it is basically an Xtensa-specific,
2142 stripped-down version of bfd_perform_relocation. */
2144 static bfd_reloc_status_type
2145 bfd_elf_xtensa_reloc (bfd
*abfd
,
2146 arelent
*reloc_entry
,
2149 asection
*input_section
,
2151 char **error_message
)
2154 bfd_reloc_status_type flag
;
2155 bfd_size_type octets
= (reloc_entry
->address
2156 * OCTETS_PER_BYTE (abfd
, input_section
));
2157 bfd_vma output_base
= 0;
2158 reloc_howto_type
*howto
= reloc_entry
->howto
;
2159 asection
*reloc_target_output_section
;
2160 bfd_boolean is_weak_undef
;
2162 if (!xtensa_default_isa
)
2163 xtensa_default_isa
= xtensa_isa_init (0, 0);
2165 /* ELF relocs are against symbols. If we are producing relocatable
2166 output, and the reloc is against an external symbol, the resulting
2167 reloc will also be against the same symbol. In such a case, we
2168 don't want to change anything about the way the reloc is handled,
2169 since it will all be done at final link time. This test is similar
2170 to what bfd_elf_generic_reloc does except that it lets relocs with
2171 howto->partial_inplace go through even if the addend is non-zero.
2172 (The real problem is that partial_inplace is set for XTENSA_32
2173 relocs to begin with, but that's a long story and there's little we
2174 can do about it now....) */
2176 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2178 reloc_entry
->address
+= input_section
->output_offset
;
2179 return bfd_reloc_ok
;
2182 /* Is the address of the relocation really within the section? */
2183 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2184 return bfd_reloc_outofrange
;
2186 /* Work out which section the relocation is targeted at and the
2187 initial relocation command value. */
2189 /* Get symbol value. (Common symbols are special.) */
2190 if (bfd_is_com_section (symbol
->section
))
2193 relocation
= symbol
->value
;
2195 reloc_target_output_section
= symbol
->section
->output_section
;
2197 /* Convert input-section-relative symbol value to absolute. */
2198 if ((output_bfd
&& !howto
->partial_inplace
)
2199 || reloc_target_output_section
== NULL
)
2202 output_base
= reloc_target_output_section
->vma
;
2204 relocation
+= output_base
+ symbol
->section
->output_offset
;
2206 /* Add in supplied addend. */
2207 relocation
+= reloc_entry
->addend
;
2209 /* Here the variable relocation holds the final address of the
2210 symbol we are relocating against, plus any addend. */
2213 if (!howto
->partial_inplace
)
2215 /* This is a partial relocation, and we want to apply the relocation
2216 to the reloc entry rather than the raw data. Everything except
2217 relocations against section symbols has already been handled
2220 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2221 reloc_entry
->addend
= relocation
;
2222 reloc_entry
->address
+= input_section
->output_offset
;
2223 return bfd_reloc_ok
;
2227 reloc_entry
->address
+= input_section
->output_offset
;
2228 reloc_entry
->addend
= 0;
2232 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2233 && (symbol
->flags
& BSF_WEAK
) != 0);
2234 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2235 (bfd_byte
*) data
, (bfd_vma
) octets
,
2236 is_weak_undef
, error_message
);
2238 if (flag
== bfd_reloc_dangerous
)
2240 /* Add the symbol name to the error message. */
2241 if (! *error_message
)
2242 *error_message
= "";
2243 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2244 strlen (symbol
->name
) + 17,
2246 (unsigned long) reloc_entry
->addend
);
2252 int xtensa_abi_choice (void)
2254 if (elf32xtensa_abi
== XTHAL_ABI_UNDEFINED
)
2257 return elf32xtensa_abi
;
2260 /* Set up an entry in the procedure linkage table. */
2263 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2265 unsigned reloc_index
)
2267 asection
*splt
, *sgotplt
;
2268 bfd_vma plt_base
, got_base
;
2269 bfd_vma code_offset
, lit_offset
, abi_offset
;
2271 int abi
= xtensa_abi_choice ();
2273 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2274 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2275 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2276 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2278 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2279 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2281 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2282 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2284 /* Fill in the literal entry. This is the offset of the dynamic
2285 relocation entry. */
2286 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2287 sgotplt
->contents
+ lit_offset
);
2289 /* Fill in the entry in the procedure linkage table. */
2290 memcpy (splt
->contents
+ code_offset
,
2291 (bfd_big_endian (output_bfd
)
2292 ? elf_xtensa_be_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]
2293 : elf_xtensa_le_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]),
2295 abi_offset
= abi
== XTHAL_ABI_WINDOWED
? 3 : 0;
2296 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2297 plt_base
+ code_offset
+ abi_offset
),
2298 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2299 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2300 plt_base
+ code_offset
+ abi_offset
+ 3),
2301 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2302 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2303 plt_base
+ code_offset
+ abi_offset
+ 6),
2304 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2306 return plt_base
+ code_offset
;
2310 static bfd_boolean
get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2313 replace_tls_insn (Elf_Internal_Rela
*rel
,
2315 asection
*input_section
,
2317 bfd_boolean is_ld_model
,
2318 char **error_message
)
2320 static xtensa_insnbuf ibuff
= NULL
;
2321 static xtensa_insnbuf sbuff
= NULL
;
2322 xtensa_isa isa
= xtensa_default_isa
;
2324 xtensa_opcode old_op
, new_op
;
2325 bfd_size_type input_size
;
2327 unsigned dest_reg
, src_reg
;
2331 ibuff
= xtensa_insnbuf_alloc (isa
);
2332 sbuff
= xtensa_insnbuf_alloc (isa
);
2335 input_size
= bfd_get_section_limit (abfd
, input_section
);
2337 /* Read the instruction into a buffer and decode the opcode. */
2338 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2339 input_size
- rel
->r_offset
);
2340 fmt
= xtensa_format_decode (isa
, ibuff
);
2341 if (fmt
== XTENSA_UNDEFINED
)
2343 *error_message
= "cannot decode instruction format";
2347 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2348 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2350 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2351 if (old_op
== XTENSA_UNDEFINED
)
2353 *error_message
= "cannot decode instruction opcode";
2357 r_type
= ELF32_R_TYPE (rel
->r_info
);
2360 case R_XTENSA_TLS_FUNC
:
2361 case R_XTENSA_TLS_ARG
:
2362 if (old_op
!= get_l32r_opcode ()
2363 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2364 sbuff
, &dest_reg
) != 0)
2366 *error_message
= "cannot extract L32R destination for TLS access";
2371 case R_XTENSA_TLS_CALL
:
2372 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2373 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2374 sbuff
, &src_reg
) != 0)
2376 *error_message
= "cannot extract CALLXn operands for TLS access";
2389 case R_XTENSA_TLS_FUNC
:
2390 case R_XTENSA_TLS_ARG
:
2391 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2392 versions of Xtensa). */
2393 new_op
= xtensa_opcode_lookup (isa
, "nop");
2394 if (new_op
== XTENSA_UNDEFINED
)
2396 new_op
= xtensa_opcode_lookup (isa
, "or");
2397 if (new_op
== XTENSA_UNDEFINED
2398 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2399 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2401 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2403 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2406 *error_message
= "cannot encode OR for TLS access";
2412 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2414 *error_message
= "cannot encode NOP for TLS access";
2420 case R_XTENSA_TLS_CALL
:
2421 /* Read THREADPTR into the CALLX's return value register. */
2422 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2423 if (new_op
== XTENSA_UNDEFINED
2424 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2425 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2426 sbuff
, dest_reg
+ 2) != 0)
2428 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2438 case R_XTENSA_TLS_FUNC
:
2439 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2440 if (new_op
== XTENSA_UNDEFINED
2441 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2442 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2443 sbuff
, dest_reg
) != 0)
2445 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2450 case R_XTENSA_TLS_ARG
:
2451 /* Nothing to do. Keep the original L32R instruction. */
2454 case R_XTENSA_TLS_CALL
:
2455 /* Add the CALLX's src register (holding the THREADPTR value)
2456 to the first argument register (holding the offset) and put
2457 the result in the CALLX's return value register. */
2458 new_op
= xtensa_opcode_lookup (isa
, "add");
2459 if (new_op
== XTENSA_UNDEFINED
2460 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2461 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2462 sbuff
, dest_reg
+ 2) != 0
2463 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2464 sbuff
, dest_reg
+ 2) != 0
2465 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2466 sbuff
, src_reg
) != 0)
2468 *error_message
= "cannot encode ADD for TLS access";
2475 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2476 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2477 input_size
- rel
->r_offset
);
2483 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2484 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2485 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2486 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2487 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2488 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2489 || (R_TYPE) == R_XTENSA_TLS_ARG \
2490 || (R_TYPE) == R_XTENSA_TLS_CALL)
2492 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2493 both relocatable and final links. */
2496 elf_xtensa_relocate_section (bfd
*output_bfd
,
2497 struct bfd_link_info
*info
,
2499 asection
*input_section
,
2501 Elf_Internal_Rela
*relocs
,
2502 Elf_Internal_Sym
*local_syms
,
2503 asection
**local_sections
)
2505 struct elf_xtensa_link_hash_table
*htab
;
2506 Elf_Internal_Shdr
*symtab_hdr
;
2507 Elf_Internal_Rela
*rel
;
2508 Elf_Internal_Rela
*relend
;
2509 struct elf_link_hash_entry
**sym_hashes
;
2510 property_table_entry
*lit_table
= 0;
2512 char *local_got_tls_types
;
2513 char *error_message
= NULL
;
2514 bfd_size_type input_size
;
2517 if (!xtensa_default_isa
)
2518 xtensa_default_isa
= xtensa_isa_init (0, 0);
2520 if (!is_xtensa_elf (input_bfd
))
2522 bfd_set_error (bfd_error_wrong_format
);
2526 htab
= elf_xtensa_hash_table (info
);
2530 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2531 sym_hashes
= elf_sym_hashes (input_bfd
);
2532 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2534 if (elf_hash_table (info
)->dynamic_sections_created
)
2536 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2537 &lit_table
, XTENSA_LIT_SEC_NAME
,
2543 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2546 relend
= relocs
+ input_section
->reloc_count
;
2547 for (; rel
< relend
; rel
++)
2550 reloc_howto_type
*howto
;
2551 unsigned long r_symndx
;
2552 struct elf_link_hash_entry
*h
;
2553 Elf_Internal_Sym
*sym
;
2558 bfd_reloc_status_type r
;
2559 bfd_boolean is_weak_undef
;
2560 bfd_boolean unresolved_reloc
;
2562 bfd_boolean dynamic_symbol
;
2564 r_type
= ELF32_R_TYPE (rel
->r_info
);
2565 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2566 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2569 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2571 bfd_set_error (bfd_error_bad_value
);
2574 howto
= &elf_howto_table
[r_type
];
2576 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2581 is_weak_undef
= FALSE
;
2582 unresolved_reloc
= FALSE
;
2585 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2587 /* Because R_XTENSA_32 was made partial_inplace to fix some
2588 problems with DWARF info in partial links, there may be
2589 an addend stored in the contents. Take it out of there
2590 and move it back into the addend field of the reloc. */
2591 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2592 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2595 if (r_symndx
< symtab_hdr
->sh_info
)
2597 sym
= local_syms
+ r_symndx
;
2598 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2599 sec
= local_sections
[r_symndx
];
2600 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2604 bfd_boolean ignored
;
2606 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2607 r_symndx
, symtab_hdr
, sym_hashes
,
2609 unresolved_reloc
, warned
, ignored
);
2612 && !unresolved_reloc
2613 && h
->root
.type
== bfd_link_hash_undefweak
)
2614 is_weak_undef
= TRUE
;
2619 if (sec
!= NULL
&& discarded_section (sec
))
2620 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2621 rel
, 1, relend
, howto
, 0, contents
);
2623 if (bfd_link_relocatable (info
))
2626 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2628 /* This is a relocatable link.
2629 1) If the reloc is against a section symbol, adjust
2630 according to the output section.
2631 2) If there is a new target for this relocation,
2632 the new target will be in the same output section.
2633 We adjust the relocation by the output section
2636 if (relaxing_section
)
2638 /* Check if this references a section in another input file. */
2639 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2644 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2645 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2647 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2649 error_message
= NULL
;
2650 /* Convert ASM_SIMPLIFY into the simpler relocation
2651 so that they never escape a relaxing link. */
2652 r
= contract_asm_expansion (contents
, input_size
, rel
,
2654 if (r
!= bfd_reloc_ok
)
2655 (*info
->callbacks
->reloc_dangerous
)
2656 (info
, error_message
,
2657 input_bfd
, input_section
, rel
->r_offset
);
2659 r_type
= ELF32_R_TYPE (rel
->r_info
);
2662 /* This is a relocatable link, so we don't have to change
2663 anything unless the reloc is against a section symbol,
2664 in which case we have to adjust according to where the
2665 section symbol winds up in the output section. */
2666 if (r_symndx
< symtab_hdr
->sh_info
)
2668 sym
= local_syms
+ r_symndx
;
2669 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2671 sec
= local_sections
[r_symndx
];
2672 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2676 /* If there is an addend with a partial_inplace howto,
2677 then move the addend to the contents. This is a hack
2678 to work around problems with DWARF in relocatable links
2679 with some previous version of BFD. Now we can't easily get
2680 rid of the hack without breaking backward compatibility.... */
2682 howto
= &elf_howto_table
[r_type
];
2683 if (howto
->partial_inplace
&& rel
->r_addend
)
2685 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2686 rel
->r_addend
, contents
,
2687 rel
->r_offset
, FALSE
,
2693 /* Put the correct bits in the target instruction, even
2694 though the relocation will still be present in the output
2695 file. This makes disassembly clearer, as well as
2696 allowing loadable kernel modules to work without needing
2697 relocations on anything other than calls and l32r's. */
2699 /* If it is not in the same section, there is nothing we can do. */
2700 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2701 sym_sec
->output_section
== input_section
->output_section
)
2703 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2704 dest_addr
, contents
,
2705 rel
->r_offset
, FALSE
,
2709 if (r
!= bfd_reloc_ok
)
2710 (*info
->callbacks
->reloc_dangerous
)
2711 (info
, error_message
,
2712 input_bfd
, input_section
, rel
->r_offset
);
2714 /* Done with work for relocatable link; continue with next reloc. */
2718 /* This is a final link. */
2720 if (relaxing_section
)
2722 /* Check if this references a section in another input file. */
2723 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2727 /* Sanity check the address. */
2728 if (rel
->r_offset
>= input_size
2729 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2732 /* xgettext:c-format */
2733 (_("%pB(%pA+%#" PRIx64
"): "
2734 "relocation offset out of range (size=%#" PRIx64
")"),
2735 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2736 (uint64_t) input_size
);
2737 bfd_set_error (bfd_error_bad_value
);
2742 name
= h
->root
.root
.string
;
2745 name
= (bfd_elf_string_from_elf_section
2746 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2747 if (name
== NULL
|| *name
== '\0')
2748 name
= bfd_section_name (sec
);
2751 if (r_symndx
!= STN_UNDEF
2752 && r_type
!= R_XTENSA_NONE
2754 || h
->root
.type
== bfd_link_hash_defined
2755 || h
->root
.type
== bfd_link_hash_defweak
)
2756 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2759 ((sym_type
== STT_TLS
2760 /* xgettext:c-format */
2761 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2762 /* xgettext:c-format */
2763 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2766 (uint64_t) rel
->r_offset
,
2771 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2773 tls_type
= GOT_UNKNOWN
;
2775 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2776 else if (local_got_tls_types
)
2777 tls_type
= local_got_tls_types
[r_symndx
];
2783 if (elf_hash_table (info
)->dynamic_sections_created
2784 && (input_section
->flags
& SEC_ALLOC
) != 0
2785 && (dynamic_symbol
|| bfd_link_pic (info
)))
2787 Elf_Internal_Rela outrel
;
2791 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2792 srel
= htab
->elf
.srelplt
;
2794 srel
= htab
->elf
.srelgot
;
2796 BFD_ASSERT (srel
!= NULL
);
2799 _bfd_elf_section_offset (output_bfd
, info
,
2800 input_section
, rel
->r_offset
);
2802 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2803 memset (&outrel
, 0, sizeof outrel
);
2806 outrel
.r_offset
+= (input_section
->output_section
->vma
2807 + input_section
->output_offset
);
2809 /* Complain if the relocation is in a read-only section
2810 and not in a literal pool. */
2811 if ((input_section
->flags
& SEC_READONLY
) != 0
2812 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2816 _("dynamic relocation in read-only section");
2817 (*info
->callbacks
->reloc_dangerous
)
2818 (info
, error_message
,
2819 input_bfd
, input_section
, rel
->r_offset
);
2824 outrel
.r_addend
= rel
->r_addend
;
2827 if (r_type
== R_XTENSA_32
)
2830 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2833 else /* r_type == R_XTENSA_PLT */
2836 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2838 /* Create the PLT entry and set the initial
2839 contents of the literal entry to the address of
2842 elf_xtensa_create_plt_entry (info
, output_bfd
,
2845 unresolved_reloc
= FALSE
;
2847 else if (!is_weak_undef
)
2849 /* Generate a RELATIVE relocation. */
2850 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2851 outrel
.r_addend
= 0;
2859 loc
= (srel
->contents
2860 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2861 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2862 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2865 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2867 /* This should only happen for non-PIC code, which is not
2868 supposed to be used on systems with dynamic linking.
2869 Just ignore these relocations. */
2874 case R_XTENSA_TLS_TPOFF
:
2875 /* Switch to LE model for local symbols in an executable. */
2876 if (! bfd_link_pic (info
) && ! dynamic_symbol
)
2878 relocation
= tpoff (info
, relocation
);
2883 case R_XTENSA_TLSDESC_FN
:
2884 case R_XTENSA_TLSDESC_ARG
:
2886 if (r_type
== R_XTENSA_TLSDESC_FN
)
2888 if (! bfd_link_pic (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2889 r_type
= R_XTENSA_NONE
;
2891 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2893 if (bfd_link_pic (info
))
2895 if ((tls_type
& GOT_TLS_IE
) != 0)
2896 r_type
= R_XTENSA_TLS_TPOFF
;
2900 r_type
= R_XTENSA_TLS_TPOFF
;
2901 if (! dynamic_symbol
)
2903 relocation
= tpoff (info
, relocation
);
2909 if (r_type
== R_XTENSA_NONE
)
2910 /* Nothing to do here; skip to the next reloc. */
2913 if (! elf_hash_table (info
)->dynamic_sections_created
)
2916 _("TLS relocation invalid without dynamic sections");
2917 (*info
->callbacks
->reloc_dangerous
)
2918 (info
, error_message
,
2919 input_bfd
, input_section
, rel
->r_offset
);
2923 Elf_Internal_Rela outrel
;
2925 asection
*srel
= htab
->elf
.srelgot
;
2928 outrel
.r_offset
= (input_section
->output_section
->vma
2929 + input_section
->output_offset
2932 /* Complain if the relocation is in a read-only section
2933 and not in a literal pool. */
2934 if ((input_section
->flags
& SEC_READONLY
) != 0
2935 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2939 _("dynamic relocation in read-only section");
2940 (*info
->callbacks
->reloc_dangerous
)
2941 (info
, error_message
,
2942 input_bfd
, input_section
, rel
->r_offset
);
2945 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2947 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2949 outrel
.r_addend
= 0;
2952 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2954 unresolved_reloc
= FALSE
;
2957 loc
= (srel
->contents
2958 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2959 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2960 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2966 case R_XTENSA_TLS_DTPOFF
:
2967 if (! bfd_link_pic (info
))
2968 /* Switch from LD model to LE model. */
2969 relocation
= tpoff (info
, relocation
);
2971 relocation
-= dtpoff_base (info
);
2974 case R_XTENSA_TLS_FUNC
:
2975 case R_XTENSA_TLS_ARG
:
2976 case R_XTENSA_TLS_CALL
:
2977 /* Check if optimizing to IE or LE model. */
2978 if ((tls_type
& GOT_TLS_IE
) != 0)
2980 bfd_boolean is_ld_model
=
2981 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
2982 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
2983 is_ld_model
, &error_message
))
2984 (*info
->callbacks
->reloc_dangerous
)
2985 (info
, error_message
,
2986 input_bfd
, input_section
, rel
->r_offset
);
2988 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
2990 /* Skip subsequent relocations on the same instruction. */
2991 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
2998 if (elf_hash_table (info
)->dynamic_sections_created
2999 && dynamic_symbol
&& (is_operand_relocation (r_type
)
3000 || r_type
== R_XTENSA_32_PCREL
))
3003 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3004 strlen (name
) + 2, name
);
3005 (*info
->callbacks
->reloc_dangerous
)
3006 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3012 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3013 because such sections are not SEC_ALLOC and thus ld.so will
3014 not process them. */
3015 if (unresolved_reloc
3016 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3018 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3019 rel
->r_offset
) != (bfd_vma
) -1)
3022 /* xgettext:c-format */
3023 (_("%pB(%pA+%#" PRIx64
"): "
3024 "unresolvable %s relocation against symbol `%s'"),
3027 (uint64_t) rel
->r_offset
,
3033 /* TLS optimizations may have changed r_type; update "howto". */
3034 howto
= &elf_howto_table
[r_type
];
3036 /* There's no point in calling bfd_perform_relocation here.
3037 Just go directly to our "special function". */
3038 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
3039 relocation
+ rel
->r_addend
,
3040 contents
, rel
->r_offset
, is_weak_undef
,
3043 if (r
!= bfd_reloc_ok
&& !warned
)
3045 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
3046 BFD_ASSERT (error_message
!= NULL
);
3048 if (rel
->r_addend
== 0)
3049 error_message
= vsprint_msg (error_message
, ": %s",
3050 strlen (name
) + 2, name
);
3052 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
3054 name
, (int) rel
->r_addend
);
3056 (*info
->callbacks
->reloc_dangerous
)
3057 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3062 input_section
->reloc_done
= TRUE
;
3068 /* Finish up dynamic symbol handling. There's not much to do here since
3069 the PLT and GOT entries are all set up by relocate_section. */
3072 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3073 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3074 struct elf_link_hash_entry
*h
,
3075 Elf_Internal_Sym
*sym
)
3077 if (h
->needs_plt
&& !h
->def_regular
)
3079 /* Mark the symbol as undefined, rather than as defined in
3080 the .plt section. Leave the value alone. */
3081 sym
->st_shndx
= SHN_UNDEF
;
3082 /* If the symbol is weak, we do need to clear the value.
3083 Otherwise, the PLT entry would provide a definition for
3084 the symbol even if the symbol wasn't defined anywhere,
3085 and so the symbol would never be NULL. */
3086 if (!h
->ref_regular_nonweak
)
3090 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3091 if (h
== elf_hash_table (info
)->hdynamic
3092 || h
== elf_hash_table (info
)->hgot
)
3093 sym
->st_shndx
= SHN_ABS
;
3099 /* Combine adjacent literal table entries in the output. Adjacent
3100 entries within each input section may have been removed during
3101 relaxation, but we repeat the process here, even though it's too late
3102 to shrink the output section, because it's important to minimize the
3103 number of literal table entries to reduce the start-up work for the
3104 runtime linker. Returns the number of remaining table entries or -1
3108 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3113 property_table_entry
*table
;
3114 bfd_size_type section_size
, sgotloc_size
;
3118 section_size
= sxtlit
->size
;
3119 BFD_ASSERT (section_size
% 8 == 0);
3120 num
= section_size
/ 8;
3122 sgotloc_size
= sgotloc
->size
;
3123 if (sgotloc_size
!= section_size
)
3126 (_("internal inconsistency in size of .got.loc section"));
3130 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3134 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3135 propagates to the output section, where it doesn't really apply and
3136 where it breaks the following call to bfd_malloc_and_get_section. */
3137 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3139 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3146 /* There should never be any relocations left at this point, so this
3147 is quite a bit easier than what is done during relaxation. */
3149 /* Copy the raw contents into a property table array and sort it. */
3151 for (n
= 0; n
< num
; n
++)
3153 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3154 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3157 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3159 for (n
= 0; n
< num
; n
++)
3161 bfd_boolean remove_entry
= FALSE
;
3163 if (table
[n
].size
== 0)
3164 remove_entry
= TRUE
;
3166 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3168 table
[n
-1].size
+= table
[n
].size
;
3169 remove_entry
= TRUE
;
3174 for (m
= n
; m
< num
- 1; m
++)
3176 table
[m
].address
= table
[m
+1].address
;
3177 table
[m
].size
= table
[m
+1].size
;
3185 /* Copy the data back to the raw contents. */
3187 for (n
= 0; n
< num
; n
++)
3189 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3190 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3194 /* Clear the removed bytes. */
3195 if ((bfd_size_type
) (num
* 8) < section_size
)
3196 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3198 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3202 /* Copy the contents to ".got.loc". */
3203 memcpy (sgotloc
->contents
, contents
, section_size
);
3211 /* Finish up the dynamic sections. */
3214 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3215 struct bfd_link_info
*info
)
3217 struct elf_xtensa_link_hash_table
*htab
;
3219 asection
*sdyn
, *srelplt
, *srelgot
, *sgot
, *sxtlit
, *sgotloc
;
3220 Elf32_External_Dyn
*dyncon
, *dynconend
;
3221 int num_xtlit_entries
= 0;
3223 if (! elf_hash_table (info
)->dynamic_sections_created
)
3226 htab
= elf_xtensa_hash_table (info
);
3230 dynobj
= elf_hash_table (info
)->dynobj
;
3231 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3232 BFD_ASSERT (sdyn
!= NULL
);
3234 /* Set the first entry in the global offset table to the address of
3235 the dynamic section. */
3236 sgot
= htab
->elf
.sgot
;
3239 BFD_ASSERT (sgot
->size
== 4);
3241 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3243 bfd_put_32 (output_bfd
,
3244 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3248 srelplt
= htab
->elf
.srelplt
;
3249 srelgot
= htab
->elf
.srelgot
;
3250 if (srelplt
&& srelplt
->size
!= 0)
3252 asection
*sgotplt
, *spltlittbl
;
3253 int chunk
, plt_chunks
, plt_entries
;
3254 Elf_Internal_Rela irela
;
3256 unsigned rtld_reloc
;
3258 spltlittbl
= htab
->spltlittbl
;
3259 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3261 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3262 of them follow immediately after.... */
3263 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3265 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3266 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3267 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3270 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3272 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3274 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3276 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3278 int chunk_entries
= 0;
3280 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3281 BFD_ASSERT (sgotplt
!= NULL
);
3283 /* Emit special RTLD relocations for the first two entries in
3284 each chunk of the .got.plt section. */
3286 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3287 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3288 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3289 irela
.r_offset
= (sgotplt
->output_section
->vma
3290 + sgotplt
->output_offset
);
3291 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3292 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3294 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3296 /* Next literal immediately follows the first. */
3297 loc
+= sizeof (Elf32_External_Rela
);
3298 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3299 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3300 irela
.r_offset
= (sgotplt
->output_section
->vma
3301 + sgotplt
->output_offset
+ 4);
3302 /* Tell rtld to set value to object's link map. */
3304 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3306 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3308 /* Fill in the literal table. */
3309 if (chunk
< plt_chunks
- 1)
3310 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3312 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3314 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3315 bfd_put_32 (output_bfd
,
3316 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3317 spltlittbl
->contents
+ (chunk
* 8) + 0);
3318 bfd_put_32 (output_bfd
,
3319 8 + (chunk_entries
* 4),
3320 spltlittbl
->contents
+ (chunk
* 8) + 4);
3323 /* The .xt.lit.plt section has just been modified. This must
3324 happen before the code below which combines adjacent literal
3325 table entries, and the .xt.lit.plt contents have to be forced to
3327 if (! bfd_set_section_contents (output_bfd
,
3328 spltlittbl
->output_section
,
3329 spltlittbl
->contents
,
3330 spltlittbl
->output_offset
,
3333 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3334 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3337 /* All the dynamic relocations have been emitted at this point.
3338 Make sure the relocation sections are the correct size. */
3339 if ((srelgot
&& srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3340 * srelgot
->reloc_count
))
3341 || (srelplt
&& srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3342 * srelplt
->reloc_count
)))
3345 /* Combine adjacent literal table entries. */
3346 BFD_ASSERT (! bfd_link_relocatable (info
));
3347 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3348 sgotloc
= htab
->sgotloc
;
3349 BFD_ASSERT (sgotloc
);
3353 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3354 if (num_xtlit_entries
< 0)
3358 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3359 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3360 for (; dyncon
< dynconend
; dyncon
++)
3362 Elf_Internal_Dyn dyn
;
3364 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3371 case DT_XTENSA_GOT_LOC_SZ
:
3372 dyn
.d_un
.d_val
= num_xtlit_entries
;
3375 case DT_XTENSA_GOT_LOC_OFF
:
3376 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3377 + htab
->sgotloc
->output_offset
);
3381 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3382 + htab
->elf
.sgot
->output_offset
);
3386 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3387 + htab
->elf
.srelplt
->output_offset
);
3391 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3395 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3402 /* Functions for dealing with the e_flags field. */
3404 /* Merge backend specific data from an object file to the output
3405 object file when linking. */
3408 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3410 bfd
*obfd
= info
->output_bfd
;
3411 unsigned out_mach
, in_mach
;
3412 flagword out_flag
, in_flag
;
3414 /* Check if we have the same endianness. */
3415 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3418 /* Don't even pretend to support mixed-format linking. */
3419 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3420 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3423 out_flag
= elf_elfheader (obfd
)->e_flags
;
3424 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3426 out_mach
= out_flag
& EF_XTENSA_MACH
;
3427 in_mach
= in_flag
& EF_XTENSA_MACH
;
3428 if (out_mach
!= in_mach
)
3431 /* xgettext:c-format */
3432 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3433 ibfd
, out_mach
, in_mach
);
3434 bfd_set_error (bfd_error_wrong_format
);
3438 if (! elf_flags_init (obfd
))
3440 elf_flags_init (obfd
) = TRUE
;
3441 elf_elfheader (obfd
)->e_flags
= in_flag
;
3443 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3444 && bfd_get_arch_info (obfd
)->the_default
)
3445 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3446 bfd_get_mach (ibfd
));
3451 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3452 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3454 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3455 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3462 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3464 BFD_ASSERT (!elf_flags_init (abfd
)
3465 || elf_elfheader (abfd
)->e_flags
== flags
);
3467 elf_elfheader (abfd
)->e_flags
|= flags
;
3468 elf_flags_init (abfd
) = TRUE
;
3475 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3477 FILE *f
= (FILE *) farg
;
3478 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3480 fprintf (f
, "\nXtensa header:\n");
3481 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3482 fprintf (f
, "\nMachine = Base\n");
3484 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3486 fprintf (f
, "Insn tables = %s\n",
3487 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3489 fprintf (f
, "Literal tables = %s\n",
3490 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3492 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3496 /* Set the right machine number for an Xtensa ELF file. */
3499 elf_xtensa_object_p (bfd
*abfd
)
3502 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3507 mach
= bfd_mach_xtensa
;
3513 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3518 /* The final processing done just before writing out an Xtensa ELF object
3519 file. This gets the Xtensa architecture right based on the machine
3523 elf_xtensa_final_write_processing (bfd
*abfd
)
3526 unsigned long val
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3528 switch (mach
= bfd_get_mach (abfd
))
3530 case bfd_mach_xtensa
:
3531 val
= E_XTENSA_MACH
;
3537 elf_elfheader (abfd
)->e_flags
&= ~EF_XTENSA_MACH
;
3538 elf_elfheader (abfd
)->e_flags
|= val
;
3539 return _bfd_elf_final_write_processing (abfd
);
3543 static enum elf_reloc_type_class
3544 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3545 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3546 const Elf_Internal_Rela
*rela
)
3548 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3550 case R_XTENSA_RELATIVE
:
3551 return reloc_class_relative
;
3552 case R_XTENSA_JMP_SLOT
:
3553 return reloc_class_plt
;
3555 return reloc_class_normal
;
3561 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3562 struct elf_reloc_cookie
*cookie
,
3563 struct bfd_link_info
*info
,
3567 bfd_vma offset
, actual_offset
;
3568 bfd_size_type removed_bytes
= 0;
3569 bfd_size_type entry_size
;
3571 if (sec
->output_section
3572 && bfd_is_abs_section (sec
->output_section
))
3575 if (xtensa_is_proptable_section (sec
))
3580 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3583 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3587 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3590 release_contents (sec
, contents
);
3594 /* Sort the relocations. They should already be in order when
3595 relaxation is enabled, but it might not be. */
3596 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3597 internal_reloc_compare
);
3599 cookie
->rel
= cookie
->rels
;
3600 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3602 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3604 actual_offset
= offset
- removed_bytes
;
3606 /* The ...symbol_deleted_p function will skip over relocs but it
3607 won't adjust their offsets, so do that here. */
3608 while (cookie
->rel
< cookie
->relend
3609 && cookie
->rel
->r_offset
< offset
)
3611 cookie
->rel
->r_offset
-= removed_bytes
;
3615 while (cookie
->rel
< cookie
->relend
3616 && cookie
->rel
->r_offset
== offset
)
3618 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3620 /* Remove the table entry. (If the reloc type is NONE, then
3621 the entry has already been merged with another and deleted
3622 during relaxation.) */
3623 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3625 /* Shift the contents up. */
3626 if (offset
+ entry_size
< sec
->size
)
3627 memmove (&contents
[actual_offset
],
3628 &contents
[actual_offset
+ entry_size
],
3629 sec
->size
- offset
- entry_size
);
3630 removed_bytes
+= entry_size
;
3633 /* Remove this relocation. */
3634 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3637 /* Adjust the relocation offset for previous removals. This
3638 should not be done before calling ...symbol_deleted_p
3639 because it might mess up the offset comparisons there.
3640 Make sure the offset doesn't underflow in the case where
3641 the first entry is removed. */
3642 if (cookie
->rel
->r_offset
>= removed_bytes
)
3643 cookie
->rel
->r_offset
-= removed_bytes
;
3645 cookie
->rel
->r_offset
= 0;
3651 if (removed_bytes
!= 0)
3653 /* Adjust any remaining relocs (shouldn't be any). */
3654 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3656 if (cookie
->rel
->r_offset
>= removed_bytes
)
3657 cookie
->rel
->r_offset
-= removed_bytes
;
3659 cookie
->rel
->r_offset
= 0;
3662 /* Clear the removed bytes. */
3663 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3665 pin_contents (sec
, contents
);
3666 pin_internal_relocs (sec
, cookie
->rels
);
3669 if (sec
->rawsize
== 0)
3670 sec
->rawsize
= sec
->size
;
3671 sec
->size
-= removed_bytes
;
3673 if (xtensa_is_littable_section (sec
))
3675 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3677 sgotloc
->size
-= removed_bytes
;
3682 release_contents (sec
, contents
);
3683 release_internal_relocs (sec
, cookie
->rels
);
3686 return (removed_bytes
!= 0);
3691 elf_xtensa_discard_info (bfd
*abfd
,
3692 struct elf_reloc_cookie
*cookie
,
3693 struct bfd_link_info
*info
)
3696 bfd_boolean changed
= FALSE
;
3698 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3700 if (xtensa_is_property_section (sec
))
3702 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3712 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3714 return xtensa_is_property_section (sec
);
3719 elf_xtensa_action_discarded (asection
*sec
)
3721 if (strcmp (".xt_except_table", sec
->name
) == 0)
3724 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3727 return _bfd_elf_default_action_discarded (sec
);
3731 /* Support for core dump NOTE sections. */
3734 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3739 /* The size for Xtensa is variable, so don't try to recognize the format
3740 based on the size. Just assume this is GNU/Linux. */
3743 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3746 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3750 size
= note
->descsz
- offset
- 4;
3752 /* Make a ".reg/999" section. */
3753 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3754 size
, note
->descpos
+ offset
);
3759 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3761 switch (note
->descsz
)
3766 case 128: /* GNU/Linux elf_prpsinfo */
3767 elf_tdata (abfd
)->core
->program
3768 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3769 elf_tdata (abfd
)->core
->command
3770 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3773 /* Note that for some reason, a spurious space is tacked
3774 onto the end of the args in some (at least one anyway)
3775 implementations, so strip it off if it exists. */
3778 char *command
= elf_tdata (abfd
)->core
->command
;
3779 int n
= strlen (command
);
3781 if (0 < n
&& command
[n
- 1] == ' ')
3782 command
[n
- 1] = '\0';
3789 /* Generic Xtensa configurability stuff. */
3791 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3792 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3793 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3794 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3795 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3796 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3797 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3798 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3801 init_call_opcodes (void)
3803 if (callx0_op
== XTENSA_UNDEFINED
)
3805 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3806 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3807 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3808 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3809 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3810 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3811 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3812 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3818 is_indirect_call_opcode (xtensa_opcode opcode
)
3820 init_call_opcodes ();
3821 return (opcode
== callx0_op
3822 || opcode
== callx4_op
3823 || opcode
== callx8_op
3824 || opcode
== callx12_op
);
3829 is_direct_call_opcode (xtensa_opcode opcode
)
3831 init_call_opcodes ();
3832 return (opcode
== call0_op
3833 || opcode
== call4_op
3834 || opcode
== call8_op
3835 || opcode
== call12_op
);
3840 is_windowed_call_opcode (xtensa_opcode opcode
)
3842 init_call_opcodes ();
3843 return (opcode
== call4_op
3844 || opcode
== call8_op
3845 || opcode
== call12_op
3846 || opcode
== callx4_op
3847 || opcode
== callx8_op
3848 || opcode
== callx12_op
);
3853 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3855 unsigned dst
= (unsigned) -1;
3857 init_call_opcodes ();
3858 if (opcode
== callx0_op
)
3860 else if (opcode
== callx4_op
)
3862 else if (opcode
== callx8_op
)
3864 else if (opcode
== callx12_op
)
3867 if (dst
== (unsigned) -1)
3875 static xtensa_opcode
3876 get_const16_opcode (void)
3878 static bfd_boolean done_lookup
= FALSE
;
3879 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3882 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3885 return const16_opcode
;
3889 static xtensa_opcode
3890 get_l32r_opcode (void)
3892 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3893 static bfd_boolean done_lookup
= FALSE
;
3897 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3905 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3909 offset
= addr
- ((pc
+3) & -4);
3910 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3911 offset
= (signed int) offset
>> 2;
3912 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3917 static xtensa_opcode
3918 get_rsr_lend_opcode (void)
3920 static xtensa_opcode rsr_lend_opcode
= XTENSA_UNDEFINED
;
3921 static bfd_boolean done_lookup
= FALSE
;
3924 rsr_lend_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "rsr.lend");
3927 return rsr_lend_opcode
;
3930 static xtensa_opcode
3931 get_wsr_lbeg_opcode (void)
3933 static xtensa_opcode wsr_lbeg_opcode
= XTENSA_UNDEFINED
;
3934 static bfd_boolean done_lookup
= FALSE
;
3937 wsr_lbeg_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "wsr.lbeg");
3940 return wsr_lbeg_opcode
;
3945 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3947 xtensa_isa isa
= xtensa_default_isa
;
3948 int last_immed
, last_opnd
, opi
;
3950 if (opcode
== XTENSA_UNDEFINED
)
3951 return XTENSA_UNDEFINED
;
3953 /* Find the last visible PC-relative immediate operand for the opcode.
3954 If there are no PC-relative immediates, then choose the last visible
3955 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3956 last_immed
= XTENSA_UNDEFINED
;
3957 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3958 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3960 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3962 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3967 if (last_immed
== XTENSA_UNDEFINED
3968 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3972 return XTENSA_UNDEFINED
;
3974 /* If the operand number was specified in an old-style relocation,
3975 check for consistency with the operand computed above. */
3976 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3978 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3979 if (reloc_opnd
!= last_immed
)
3980 return XTENSA_UNDEFINED
;
3988 get_relocation_slot (int r_type
)
3998 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
3999 return r_type
- R_XTENSA_SLOT0_OP
;
4000 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4001 return r_type
- R_XTENSA_SLOT0_ALT
;
4005 return XTENSA_UNDEFINED
;
4009 /* Get the opcode for a relocation. */
4011 static xtensa_opcode
4012 get_relocation_opcode (bfd
*abfd
,
4015 Elf_Internal_Rela
*irel
)
4017 static xtensa_insnbuf ibuff
= NULL
;
4018 static xtensa_insnbuf sbuff
= NULL
;
4019 xtensa_isa isa
= xtensa_default_isa
;
4023 if (contents
== NULL
)
4024 return XTENSA_UNDEFINED
;
4026 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
4027 return XTENSA_UNDEFINED
;
4031 ibuff
= xtensa_insnbuf_alloc (isa
);
4032 sbuff
= xtensa_insnbuf_alloc (isa
);
4035 /* Decode the instruction. */
4036 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
4037 sec
->size
- irel
->r_offset
);
4038 fmt
= xtensa_format_decode (isa
, ibuff
);
4039 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
4040 if (slot
== XTENSA_UNDEFINED
)
4041 return XTENSA_UNDEFINED
;
4042 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
4043 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
4048 is_l32r_relocation (bfd
*abfd
,
4051 Elf_Internal_Rela
*irel
)
4053 xtensa_opcode opcode
;
4054 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
4056 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
4057 return (opcode
== get_l32r_opcode ());
4061 static bfd_size_type
4062 get_asm_simplify_size (bfd_byte
*contents
,
4063 bfd_size_type content_len
,
4064 bfd_size_type offset
)
4066 bfd_size_type insnlen
, size
= 0;
4068 /* Decode the size of the next two instructions. */
4069 insnlen
= insn_decode_len (contents
, content_len
, offset
);
4075 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
4085 is_alt_relocation (int r_type
)
4087 return (r_type
>= R_XTENSA_SLOT0_ALT
4088 && r_type
<= R_XTENSA_SLOT14_ALT
);
4093 is_operand_relocation (int r_type
)
4103 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4105 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4114 #define MIN_INSN_LENGTH 2
4116 /* Return 0 if it fails to decode. */
4119 insn_decode_len (bfd_byte
*contents
,
4120 bfd_size_type content_len
,
4121 bfd_size_type offset
)
4124 xtensa_isa isa
= xtensa_default_isa
;
4126 static xtensa_insnbuf ibuff
= NULL
;
4128 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4132 ibuff
= xtensa_insnbuf_alloc (isa
);
4133 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4134 content_len
- offset
);
4135 fmt
= xtensa_format_decode (isa
, ibuff
);
4136 if (fmt
== XTENSA_UNDEFINED
)
4138 insn_len
= xtensa_format_length (isa
, fmt
);
4139 if (insn_len
== XTENSA_UNDEFINED
)
4145 insn_num_slots (bfd_byte
*contents
,
4146 bfd_size_type content_len
,
4147 bfd_size_type offset
)
4149 xtensa_isa isa
= xtensa_default_isa
;
4151 static xtensa_insnbuf ibuff
= NULL
;
4153 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4154 return XTENSA_UNDEFINED
;
4157 ibuff
= xtensa_insnbuf_alloc (isa
);
4158 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4159 content_len
- offset
);
4160 fmt
= xtensa_format_decode (isa
, ibuff
);
4161 if (fmt
== XTENSA_UNDEFINED
)
4162 return XTENSA_UNDEFINED
;
4163 return xtensa_format_num_slots (isa
, fmt
);
4167 /* Decode the opcode for a single slot instruction.
4168 Return 0 if it fails to decode or the instruction is multi-slot. */
4171 insn_decode_opcode (bfd_byte
*contents
,
4172 bfd_size_type content_len
,
4173 bfd_size_type offset
,
4176 xtensa_isa isa
= xtensa_default_isa
;
4178 static xtensa_insnbuf insnbuf
= NULL
;
4179 static xtensa_insnbuf slotbuf
= NULL
;
4181 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4182 return XTENSA_UNDEFINED
;
4184 if (insnbuf
== NULL
)
4186 insnbuf
= xtensa_insnbuf_alloc (isa
);
4187 slotbuf
= xtensa_insnbuf_alloc (isa
);
4190 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4191 content_len
- offset
);
4192 fmt
= xtensa_format_decode (isa
, insnbuf
);
4193 if (fmt
== XTENSA_UNDEFINED
)
4194 return XTENSA_UNDEFINED
;
4196 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4197 return XTENSA_UNDEFINED
;
4199 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4200 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4204 /* The offset is the offset in the contents.
4205 The address is the address of that offset. */
4208 check_branch_target_aligned (bfd_byte
*contents
,
4209 bfd_size_type content_length
,
4213 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4216 return check_branch_target_aligned_address (address
, insn_len
);
4221 check_loop_aligned (bfd_byte
*contents
,
4222 bfd_size_type content_length
,
4226 bfd_size_type loop_len
, insn_len
;
4227 xtensa_opcode opcode
;
4229 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4230 if (opcode
== XTENSA_UNDEFINED
4231 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4237 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4238 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4239 if (loop_len
== 0 || insn_len
== 0)
4245 /* If this is relaxed loop, analyze first instruction of the actual loop
4246 body. It must be at offset 27 from the loop instruction address. */
4248 && insn_num_slots (contents
, content_length
, offset
+ loop_len
) == 1
4249 && insn_decode_opcode (contents
, content_length
,
4250 offset
+ loop_len
, 0) == get_rsr_lend_opcode()
4251 && insn_decode_len (contents
, content_length
, offset
+ loop_len
+ 3) == 3
4252 && insn_num_slots (contents
, content_length
, offset
+ loop_len
+ 3) == 1
4253 && insn_decode_opcode (contents
, content_length
,
4254 offset
+ loop_len
+ 3, 0) == get_wsr_lbeg_opcode())
4257 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4259 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4264 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4267 return (addr
% 8 == 0);
4268 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4272 /* Instruction widening and narrowing. */
4274 /* When FLIX is available we need to access certain instructions only
4275 when they are 16-bit or 24-bit instructions. This table caches
4276 information about such instructions by walking through all the
4277 opcodes and finding the smallest single-slot format into which each
4280 static xtensa_format
*op_single_fmt_table
= NULL
;
4284 init_op_single_format_table (void)
4286 xtensa_isa isa
= xtensa_default_isa
;
4287 xtensa_insnbuf ibuf
;
4288 xtensa_opcode opcode
;
4292 if (op_single_fmt_table
)
4295 ibuf
= xtensa_insnbuf_alloc (isa
);
4296 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4298 op_single_fmt_table
= (xtensa_format
*)
4299 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4300 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4302 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4303 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4305 if (xtensa_format_num_slots (isa
, fmt
) == 1
4306 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4308 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4309 int fmt_length
= xtensa_format_length (isa
, fmt
);
4310 if (old_fmt
== XTENSA_UNDEFINED
4311 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4312 op_single_fmt_table
[opcode
] = fmt
;
4316 xtensa_insnbuf_free (isa
, ibuf
);
4320 static xtensa_format
4321 get_single_format (xtensa_opcode opcode
)
4323 init_op_single_format_table ();
4324 return op_single_fmt_table
[opcode
];
4328 /* For the set of narrowable instructions we do NOT include the
4329 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4330 involved during linker relaxation that may require these to
4331 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4332 requires special case code to ensure it only works when op1 == op2. */
4340 struct string_pair narrowable
[] =
4343 { "addi", "addi.n" },
4344 { "addmi", "addi.n" },
4345 { "l32i", "l32i.n" },
4346 { "movi", "movi.n" },
4348 { "retw", "retw.n" },
4349 { "s32i", "s32i.n" },
4350 { "or", "mov.n" } /* special case only when op1 == op2 */
4353 struct string_pair widenable
[] =
4356 { "addi", "addi.n" },
4357 { "addmi", "addi.n" },
4358 { "beqz", "beqz.n" },
4359 { "bnez", "bnez.n" },
4360 { "l32i", "l32i.n" },
4361 { "movi", "movi.n" },
4363 { "retw", "retw.n" },
4364 { "s32i", "s32i.n" },
4365 { "or", "mov.n" } /* special case only when op1 == op2 */
4369 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4370 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4371 return the instruction buffer holding the narrow instruction. Otherwise,
4372 return 0. The set of valid narrowing are specified by a string table
4373 but require some special case operand checks in some cases. */
4375 static xtensa_insnbuf
4376 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4378 xtensa_opcode opcode
)
4380 xtensa_isa isa
= xtensa_default_isa
;
4381 xtensa_format o_fmt
;
4384 static xtensa_insnbuf o_insnbuf
= NULL
;
4385 static xtensa_insnbuf o_slotbuf
= NULL
;
4387 if (o_insnbuf
== NULL
)
4389 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4390 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4393 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4395 bfd_boolean is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4397 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4399 uint32 value
, newval
;
4400 int i
, operand_count
, o_operand_count
;
4401 xtensa_opcode o_opcode
;
4403 /* Address does not matter in this case. We might need to
4404 fix it to handle branches/jumps. */
4405 bfd_vma self_address
= 0;
4407 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4408 if (o_opcode
== XTENSA_UNDEFINED
)
4410 o_fmt
= get_single_format (o_opcode
);
4411 if (o_fmt
== XTENSA_UNDEFINED
)
4414 if (xtensa_format_length (isa
, fmt
) != 3
4415 || xtensa_format_length (isa
, o_fmt
) != 2)
4418 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4419 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4420 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4422 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4427 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4432 uint32 rawval0
, rawval1
, rawval2
;
4434 if (o_operand_count
+ 1 != operand_count
4435 || xtensa_operand_get_field (isa
, opcode
, 0,
4436 fmt
, 0, slotbuf
, &rawval0
) != 0
4437 || xtensa_operand_get_field (isa
, opcode
, 1,
4438 fmt
, 0, slotbuf
, &rawval1
) != 0
4439 || xtensa_operand_get_field (isa
, opcode
, 2,
4440 fmt
, 0, slotbuf
, &rawval2
) != 0
4441 || rawval1
!= rawval2
4442 || rawval0
== rawval1
/* it is a nop */)
4446 for (i
= 0; i
< o_operand_count
; ++i
)
4448 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4450 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4453 /* PC-relative branches need adjustment, but
4454 the PC-rel operand will always have a relocation. */
4456 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4458 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4459 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4464 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4474 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4475 the action in-place directly into the contents and return TRUE. Otherwise,
4476 the return value is FALSE and the contents are not modified. */
4479 narrow_instruction (bfd_byte
*contents
,
4480 bfd_size_type content_length
,
4481 bfd_size_type offset
)
4483 xtensa_opcode opcode
;
4484 bfd_size_type insn_len
;
4485 xtensa_isa isa
= xtensa_default_isa
;
4487 xtensa_insnbuf o_insnbuf
;
4489 static xtensa_insnbuf insnbuf
= NULL
;
4490 static xtensa_insnbuf slotbuf
= NULL
;
4492 if (insnbuf
== NULL
)
4494 insnbuf
= xtensa_insnbuf_alloc (isa
);
4495 slotbuf
= xtensa_insnbuf_alloc (isa
);
4498 BFD_ASSERT (offset
< content_length
);
4500 if (content_length
< 2)
4503 /* We will hand-code a few of these for a little while.
4504 These have all been specified in the assembler aleady. */
4505 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4506 content_length
- offset
);
4507 fmt
= xtensa_format_decode (isa
, insnbuf
);
4508 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4511 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4514 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4515 if (opcode
== XTENSA_UNDEFINED
)
4517 insn_len
= xtensa_format_length (isa
, fmt
);
4518 if (insn_len
> content_length
)
4521 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4524 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4525 content_length
- offset
);
4533 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4534 "density" instruction to a standard 3-byte instruction. If it is valid,
4535 return the instruction buffer holding the wide instruction. Otherwise,
4536 return 0. The set of valid widenings are specified by a string table
4537 but require some special case operand checks in some cases. */
4539 static xtensa_insnbuf
4540 can_widen_instruction (xtensa_insnbuf slotbuf
,
4542 xtensa_opcode opcode
)
4544 xtensa_isa isa
= xtensa_default_isa
;
4545 xtensa_format o_fmt
;
4548 static xtensa_insnbuf o_insnbuf
= NULL
;
4549 static xtensa_insnbuf o_slotbuf
= NULL
;
4551 if (o_insnbuf
== NULL
)
4553 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4554 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4557 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4559 bfd_boolean is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4560 bfd_boolean is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4561 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4563 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4565 uint32 value
, newval
;
4566 int i
, operand_count
, o_operand_count
, check_operand_count
;
4567 xtensa_opcode o_opcode
;
4569 /* Address does not matter in this case. We might need to fix it
4570 to handle branches/jumps. */
4571 bfd_vma self_address
= 0;
4573 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4574 if (o_opcode
== XTENSA_UNDEFINED
)
4576 o_fmt
= get_single_format (o_opcode
);
4577 if (o_fmt
== XTENSA_UNDEFINED
)
4580 if (xtensa_format_length (isa
, fmt
) != 2
4581 || xtensa_format_length (isa
, o_fmt
) != 3)
4584 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4585 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4586 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4587 check_operand_count
= o_operand_count
;
4589 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4594 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4599 uint32 rawval0
, rawval1
;
4601 if (o_operand_count
!= operand_count
+ 1
4602 || xtensa_operand_get_field (isa
, opcode
, 0,
4603 fmt
, 0, slotbuf
, &rawval0
) != 0
4604 || xtensa_operand_get_field (isa
, opcode
, 1,
4605 fmt
, 0, slotbuf
, &rawval1
) != 0
4606 || rawval0
== rawval1
/* it is a nop */)
4610 check_operand_count
--;
4612 for (i
= 0; i
< check_operand_count
; i
++)
4615 if (is_or
&& i
== o_operand_count
- 1)
4617 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4619 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4622 /* PC-relative branches need adjustment, but
4623 the PC-rel operand will always have a relocation. */
4625 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4627 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4628 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4633 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4643 /* Attempt to widen an instruction. If the widening is valid, perform
4644 the action in-place directly into the contents and return TRUE. Otherwise,
4645 the return value is FALSE and the contents are not modified. */
4648 widen_instruction (bfd_byte
*contents
,
4649 bfd_size_type content_length
,
4650 bfd_size_type offset
)
4652 xtensa_opcode opcode
;
4653 bfd_size_type insn_len
;
4654 xtensa_isa isa
= xtensa_default_isa
;
4656 xtensa_insnbuf o_insnbuf
;
4658 static xtensa_insnbuf insnbuf
= NULL
;
4659 static xtensa_insnbuf slotbuf
= NULL
;
4661 if (insnbuf
== NULL
)
4663 insnbuf
= xtensa_insnbuf_alloc (isa
);
4664 slotbuf
= xtensa_insnbuf_alloc (isa
);
4667 BFD_ASSERT (offset
< content_length
);
4669 if (content_length
< 2)
4672 /* We will hand-code a few of these for a little while.
4673 These have all been specified in the assembler aleady. */
4674 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4675 content_length
- offset
);
4676 fmt
= xtensa_format_decode (isa
, insnbuf
);
4677 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4680 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4683 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4684 if (opcode
== XTENSA_UNDEFINED
)
4686 insn_len
= xtensa_format_length (isa
, fmt
);
4687 if (insn_len
> content_length
)
4690 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4693 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4694 content_length
- offset
);
4701 /* Code for transforming CALLs at link-time. */
4703 static bfd_reloc_status_type
4704 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4706 bfd_vma content_length
,
4707 char **error_message
)
4709 static xtensa_insnbuf insnbuf
= NULL
;
4710 static xtensa_insnbuf slotbuf
= NULL
;
4711 xtensa_format core_format
= XTENSA_UNDEFINED
;
4712 xtensa_opcode opcode
;
4713 xtensa_opcode direct_call_opcode
;
4714 xtensa_isa isa
= xtensa_default_isa
;
4715 bfd_byte
*chbuf
= contents
+ address
;
4718 if (insnbuf
== NULL
)
4720 insnbuf
= xtensa_insnbuf_alloc (isa
);
4721 slotbuf
= xtensa_insnbuf_alloc (isa
);
4724 if (content_length
< address
)
4726 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4727 return bfd_reloc_other
;
4730 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4731 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4732 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4734 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4735 return bfd_reloc_other
;
4738 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4739 core_format
= xtensa_format_lookup (isa
, "x24");
4740 opcode
= xtensa_opcode_lookup (isa
, "or");
4741 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4742 for (opn
= 0; opn
< 3; opn
++)
4745 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4746 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4749 xtensa_format_encode (isa
, core_format
, insnbuf
);
4750 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4751 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4753 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4754 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4755 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4757 xtensa_format_encode (isa
, core_format
, insnbuf
);
4758 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4759 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4760 content_length
- address
- 3);
4762 return bfd_reloc_ok
;
4766 static bfd_reloc_status_type
4767 contract_asm_expansion (bfd_byte
*contents
,
4768 bfd_vma content_length
,
4769 Elf_Internal_Rela
*irel
,
4770 char **error_message
)
4772 bfd_reloc_status_type retval
=
4773 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4776 if (retval
!= bfd_reloc_ok
)
4777 return bfd_reloc_dangerous
;
4779 /* Update the irel->r_offset field so that the right immediate and
4780 the right instruction are modified during the relocation. */
4781 irel
->r_offset
+= 3;
4782 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4783 return bfd_reloc_ok
;
4787 static xtensa_opcode
4788 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4790 init_call_opcodes ();
4792 if (opcode
== callx0_op
) return call0_op
;
4793 if (opcode
== callx4_op
) return call4_op
;
4794 if (opcode
== callx8_op
) return call8_op
;
4795 if (opcode
== callx12_op
) return call12_op
;
4797 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4798 return XTENSA_UNDEFINED
;
4802 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4803 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4804 If not, return XTENSA_UNDEFINED. */
4806 #define L32R_TARGET_REG_OPERAND 0
4807 #define CONST16_TARGET_REG_OPERAND 0
4808 #define CALLN_SOURCE_OPERAND 0
4810 static xtensa_opcode
4811 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bfd_boolean
*p_uses_l32r
)
4813 static xtensa_insnbuf insnbuf
= NULL
;
4814 static xtensa_insnbuf slotbuf
= NULL
;
4816 xtensa_opcode opcode
;
4817 xtensa_isa isa
= xtensa_default_isa
;
4818 uint32 regno
, const16_regno
, call_regno
;
4821 if (insnbuf
== NULL
)
4823 insnbuf
= xtensa_insnbuf_alloc (isa
);
4824 slotbuf
= xtensa_insnbuf_alloc (isa
);
4827 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4828 fmt
= xtensa_format_decode (isa
, insnbuf
);
4829 if (fmt
== XTENSA_UNDEFINED
4830 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4831 return XTENSA_UNDEFINED
;
4833 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4834 if (opcode
== XTENSA_UNDEFINED
)
4835 return XTENSA_UNDEFINED
;
4837 if (opcode
== get_l32r_opcode ())
4840 *p_uses_l32r
= TRUE
;
4841 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4842 fmt
, 0, slotbuf
, ®no
)
4843 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4845 return XTENSA_UNDEFINED
;
4847 else if (opcode
== get_const16_opcode ())
4850 *p_uses_l32r
= FALSE
;
4851 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4852 fmt
, 0, slotbuf
, ®no
)
4853 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4855 return XTENSA_UNDEFINED
;
4857 /* Check that the next instruction is also CONST16. */
4858 offset
+= xtensa_format_length (isa
, fmt
);
4859 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4860 fmt
= xtensa_format_decode (isa
, insnbuf
);
4861 if (fmt
== XTENSA_UNDEFINED
4862 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4863 return XTENSA_UNDEFINED
;
4864 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4865 if (opcode
!= get_const16_opcode ())
4866 return XTENSA_UNDEFINED
;
4868 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4869 fmt
, 0, slotbuf
, &const16_regno
)
4870 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4872 || const16_regno
!= regno
)
4873 return XTENSA_UNDEFINED
;
4876 return XTENSA_UNDEFINED
;
4878 /* Next instruction should be an CALLXn with operand 0 == regno. */
4879 offset
+= xtensa_format_length (isa
, fmt
);
4880 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4881 fmt
= xtensa_format_decode (isa
, insnbuf
);
4882 if (fmt
== XTENSA_UNDEFINED
4883 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4884 return XTENSA_UNDEFINED
;
4885 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4886 if (opcode
== XTENSA_UNDEFINED
4887 || !is_indirect_call_opcode (opcode
))
4888 return XTENSA_UNDEFINED
;
4890 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4891 fmt
, 0, slotbuf
, &call_regno
)
4892 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4894 return XTENSA_UNDEFINED
;
4896 if (call_regno
!= regno
)
4897 return XTENSA_UNDEFINED
;
4903 /* Data structures used during relaxation. */
4905 /* r_reloc: relocation values. */
4907 /* Through the relaxation process, we need to keep track of the values
4908 that will result from evaluating relocations. The standard ELF
4909 relocation structure is not sufficient for this purpose because we're
4910 operating on multiple input files at once, so we need to know which
4911 input file a relocation refers to. The r_reloc structure thus
4912 records both the input file (bfd) and ELF relocation.
4914 For efficiency, an r_reloc also contains a "target_offset" field to
4915 cache the target-section-relative offset value that is represented by
4918 The r_reloc also contains a virtual offset that allows multiple
4919 inserted literals to be placed at the same "address" with
4920 different offsets. */
4922 typedef struct r_reloc_struct r_reloc
;
4924 struct r_reloc_struct
4927 Elf_Internal_Rela rela
;
4928 bfd_vma target_offset
;
4929 bfd_vma virtual_offset
;
4933 /* The r_reloc structure is included by value in literal_value, but not
4934 every literal_value has an associated relocation -- some are simple
4935 constants. In such cases, we set all the fields in the r_reloc
4936 struct to zero. The r_reloc_is_const function should be used to
4937 detect this case. */
4940 r_reloc_is_const (const r_reloc
*r_rel
)
4942 return (r_rel
->abfd
== NULL
);
4947 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4949 bfd_vma target_offset
;
4950 unsigned long r_symndx
;
4952 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4953 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4954 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4955 return (target_offset
+ r_rel
->rela
.r_addend
);
4959 static struct elf_link_hash_entry
*
4960 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4962 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4963 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4968 r_reloc_get_section (const r_reloc
*r_rel
)
4970 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4971 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4976 r_reloc_is_defined (const r_reloc
*r_rel
)
4982 sec
= r_reloc_get_section (r_rel
);
4983 if (sec
== bfd_abs_section_ptr
4984 || sec
== bfd_com_section_ptr
4985 || sec
== bfd_und_section_ptr
)
4992 r_reloc_init (r_reloc
*r_rel
,
4994 Elf_Internal_Rela
*irel
,
4996 bfd_size_type content_length
)
4999 reloc_howto_type
*howto
;
5003 r_rel
->rela
= *irel
;
5005 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
5006 r_rel
->virtual_offset
= 0;
5007 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
5008 howto
= &elf_howto_table
[r_type
];
5009 if (howto
->partial_inplace
)
5011 bfd_vma inplace_val
;
5012 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
5014 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
5015 r_rel
->target_offset
+= inplace_val
;
5019 memset (r_rel
, 0, sizeof (r_reloc
));
5026 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
5028 if (r_reloc_is_defined (r_rel
))
5030 asection
*sec
= r_reloc_get_section (r_rel
);
5031 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
5033 else if (r_reloc_get_hash_entry (r_rel
))
5034 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
5036 fprintf (fp
, " ?? + ");
5038 fprintf_vma (fp
, r_rel
->target_offset
);
5039 if (r_rel
->virtual_offset
)
5041 fprintf (fp
, " + ");
5042 fprintf_vma (fp
, r_rel
->virtual_offset
);
5051 /* source_reloc: relocations that reference literals. */
5053 /* To determine whether literals can be coalesced, we need to first
5054 record all the relocations that reference the literals. The
5055 source_reloc structure below is used for this purpose. The
5056 source_reloc entries are kept in a per-literal-section array, sorted
5057 by offset within the literal section (i.e., target offset).
5059 The source_sec and r_rel.rela.r_offset fields identify the source of
5060 the relocation. The r_rel field records the relocation value, i.e.,
5061 the offset of the literal being referenced. The opnd field is needed
5062 to determine the range of the immediate field to which the relocation
5063 applies, so we can determine whether another literal with the same
5064 value is within range. The is_null field is true when the relocation
5065 is being removed (e.g., when an L32R is being removed due to a CALLX
5066 that is converted to a direct CALL). */
5068 typedef struct source_reloc_struct source_reloc
;
5070 struct source_reloc_struct
5072 asection
*source_sec
;
5074 xtensa_opcode opcode
;
5076 bfd_boolean is_null
;
5077 bfd_boolean is_abs_literal
;
5082 init_source_reloc (source_reloc
*reloc
,
5083 asection
*source_sec
,
5084 const r_reloc
*r_rel
,
5085 xtensa_opcode opcode
,
5087 bfd_boolean is_abs_literal
)
5089 reloc
->source_sec
= source_sec
;
5090 reloc
->r_rel
= *r_rel
;
5091 reloc
->opcode
= opcode
;
5093 reloc
->is_null
= FALSE
;
5094 reloc
->is_abs_literal
= is_abs_literal
;
5098 /* Find the source_reloc for a particular source offset and relocation
5099 type. Note that the array is sorted by _target_ offset, so this is
5100 just a linear search. */
5102 static source_reloc
*
5103 find_source_reloc (source_reloc
*src_relocs
,
5106 Elf_Internal_Rela
*irel
)
5110 for (i
= 0; i
< src_count
; i
++)
5112 if (src_relocs
[i
].source_sec
== sec
5113 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
5114 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
5115 == ELF32_R_TYPE (irel
->r_info
)))
5116 return &src_relocs
[i
];
5124 source_reloc_compare (const void *ap
, const void *bp
)
5126 const source_reloc
*a
= (const source_reloc
*) ap
;
5127 const source_reloc
*b
= (const source_reloc
*) bp
;
5129 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
5130 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5132 /* We don't need to sort on these criteria for correctness,
5133 but enforcing a more strict ordering prevents unstable qsort
5134 from behaving differently with different implementations.
5135 Without the code below we get correct but different results
5136 on Solaris 2.7 and 2.8. We would like to always produce the
5137 same results no matter the host. */
5139 if ((!a
->is_null
) - (!b
->is_null
))
5140 return ((!a
->is_null
) - (!b
->is_null
));
5141 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5145 /* Literal values and value hash tables. */
5147 /* Literals with the same value can be coalesced. The literal_value
5148 structure records the value of a literal: the "r_rel" field holds the
5149 information from the relocation on the literal (if there is one) and
5150 the "value" field holds the contents of the literal word itself.
5152 The value_map structure records a literal value along with the
5153 location of a literal holding that value. The value_map hash table
5154 is indexed by the literal value, so that we can quickly check if a
5155 particular literal value has been seen before and is thus a candidate
5158 typedef struct literal_value_struct literal_value
;
5159 typedef struct value_map_struct value_map
;
5160 typedef struct value_map_hash_table_struct value_map_hash_table
;
5162 struct literal_value_struct
5165 unsigned long value
;
5166 bfd_boolean is_abs_literal
;
5169 struct value_map_struct
5171 literal_value val
; /* The literal value. */
5172 r_reloc loc
; /* Location of the literal. */
5176 struct value_map_hash_table_struct
5178 unsigned bucket_count
;
5179 value_map
**buckets
;
5181 bfd_boolean has_last_loc
;
5187 init_literal_value (literal_value
*lit
,
5188 const r_reloc
*r_rel
,
5189 unsigned long value
,
5190 bfd_boolean is_abs_literal
)
5192 lit
->r_rel
= *r_rel
;
5194 lit
->is_abs_literal
= is_abs_literal
;
5199 literal_value_equal (const literal_value
*src1
,
5200 const literal_value
*src2
,
5201 bfd_boolean final_static_link
)
5203 struct elf_link_hash_entry
*h1
, *h2
;
5205 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5208 if (r_reloc_is_const (&src1
->r_rel
))
5209 return (src1
->value
== src2
->value
);
5211 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5212 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5215 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5218 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5221 if (src1
->value
!= src2
->value
)
5224 /* Now check for the same section (if defined) or the same elf_hash
5225 (if undefined or weak). */
5226 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5227 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5228 if (r_reloc_is_defined (&src1
->r_rel
)
5229 && (final_static_link
5230 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5231 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5233 if (r_reloc_get_section (&src1
->r_rel
)
5234 != r_reloc_get_section (&src2
->r_rel
))
5239 /* Require that the hash entries (i.e., symbols) be identical. */
5240 if (h1
!= h2
|| h1
== 0)
5244 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5251 /* Must be power of 2. */
5252 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5254 static value_map_hash_table
*
5255 value_map_hash_table_init (void)
5257 value_map_hash_table
*values
;
5259 values
= (value_map_hash_table
*)
5260 bfd_zmalloc (sizeof (value_map_hash_table
));
5261 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5263 values
->buckets
= (value_map
**)
5264 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5265 if (values
->buckets
== NULL
)
5270 values
->has_last_loc
= FALSE
;
5277 value_map_hash_table_delete (value_map_hash_table
*table
)
5279 free (table
->buckets
);
5285 hash_bfd_vma (bfd_vma val
)
5287 return (val
>> 2) + (val
>> 10);
5292 literal_value_hash (const literal_value
*src
)
5296 hash_val
= hash_bfd_vma (src
->value
);
5297 if (!r_reloc_is_const (&src
->r_rel
))
5301 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5302 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5303 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5305 /* Now check for the same section and the same elf_hash. */
5306 if (r_reloc_is_defined (&src
->r_rel
))
5307 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5309 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5310 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5316 /* Check if the specified literal_value has been seen before. */
5319 value_map_get_cached_value (value_map_hash_table
*map
,
5320 const literal_value
*val
,
5321 bfd_boolean final_static_link
)
5327 idx
= literal_value_hash (val
);
5328 idx
= idx
& (map
->bucket_count
- 1);
5329 bucket
= map
->buckets
[idx
];
5330 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5332 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5339 /* Record a new literal value. It is illegal to call this if VALUE
5340 already has an entry here. */
5343 add_value_map (value_map_hash_table
*map
,
5344 const literal_value
*val
,
5346 bfd_boolean final_static_link
)
5348 value_map
**bucket_p
;
5351 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5354 bfd_set_error (bfd_error_no_memory
);
5358 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5362 idx
= literal_value_hash (val
);
5363 idx
= idx
& (map
->bucket_count
- 1);
5364 bucket_p
= &map
->buckets
[idx
];
5366 val_e
->next
= *bucket_p
;
5369 /* FIXME: Consider resizing the hash table if we get too many entries. */
5375 /* Lists of text actions (ta_) for narrowing, widening, longcall
5376 conversion, space fill, code & literal removal, etc. */
5378 /* The following text actions are generated:
5380 "ta_remove_insn" remove an instruction or instructions
5381 "ta_remove_longcall" convert longcall to call
5382 "ta_convert_longcall" convert longcall to nop/call
5383 "ta_narrow_insn" narrow a wide instruction
5384 "ta_widen" widen a narrow instruction
5385 "ta_fill" add fill or remove fill
5386 removed < 0 is a fill; branches to the fill address will be
5387 changed to address + fill size (e.g., address - removed)
5388 removed >= 0 branches to the fill address will stay unchanged
5389 "ta_remove_literal" remove a literal; this action is
5390 indicated when a literal is removed
5392 "ta_add_literal" insert a new literal; this action is
5393 indicated when a literal has been moved.
5394 It may use a virtual_offset because
5395 multiple literals can be placed at the
5398 For each of these text actions, we also record the number of bytes
5399 removed by performing the text action. In the case of a "ta_widen"
5400 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5402 typedef struct text_action_struct text_action
;
5403 typedef struct text_action_list_struct text_action_list
;
5404 typedef enum text_action_enum_t text_action_t
;
5406 enum text_action_enum_t
5409 ta_remove_insn
, /* removed = -size */
5410 ta_remove_longcall
, /* removed = -size */
5411 ta_convert_longcall
, /* removed = 0 */
5412 ta_narrow_insn
, /* removed = -1 */
5413 ta_widen_insn
, /* removed = +1 */
5414 ta_fill
, /* removed = +size */
5420 /* Structure for a text action record. */
5421 struct text_action_struct
5423 text_action_t action
;
5424 asection
*sec
; /* Optional */
5426 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5428 literal_value value
; /* Only valid when adding literals. */
5431 struct removal_by_action_entry_struct
5436 int eq_removed_before_fill
;
5438 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5440 struct removal_by_action_map_struct
5443 removal_by_action_entry
*entry
;
5445 typedef struct removal_by_action_map_struct removal_by_action_map
;
5448 /* List of all of the actions taken on a text section. */
5449 struct text_action_list_struct
5453 removal_by_action_map map
;
5457 static text_action
*
5458 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5462 /* It is not necessary to fill at the end of a section. */
5463 if (sec
->size
== offset
)
5469 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5471 return (text_action
*)node
->value
;
5477 compute_removed_action_diff (const text_action
*ta
,
5481 int removable_space
)
5484 int current_removed
= 0;
5487 current_removed
= ta
->removed_bytes
;
5489 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5490 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5492 /* It is not necessary to fill at the end of a section. Clean this up. */
5493 if (sec
->size
== offset
)
5494 new_removed
= removable_space
- 0;
5498 int added
= -removed
- current_removed
;
5499 /* Ignore multiples of the section alignment. */
5500 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5501 new_removed
= (-added
);
5503 /* Modify for removable. */
5504 space
= removable_space
- new_removed
;
5505 new_removed
= (removable_space
5506 - (((1 << sec
->alignment_power
) - 1) & space
));
5508 return (new_removed
- current_removed
);
5513 adjust_fill_action (text_action
*ta
, int fill_diff
)
5515 ta
->removed_bytes
+= fill_diff
;
5520 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5522 text_action
*pa
= (text_action
*)a
;
5523 text_action
*pb
= (text_action
*)b
;
5524 static const int action_priority
[] =
5528 [ta_convert_longcall
] = 2,
5529 [ta_narrow_insn
] = 3,
5530 [ta_remove_insn
] = 4,
5531 [ta_remove_longcall
] = 5,
5532 [ta_remove_literal
] = 6,
5533 [ta_widen_insn
] = 7,
5534 [ta_add_literal
] = 8,
5537 if (pa
->offset
== pb
->offset
)
5539 if (pa
->action
== pb
->action
)
5541 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5544 return pa
->offset
< pb
->offset
? -1 : 1;
5547 static text_action
*
5548 action_first (text_action_list
*action_list
)
5550 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5551 return node
? (text_action
*)node
->value
: NULL
;
5554 static text_action
*
5555 action_next (text_action_list
*action_list
, text_action
*action
)
5557 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5558 (splay_tree_key
)action
);
5559 return node
? (text_action
*)node
->value
: NULL
;
5562 /* Add a modification action to the text. For the case of adding or
5563 removing space, modify any current fill and assume that
5564 "unreachable_space" bytes can be freely contracted. Note that a
5565 negative removed value is a fill. */
5568 text_action_add (text_action_list
*l
,
5569 text_action_t action
,
5577 /* It is not necessary to fill at the end of a section. */
5578 if (action
== ta_fill
&& sec
->size
== offset
)
5581 /* It is not necessary to fill 0 bytes. */
5582 if (action
== ta_fill
&& removed
== 0)
5588 if (action
== ta_fill
)
5590 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5594 ta
= (text_action
*)node
->value
;
5595 ta
->removed_bytes
+= removed
;
5600 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5602 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5603 ta
->action
= action
;
5605 ta
->offset
= offset
;
5606 ta
->removed_bytes
= removed
;
5607 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5613 text_action_add_literal (text_action_list
*l
,
5614 text_action_t action
,
5616 const literal_value
*value
,
5620 asection
*sec
= r_reloc_get_section (loc
);
5621 bfd_vma offset
= loc
->target_offset
;
5622 bfd_vma virtual_offset
= loc
->virtual_offset
;
5624 BFD_ASSERT (action
== ta_add_literal
);
5626 /* Create a new record and fill it up. */
5627 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5628 ta
->action
= action
;
5630 ta
->offset
= offset
;
5631 ta
->virtual_offset
= virtual_offset
;
5633 ta
->removed_bytes
= removed
;
5635 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5636 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5641 /* Find the total offset adjustment for the relaxations specified by
5642 text_actions, beginning from a particular starting action. This is
5643 typically used from offset_with_removed_text to search an entire list of
5644 actions, but it may also be called directly when adjusting adjacent offsets
5645 so that each search may begin where the previous one left off. */
5648 removed_by_actions (text_action_list
*action_list
,
5649 text_action
**p_start_action
,
5651 bfd_boolean before_fill
)
5656 r
= *p_start_action
;
5659 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5661 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5666 if (r
->offset
> offset
)
5669 if (r
->offset
== offset
5670 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5673 removed
+= r
->removed_bytes
;
5675 r
= action_next (action_list
, r
);
5678 *p_start_action
= r
;
5684 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5686 text_action
*r
= action_first (action_list
);
5688 return offset
- removed_by_actions (action_list
, &r
, offset
, FALSE
);
5693 action_list_count (text_action_list
*action_list
)
5695 return action_list
->count
;
5698 typedef struct map_action_fn_context_struct map_action_fn_context
;
5699 struct map_action_fn_context_struct
5702 removal_by_action_map map
;
5703 bfd_boolean eq_complete
;
5707 map_action_fn (splay_tree_node node
, void *p
)
5709 map_action_fn_context
*ctx
= p
;
5710 text_action
*r
= (text_action
*)node
->value
;
5711 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5713 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5719 ++ctx
->map
.n_entries
;
5720 ctx
->eq_complete
= FALSE
;
5721 ientry
->offset
= r
->offset
;
5722 ientry
->eq_removed_before_fill
= ctx
->removed
;
5725 if (!ctx
->eq_complete
)
5727 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5729 ientry
->eq_removed
= ctx
->removed
;
5730 ctx
->eq_complete
= TRUE
;
5733 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5736 ctx
->removed
+= r
->removed_bytes
;
5737 ientry
->removed
= ctx
->removed
;
5742 map_removal_by_action (text_action_list
*action_list
)
5744 map_action_fn_context ctx
;
5747 ctx
.map
.n_entries
= 0;
5748 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5749 sizeof (removal_by_action_entry
));
5750 ctx
.eq_complete
= FALSE
;
5752 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5753 action_list
->map
= ctx
.map
;
5757 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5758 bfd_boolean before_fill
)
5762 if (!action_list
->map
.entry
)
5763 map_removal_by_action (action_list
);
5765 if (!action_list
->map
.n_entries
)
5769 b
= action_list
->map
.n_entries
;
5773 unsigned c
= (a
+ b
) / 2;
5775 if (action_list
->map
.entry
[c
].offset
<= offset
)
5781 if (action_list
->map
.entry
[a
].offset
< offset
)
5783 return action_list
->map
.entry
[a
].removed
;
5785 else if (action_list
->map
.entry
[a
].offset
== offset
)
5787 return before_fill
?
5788 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5789 action_list
->map
.entry
[a
].eq_removed
;
5798 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5800 int removed
= removed_by_actions_map (action_list
, offset
, FALSE
);
5801 return offset
- removed
;
5805 /* The find_insn_action routine will only find non-fill actions. */
5807 static text_action
*
5808 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5810 static const text_action_t action
[] =
5812 ta_convert_longcall
,
5822 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5824 splay_tree_node node
;
5826 a
.action
= action
[i
];
5827 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5829 return (text_action
*)node
->value
;
5838 print_action (FILE *fp
, text_action
*r
)
5840 const char *t
= "unknown";
5843 case ta_remove_insn
:
5844 t
= "remove_insn"; break;
5845 case ta_remove_longcall
:
5846 t
= "remove_longcall"; break;
5847 case ta_convert_longcall
:
5848 t
= "convert_longcall"; break;
5849 case ta_narrow_insn
:
5850 t
= "narrow_insn"; break;
5852 t
= "widen_insn"; break;
5857 case ta_remove_literal
:
5858 t
= "remove_literal"; break;
5859 case ta_add_literal
:
5860 t
= "add_literal"; break;
5863 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5864 r
->sec
->owner
->filename
,
5865 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5869 print_action_list_fn (splay_tree_node node
, void *p
)
5871 text_action
*r
= (text_action
*)node
->value
;
5873 print_action (p
, r
);
5878 print_action_list (FILE *fp
, text_action_list
*action_list
)
5880 fprintf (fp
, "Text Action\n");
5881 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5887 /* Lists of literals being coalesced or removed. */
5889 /* In the usual case, the literal identified by "from" is being
5890 coalesced with another literal identified by "to". If the literal is
5891 unused and is being removed altogether, "to.abfd" will be NULL.
5892 The removed_literal entries are kept on a per-section list, sorted
5893 by the "from" offset field. */
5895 typedef struct removed_literal_struct removed_literal
;
5896 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5897 typedef struct removed_literal_list_struct removed_literal_list
;
5899 struct removed_literal_struct
5903 removed_literal
*next
;
5906 struct removed_literal_map_entry_struct
5909 removed_literal
*literal
;
5912 struct removed_literal_list_struct
5914 removed_literal
*head
;
5915 removed_literal
*tail
;
5918 removed_literal_map_entry
*map
;
5922 /* Record that the literal at "from" is being removed. If "to" is not
5923 NULL, the "from" literal is being coalesced with the "to" literal. */
5926 add_removed_literal (removed_literal_list
*removed_list
,
5927 const r_reloc
*from
,
5930 removed_literal
*r
, *new_r
, *next_r
;
5932 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5934 new_r
->from
= *from
;
5938 new_r
->to
.abfd
= NULL
;
5941 r
= removed_list
->head
;
5944 removed_list
->head
= new_r
;
5945 removed_list
->tail
= new_r
;
5947 /* Special check for common case of append. */
5948 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5950 removed_list
->tail
->next
= new_r
;
5951 removed_list
->tail
= new_r
;
5955 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5961 new_r
->next
= next_r
;
5963 removed_list
->tail
= new_r
;
5968 map_removed_literal (removed_literal_list
*removed_list
)
5972 removed_literal_map_entry
*map
= NULL
;
5973 removed_literal
*r
= removed_list
->head
;
5975 for (i
= 0; r
; ++i
, r
= r
->next
)
5979 n_map
= (n_map
* 2) + 2;
5980 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5982 map
[i
].addr
= r
->from
.target_offset
;
5985 removed_list
->map
= map
;
5986 removed_list
->n_map
= i
;
5990 removed_literal_compare (const void *a
, const void *b
)
5992 const bfd_vma
*key
= a
;
5993 const removed_literal_map_entry
*memb
= b
;
5995 if (*key
== memb
->addr
)
5998 return *key
< memb
->addr
? -1 : 1;
6001 /* Check if the list of removed literals contains an entry for the
6002 given address. Return the entry if found. */
6004 static removed_literal
*
6005 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
6007 removed_literal_map_entry
*p
;
6008 removed_literal
*r
= NULL
;
6010 if (removed_list
->map
== NULL
)
6011 map_removed_literal (removed_list
);
6013 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
6014 sizeof (*removed_list
->map
), removed_literal_compare
);
6017 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
6028 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
6031 r
= removed_list
->head
;
6033 fprintf (fp
, "Removed Literals\n");
6034 for (; r
!= NULL
; r
= r
->next
)
6036 print_r_reloc (fp
, &r
->from
);
6037 fprintf (fp
, " => ");
6038 if (r
->to
.abfd
== NULL
)
6039 fprintf (fp
, "REMOVED");
6041 print_r_reloc (fp
, &r
->to
);
6049 /* Per-section data for relaxation. */
6051 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
6053 struct xtensa_relax_info_struct
6055 bfd_boolean is_relaxable_literal_section
;
6056 bfd_boolean is_relaxable_asm_section
;
6057 int visited
; /* Number of times visited. */
6059 source_reloc
*src_relocs
; /* Array[src_count]. */
6061 int src_next
; /* Next src_relocs entry to assign. */
6063 removed_literal_list removed_list
;
6064 text_action_list action_list
;
6066 reloc_bfd_fix
*fix_list
;
6067 reloc_bfd_fix
*fix_array
;
6068 unsigned fix_array_count
;
6070 /* Support for expanding the reloc array that is stored
6071 in the section structure. If the relocations have been
6072 reallocated, the newly allocated relocations will be referenced
6073 here along with the actual size allocated. The relocation
6074 count will always be found in the section structure. */
6075 Elf_Internal_Rela
*allocated_relocs
;
6076 unsigned relocs_count
;
6077 unsigned allocated_relocs_count
;
6080 struct elf_xtensa_section_data
6082 struct bfd_elf_section_data elf
;
6083 xtensa_relax_info relax_info
;
6088 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
6090 if (!sec
->used_by_bfd
)
6092 struct elf_xtensa_section_data
*sdata
;
6093 size_t amt
= sizeof (*sdata
);
6095 sdata
= bfd_zalloc (abfd
, amt
);
6098 sec
->used_by_bfd
= sdata
;
6101 return _bfd_elf_new_section_hook (abfd
, sec
);
6105 static xtensa_relax_info
*
6106 get_xtensa_relax_info (asection
*sec
)
6108 struct elf_xtensa_section_data
*section_data
;
6110 /* No info available if no section or if it is an output section. */
6111 if (!sec
|| sec
== sec
->output_section
)
6114 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
6115 return §ion_data
->relax_info
;
6120 init_xtensa_relax_info (asection
*sec
)
6122 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6124 relax_info
->is_relaxable_literal_section
= FALSE
;
6125 relax_info
->is_relaxable_asm_section
= FALSE
;
6126 relax_info
->visited
= 0;
6128 relax_info
->src_relocs
= NULL
;
6129 relax_info
->src_count
= 0;
6130 relax_info
->src_next
= 0;
6132 relax_info
->removed_list
.head
= NULL
;
6133 relax_info
->removed_list
.tail
= NULL
;
6135 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6137 relax_info
->action_list
.map
.n_entries
= 0;
6138 relax_info
->action_list
.map
.entry
= NULL
;
6140 relax_info
->fix_list
= NULL
;
6141 relax_info
->fix_array
= NULL
;
6142 relax_info
->fix_array_count
= 0;
6144 relax_info
->allocated_relocs
= NULL
;
6145 relax_info
->relocs_count
= 0;
6146 relax_info
->allocated_relocs_count
= 0;
6150 /* Coalescing literals may require a relocation to refer to a section in
6151 a different input file, but the standard relocation information
6152 cannot express that. Instead, the reloc_bfd_fix structures are used
6153 to "fix" the relocations that refer to sections in other input files.
6154 These structures are kept on per-section lists. The "src_type" field
6155 records the relocation type in case there are multiple relocations on
6156 the same location. FIXME: This is ugly; an alternative might be to
6157 add new symbols with the "owner" field to some other input file. */
6159 struct reloc_bfd_fix_struct
6163 unsigned src_type
; /* Relocation type. */
6165 asection
*target_sec
;
6166 bfd_vma target_offset
;
6167 bfd_boolean translated
;
6169 reloc_bfd_fix
*next
;
6173 static reloc_bfd_fix
*
6174 reloc_bfd_fix_init (asection
*src_sec
,
6177 asection
*target_sec
,
6178 bfd_vma target_offset
,
6179 bfd_boolean translated
)
6183 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6184 fix
->src_sec
= src_sec
;
6185 fix
->src_offset
= src_offset
;
6186 fix
->src_type
= src_type
;
6187 fix
->target_sec
= target_sec
;
6188 fix
->target_offset
= target_offset
;
6189 fix
->translated
= translated
;
6196 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6198 xtensa_relax_info
*relax_info
;
6200 relax_info
= get_xtensa_relax_info (src_sec
);
6201 fix
->next
= relax_info
->fix_list
;
6202 relax_info
->fix_list
= fix
;
6207 fix_compare (const void *ap
, const void *bp
)
6209 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6210 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6212 if (a
->src_offset
!= b
->src_offset
)
6213 return (a
->src_offset
- b
->src_offset
);
6214 return (a
->src_type
- b
->src_type
);
6219 cache_fix_array (asection
*sec
)
6221 unsigned i
, count
= 0;
6223 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6225 if (relax_info
== NULL
)
6227 if (relax_info
->fix_list
== NULL
)
6230 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6233 relax_info
->fix_array
=
6234 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6235 relax_info
->fix_array_count
= count
;
6237 r
= relax_info
->fix_list
;
6238 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6240 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6241 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6244 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6245 sizeof (reloc_bfd_fix
), fix_compare
);
6249 static reloc_bfd_fix
*
6250 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6252 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6256 if (relax_info
== NULL
)
6258 if (relax_info
->fix_list
== NULL
)
6261 if (relax_info
->fix_array
== NULL
)
6262 cache_fix_array (sec
);
6264 key
.src_offset
= offset
;
6265 key
.src_type
= type
;
6266 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6267 sizeof (reloc_bfd_fix
), fix_compare
);
6272 /* Section caching. */
6274 typedef struct section_cache_struct section_cache_t
;
6276 struct section_cache_struct
6280 bfd_byte
*contents
; /* Cache of the section contents. */
6281 bfd_size_type content_length
;
6283 property_table_entry
*ptbl
; /* Cache of the section property table. */
6286 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6287 unsigned reloc_count
;
6292 init_section_cache (section_cache_t
*sec_cache
)
6294 memset (sec_cache
, 0, sizeof (*sec_cache
));
6299 free_section_cache (section_cache_t
*sec_cache
)
6303 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6304 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6305 free (sec_cache
->ptbl
);
6311 section_cache_section (section_cache_t
*sec_cache
,
6313 struct bfd_link_info
*link_info
)
6316 property_table_entry
*prop_table
= NULL
;
6318 bfd_byte
*contents
= NULL
;
6319 Elf_Internal_Rela
*internal_relocs
= NULL
;
6320 bfd_size_type sec_size
;
6324 if (sec
== sec_cache
->sec
)
6328 sec_size
= bfd_get_section_limit (abfd
, sec
);
6330 /* Get the contents. */
6331 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6332 if (contents
== NULL
&& sec_size
!= 0)
6335 /* Get the relocations. */
6336 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6337 link_info
->keep_memory
);
6339 /* Get the entry table. */
6340 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6341 XTENSA_PROP_SEC_NAME
, FALSE
);
6345 /* Fill in the new section cache. */
6346 free_section_cache (sec_cache
);
6347 init_section_cache (sec_cache
);
6349 sec_cache
->sec
= sec
;
6350 sec_cache
->contents
= contents
;
6351 sec_cache
->content_length
= sec_size
;
6352 sec_cache
->relocs
= internal_relocs
;
6353 sec_cache
->reloc_count
= sec
->reloc_count
;
6354 sec_cache
->pte_count
= ptblsize
;
6355 sec_cache
->ptbl
= prop_table
;
6360 release_contents (sec
, contents
);
6361 release_internal_relocs (sec
, internal_relocs
);
6367 /* Extended basic blocks. */
6369 /* An ebb_struct represents an Extended Basic Block. Within this
6370 range, we guarantee that all instructions are decodable, the
6371 property table entries are contiguous, and no property table
6372 specifies a segment that cannot have instructions moved. This
6373 structure contains caches of the contents, property table and
6374 relocations for the specified section for easy use. The range is
6375 specified by ranges of indices for the byte offset, property table
6376 offsets and relocation offsets. These must be consistent. */
6378 typedef struct ebb_struct ebb_t
;
6384 bfd_byte
*contents
; /* Cache of the section contents. */
6385 bfd_size_type content_length
;
6387 property_table_entry
*ptbl
; /* Cache of the section property table. */
6390 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6391 unsigned reloc_count
;
6393 bfd_vma start_offset
; /* Offset in section. */
6394 unsigned start_ptbl_idx
; /* Offset in the property table. */
6395 unsigned start_reloc_idx
; /* Offset in the relocations. */
6398 unsigned end_ptbl_idx
;
6399 unsigned end_reloc_idx
;
6401 bfd_boolean ends_section
; /* Is this the last ebb in a section? */
6403 /* The unreachable property table at the end of this set of blocks;
6404 NULL if the end is not an unreachable block. */
6405 property_table_entry
*ends_unreachable
;
6409 enum ebb_target_enum
6412 EBB_DESIRE_TGT_ALIGN
,
6413 EBB_REQUIRE_TGT_ALIGN
,
6414 EBB_REQUIRE_LOOP_ALIGN
,
6419 /* proposed_action_struct is similar to the text_action_struct except
6420 that is represents a potential transformation, not one that will
6421 occur. We build a list of these for an extended basic block
6422 and use them to compute the actual actions desired. We must be
6423 careful that the entire set of actual actions we perform do not
6424 break any relocations that would fit if the actions were not
6427 typedef struct proposed_action_struct proposed_action
;
6429 struct proposed_action_struct
6431 enum ebb_target_enum align_type
; /* for the target alignment */
6432 bfd_vma alignment_pow
;
6433 text_action_t action
;
6436 bfd_boolean do_action
; /* If false, then we will not perform the action. */
6440 /* The ebb_constraint_struct keeps a set of proposed actions for an
6441 extended basic block. */
6443 typedef struct ebb_constraint_struct ebb_constraint
;
6445 struct ebb_constraint_struct
6448 bfd_boolean start_movable
;
6450 /* Bytes of extra space at the beginning if movable. */
6451 int start_extra_space
;
6453 enum ebb_target_enum start_align
;
6455 bfd_boolean end_movable
;
6457 /* Bytes of extra space at the end if movable. */
6458 int end_extra_space
;
6460 unsigned action_count
;
6461 unsigned action_allocated
;
6463 /* Array of proposed actions. */
6464 proposed_action
*actions
;
6466 /* Action alignments -- one for each proposed action. */
6467 enum ebb_target_enum
*action_aligns
;
6472 init_ebb_constraint (ebb_constraint
*c
)
6474 memset (c
, 0, sizeof (ebb_constraint
));
6479 free_ebb_constraint (ebb_constraint
*c
)
6486 init_ebb (ebb_t
*ebb
,
6489 bfd_size_type content_length
,
6490 property_table_entry
*prop_table
,
6492 Elf_Internal_Rela
*internal_relocs
,
6493 unsigned reloc_count
)
6495 memset (ebb
, 0, sizeof (ebb_t
));
6497 ebb
->contents
= contents
;
6498 ebb
->content_length
= content_length
;
6499 ebb
->ptbl
= prop_table
;
6500 ebb
->pte_count
= ptblsize
;
6501 ebb
->relocs
= internal_relocs
;
6502 ebb
->reloc_count
= reloc_count
;
6503 ebb
->start_offset
= 0;
6504 ebb
->end_offset
= ebb
->content_length
- 1;
6505 ebb
->start_ptbl_idx
= 0;
6506 ebb
->end_ptbl_idx
= ptblsize
;
6507 ebb
->start_reloc_idx
= 0;
6508 ebb
->end_reloc_idx
= reloc_count
;
6512 /* Extend the ebb to all decodable contiguous sections. The algorithm
6513 for building a basic block around an instruction is to push it
6514 forward until we hit the end of a section, an unreachable block or
6515 a block that cannot be transformed. Then we push it backwards
6516 searching for similar conditions. */
6518 static bfd_boolean
extend_ebb_bounds_forward (ebb_t
*);
6519 static bfd_boolean
extend_ebb_bounds_backward (ebb_t
*);
6520 static bfd_size_type insn_block_decodable_len
6521 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6524 extend_ebb_bounds (ebb_t
*ebb
)
6526 if (!extend_ebb_bounds_forward (ebb
))
6528 if (!extend_ebb_bounds_backward (ebb
))
6535 extend_ebb_bounds_forward (ebb_t
*ebb
)
6537 property_table_entry
*the_entry
, *new_entry
;
6539 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6541 /* Stop when (1) we cannot decode an instruction, (2) we are at
6542 the end of the property tables, (3) we hit a non-contiguous property
6543 table entry, (4) we hit a NO_TRANSFORM region. */
6548 bfd_size_type insn_block_len
;
6550 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6552 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6554 entry_end
- ebb
->end_offset
);
6555 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6558 /* xgettext:c-format */
6559 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6560 "possible configuration mismatch"),
6561 ebb
->sec
->owner
, ebb
->sec
,
6562 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6565 ebb
->end_offset
+= insn_block_len
;
6567 if (ebb
->end_offset
== ebb
->sec
->size
)
6568 ebb
->ends_section
= TRUE
;
6570 /* Update the reloc counter. */
6571 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6572 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6575 ebb
->end_reloc_idx
++;
6578 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6581 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6582 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6583 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6584 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6587 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6590 the_entry
= new_entry
;
6591 ebb
->end_ptbl_idx
++;
6594 /* Quick check for an unreachable or end of file just at the end. */
6595 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6597 if (ebb
->end_offset
== ebb
->content_length
)
6598 ebb
->ends_section
= TRUE
;
6602 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6603 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6604 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6605 ebb
->ends_unreachable
= new_entry
;
6608 /* Any other ending requires exact alignment. */
6614 extend_ebb_bounds_backward (ebb_t
*ebb
)
6616 property_table_entry
*the_entry
, *new_entry
;
6618 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6620 /* Stop when (1) we cannot decode the instructions in the current entry.
6621 (2) we are at the beginning of the property tables, (3) we hit a
6622 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6626 bfd_vma block_begin
;
6627 bfd_size_type insn_block_len
;
6629 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6631 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6633 ebb
->start_offset
- block_begin
);
6634 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6637 /* xgettext:c-format */
6638 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6639 "possible configuration mismatch"),
6640 ebb
->sec
->owner
, ebb
->sec
,
6641 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6644 ebb
->start_offset
-= insn_block_len
;
6646 /* Update the reloc counter. */
6647 while (ebb
->start_reloc_idx
> 0
6648 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6649 >= ebb
->start_offset
))
6651 ebb
->start_reloc_idx
--;
6654 if (ebb
->start_ptbl_idx
== 0)
6657 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6658 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6659 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6660 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6662 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6665 the_entry
= new_entry
;
6666 ebb
->start_ptbl_idx
--;
6672 static bfd_size_type
6673 insn_block_decodable_len (bfd_byte
*contents
,
6674 bfd_size_type content_len
,
6675 bfd_vma block_offset
,
6676 bfd_size_type block_len
)
6678 bfd_vma offset
= block_offset
;
6680 while (offset
< block_offset
+ block_len
)
6682 bfd_size_type insn_len
= 0;
6684 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6686 return (offset
- block_offset
);
6689 return (offset
- block_offset
);
6694 ebb_propose_action (ebb_constraint
*c
,
6695 enum ebb_target_enum align_type
,
6696 bfd_vma alignment_pow
,
6697 text_action_t action
,
6700 bfd_boolean do_action
)
6702 proposed_action
*act
;
6704 if (c
->action_allocated
<= c
->action_count
)
6706 unsigned new_allocated
, i
;
6707 proposed_action
*new_actions
;
6709 new_allocated
= (c
->action_count
+ 2) * 2;
6710 new_actions
= (proposed_action
*)
6711 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6713 for (i
= 0; i
< c
->action_count
; i
++)
6714 new_actions
[i
] = c
->actions
[i
];
6716 c
->actions
= new_actions
;
6717 c
->action_allocated
= new_allocated
;
6720 act
= &c
->actions
[c
->action_count
];
6721 act
->align_type
= align_type
;
6722 act
->alignment_pow
= alignment_pow
;
6723 act
->action
= action
;
6724 act
->offset
= offset
;
6725 act
->removed_bytes
= removed_bytes
;
6726 act
->do_action
= do_action
;
6732 /* Access to internal relocations, section contents and symbols. */
6734 /* During relaxation, we need to modify relocations, section contents,
6735 and symbol definitions, and we need to keep the original values from
6736 being reloaded from the input files, i.e., we need to "pin" the
6737 modified values in memory. We also want to continue to observe the
6738 setting of the "keep-memory" flag. The following functions wrap the
6739 standard BFD functions to take care of this for us. */
6741 static Elf_Internal_Rela
*
6742 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6744 Elf_Internal_Rela
*internal_relocs
;
6746 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6749 internal_relocs
= elf_section_data (sec
)->relocs
;
6750 if (internal_relocs
== NULL
)
6751 internal_relocs
= (_bfd_elf_link_read_relocs
6752 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6753 return internal_relocs
;
6758 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6760 elf_section_data (sec
)->relocs
= internal_relocs
;
6765 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6767 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
6768 free (internal_relocs
);
6773 retrieve_contents (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6776 bfd_size_type sec_size
;
6778 sec_size
= bfd_get_section_limit (abfd
, sec
);
6779 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6781 if (contents
== NULL
&& sec_size
!= 0)
6783 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6789 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6796 pin_contents (asection
*sec
, bfd_byte
*contents
)
6798 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6803 release_contents (asection
*sec
, bfd_byte
*contents
)
6805 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6810 static Elf_Internal_Sym
*
6811 retrieve_local_syms (bfd
*input_bfd
)
6813 Elf_Internal_Shdr
*symtab_hdr
;
6814 Elf_Internal_Sym
*isymbuf
;
6817 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6818 locsymcount
= symtab_hdr
->sh_info
;
6820 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6821 if (isymbuf
== NULL
&& locsymcount
!= 0)
6822 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6825 /* Save the symbols for this input file so they won't be read again. */
6826 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6827 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6833 /* Code for link-time relaxation. */
6835 /* Initialization for relaxation: */
6836 static bfd_boolean
analyze_relocations (struct bfd_link_info
*);
6837 static bfd_boolean find_relaxable_sections
6838 (bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*);
6839 static bfd_boolean collect_source_relocs
6840 (bfd
*, asection
*, struct bfd_link_info
*);
6841 static bfd_boolean is_resolvable_asm_expansion
6842 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6844 static Elf_Internal_Rela
*find_associated_l32r_irel
6845 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6846 static bfd_boolean compute_text_actions
6847 (bfd
*, asection
*, struct bfd_link_info
*);
6848 static bfd_boolean
compute_ebb_proposed_actions (ebb_constraint
*);
6849 static bfd_boolean
compute_ebb_actions (ebb_constraint
*);
6850 typedef struct reloc_range_list_struct reloc_range_list
;
6851 static bfd_boolean check_section_ebb_pcrels_fit
6852 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6853 reloc_range_list
*, const ebb_constraint
*,
6854 const xtensa_opcode
*);
6855 static bfd_boolean
check_section_ebb_reduces (const ebb_constraint
*);
6856 static void text_action_add_proposed
6857 (text_action_list
*, const ebb_constraint
*, asection
*);
6860 static bfd_boolean compute_removed_literals
6861 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6862 static Elf_Internal_Rela
*get_irel_at_offset
6863 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6864 static bfd_boolean is_removable_literal
6865 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6866 property_table_entry
*, int);
6867 static bfd_boolean remove_dead_literal
6868 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6869 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6870 static bfd_boolean identify_literal_placement
6871 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6872 value_map_hash_table
*, bfd_boolean
*, Elf_Internal_Rela
*, int,
6873 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6875 static bfd_boolean
relocations_reach (source_reloc
*, int, const r_reloc
*);
6876 static bfd_boolean coalesce_shared_literal
6877 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6878 static bfd_boolean move_shared_literal
6879 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6880 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6883 static bfd_boolean
relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6884 static bfd_boolean
translate_section_fixes (asection
*);
6885 static bfd_boolean
translate_reloc_bfd_fix (reloc_bfd_fix
*);
6886 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6887 static void shrink_dynamic_reloc_sections
6888 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6889 static bfd_boolean move_literal
6890 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6891 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6892 static bfd_boolean relax_property_section
6893 (bfd
*, asection
*, struct bfd_link_info
*);
6896 static bfd_boolean
relax_section_symbols (bfd
*, asection
*);
6900 elf_xtensa_relax_section (bfd
*abfd
,
6902 struct bfd_link_info
*link_info
,
6905 static value_map_hash_table
*values
= NULL
;
6906 static bfd_boolean relocations_analyzed
= FALSE
;
6907 xtensa_relax_info
*relax_info
;
6909 if (!relocations_analyzed
)
6911 /* Do some overall initialization for relaxation. */
6912 values
= value_map_hash_table_init ();
6915 relaxing_section
= TRUE
;
6916 if (!analyze_relocations (link_info
))
6918 relocations_analyzed
= TRUE
;
6922 /* Don't mess with linker-created sections. */
6923 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6926 relax_info
= get_xtensa_relax_info (sec
);
6927 BFD_ASSERT (relax_info
!= NULL
);
6929 switch (relax_info
->visited
)
6932 /* Note: It would be nice to fold this pass into
6933 analyze_relocations, but it is important for this step that the
6934 sections be examined in link order. */
6935 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6942 value_map_hash_table_delete (values
);
6944 if (!relax_section (abfd
, sec
, link_info
))
6950 if (!relax_section_symbols (abfd
, sec
))
6955 relax_info
->visited
++;
6960 /* Initialization for relaxation. */
6962 /* This function is called once at the start of relaxation. It scans
6963 all the input sections and marks the ones that are relaxable (i.e.,
6964 literal sections with L32R relocations against them), and then
6965 collects source_reloc information for all the relocations against
6966 those relaxable sections. During this process, it also detects
6967 longcalls, i.e., calls relaxed by the assembler into indirect
6968 calls, that can be optimized back into direct calls. Within each
6969 extended basic block (ebb) containing an optimized longcall, it
6970 computes a set of "text actions" that can be performed to remove
6971 the L32R associated with the longcall while optionally preserving
6972 branch target alignments. */
6975 analyze_relocations (struct bfd_link_info
*link_info
)
6979 bfd_boolean is_relaxable
= FALSE
;
6981 /* Initialize the per-section relaxation info. */
6982 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6983 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6985 init_xtensa_relax_info (sec
);
6988 /* Mark relaxable sections (and count relocations against each one). */
6989 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6990 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6992 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
6996 /* Bail out if there are no relaxable sections. */
7000 /* Allocate space for source_relocs. */
7001 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7002 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7004 xtensa_relax_info
*relax_info
;
7006 relax_info
= get_xtensa_relax_info (sec
);
7007 if (relax_info
->is_relaxable_literal_section
7008 || relax_info
->is_relaxable_asm_section
)
7010 relax_info
->src_relocs
= (source_reloc
*)
7011 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
7014 relax_info
->src_count
= 0;
7017 /* Collect info on relocations against each relaxable section. */
7018 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7019 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7021 if (!collect_source_relocs (abfd
, sec
, link_info
))
7025 /* Compute the text actions. */
7026 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7027 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7029 if (!compute_text_actions (abfd
, sec
, link_info
))
7037 /* Find all the sections that might be relaxed. The motivation for
7038 this pass is that collect_source_relocs() needs to record _all_ the
7039 relocations that target each relaxable section. That is expensive
7040 and unnecessary unless the target section is actually going to be
7041 relaxed. This pass identifies all such sections by checking if
7042 they have L32Rs pointing to them. In the process, the total number
7043 of relocations targeting each section is also counted so that we
7044 know how much space to allocate for source_relocs against each
7045 relaxable literal section. */
7048 find_relaxable_sections (bfd
*abfd
,
7050 struct bfd_link_info
*link_info
,
7051 bfd_boolean
*is_relaxable_p
)
7053 Elf_Internal_Rela
*internal_relocs
;
7055 bfd_boolean ok
= TRUE
;
7057 xtensa_relax_info
*source_relax_info
;
7058 bfd_boolean is_l32r_reloc
;
7060 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7061 link_info
->keep_memory
);
7062 if (internal_relocs
== NULL
)
7065 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7066 if (contents
== NULL
&& sec
->size
!= 0)
7072 source_relax_info
= get_xtensa_relax_info (sec
);
7073 for (i
= 0; i
< sec
->reloc_count
; i
++)
7075 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7077 asection
*target_sec
;
7078 xtensa_relax_info
*target_relax_info
;
7080 /* If this section has not already been marked as "relaxable", and
7081 if it contains any ASM_EXPAND relocations (marking expanded
7082 longcalls) that can be optimized into direct calls, then mark
7083 the section as "relaxable". */
7084 if (source_relax_info
7085 && !source_relax_info
->is_relaxable_asm_section
7086 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
7088 bfd_boolean is_reachable
= FALSE
;
7089 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
7090 link_info
, &is_reachable
)
7093 source_relax_info
->is_relaxable_asm_section
= TRUE
;
7094 *is_relaxable_p
= TRUE
;
7098 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7099 bfd_get_section_limit (abfd
, sec
));
7101 target_sec
= r_reloc_get_section (&r_rel
);
7102 target_relax_info
= get_xtensa_relax_info (target_sec
);
7103 if (!target_relax_info
)
7106 /* Count PC-relative operand relocations against the target section.
7107 Note: The conditions tested here must match the conditions under
7108 which init_source_reloc is called in collect_source_relocs(). */
7109 is_l32r_reloc
= FALSE
;
7110 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7112 xtensa_opcode opcode
=
7113 get_relocation_opcode (abfd
, sec
, contents
, irel
);
7114 if (opcode
!= XTENSA_UNDEFINED
)
7116 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
7117 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
7119 target_relax_info
->src_count
++;
7123 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7125 /* Mark the target section as relaxable. */
7126 target_relax_info
->is_relaxable_literal_section
= TRUE
;
7127 *is_relaxable_p
= TRUE
;
7132 release_contents (sec
, contents
);
7133 release_internal_relocs (sec
, internal_relocs
);
7138 /* Record _all_ the relocations that point to relaxable sections, and
7139 get rid of ASM_EXPAND relocs by either converting them to
7140 ASM_SIMPLIFY or by removing them. */
7143 collect_source_relocs (bfd
*abfd
,
7145 struct bfd_link_info
*link_info
)
7147 Elf_Internal_Rela
*internal_relocs
;
7149 bfd_boolean ok
= TRUE
;
7151 bfd_size_type sec_size
;
7153 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7154 link_info
->keep_memory
);
7155 if (internal_relocs
== NULL
)
7158 sec_size
= bfd_get_section_limit (abfd
, sec
);
7159 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7160 if (contents
== NULL
&& sec_size
!= 0)
7166 /* Record relocations against relaxable literal sections. */
7167 for (i
= 0; i
< sec
->reloc_count
; i
++)
7169 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7171 asection
*target_sec
;
7172 xtensa_relax_info
*target_relax_info
;
7174 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7176 target_sec
= r_reloc_get_section (&r_rel
);
7177 target_relax_info
= get_xtensa_relax_info (target_sec
);
7179 if (target_relax_info
7180 && (target_relax_info
->is_relaxable_literal_section
7181 || target_relax_info
->is_relaxable_asm_section
))
7183 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7185 bfd_boolean is_abs_literal
= FALSE
;
7187 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7189 /* None of the current alternate relocs are PC-relative,
7190 and only PC-relative relocs matter here. However, we
7191 still need to record the opcode for literal
7193 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7194 if (opcode
== get_l32r_opcode ())
7196 is_abs_literal
= TRUE
;
7200 opcode
= XTENSA_UNDEFINED
;
7202 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7204 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7205 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7208 if (opcode
!= XTENSA_UNDEFINED
)
7210 int src_next
= target_relax_info
->src_next
++;
7211 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7213 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7219 /* Now get rid of ASM_EXPAND relocations. At this point, the
7220 src_relocs array for the target literal section may still be
7221 incomplete, but it must at least contain the entries for the L32R
7222 relocations associated with ASM_EXPANDs because they were just
7223 added in the preceding loop over the relocations. */
7225 for (i
= 0; i
< sec
->reloc_count
; i
++)
7227 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7228 bfd_boolean is_reachable
;
7230 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7236 Elf_Internal_Rela
*l32r_irel
;
7238 asection
*target_sec
;
7239 xtensa_relax_info
*target_relax_info
;
7241 /* Mark the source_reloc for the L32R so that it will be
7242 removed in compute_removed_literals(), along with the
7243 associated literal. */
7244 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7245 irel
, internal_relocs
);
7246 if (l32r_irel
== NULL
)
7249 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7251 target_sec
= r_reloc_get_section (&r_rel
);
7252 target_relax_info
= get_xtensa_relax_info (target_sec
);
7254 if (target_relax_info
7255 && (target_relax_info
->is_relaxable_literal_section
7256 || target_relax_info
->is_relaxable_asm_section
))
7258 source_reloc
*s_reloc
;
7260 /* Search the source_relocs for the entry corresponding to
7261 the l32r_irel. Note: The src_relocs array is not yet
7262 sorted, but it wouldn't matter anyway because we're
7263 searching by source offset instead of target offset. */
7264 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7265 target_relax_info
->src_next
,
7267 BFD_ASSERT (s_reloc
);
7268 s_reloc
->is_null
= TRUE
;
7271 /* Convert this reloc to ASM_SIMPLIFY. */
7272 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7273 R_XTENSA_ASM_SIMPLIFY
);
7274 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7276 pin_internal_relocs (sec
, internal_relocs
);
7280 /* It is resolvable but doesn't reach. We resolve now
7281 by eliminating the relocation -- the call will remain
7282 expanded into L32R/CALLX. */
7283 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7284 pin_internal_relocs (sec
, internal_relocs
);
7289 release_contents (sec
, contents
);
7290 release_internal_relocs (sec
, internal_relocs
);
7295 /* Return TRUE if the asm expansion can be resolved. Generally it can
7296 be resolved on a final link or when a partial link locates it in the
7297 same section as the target. Set "is_reachable" flag if the target of
7298 the call is within the range of a direct call, given the current VMA
7299 for this section and the target section. */
7302 is_resolvable_asm_expansion (bfd
*abfd
,
7305 Elf_Internal_Rela
*irel
,
7306 struct bfd_link_info
*link_info
,
7307 bfd_boolean
*is_reachable_p
)
7309 asection
*target_sec
;
7313 unsigned int first_align
;
7314 unsigned int adjust
;
7315 bfd_vma target_offset
;
7317 xtensa_opcode opcode
, direct_call_opcode
;
7318 bfd_vma self_address
;
7319 bfd_vma dest_address
;
7320 bfd_boolean uses_l32r
;
7321 bfd_size_type sec_size
;
7323 *is_reachable_p
= FALSE
;
7325 if (contents
== NULL
)
7328 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7331 sec_size
= bfd_get_section_limit (abfd
, sec
);
7332 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7333 sec_size
- irel
->r_offset
, &uses_l32r
);
7334 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7338 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7339 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7342 /* Check and see that the target resolves. */
7343 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7344 if (!r_reloc_is_defined (&r_rel
))
7347 target_sec
= r_reloc_get_section (&r_rel
);
7348 target_offset
= r_rel
.target_offset
;
7350 /* If the target is in a shared library, then it doesn't reach. This
7351 isn't supposed to come up because the compiler should never generate
7352 non-PIC calls on systems that use shared libraries, but the linker
7353 shouldn't crash regardless. */
7354 if (!target_sec
->output_section
)
7357 /* For relocatable sections, we can only simplify when the output
7358 section of the target is the same as the output section of the
7360 if (bfd_link_relocatable (link_info
)
7361 && (target_sec
->output_section
!= sec
->output_section
7362 || is_reloc_sym_weak (abfd
, irel
)))
7365 if (target_sec
->output_section
!= sec
->output_section
)
7367 /* If the two sections are sufficiently far away that relaxation
7368 might take the call out of range, we can't simplify. For
7369 example, a positive displacement call into another memory
7370 could get moved to a lower address due to literal removal,
7371 but the destination won't move, and so the displacment might
7374 If the displacement is negative, assume the destination could
7375 move as far back as the start of the output section. The
7376 self_address will be at least as far into the output section
7377 as it is prior to relaxation.
7379 If the displacement is postive, assume the destination will be in
7380 it's pre-relaxed location (because relaxation only makes sections
7381 smaller). The self_address could go all the way to the beginning
7382 of the output section. */
7384 dest_address
= target_sec
->output_section
->vma
;
7385 self_address
= sec
->output_section
->vma
;
7387 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7388 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7390 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7391 /* Call targets should be four-byte aligned. */
7392 dest_address
= (dest_address
+ 3) & ~3;
7397 self_address
= (sec
->output_section
->vma
7398 + sec
->output_offset
+ irel
->r_offset
+ 3);
7399 dest_address
= (target_sec
->output_section
->vma
7400 + target_sec
->output_offset
+ target_offset
);
7403 /* Adjust addresses with alignments for the worst case to see if call insn
7404 can fit. Don't relax l32r + callx to call if the target can be out of
7405 range due to alignment.
7406 Caller and target addresses are highest and lowest address.
7407 Search all sections between caller and target, looking for max alignment.
7408 The adjustment is max alignment bytes. If the alignment at the lowest
7409 address is less than the adjustment, apply the adjustment to highest
7412 /* Start from lowest address.
7413 Lowest address aligmnet is from input section.
7414 Initial alignment (adjust) is from input section. */
7415 if (dest_address
> self_address
)
7417 s
= sec
->output_section
;
7418 last_vma
= dest_address
;
7419 first_align
= sec
->alignment_power
;
7420 adjust
= target_sec
->alignment_power
;
7424 s
= target_sec
->output_section
;
7425 last_vma
= self_address
;
7426 first_align
= target_sec
->alignment_power
;
7427 adjust
= sec
->alignment_power
;
7432 /* Find the largest alignment in output section list. */
7433 for (; s
&& s
->vma
>= first_vma
&& s
->vma
<= last_vma
; s
= s
->next
)
7435 if (s
->alignment_power
> adjust
)
7436 adjust
= s
->alignment_power
;
7439 if (adjust
> first_align
)
7441 /* Alignment may enlarge the range, adjust highest address. */
7442 adjust
= 1 << adjust
;
7443 if (dest_address
> self_address
)
7445 dest_address
+= adjust
;
7449 self_address
+= adjust
;
7453 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7454 self_address
, dest_address
);
7456 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7457 (dest_address
>> CALL_SEGMENT_BITS
))
7464 static Elf_Internal_Rela
*
7465 find_associated_l32r_irel (bfd
*abfd
,
7468 Elf_Internal_Rela
*other_irel
,
7469 Elf_Internal_Rela
*internal_relocs
)
7473 for (i
= 0; i
< sec
->reloc_count
; i
++)
7475 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7477 if (irel
== other_irel
)
7479 if (irel
->r_offset
!= other_irel
->r_offset
)
7481 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7489 static xtensa_opcode
*
7490 build_reloc_opcodes (bfd
*abfd
,
7493 Elf_Internal_Rela
*internal_relocs
)
7496 xtensa_opcode
*reloc_opcodes
=
7497 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7498 for (i
= 0; i
< sec
->reloc_count
; i
++)
7500 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7501 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7503 return reloc_opcodes
;
7506 struct reloc_range_struct
7509 bfd_boolean add
; /* TRUE if start of a range, FALSE otherwise. */
7510 /* Original irel index in the array of relocations for a section. */
7511 unsigned irel_index
;
7513 typedef struct reloc_range_struct reloc_range
;
7515 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7516 struct reloc_range_list_entry_struct
7518 reloc_range_list_entry
*next
;
7519 reloc_range_list_entry
*prev
;
7520 Elf_Internal_Rela
*irel
;
7521 xtensa_opcode opcode
;
7525 struct reloc_range_list_struct
7527 /* The rest of the structure is only meaningful when ok is TRUE. */
7530 unsigned n_range
; /* Number of range markers. */
7531 reloc_range
*range
; /* Sorted range markers. */
7533 unsigned first
; /* Index of a first range element in the list. */
7534 unsigned last
; /* One past index of a last range element in the list. */
7536 unsigned n_list
; /* Number of list elements. */
7537 reloc_range_list_entry
*reloc
; /* */
7538 reloc_range_list_entry list_root
;
7542 reloc_range_compare (const void *a
, const void *b
)
7544 const reloc_range
*ra
= a
;
7545 const reloc_range
*rb
= b
;
7547 if (ra
->addr
!= rb
->addr
)
7548 return ra
->addr
< rb
->addr
? -1 : 1;
7549 if (ra
->add
!= rb
->add
)
7550 return ra
->add
? -1 : 1;
7555 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7557 Elf_Internal_Rela
*internal_relocs
,
7558 xtensa_opcode
*reloc_opcodes
,
7559 reloc_range_list
*list
)
7564 reloc_range
*ranges
= NULL
;
7565 reloc_range_list_entry
*reloc
=
7566 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7568 memset (list
, 0, sizeof (*list
));
7571 for (i
= 0; i
< sec
->reloc_count
; i
++)
7573 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7574 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7575 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7578 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7579 || r_type
== R_XTENSA_32_PCREL
7580 || !howto
->pc_relative
)
7583 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7584 bfd_get_section_limit (abfd
, sec
));
7586 if (r_reloc_get_section (&r_rel
) != sec
)
7591 max_n
= (max_n
+ 2) * 2;
7592 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7595 ranges
[n
].addr
= irel
->r_offset
;
7596 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7598 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7599 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7601 ranges
[n
].irel_index
= i
;
7602 ranges
[n
+ 1].irel_index
= i
;
7606 reloc
[i
].irel
= irel
;
7608 /* Every relocation won't possibly be checked in the optimized version of
7609 check_section_ebb_pcrels_fit, so this needs to be done here. */
7610 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7612 /* None of the current alternate relocs are PC-relative,
7613 and only PC-relative relocs matter here. */
7617 xtensa_opcode opcode
;
7621 opcode
= reloc_opcodes
[i
];
7623 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7625 if (opcode
== XTENSA_UNDEFINED
)
7631 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7632 if (opnum
== XTENSA_UNDEFINED
)
7638 /* Record relocation opcode and opnum as we've calculated them
7639 anyway and they won't change. */
7640 reloc
[i
].opcode
= opcode
;
7641 reloc
[i
].opnum
= opnum
;
7647 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7648 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7651 list
->range
= ranges
;
7652 list
->reloc
= reloc
;
7653 list
->list_root
.prev
= &list
->list_root
;
7654 list
->list_root
.next
= &list
->list_root
;
7663 static void reloc_range_list_append (reloc_range_list
*list
,
7664 unsigned irel_index
)
7666 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7668 entry
->prev
= list
->list_root
.prev
;
7669 entry
->next
= &list
->list_root
;
7670 entry
->prev
->next
= entry
;
7671 entry
->next
->prev
= entry
;
7675 static void reloc_range_list_remove (reloc_range_list
*list
,
7676 unsigned irel_index
)
7678 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7680 entry
->next
->prev
= entry
->prev
;
7681 entry
->prev
->next
= entry
->next
;
7685 /* Update relocation list object so that it lists all relocations that cross
7686 [first; last] range. Range bounds should not decrease with successive
7688 static void reloc_range_list_update_range (reloc_range_list
*list
,
7689 bfd_vma first
, bfd_vma last
)
7691 /* This should not happen: EBBs are iterated from lower addresses to higher.
7692 But even if that happens there's no need to break: just flush current list
7693 and start from scratch. */
7694 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7695 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7700 list
->list_root
.next
= &list
->list_root
;
7701 list
->list_root
.prev
= &list
->list_root
;
7702 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7705 for (; list
->last
< list
->n_range
&&
7706 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7707 if (list
->range
[list
->last
].add
)
7708 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7710 for (; list
->first
< list
->n_range
&&
7711 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7712 if (!list
->range
[list
->first
].add
)
7713 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7716 static void free_reloc_range_list (reloc_range_list
*list
)
7722 /* The compute_text_actions function will build a list of potential
7723 transformation actions for code in the extended basic block of each
7724 longcall that is optimized to a direct call. From this list we
7725 generate a set of actions to actually perform that optimizes for
7726 space and, if not using size_opt, maintains branch target
7729 These actions to be performed are placed on a per-section list.
7730 The actual changes are performed by relax_section() in the second
7734 compute_text_actions (bfd
*abfd
,
7736 struct bfd_link_info
*link_info
)
7738 xtensa_opcode
*reloc_opcodes
= NULL
;
7739 xtensa_relax_info
*relax_info
;
7741 Elf_Internal_Rela
*internal_relocs
;
7742 bfd_boolean ok
= TRUE
;
7744 property_table_entry
*prop_table
= 0;
7746 bfd_size_type sec_size
;
7747 reloc_range_list relevant_relocs
;
7749 relax_info
= get_xtensa_relax_info (sec
);
7750 BFD_ASSERT (relax_info
);
7751 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7753 /* Do nothing if the section contains no optimized longcalls. */
7754 if (!relax_info
->is_relaxable_asm_section
)
7757 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7758 link_info
->keep_memory
);
7760 if (internal_relocs
)
7761 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7762 internal_reloc_compare
);
7764 sec_size
= bfd_get_section_limit (abfd
, sec
);
7765 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7766 if (contents
== NULL
&& sec_size
!= 0)
7772 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7773 XTENSA_PROP_SEC_NAME
, FALSE
);
7780 /* Precompute the opcode for each relocation. */
7781 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7783 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7786 for (i
= 0; i
< sec
->reloc_count
; i
++)
7788 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7790 property_table_entry
*the_entry
;
7793 ebb_constraint ebb_table
;
7794 bfd_size_type simplify_size
;
7796 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7798 r_offset
= irel
->r_offset
;
7800 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7801 if (simplify_size
== 0)
7804 /* xgettext:c-format */
7805 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7806 "XTENSA_ASM_SIMPLIFY relocation; "
7807 "possible configuration mismatch"),
7808 sec
->owner
, sec
, (uint64_t) r_offset
);
7812 /* If the instruction table is not around, then don't do this
7814 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7815 sec
->vma
+ irel
->r_offset
);
7816 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7818 text_action_add (&relax_info
->action_list
,
7819 ta_convert_longcall
, sec
, r_offset
,
7824 /* If the next longcall happens to be at the same address as an
7825 unreachable section of size 0, then skip forward. */
7826 ptbl_idx
= the_entry
- prop_table
;
7827 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7828 && the_entry
->size
== 0
7829 && ptbl_idx
+ 1 < ptblsize
7830 && (prop_table
[ptbl_idx
+ 1].address
7831 == prop_table
[ptbl_idx
].address
))
7837 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7838 /* NO_REORDER is OK */
7841 init_ebb_constraint (&ebb_table
);
7842 ebb
= &ebb_table
.ebb
;
7843 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7844 internal_relocs
, sec
->reloc_count
);
7845 ebb
->start_offset
= r_offset
+ simplify_size
;
7846 ebb
->end_offset
= r_offset
+ simplify_size
;
7847 ebb
->start_ptbl_idx
= ptbl_idx
;
7848 ebb
->end_ptbl_idx
= ptbl_idx
;
7849 ebb
->start_reloc_idx
= i
;
7850 ebb
->end_reloc_idx
= i
;
7852 if (!extend_ebb_bounds (ebb
)
7853 || !compute_ebb_proposed_actions (&ebb_table
)
7854 || !compute_ebb_actions (&ebb_table
)
7855 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7858 &ebb_table
, reloc_opcodes
)
7859 || !check_section_ebb_reduces (&ebb_table
))
7861 /* If anything goes wrong or we get unlucky and something does
7862 not fit, with our plan because of expansion between
7863 critical branches, just convert to a NOP. */
7865 text_action_add (&relax_info
->action_list
,
7866 ta_convert_longcall
, sec
, r_offset
, 0);
7867 i
= ebb_table
.ebb
.end_reloc_idx
;
7868 free_ebb_constraint (&ebb_table
);
7872 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7874 /* Update the index so we do not go looking at the relocations
7875 we have already processed. */
7876 i
= ebb_table
.ebb
.end_reloc_idx
;
7877 free_ebb_constraint (&ebb_table
);
7880 free_reloc_range_list (&relevant_relocs
);
7883 if (action_list_count (&relax_info
->action_list
))
7884 print_action_list (stderr
, &relax_info
->action_list
);
7888 release_contents (sec
, contents
);
7889 release_internal_relocs (sec
, internal_relocs
);
7891 free (reloc_opcodes
);
7897 /* Do not widen an instruction if it is preceeded by a
7898 loop opcode. It might cause misalignment. */
7901 prev_instr_is_a_loop (bfd_byte
*contents
,
7902 bfd_size_type content_length
,
7903 bfd_size_type offset
)
7905 xtensa_opcode prev_opcode
;
7909 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7910 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7914 /* Find all of the possible actions for an extended basic block. */
7917 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7919 const ebb_t
*ebb
= &ebb_table
->ebb
;
7920 unsigned rel_idx
= ebb
->start_reloc_idx
;
7921 property_table_entry
*entry
, *start_entry
, *end_entry
;
7923 xtensa_isa isa
= xtensa_default_isa
;
7925 static xtensa_insnbuf insnbuf
= NULL
;
7926 static xtensa_insnbuf slotbuf
= NULL
;
7928 if (insnbuf
== NULL
)
7930 insnbuf
= xtensa_insnbuf_alloc (isa
);
7931 slotbuf
= xtensa_insnbuf_alloc (isa
);
7934 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7935 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7937 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7939 bfd_vma start_offset
, end_offset
;
7940 bfd_size_type insn_len
;
7942 start_offset
= entry
->address
- ebb
->sec
->vma
;
7943 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7945 if (entry
== start_entry
)
7946 start_offset
= ebb
->start_offset
;
7947 if (entry
== end_entry
)
7948 end_offset
= ebb
->end_offset
;
7949 offset
= start_offset
;
7951 if (offset
== entry
->address
- ebb
->sec
->vma
7952 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7954 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7955 BFD_ASSERT (offset
!= end_offset
);
7956 if (offset
== end_offset
)
7959 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7964 if (check_branch_target_aligned_address (offset
, insn_len
))
7965 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7967 ebb_propose_action (ebb_table
, align_type
, 0,
7968 ta_none
, offset
, 0, TRUE
);
7971 while (offset
!= end_offset
)
7973 Elf_Internal_Rela
*irel
;
7974 xtensa_opcode opcode
;
7976 while (rel_idx
< ebb
->end_reloc_idx
7977 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7978 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7979 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
7980 != R_XTENSA_ASM_SIMPLIFY
))))
7983 /* Check for longcall. */
7984 irel
= &ebb
->relocs
[rel_idx
];
7985 if (irel
->r_offset
== offset
7986 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
7988 bfd_size_type simplify_size
;
7990 simplify_size
= get_asm_simplify_size (ebb
->contents
,
7991 ebb
->content_length
,
7993 if (simplify_size
== 0)
7996 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7997 ta_convert_longcall
, offset
, 0, TRUE
);
7999 offset
+= simplify_size
;
8003 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
8005 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
8006 ebb
->content_length
- offset
);
8007 fmt
= xtensa_format_decode (isa
, insnbuf
);
8008 if (fmt
== XTENSA_UNDEFINED
)
8010 insn_len
= xtensa_format_length (isa
, fmt
);
8011 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
8014 if (xtensa_format_num_slots (isa
, fmt
) != 1)
8020 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
8021 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
8022 if (opcode
== XTENSA_UNDEFINED
)
8025 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
8026 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8027 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
8029 /* Add an instruction narrow action. */
8030 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8031 ta_narrow_insn
, offset
, 0, FALSE
);
8033 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8034 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
8035 && ! prev_instr_is_a_loop (ebb
->contents
,
8036 ebb
->content_length
, offset
))
8038 /* Add an instruction widen action. */
8039 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8040 ta_widen_insn
, offset
, 0, FALSE
);
8042 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
8044 /* Check for branch targets. */
8045 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
8046 ta_none
, offset
, 0, TRUE
);
8053 if (ebb
->ends_unreachable
)
8055 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8056 ta_fill
, ebb
->end_offset
, 0, TRUE
);
8063 /* xgettext:c-format */
8064 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
8065 "possible configuration mismatch"),
8066 ebb
->sec
->owner
, ebb
->sec
, (uint64_t) offset
);
8071 /* After all of the information has collected about the
8072 transformations possible in an EBB, compute the appropriate actions
8073 here in compute_ebb_actions. We still must check later to make
8074 sure that the actions do not break any relocations. The algorithm
8075 used here is pretty greedy. Basically, it removes as many no-ops
8076 as possible so that the end of the EBB has the same alignment
8077 characteristics as the original. First, it uses narrowing, then
8078 fill space at the end of the EBB, and finally widenings. If that
8079 does not work, it tries again with one fewer no-op removed. The
8080 optimization will only be performed if all of the branch targets
8081 that were aligned before transformation are also aligned after the
8084 When the size_opt flag is set, ignore the branch target alignments,
8085 narrow all wide instructions, and remove all no-ops unless the end
8086 of the EBB prevents it. */
8089 compute_ebb_actions (ebb_constraint
*ebb_table
)
8093 int removed_bytes
= 0;
8094 ebb_t
*ebb
= &ebb_table
->ebb
;
8095 unsigned seg_idx_start
= 0;
8096 unsigned seg_idx_end
= 0;
8098 /* We perform this like the assembler relaxation algorithm: Start by
8099 assuming all instructions are narrow and all no-ops removed; then
8102 /* For each segment of this that has a solid constraint, check to
8103 see if there are any combinations that will keep the constraint.
8105 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
8107 bfd_boolean requires_text_end_align
= FALSE
;
8108 unsigned longcall_count
= 0;
8109 unsigned longcall_convert_count
= 0;
8110 unsigned narrowable_count
= 0;
8111 unsigned narrowable_convert_count
= 0;
8112 unsigned widenable_count
= 0;
8113 unsigned widenable_convert_count
= 0;
8115 proposed_action
*action
= NULL
;
8116 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
8118 seg_idx_start
= seg_idx_end
;
8120 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
8122 action
= &ebb_table
->actions
[i
];
8123 if (action
->action
== ta_convert_longcall
)
8125 if (action
->action
== ta_narrow_insn
)
8127 if (action
->action
== ta_widen_insn
)
8129 if (action
->action
== ta_fill
)
8131 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8133 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
8134 && !elf32xtensa_size_opt
)
8139 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
8140 requires_text_end_align
= TRUE
;
8142 if (elf32xtensa_size_opt
&& !requires_text_end_align
8143 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
8144 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
8146 longcall_convert_count
= longcall_count
;
8147 narrowable_convert_count
= narrowable_count
;
8148 widenable_convert_count
= 0;
8152 /* There is a constraint. Convert the max number of longcalls. */
8153 narrowable_convert_count
= 0;
8154 longcall_convert_count
= 0;
8155 widenable_convert_count
= 0;
8157 for (j
= 0; j
< longcall_count
; j
++)
8159 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
8160 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
8161 unsigned desire_widen
= removed
;
8162 if (desire_narrow
<= narrowable_count
)
8164 narrowable_convert_count
= desire_narrow
;
8165 narrowable_convert_count
+=
8166 (align
* ((narrowable_count
- narrowable_convert_count
)
8168 longcall_convert_count
= (longcall_count
- j
);
8169 widenable_convert_count
= 0;
8172 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
8174 narrowable_convert_count
= 0;
8175 longcall_convert_count
= longcall_count
- j
;
8176 widenable_convert_count
= desire_widen
;
8182 /* Now the number of conversions are saved. Do them. */
8183 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
8185 action
= &ebb_table
->actions
[i
];
8186 switch (action
->action
)
8188 case ta_convert_longcall
:
8189 if (longcall_convert_count
!= 0)
8191 action
->action
= ta_remove_longcall
;
8192 action
->do_action
= TRUE
;
8193 action
->removed_bytes
+= 3;
8194 longcall_convert_count
--;
8197 case ta_narrow_insn
:
8198 if (narrowable_convert_count
!= 0)
8200 action
->do_action
= TRUE
;
8201 action
->removed_bytes
+= 1;
8202 narrowable_convert_count
--;
8206 if (widenable_convert_count
!= 0)
8208 action
->do_action
= TRUE
;
8209 action
->removed_bytes
-= 1;
8210 widenable_convert_count
--;
8219 /* Now we move on to some local opts. Try to remove each of the
8220 remaining longcalls. */
8222 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8225 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8227 int old_removed_bytes
= removed_bytes
;
8228 proposed_action
*action
= &ebb_table
->actions
[i
];
8230 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8232 bfd_boolean bad_alignment
= FALSE
;
8234 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8236 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8237 bfd_vma offset
= new_action
->offset
;
8238 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8240 if (!check_branch_target_aligned
8241 (ebb_table
->ebb
.contents
,
8242 ebb_table
->ebb
.content_length
,
8243 offset
, offset
- removed_bytes
))
8245 bad_alignment
= TRUE
;
8249 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8251 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8252 ebb_table
->ebb
.content_length
,
8254 offset
- removed_bytes
))
8256 bad_alignment
= TRUE
;
8260 if (new_action
->action
== ta_narrow_insn
8261 && !new_action
->do_action
8262 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8264 /* Narrow an instruction and we are done. */
8265 new_action
->do_action
= TRUE
;
8266 new_action
->removed_bytes
+= 1;
8267 bad_alignment
= FALSE
;
8270 if (new_action
->action
== ta_widen_insn
8271 && new_action
->do_action
8272 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8274 /* Narrow an instruction and we are done. */
8275 new_action
->do_action
= FALSE
;
8276 new_action
->removed_bytes
+= 1;
8277 bad_alignment
= FALSE
;
8280 if (new_action
->do_action
)
8281 removed_bytes
+= new_action
->removed_bytes
;
8285 action
->removed_bytes
+= 3;
8286 action
->action
= ta_remove_longcall
;
8287 action
->do_action
= TRUE
;
8290 removed_bytes
= old_removed_bytes
;
8291 if (action
->do_action
)
8292 removed_bytes
+= action
->removed_bytes
;
8297 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8299 proposed_action
*action
= &ebb_table
->actions
[i
];
8300 if (action
->do_action
)
8301 removed_bytes
+= action
->removed_bytes
;
8304 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8305 && ebb
->ends_unreachable
)
8307 proposed_action
*action
;
8311 BFD_ASSERT (ebb_table
->action_count
!= 0);
8312 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8313 BFD_ASSERT (action
->action
== ta_fill
);
8314 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8316 extra_space
= xtensa_compute_fill_extra_space (ebb
->ends_unreachable
);
8317 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8318 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8320 action
->removed_bytes
= extra_space
- br
;
8326 /* The xlate_map is a sorted array of address mappings designed to
8327 answer the offset_with_removed_text() query with a binary search instead
8328 of a linear search through the section's action_list. */
8330 typedef struct xlate_map_entry xlate_map_entry_t
;
8331 typedef struct xlate_map xlate_map_t
;
8333 struct xlate_map_entry
8335 bfd_vma orig_address
;
8336 bfd_vma new_address
;
8342 unsigned entry_count
;
8343 xlate_map_entry_t
*entry
;
8348 xlate_compare (const void *a_v
, const void *b_v
)
8350 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8351 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8352 if (a
->orig_address
< b
->orig_address
)
8354 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8361 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8362 text_action_list
*action_list
,
8366 xlate_map_entry_t
*e
;
8367 struct xlate_map_entry se
;
8370 return offset_with_removed_text (action_list
, offset
);
8372 if (map
->entry_count
== 0)
8375 se
.orig_address
= offset
;
8376 r
= bsearch (&se
, map
->entry
, map
->entry_count
,
8377 sizeof (xlate_map_entry_t
), &xlate_compare
);
8378 e
= (xlate_map_entry_t
*) r
;
8380 /* There could be a jump past the end of the section,
8381 allow it using the last xlate map entry to translate its address. */
8384 e
= map
->entry
+ map
->entry_count
- 1;
8385 if (xlate_compare (&se
, e
) <= 0)
8388 BFD_ASSERT (e
!= NULL
);
8391 return e
->new_address
- e
->orig_address
+ offset
;
8394 typedef struct xlate_map_context_struct xlate_map_context
;
8395 struct xlate_map_context_struct
8398 xlate_map_entry_t
*current_entry
;
8403 xlate_map_fn (splay_tree_node node
, void *p
)
8405 text_action
*r
= (text_action
*)node
->value
;
8406 xlate_map_context
*ctx
= p
;
8407 unsigned orig_size
= 0;
8412 case ta_remove_insn
:
8413 case ta_convert_longcall
:
8414 case ta_remove_literal
:
8415 case ta_add_literal
:
8417 case ta_remove_longcall
:
8420 case ta_narrow_insn
:
8429 ctx
->current_entry
->size
=
8430 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8431 if (ctx
->current_entry
->size
!= 0)
8433 ctx
->current_entry
++;
8434 ctx
->map
->entry_count
++;
8436 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8437 ctx
->removed
+= r
->removed_bytes
;
8438 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8439 ctx
->current_entry
->size
= 0;
8443 /* Build a binary searchable offset translation map from a section's
8446 static xlate_map_t
*
8447 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8449 text_action_list
*action_list
= &relax_info
->action_list
;
8450 unsigned num_actions
= 0;
8451 xlate_map_context ctx
;
8453 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8455 if (ctx
.map
== NULL
)
8458 num_actions
= action_list_count (action_list
);
8459 ctx
.map
->entry
= (xlate_map_entry_t
*)
8460 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8461 if (ctx
.map
->entry
== NULL
)
8466 ctx
.map
->entry_count
= 0;
8469 ctx
.current_entry
= &ctx
.map
->entry
[0];
8471 ctx
.current_entry
->orig_address
= 0;
8472 ctx
.current_entry
->new_address
= 0;
8473 ctx
.current_entry
->size
= 0;
8475 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8477 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8478 - ctx
.current_entry
->orig_address
);
8479 if (ctx
.current_entry
->size
!= 0)
8480 ctx
.map
->entry_count
++;
8486 /* Free an offset translation map. */
8489 free_xlate_map (xlate_map_t
*map
)
8499 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8500 relocations in a section will fit if a proposed set of actions
8504 check_section_ebb_pcrels_fit (bfd
*abfd
,
8507 Elf_Internal_Rela
*internal_relocs
,
8508 reloc_range_list
*relevant_relocs
,
8509 const ebb_constraint
*constraint
,
8510 const xtensa_opcode
*reloc_opcodes
)
8513 unsigned n
= sec
->reloc_count
;
8514 Elf_Internal_Rela
*irel
;
8515 xlate_map_t
*xmap
= NULL
;
8516 bfd_boolean ok
= TRUE
;
8517 xtensa_relax_info
*relax_info
;
8518 reloc_range_list_entry
*entry
= NULL
;
8520 relax_info
= get_xtensa_relax_info (sec
);
8522 if (relax_info
&& sec
->reloc_count
> 100)
8524 xmap
= build_xlate_map (sec
, relax_info
);
8525 /* NULL indicates out of memory, but the slow version
8526 can still be used. */
8529 if (relevant_relocs
&& constraint
->action_count
)
8531 if (!relevant_relocs
->ok
)
8538 bfd_vma min_offset
, max_offset
;
8539 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8541 for (i
= 1; i
< constraint
->action_count
; ++i
)
8543 proposed_action
*action
= &constraint
->actions
[i
];
8544 bfd_vma offset
= action
->offset
;
8546 if (offset
< min_offset
)
8547 min_offset
= offset
;
8548 if (offset
> max_offset
)
8549 max_offset
= offset
;
8551 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8553 n
= relevant_relocs
->n_list
;
8554 entry
= &relevant_relocs
->list_root
;
8559 relevant_relocs
= NULL
;
8562 for (i
= 0; i
< n
; i
++)
8565 bfd_vma orig_self_offset
, orig_target_offset
;
8566 bfd_vma self_offset
, target_offset
;
8568 reloc_howto_type
*howto
;
8569 int self_removed_bytes
, target_removed_bytes
;
8571 if (relevant_relocs
)
8573 entry
= entry
->next
;
8578 irel
= internal_relocs
+ i
;
8580 r_type
= ELF32_R_TYPE (irel
->r_info
);
8582 howto
= &elf_howto_table
[r_type
];
8583 /* We maintain the required invariant: PC-relative relocations
8584 that fit before linking must fit after linking. Thus we only
8585 need to deal with relocations to the same section that are
8587 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8588 || r_type
== R_XTENSA_32_PCREL
8589 || !howto
->pc_relative
)
8592 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8593 bfd_get_section_limit (abfd
, sec
));
8595 if (r_reloc_get_section (&r_rel
) != sec
)
8598 orig_self_offset
= irel
->r_offset
;
8599 orig_target_offset
= r_rel
.target_offset
;
8601 self_offset
= orig_self_offset
;
8602 target_offset
= orig_target_offset
;
8607 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8610 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8611 orig_target_offset
);
8614 self_removed_bytes
= 0;
8615 target_removed_bytes
= 0;
8617 for (j
= 0; j
< constraint
->action_count
; ++j
)
8619 proposed_action
*action
= &constraint
->actions
[j
];
8620 bfd_vma offset
= action
->offset
;
8621 int removed_bytes
= action
->removed_bytes
;
8622 if (offset
< orig_self_offset
8623 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8624 && action
->removed_bytes
< 0))
8625 self_removed_bytes
+= removed_bytes
;
8626 if (offset
< orig_target_offset
8627 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8628 && action
->removed_bytes
< 0))
8629 target_removed_bytes
+= removed_bytes
;
8631 self_offset
-= self_removed_bytes
;
8632 target_offset
-= target_removed_bytes
;
8634 /* Try to encode it. Get the operand and check. */
8635 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8637 /* None of the current alternate relocs are PC-relative,
8638 and only PC-relative relocs matter here. */
8642 xtensa_opcode opcode
;
8645 if (relevant_relocs
)
8647 opcode
= entry
->opcode
;
8648 opnum
= entry
->opnum
;
8653 opcode
= reloc_opcodes
[relevant_relocs
?
8654 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8656 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8657 if (opcode
== XTENSA_UNDEFINED
)
8663 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8664 if (opnum
== XTENSA_UNDEFINED
)
8671 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8679 free_xlate_map (xmap
);
8686 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8691 for (i
= 0; i
< constraint
->action_count
; i
++)
8693 const proposed_action
*action
= &constraint
->actions
[i
];
8694 if (action
->do_action
)
8695 removed
+= action
->removed_bytes
;
8705 text_action_add_proposed (text_action_list
*l
,
8706 const ebb_constraint
*ebb_table
,
8711 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8713 proposed_action
*action
= &ebb_table
->actions
[i
];
8715 if (!action
->do_action
)
8717 switch (action
->action
)
8719 case ta_remove_insn
:
8720 case ta_remove_longcall
:
8721 case ta_convert_longcall
:
8722 case ta_narrow_insn
:
8725 case ta_remove_literal
:
8726 text_action_add (l
, action
->action
, sec
, action
->offset
,
8727 action
->removed_bytes
);
8740 xtensa_compute_fill_extra_space (property_table_entry
*entry
)
8742 int fill_extra_space
;
8747 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8750 fill_extra_space
= entry
->size
;
8751 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8753 /* Fill bytes for alignment:
8754 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8755 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8756 int nsm
= (1 << pow
) - 1;
8757 bfd_vma addr
= entry
->address
+ entry
->size
;
8758 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8759 fill_extra_space
+= align_fill
;
8761 return fill_extra_space
;
8765 /* First relaxation pass. */
8767 /* If the section contains relaxable literals, check each literal to
8768 see if it has the same value as another literal that has already
8769 been seen, either in the current section or a previous one. If so,
8770 add an entry to the per-section list of removed literals. The
8771 actual changes are deferred until the next pass. */
8774 compute_removed_literals (bfd
*abfd
,
8776 struct bfd_link_info
*link_info
,
8777 value_map_hash_table
*values
)
8779 xtensa_relax_info
*relax_info
;
8781 Elf_Internal_Rela
*internal_relocs
;
8782 source_reloc
*src_relocs
, *rel
;
8783 bfd_boolean ok
= TRUE
;
8784 property_table_entry
*prop_table
= NULL
;
8787 bfd_boolean last_loc_is_prev
= FALSE
;
8788 bfd_vma last_target_offset
= 0;
8789 section_cache_t target_sec_cache
;
8790 bfd_size_type sec_size
;
8792 init_section_cache (&target_sec_cache
);
8794 /* Do nothing if it is not a relaxable literal section. */
8795 relax_info
= get_xtensa_relax_info (sec
);
8796 BFD_ASSERT (relax_info
);
8797 if (!relax_info
->is_relaxable_literal_section
)
8800 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8801 link_info
->keep_memory
);
8803 sec_size
= bfd_get_section_limit (abfd
, sec
);
8804 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8805 if (contents
== NULL
&& sec_size
!= 0)
8811 /* Sort the source_relocs by target offset. */
8812 src_relocs
= relax_info
->src_relocs
;
8813 qsort (src_relocs
, relax_info
->src_count
,
8814 sizeof (source_reloc
), source_reloc_compare
);
8815 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8816 internal_reloc_compare
);
8818 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8819 XTENSA_PROP_SEC_NAME
, FALSE
);
8827 for (i
= 0; i
< relax_info
->src_count
; i
++)
8829 Elf_Internal_Rela
*irel
= NULL
;
8831 rel
= &src_relocs
[i
];
8832 if (get_l32r_opcode () != rel
->opcode
)
8834 irel
= get_irel_at_offset (sec
, internal_relocs
,
8835 rel
->r_rel
.target_offset
);
8837 /* If the relocation on this is not a simple R_XTENSA_32 or
8838 R_XTENSA_PLT then do not consider it. This may happen when
8839 the difference of two symbols is used in a literal. */
8840 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8841 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8844 /* If the target_offset for this relocation is the same as the
8845 previous relocation, then we've already considered whether the
8846 literal can be coalesced. Skip to the next one.... */
8847 if (i
!= 0 && prev_i
!= -1
8848 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8852 if (last_loc_is_prev
&&
8853 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8854 last_loc_is_prev
= FALSE
;
8856 /* Check if the relocation was from an L32R that is being removed
8857 because a CALLX was converted to a direct CALL, and check if
8858 there are no other relocations to the literal. */
8859 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8860 sec
, prop_table
, ptblsize
))
8862 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8863 irel
, rel
, prop_table
, ptblsize
))
8868 last_target_offset
= rel
->r_rel
.target_offset
;
8872 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8874 &last_loc_is_prev
, irel
,
8875 relax_info
->src_count
- i
, rel
,
8876 prop_table
, ptblsize
,
8877 &target_sec_cache
, rel
->is_abs_literal
))
8882 last_target_offset
= rel
->r_rel
.target_offset
;
8886 print_removed_literals (stderr
, &relax_info
->removed_list
);
8887 print_action_list (stderr
, &relax_info
->action_list
);
8892 free_section_cache (&target_sec_cache
);
8894 release_contents (sec
, contents
);
8895 release_internal_relocs (sec
, internal_relocs
);
8900 static Elf_Internal_Rela
*
8901 get_irel_at_offset (asection
*sec
,
8902 Elf_Internal_Rela
*internal_relocs
,
8906 Elf_Internal_Rela
*irel
;
8908 Elf_Internal_Rela key
;
8910 if (!internal_relocs
)
8913 key
.r_offset
= offset
;
8914 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8915 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8919 /* bsearch does not guarantee which will be returned if there are
8920 multiple matches. We need the first that is not an alignment. */
8921 i
= irel
- internal_relocs
;
8924 if (internal_relocs
[i
-1].r_offset
!= offset
)
8928 for ( ; i
< sec
->reloc_count
; i
++)
8930 irel
= &internal_relocs
[i
];
8931 r_type
= ELF32_R_TYPE (irel
->r_info
);
8932 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8941 is_removable_literal (const source_reloc
*rel
,
8943 const source_reloc
*src_relocs
,
8946 property_table_entry
*prop_table
,
8949 const source_reloc
*curr_rel
;
8950 property_table_entry
*entry
;
8955 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8956 sec
->vma
+ rel
->r_rel
.target_offset
);
8957 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8960 for (++i
; i
< src_count
; ++i
)
8962 curr_rel
= &src_relocs
[i
];
8963 /* If all others have the same target offset.... */
8964 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8967 if (!curr_rel
->is_null
8968 && !xtensa_is_property_section (curr_rel
->source_sec
)
8969 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8977 remove_dead_literal (bfd
*abfd
,
8979 struct bfd_link_info
*link_info
,
8980 Elf_Internal_Rela
*internal_relocs
,
8981 Elf_Internal_Rela
*irel
,
8983 property_table_entry
*prop_table
,
8986 property_table_entry
*entry
;
8987 xtensa_relax_info
*relax_info
;
8989 relax_info
= get_xtensa_relax_info (sec
);
8993 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8994 sec
->vma
+ rel
->r_rel
.target_offset
);
8996 /* Mark the unused literal so that it will be removed. */
8997 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
8999 text_action_add (&relax_info
->action_list
,
9000 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9002 /* If the section is 4-byte aligned, do not add fill. */
9003 if (sec
->alignment_power
> 2)
9005 int fill_extra_space
;
9006 bfd_vma entry_sec_offset
;
9008 property_table_entry
*the_add_entry
;
9012 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9014 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9016 /* If the literal range is at the end of the section,
9018 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9020 fill_extra_space
= xtensa_compute_fill_extra_space (the_add_entry
);
9022 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9023 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9024 -4, fill_extra_space
);
9026 adjust_fill_action (fa
, removed_diff
);
9028 text_action_add (&relax_info
->action_list
,
9029 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9032 /* Zero out the relocation on this literal location. */
9035 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9036 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9038 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9039 pin_internal_relocs (sec
, internal_relocs
);
9042 /* Do not modify "last_loc_is_prev". */
9048 identify_literal_placement (bfd
*abfd
,
9051 struct bfd_link_info
*link_info
,
9052 value_map_hash_table
*values
,
9053 bfd_boolean
*last_loc_is_prev_p
,
9054 Elf_Internal_Rela
*irel
,
9055 int remaining_src_rels
,
9057 property_table_entry
*prop_table
,
9059 section_cache_t
*target_sec_cache
,
9060 bfd_boolean is_abs_literal
)
9064 xtensa_relax_info
*relax_info
;
9065 bfd_boolean literal_placed
= FALSE
;
9067 unsigned long value
;
9068 bfd_boolean final_static_link
;
9069 bfd_size_type sec_size
;
9071 relax_info
= get_xtensa_relax_info (sec
);
9075 sec_size
= bfd_get_section_limit (abfd
, sec
);
9078 (!bfd_link_relocatable (link_info
)
9079 && !elf_hash_table (link_info
)->dynamic_sections_created
);
9081 /* The placement algorithm first checks to see if the literal is
9082 already in the value map. If so and the value map is reachable
9083 from all uses, then the literal is moved to that location. If
9084 not, then we identify the last location where a fresh literal was
9085 placed. If the literal can be safely moved there, then we do so.
9086 If not, then we assume that the literal is not to move and leave
9087 the literal where it is, marking it as the last literal
9090 /* Find the literal value. */
9092 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9095 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
9096 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
9098 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
9100 /* Check if we've seen another literal with the same value that
9101 is in the same output section. */
9102 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
9105 && (r_reloc_get_section (&val_map
->loc
)->output_section
9106 == sec
->output_section
)
9107 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
9108 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
9110 /* No change to last_loc_is_prev. */
9111 literal_placed
= TRUE
;
9114 /* For relocatable links, do not try to move literals. To do it
9115 correctly might increase the number of relocations in an input
9116 section making the default relocatable linking fail. */
9117 if (!bfd_link_relocatable (link_info
) && !literal_placed
9118 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
9120 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
9121 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
9123 /* Increment the virtual offset. */
9124 r_reloc try_loc
= values
->last_loc
;
9125 try_loc
.virtual_offset
+= 4;
9127 /* There is a last loc that was in the same output section. */
9128 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
9129 && move_shared_literal (sec
, link_info
, rel
,
9130 prop_table
, ptblsize
,
9131 &try_loc
, &val
, target_sec_cache
))
9133 values
->last_loc
.virtual_offset
+= 4;
9134 literal_placed
= TRUE
;
9136 val_map
= add_value_map (values
, &val
, &try_loc
,
9139 val_map
->loc
= try_loc
;
9144 if (!literal_placed
)
9146 /* Nothing worked, leave the literal alone but update the last loc. */
9147 values
->has_last_loc
= TRUE
;
9148 values
->last_loc
= rel
->r_rel
;
9150 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
9152 val_map
->loc
= rel
->r_rel
;
9153 *last_loc_is_prev_p
= TRUE
;
9160 /* Check if the original relocations (presumably on L32R instructions)
9161 identified by reloc[0..N] can be changed to reference the literal
9162 identified by r_rel. If r_rel is out of range for any of the
9163 original relocations, then we don't want to coalesce the original
9164 literal with the one at r_rel. We only check reloc[0..N], where the
9165 offsets are all the same as for reloc[0] (i.e., they're all
9166 referencing the same literal) and where N is also bounded by the
9167 number of remaining entries in the "reloc" array. The "reloc" array
9168 is sorted by target offset so we know all the entries for the same
9169 literal will be contiguous. */
9172 relocations_reach (source_reloc
*reloc
,
9173 int remaining_relocs
,
9174 const r_reloc
*r_rel
)
9176 bfd_vma from_offset
, source_address
, dest_address
;
9180 if (!r_reloc_is_defined (r_rel
))
9183 sec
= r_reloc_get_section (r_rel
);
9184 from_offset
= reloc
[0].r_rel
.target_offset
;
9186 for (i
= 0; i
< remaining_relocs
; i
++)
9188 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9191 /* Ignore relocations that have been removed. */
9192 if (reloc
[i
].is_null
)
9195 /* The original and new output section for these must be the same
9196 in order to coalesce. */
9197 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9198 != sec
->output_section
)
9201 /* Absolute literals in the same output section can always be
9203 if (reloc
[i
].is_abs_literal
)
9206 /* A literal with no PC-relative relocations can be moved anywhere. */
9207 if (reloc
[i
].opnd
!= -1)
9209 /* Otherwise, check to see that it fits. */
9210 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9211 + reloc
[i
].source_sec
->output_offset
9212 + reloc
[i
].r_rel
.rela
.r_offset
);
9213 dest_address
= (sec
->output_section
->vma
9214 + sec
->output_offset
9215 + r_rel
->target_offset
);
9217 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9218 source_address
, dest_address
))
9227 /* Move a literal to another literal location because it is
9228 the same as the other literal value. */
9231 coalesce_shared_literal (asection
*sec
,
9233 property_table_entry
*prop_table
,
9237 property_table_entry
*entry
;
9239 property_table_entry
*the_add_entry
;
9241 xtensa_relax_info
*relax_info
;
9243 relax_info
= get_xtensa_relax_info (sec
);
9247 entry
= elf_xtensa_find_property_entry
9248 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9249 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9252 /* Mark that the literal will be coalesced. */
9253 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9255 text_action_add (&relax_info
->action_list
,
9256 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9258 /* If the section is 4-byte aligned, do not add fill. */
9259 if (sec
->alignment_power
> 2)
9261 int fill_extra_space
;
9262 bfd_vma entry_sec_offset
;
9265 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9267 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9269 /* If the literal range is at the end of the section,
9271 fill_extra_space
= 0;
9272 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9274 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9275 fill_extra_space
= the_add_entry
->size
;
9277 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9278 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9279 -4, fill_extra_space
);
9281 adjust_fill_action (fa
, removed_diff
);
9283 text_action_add (&relax_info
->action_list
,
9284 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9291 /* Move a literal to another location. This may actually increase the
9292 total amount of space used because of alignments so we need to do
9293 this carefully. Also, it may make a branch go out of range. */
9296 move_shared_literal (asection
*sec
,
9297 struct bfd_link_info
*link_info
,
9299 property_table_entry
*prop_table
,
9301 const r_reloc
*target_loc
,
9302 const literal_value
*lit_value
,
9303 section_cache_t
*target_sec_cache
)
9305 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9306 text_action
*fa
, *target_fa
;
9308 xtensa_relax_info
*relax_info
, *target_relax_info
;
9309 asection
*target_sec
;
9311 ebb_constraint ebb_table
;
9312 bfd_boolean relocs_fit
;
9314 /* If this routine always returns FALSE, the literals that cannot be
9315 coalesced will not be moved. */
9316 if (elf32xtensa_no_literal_movement
)
9319 relax_info
= get_xtensa_relax_info (sec
);
9323 target_sec
= r_reloc_get_section (target_loc
);
9324 target_relax_info
= get_xtensa_relax_info (target_sec
);
9326 /* Literals to undefined sections may not be moved because they
9327 must report an error. */
9328 if (bfd_is_und_section (target_sec
))
9331 src_entry
= elf_xtensa_find_property_entry
9332 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9334 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9337 target_entry
= elf_xtensa_find_property_entry
9338 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9339 target_sec
->vma
+ target_loc
->target_offset
);
9344 /* Make sure that we have not broken any branches. */
9347 init_ebb_constraint (&ebb_table
);
9348 ebb
= &ebb_table
.ebb
;
9349 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9350 target_sec_cache
->content_length
,
9351 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9352 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9354 /* Propose to add 4 bytes + worst-case alignment size increase to
9356 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9357 ta_fill
, target_loc
->target_offset
,
9358 -4 - (1 << target_sec
->alignment_power
), TRUE
);
9360 /* Check all of the PC-relative relocations to make sure they still fit. */
9361 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9362 target_sec_cache
->contents
,
9363 target_sec_cache
->relocs
, NULL
,
9369 text_action_add_literal (&target_relax_info
->action_list
,
9370 ta_add_literal
, target_loc
, lit_value
, -4);
9372 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9374 /* May need to add or remove some fill to maintain alignment. */
9375 int fill_extra_space
;
9376 bfd_vma entry_sec_offset
;
9379 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9381 /* If the literal range is at the end of the section,
9383 fill_extra_space
= 0;
9385 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9386 target_sec_cache
->pte_count
,
9388 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9389 fill_extra_space
= the_add_entry
->size
;
9391 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9392 target_sec
, entry_sec_offset
);
9393 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9394 entry_sec_offset
, 4,
9397 adjust_fill_action (target_fa
, removed_diff
);
9399 text_action_add (&target_relax_info
->action_list
,
9400 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9403 /* Mark that the literal will be moved to the new location. */
9404 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9406 /* Remove the literal. */
9407 text_action_add (&relax_info
->action_list
,
9408 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9410 /* If the section is 4-byte aligned, do not add fill. */
9411 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9413 int fill_extra_space
;
9414 bfd_vma entry_sec_offset
;
9417 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9419 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9421 /* If the literal range is at the end of the section,
9423 fill_extra_space
= 0;
9424 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9426 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9427 fill_extra_space
= the_add_entry
->size
;
9429 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9430 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9431 -4, fill_extra_space
);
9433 adjust_fill_action (fa
, removed_diff
);
9435 text_action_add (&relax_info
->action_list
,
9436 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9443 /* Second relaxation pass. */
9446 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9448 bfd_size_type
*final_size
= p
;
9449 text_action
*action
= (text_action
*)node
->value
;
9451 *final_size
-= action
->removed_bytes
;
9455 /* Modify all of the relocations to point to the right spot, and if this
9456 is a relaxable section, delete the unwanted literals and fix the
9460 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9462 Elf_Internal_Rela
*internal_relocs
;
9463 xtensa_relax_info
*relax_info
;
9465 bfd_boolean ok
= TRUE
;
9467 bfd_boolean rv
= FALSE
;
9468 bfd_boolean virtual_action
;
9469 bfd_size_type sec_size
;
9471 sec_size
= bfd_get_section_limit (abfd
, sec
);
9472 relax_info
= get_xtensa_relax_info (sec
);
9473 BFD_ASSERT (relax_info
);
9475 /* First translate any of the fixes that have been added already. */
9476 translate_section_fixes (sec
);
9478 /* Handle property sections (e.g., literal tables) specially. */
9479 if (xtensa_is_property_section (sec
))
9481 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9482 return relax_property_section (abfd
, sec
, link_info
);
9485 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9486 link_info
->keep_memory
);
9487 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9490 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9491 if (contents
== NULL
&& sec_size
!= 0)
9497 if (internal_relocs
)
9499 for (i
= 0; i
< sec
->reloc_count
; i
++)
9501 Elf_Internal_Rela
*irel
;
9502 xtensa_relax_info
*target_relax_info
;
9503 bfd_vma source_offset
, old_source_offset
;
9506 asection
*target_sec
;
9508 /* Locally change the source address.
9509 Translate the target to the new target address.
9510 If it points to this section and has been removed,
9514 irel
= &internal_relocs
[i
];
9515 source_offset
= irel
->r_offset
;
9516 old_source_offset
= source_offset
;
9518 r_type
= ELF32_R_TYPE (irel
->r_info
);
9519 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9520 bfd_get_section_limit (abfd
, sec
));
9522 /* If this section could have changed then we may need to
9523 change the relocation's offset. */
9525 if (relax_info
->is_relaxable_literal_section
9526 || relax_info
->is_relaxable_asm_section
)
9528 pin_internal_relocs (sec
, internal_relocs
);
9530 if (r_type
!= R_XTENSA_NONE
9531 && find_removed_literal (&relax_info
->removed_list
,
9534 /* Remove this relocation. */
9535 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9536 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9537 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9538 irel
->r_offset
= offset_with_removed_text_map
9539 (&relax_info
->action_list
, irel
->r_offset
);
9543 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9545 text_action
*action
=
9546 find_insn_action (&relax_info
->action_list
,
9548 if (action
&& (action
->action
== ta_convert_longcall
9549 || action
->action
== ta_remove_longcall
))
9551 bfd_reloc_status_type retval
;
9552 char *error_message
= NULL
;
9554 retval
= contract_asm_expansion (contents
, sec_size
,
9555 irel
, &error_message
);
9556 if (retval
!= bfd_reloc_ok
)
9558 (*link_info
->callbacks
->reloc_dangerous
)
9559 (link_info
, error_message
, abfd
, sec
,
9563 /* Update the action so that the code that moves
9564 the contents will do the right thing. */
9565 /* ta_remove_longcall and ta_remove_insn actions are
9566 grouped together in the tree as well as
9567 ta_convert_longcall and ta_none, so that changes below
9568 can be done w/o removing and reinserting action into
9571 if (action
->action
== ta_remove_longcall
)
9572 action
->action
= ta_remove_insn
;
9574 action
->action
= ta_none
;
9575 /* Refresh the info in the r_rel. */
9576 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9577 r_type
= ELF32_R_TYPE (irel
->r_info
);
9581 source_offset
= offset_with_removed_text_map
9582 (&relax_info
->action_list
, irel
->r_offset
);
9583 irel
->r_offset
= source_offset
;
9586 /* If the target section could have changed then
9587 we may need to change the relocation's target offset. */
9589 target_sec
= r_reloc_get_section (&r_rel
);
9591 /* For a reference to a discarded section from a DWARF section,
9592 i.e., where action_discarded is PRETEND, the symbol will
9593 eventually be modified to refer to the kept section (at least if
9594 the kept and discarded sections are the same size). Anticipate
9595 that here and adjust things accordingly. */
9596 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9597 && elf_xtensa_action_discarded (sec
) == PRETEND
9598 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9599 && target_sec
!= NULL
9600 && discarded_section (target_sec
))
9602 /* It would be natural to call _bfd_elf_check_kept_section
9603 here, but it's not exported from elflink.c. It's also a
9604 fairly expensive check. Adjusting the relocations to the
9605 discarded section is fairly harmless; it will only adjust
9606 some addends and difference values. If it turns out that
9607 _bfd_elf_check_kept_section fails later, it won't matter,
9608 so just compare the section names to find the right group
9610 asection
*kept
= target_sec
->kept_section
;
9613 if ((kept
->flags
& SEC_GROUP
) != 0)
9615 asection
*first
= elf_next_in_group (kept
);
9616 asection
*s
= first
;
9621 if (strcmp (s
->name
, target_sec
->name
) == 0)
9626 s
= elf_next_in_group (s
);
9633 && ((target_sec
->rawsize
!= 0
9634 ? target_sec
->rawsize
: target_sec
->size
)
9635 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9639 target_relax_info
= get_xtensa_relax_info (target_sec
);
9640 if (target_relax_info
9641 && (target_relax_info
->is_relaxable_literal_section
9642 || target_relax_info
->is_relaxable_asm_section
))
9645 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9647 if (r_type
== R_XTENSA_DIFF8
9648 || r_type
== R_XTENSA_DIFF16
9649 || r_type
== R_XTENSA_DIFF32
9650 || r_type
== R_XTENSA_PDIFF8
9651 || r_type
== R_XTENSA_PDIFF16
9652 || r_type
== R_XTENSA_PDIFF32
9653 || r_type
== R_XTENSA_NDIFF8
9654 || r_type
== R_XTENSA_NDIFF16
9655 || r_type
== R_XTENSA_NDIFF32
)
9657 bfd_signed_vma diff_value
= 0;
9658 bfd_vma new_end_offset
, diff_mask
= 0;
9660 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9662 (*link_info
->callbacks
->reloc_dangerous
)
9663 (link_info
, _("invalid relocation address"),
9664 abfd
, sec
, old_source_offset
);
9670 case R_XTENSA_DIFF8
:
9673 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9675 case R_XTENSA_DIFF16
:
9678 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9680 case R_XTENSA_DIFF32
:
9681 diff_mask
= 0x7fffffff;
9683 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9685 case R_XTENSA_PDIFF8
:
9686 case R_XTENSA_NDIFF8
:
9689 bfd_get_8 (abfd
, &contents
[old_source_offset
]);
9691 case R_XTENSA_PDIFF16
:
9692 case R_XTENSA_NDIFF16
:
9695 bfd_get_16 (abfd
, &contents
[old_source_offset
]);
9697 case R_XTENSA_PDIFF32
:
9698 case R_XTENSA_NDIFF32
:
9699 diff_mask
= 0xffffffff;
9701 bfd_get_32 (abfd
, &contents
[old_source_offset
]);
9705 if (r_type
>= R_XTENSA_NDIFF8
9706 && r_type
<= R_XTENSA_NDIFF32
9708 diff_value
|= ~diff_mask
;
9710 new_end_offset
= offset_with_removed_text_map
9711 (&target_relax_info
->action_list
,
9712 r_rel
.target_offset
+ diff_value
);
9713 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9717 case R_XTENSA_DIFF8
:
9718 bfd_put_signed_8 (abfd
, diff_value
,
9719 &contents
[old_source_offset
]);
9721 case R_XTENSA_DIFF16
:
9722 bfd_put_signed_16 (abfd
, diff_value
,
9723 &contents
[old_source_offset
]);
9725 case R_XTENSA_DIFF32
:
9726 bfd_put_signed_32 (abfd
, diff_value
,
9727 &contents
[old_source_offset
]);
9729 case R_XTENSA_PDIFF8
:
9730 case R_XTENSA_NDIFF8
:
9731 bfd_put_8 (abfd
, diff_value
,
9732 &contents
[old_source_offset
]);
9734 case R_XTENSA_PDIFF16
:
9735 case R_XTENSA_NDIFF16
:
9736 bfd_put_16 (abfd
, diff_value
,
9737 &contents
[old_source_offset
]);
9739 case R_XTENSA_PDIFF32
:
9740 case R_XTENSA_NDIFF32
:
9741 bfd_put_32 (abfd
, diff_value
,
9742 &contents
[old_source_offset
]);
9746 /* Check for overflow. Sign bits must be all zeroes or
9747 all ones. When sign bits are all ones diff_value
9749 if (((diff_value
& ~diff_mask
) != 0
9750 && (diff_value
& ~diff_mask
) != ~diff_mask
)
9751 || (diff_value
&& (bfd_vma
) diff_value
== ~diff_mask
))
9753 (*link_info
->callbacks
->reloc_dangerous
)
9754 (link_info
, _("overflow after relaxation"),
9755 abfd
, sec
, old_source_offset
);
9759 pin_contents (sec
, contents
);
9762 /* If the relocation still references a section in the same
9763 input file, modify the relocation directly instead of
9764 adding a "fix" record. */
9765 if (target_sec
->owner
== abfd
)
9767 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9768 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9769 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9770 pin_internal_relocs (sec
, internal_relocs
);
9774 bfd_vma addend_displacement
;
9777 addend_displacement
=
9778 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9779 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9781 addend_displacement
, TRUE
);
9788 if ((relax_info
->is_relaxable_literal_section
9789 || relax_info
->is_relaxable_asm_section
)
9790 && action_list_count (&relax_info
->action_list
))
9792 /* Walk through the planned actions and build up a table
9793 of move, copy and fill records. Use the move, copy and
9794 fill records to perform the actions once. */
9796 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9797 bfd_byte
*scratch
= NULL
;
9798 bfd_byte
*dup_contents
= NULL
;
9799 bfd_size_type orig_size
= sec
->size
;
9800 bfd_vma orig_dot
= 0;
9801 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9802 orig dot in physical memory. */
9803 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9804 bfd_vma dup_dot
= 0;
9806 text_action
*action
;
9808 final_size
= sec
->size
;
9810 splay_tree_foreach (relax_info
->action_list
.tree
,
9811 action_remove_bytes_fn
, &final_size
);
9812 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9813 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9815 /* The dot is the current fill location. */
9817 print_action_list (stderr
, &relax_info
->action_list
);
9820 for (action
= action_first (&relax_info
->action_list
); action
;
9821 action
= action_next (&relax_info
->action_list
, action
))
9823 virtual_action
= FALSE
;
9824 if (action
->offset
> orig_dot
)
9826 orig_dot
+= orig_dot_copied
;
9827 orig_dot_copied
= 0;
9829 /* Out of the virtual world. */
9832 if (action
->offset
> orig_dot
)
9834 copy_size
= action
->offset
- orig_dot
;
9835 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9836 orig_dot
+= copy_size
;
9837 dup_dot
+= copy_size
;
9838 BFD_ASSERT (action
->offset
== orig_dot
);
9840 else if (action
->offset
< orig_dot
)
9842 if (action
->action
== ta_fill
9843 && action
->offset
- action
->removed_bytes
== orig_dot
)
9845 /* This is OK because the fill only effects the dup_dot. */
9847 else if (action
->action
== ta_add_literal
)
9849 /* TBD. Might need to handle this. */
9852 if (action
->offset
== orig_dot
)
9854 if (action
->virtual_offset
> orig_dot_vo
)
9856 if (orig_dot_vo
== 0)
9858 /* Need to copy virtual_offset bytes. Probably four. */
9859 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9860 memmove (&dup_contents
[dup_dot
],
9861 &contents
[orig_dot
], copy_size
);
9862 orig_dot_copied
= copy_size
;
9863 dup_dot
+= copy_size
;
9865 virtual_action
= TRUE
;
9868 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9870 switch (action
->action
)
9872 case ta_remove_literal
:
9873 case ta_remove_insn
:
9874 BFD_ASSERT (action
->removed_bytes
>= 0);
9875 orig_dot
+= action
->removed_bytes
;
9878 case ta_narrow_insn
:
9881 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9882 BFD_ASSERT (action
->removed_bytes
== 1);
9883 rv
= narrow_instruction (scratch
, final_size
, 0);
9885 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9886 orig_dot
+= orig_insn_size
;
9887 dup_dot
+= copy_size
;
9891 if (action
->removed_bytes
>= 0)
9892 orig_dot
+= action
->removed_bytes
;
9895 /* Already zeroed in dup_contents. Just bump the
9897 dup_dot
+= (-action
->removed_bytes
);
9902 BFD_ASSERT (action
->removed_bytes
== 0);
9905 case ta_convert_longcall
:
9906 case ta_remove_longcall
:
9907 /* These will be removed or converted before we get here. */
9914 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9915 BFD_ASSERT (action
->removed_bytes
== -1);
9916 rv
= widen_instruction (scratch
, final_size
, 0);
9918 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9919 orig_dot
+= orig_insn_size
;
9920 dup_dot
+= copy_size
;
9923 case ta_add_literal
:
9926 BFD_ASSERT (action
->removed_bytes
== -4);
9927 /* TBD -- place the literal value here and insert
9929 memset (&dup_contents
[dup_dot
], 0, 4);
9930 pin_internal_relocs (sec
, internal_relocs
);
9931 pin_contents (sec
, contents
);
9933 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9934 relax_info
, &internal_relocs
, &action
->value
))
9938 orig_dot_vo
+= copy_size
;
9940 orig_dot
+= orig_insn_size
;
9941 dup_dot
+= copy_size
;
9945 /* Not implemented yet. */
9950 BFD_ASSERT (dup_dot
<= final_size
);
9951 BFD_ASSERT (orig_dot
<= orig_size
);
9954 orig_dot
+= orig_dot_copied
;
9955 orig_dot_copied
= 0;
9957 if (orig_dot
!= orig_size
)
9959 copy_size
= orig_size
- orig_dot
;
9960 BFD_ASSERT (orig_size
> orig_dot
);
9961 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9962 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9963 orig_dot
+= copy_size
;
9964 dup_dot
+= copy_size
;
9966 BFD_ASSERT (orig_size
== orig_dot
);
9967 BFD_ASSERT (final_size
== dup_dot
);
9969 /* Move the dup_contents back. */
9970 if (final_size
> orig_size
)
9972 /* Contents need to be reallocated. Swap the dup_contents into
9974 sec
->contents
= dup_contents
;
9976 contents
= dup_contents
;
9977 pin_contents (sec
, contents
);
9981 BFD_ASSERT (final_size
<= orig_size
);
9982 memset (contents
, 0, orig_size
);
9983 memcpy (contents
, dup_contents
, final_size
);
9984 free (dup_contents
);
9987 pin_contents (sec
, contents
);
9989 if (sec
->rawsize
== 0)
9990 sec
->rawsize
= sec
->size
;
9991 sec
->size
= final_size
;
9995 release_internal_relocs (sec
, internal_relocs
);
9996 release_contents (sec
, contents
);
10002 translate_section_fixes (asection
*sec
)
10004 xtensa_relax_info
*relax_info
;
10007 relax_info
= get_xtensa_relax_info (sec
);
10011 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
10012 if (!translate_reloc_bfd_fix (r
))
10019 /* Translate a fix given the mapping in the relax info for the target
10020 section. If it has already been translated, no work is required. */
10023 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
10025 reloc_bfd_fix new_fix
;
10027 xtensa_relax_info
*relax_info
;
10028 removed_literal
*removed
;
10029 bfd_vma new_offset
, target_offset
;
10031 if (fix
->translated
)
10034 sec
= fix
->target_sec
;
10035 target_offset
= fix
->target_offset
;
10037 relax_info
= get_xtensa_relax_info (sec
);
10040 fix
->translated
= TRUE
;
10046 /* The fix does not need to be translated if the section cannot change. */
10047 if (!relax_info
->is_relaxable_literal_section
10048 && !relax_info
->is_relaxable_asm_section
)
10050 fix
->translated
= TRUE
;
10054 /* If the literal has been moved and this relocation was on an
10055 opcode, then the relocation should move to the new literal
10056 location. Otherwise, the relocation should move within the
10060 if (is_operand_relocation (fix
->src_type
))
10062 /* Check if the original relocation is against a literal being
10064 removed
= find_removed_literal (&relax_info
->removed_list
,
10072 /* The fact that there is still a relocation to this literal indicates
10073 that the literal is being coalesced, not simply removed. */
10074 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10076 /* This was moved to some other address (possibly another section). */
10077 new_sec
= r_reloc_get_section (&removed
->to
);
10078 if (new_sec
!= sec
)
10081 relax_info
= get_xtensa_relax_info (sec
);
10083 (!relax_info
->is_relaxable_literal_section
10084 && !relax_info
->is_relaxable_asm_section
))
10086 target_offset
= removed
->to
.target_offset
;
10087 new_fix
.target_sec
= new_sec
;
10088 new_fix
.target_offset
= target_offset
;
10089 new_fix
.translated
= TRUE
;
10094 target_offset
= removed
->to
.target_offset
;
10095 new_fix
.target_sec
= new_sec
;
10098 /* The target address may have been moved within its section. */
10099 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
10102 new_fix
.target_offset
= new_offset
;
10103 new_fix
.target_offset
= new_offset
;
10104 new_fix
.translated
= TRUE
;
10110 /* Fix up a relocation to take account of removed literals. */
10113 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
10115 xtensa_relax_info
*relax_info
;
10116 removed_literal
*removed
;
10117 bfd_vma target_offset
, base_offset
;
10119 *new_rel
= *orig_rel
;
10121 if (!r_reloc_is_defined (orig_rel
))
10124 relax_info
= get_xtensa_relax_info (sec
);
10125 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
10126 || relax_info
->is_relaxable_asm_section
));
10128 target_offset
= orig_rel
->target_offset
;
10131 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
10133 /* Check if the original relocation is against a literal being
10135 removed
= find_removed_literal (&relax_info
->removed_list
,
10138 if (removed
&& removed
->to
.abfd
)
10142 /* The fact that there is still a relocation to this literal indicates
10143 that the literal is being coalesced, not simply removed. */
10144 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10146 /* This was moved to some other address
10147 (possibly in another section). */
10148 *new_rel
= removed
->to
;
10149 new_sec
= r_reloc_get_section (new_rel
);
10150 if (new_sec
!= sec
)
10153 relax_info
= get_xtensa_relax_info (sec
);
10155 || (!relax_info
->is_relaxable_literal_section
10156 && !relax_info
->is_relaxable_asm_section
))
10159 target_offset
= new_rel
->target_offset
;
10162 /* Find the base offset of the reloc symbol, excluding any addend from the
10163 reloc or from the section contents (for a partial_inplace reloc). Then
10164 find the adjusted values of the offsets due to relaxation. The base
10165 offset is needed to determine the change to the reloc's addend; the reloc
10166 addend should not be adjusted due to relaxations located before the base
10169 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
10170 if (base_offset
<= target_offset
)
10172 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
10173 base_offset
, FALSE
);
10174 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10175 target_offset
, FALSE
) -
10178 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
10179 new_rel
->rela
.r_addend
-= addend_removed
;
10183 /* Handle a negative addend. The base offset comes first. */
10184 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
10185 target_offset
, FALSE
);
10186 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10187 base_offset
, FALSE
) -
10190 new_rel
->target_offset
= target_offset
- tgt_removed
;
10191 new_rel
->rela
.r_addend
+= addend_removed
;
10198 /* For dynamic links, there may be a dynamic relocation for each
10199 literal. The number of dynamic relocations must be computed in
10200 size_dynamic_sections, which occurs before relaxation. When a
10201 literal is removed, this function checks if there is a corresponding
10202 dynamic relocation and shrinks the size of the appropriate dynamic
10203 relocation section accordingly. At this point, the contents of the
10204 dynamic relocation sections have not yet been filled in, so there's
10205 nothing else that needs to be done. */
10208 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
10210 asection
*input_section
,
10211 Elf_Internal_Rela
*rel
)
10213 struct elf_xtensa_link_hash_table
*htab
;
10214 Elf_Internal_Shdr
*symtab_hdr
;
10215 struct elf_link_hash_entry
**sym_hashes
;
10216 unsigned long r_symndx
;
10218 struct elf_link_hash_entry
*h
;
10219 bfd_boolean dynamic_symbol
;
10221 htab
= elf_xtensa_hash_table (info
);
10225 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10226 sym_hashes
= elf_sym_hashes (abfd
);
10228 r_type
= ELF32_R_TYPE (rel
->r_info
);
10229 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10231 if (r_symndx
< symtab_hdr
->sh_info
)
10234 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10236 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10238 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10239 && (input_section
->flags
& SEC_ALLOC
) != 0
10241 || (bfd_link_pic (info
)
10242 && (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
))))
10245 bfd_boolean is_plt
= FALSE
;
10247 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10249 srel
= htab
->elf
.srelplt
;
10253 srel
= htab
->elf
.srelgot
;
10255 /* Reduce size of the .rela.* section by one reloc. */
10256 BFD_ASSERT (srel
!= NULL
);
10257 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10258 srel
->size
-= sizeof (Elf32_External_Rela
);
10262 asection
*splt
, *sgotplt
, *srelgot
;
10263 int reloc_index
, chunk
;
10265 /* Find the PLT reloc index of the entry being removed. This
10266 is computed from the size of ".rela.plt". It is needed to
10267 figure out which PLT chunk to resize. Usually "last index
10268 = size - 1" since the index starts at zero, but in this
10269 context, the size has just been decremented so there's no
10270 need to subtract one. */
10271 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10273 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10274 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10275 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10276 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10278 /* Check if an entire PLT chunk has just been eliminated. */
10279 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10281 /* The two magic GOT entries for that chunk can go away. */
10282 srelgot
= htab
->elf
.srelgot
;
10283 BFD_ASSERT (srelgot
!= NULL
);
10284 srelgot
->reloc_count
-= 2;
10285 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10286 sgotplt
->size
-= 8;
10288 /* There should be only one entry left (and it will be
10290 BFD_ASSERT (sgotplt
->size
== 4);
10291 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10294 BFD_ASSERT (sgotplt
->size
>= 4);
10295 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10297 sgotplt
->size
-= 4;
10298 splt
->size
-= PLT_ENTRY_SIZE
;
10304 /* Take an r_rel and move it to another section. This usually
10305 requires extending the interal_relocation array and pinning it. If
10306 the original r_rel is from the same BFD, we can complete this here.
10307 Otherwise, we add a fix record to let the final link fix the
10308 appropriate address. Contents and internal relocations for the
10309 section must be pinned after calling this routine. */
10312 move_literal (bfd
*abfd
,
10313 struct bfd_link_info
*link_info
,
10316 bfd_byte
*contents
,
10317 xtensa_relax_info
*relax_info
,
10318 Elf_Internal_Rela
**internal_relocs_p
,
10319 const literal_value
*lit
)
10321 Elf_Internal_Rela
*new_relocs
= NULL
;
10322 size_t new_relocs_count
= 0;
10323 Elf_Internal_Rela this_rela
;
10324 const r_reloc
*r_rel
;
10326 r_rel
= &lit
->r_rel
;
10327 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10329 if (r_reloc_is_const (r_rel
))
10330 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10335 reloc_bfd_fix
*fix
;
10336 unsigned insert_at
;
10338 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10340 /* This is the difficult case. We have to create a fix up. */
10341 this_rela
.r_offset
= offset
;
10342 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10343 this_rela
.r_addend
=
10344 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10345 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10347 /* Currently, we cannot move relocations during a relocatable link. */
10348 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10349 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10350 r_reloc_get_section (r_rel
),
10351 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10353 /* We also need to mark that relocations are needed here. */
10354 sec
->flags
|= SEC_RELOC
;
10356 translate_reloc_bfd_fix (fix
);
10357 /* This fix has not yet been translated. */
10358 add_fix (sec
, fix
);
10360 /* Add the relocation. If we have already allocated our own
10361 space for the relocations and we have room for more, then use
10362 it. Otherwise, allocate new space and move the literals. */
10363 insert_at
= sec
->reloc_count
;
10364 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10366 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10373 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10374 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10376 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10377 || sec
->reloc_count
== relax_info
->relocs_count
);
10379 if (relax_info
->allocated_relocs_count
== 0)
10380 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10382 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10384 new_relocs
= (Elf_Internal_Rela
*)
10385 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10389 /* We could handle this more quickly by finding the split point. */
10390 if (insert_at
!= 0)
10391 memcpy (new_relocs
, *internal_relocs_p
,
10392 insert_at
* sizeof (Elf_Internal_Rela
));
10394 new_relocs
[insert_at
] = this_rela
;
10396 if (insert_at
!= sec
->reloc_count
)
10397 memcpy (new_relocs
+ insert_at
+ 1,
10398 (*internal_relocs_p
) + insert_at
,
10399 (sec
->reloc_count
- insert_at
)
10400 * sizeof (Elf_Internal_Rela
));
10402 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10404 /* The first time we re-allocate, we can only free the
10405 old relocs if they were allocated with bfd_malloc.
10406 This is not true when keep_memory is in effect. */
10407 if (!link_info
->keep_memory
)
10408 free (*internal_relocs_p
);
10411 free (*internal_relocs_p
);
10412 relax_info
->allocated_relocs
= new_relocs
;
10413 relax_info
->allocated_relocs_count
= new_relocs_count
;
10414 elf_section_data (sec
)->relocs
= new_relocs
;
10415 sec
->reloc_count
++;
10416 relax_info
->relocs_count
= sec
->reloc_count
;
10417 *internal_relocs_p
= new_relocs
;
10421 if (insert_at
!= sec
->reloc_count
)
10424 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10425 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10427 (*internal_relocs_p
)[insert_at
] = this_rela
;
10428 sec
->reloc_count
++;
10429 if (relax_info
->allocated_relocs
)
10430 relax_info
->relocs_count
= sec
->reloc_count
;
10437 /* This is similar to relax_section except that when a target is moved,
10438 we shift addresses up. We also need to modify the size. This
10439 algorithm does NOT allow for relocations into the middle of the
10440 property sections. */
10443 relax_property_section (bfd
*abfd
,
10445 struct bfd_link_info
*link_info
)
10447 Elf_Internal_Rela
*internal_relocs
;
10448 bfd_byte
*contents
;
10450 bfd_boolean ok
= TRUE
;
10451 bfd_boolean is_full_prop_section
;
10452 size_t last_zfill_target_offset
= 0;
10453 asection
*last_zfill_target_sec
= NULL
;
10454 bfd_size_type sec_size
;
10455 bfd_size_type entry_size
;
10457 sec_size
= bfd_get_section_limit (abfd
, sec
);
10458 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10459 link_info
->keep_memory
);
10460 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10461 if (contents
== NULL
&& sec_size
!= 0)
10467 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10468 if (is_full_prop_section
)
10473 if (internal_relocs
)
10475 for (i
= 0; i
< sec
->reloc_count
; i
++)
10477 Elf_Internal_Rela
*irel
;
10478 xtensa_relax_info
*target_relax_info
;
10480 asection
*target_sec
;
10482 bfd_byte
*size_p
, *flags_p
;
10484 /* Locally change the source address.
10485 Translate the target to the new target address.
10486 If it points to this section and has been removed, MOVE IT.
10487 Also, don't forget to modify the associated SIZE at
10490 irel
= &internal_relocs
[i
];
10491 r_type
= ELF32_R_TYPE (irel
->r_info
);
10492 if (r_type
== R_XTENSA_NONE
)
10495 /* Find the literal value. */
10496 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10497 size_p
= &contents
[irel
->r_offset
+ 4];
10499 if (is_full_prop_section
)
10500 flags_p
= &contents
[irel
->r_offset
+ 8];
10501 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10503 target_sec
= r_reloc_get_section (&val
.r_rel
);
10504 target_relax_info
= get_xtensa_relax_info (target_sec
);
10506 if (target_relax_info
10507 && (target_relax_info
->is_relaxable_literal_section
10508 || target_relax_info
->is_relaxable_asm_section
))
10510 /* Translate the relocation's destination. */
10511 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10512 bfd_vma new_offset
;
10513 long old_size
, new_size
;
10514 int removed_by_old_offset
=
10515 removed_by_actions_map (&target_relax_info
->action_list
,
10516 old_offset
, FALSE
);
10517 new_offset
= old_offset
- removed_by_old_offset
;
10519 /* Assert that we are not out of bounds. */
10520 old_size
= bfd_get_32 (abfd
, size_p
);
10521 new_size
= old_size
;
10525 /* Only the first zero-sized unreachable entry is
10526 allowed to expand. In this case the new offset
10527 should be the offset before the fill and the new
10528 size is the expansion size. For other zero-sized
10529 entries the resulting size should be zero with an
10530 offset before or after the fill address depending
10531 on whether the expanding unreachable entry
10533 if (last_zfill_target_sec
== 0
10534 || last_zfill_target_sec
!= target_sec
10535 || last_zfill_target_offset
!= old_offset
)
10537 bfd_vma new_end_offset
= new_offset
;
10539 /* Recompute the new_offset, but this time don't
10540 include any fill inserted by relaxation. */
10541 removed_by_old_offset
=
10542 removed_by_actions_map (&target_relax_info
->action_list
,
10544 new_offset
= old_offset
- removed_by_old_offset
;
10546 /* If it is not unreachable and we have not yet
10547 seen an unreachable at this address, place it
10548 before the fill address. */
10549 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10550 & XTENSA_PROP_UNREACHABLE
) != 0)
10552 new_size
= new_end_offset
- new_offset
;
10554 last_zfill_target_sec
= target_sec
;
10555 last_zfill_target_offset
= old_offset
;
10561 int removed_by_old_offset_size
=
10562 removed_by_actions_map (&target_relax_info
->action_list
,
10563 old_offset
+ old_size
, TRUE
);
10564 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10567 if (new_size
!= old_size
)
10569 bfd_put_32 (abfd
, new_size
, size_p
);
10570 pin_contents (sec
, contents
);
10573 if (new_offset
!= old_offset
)
10575 bfd_vma diff
= new_offset
- old_offset
;
10576 irel
->r_addend
+= diff
;
10577 pin_internal_relocs (sec
, internal_relocs
);
10583 /* Combine adjacent property table entries. This is also done in
10584 finish_dynamic_sections() but at that point it's too late to
10585 reclaim the space in the output section, so we do this twice. */
10587 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10588 || xtensa_is_littable_section (sec
)))
10590 Elf_Internal_Rela
*last_irel
= NULL
;
10591 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10592 int removed_bytes
= 0;
10594 flagword predef_flags
;
10596 predef_flags
= xtensa_get_property_predef_flags (sec
);
10598 /* Walk over memory and relocations at the same time.
10599 This REQUIRES that the internal_relocs be sorted by offset. */
10600 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10601 internal_reloc_compare
);
10603 pin_internal_relocs (sec
, internal_relocs
);
10604 pin_contents (sec
, contents
);
10606 next_rel
= internal_relocs
;
10607 rel_end
= internal_relocs
+ sec
->reloc_count
;
10609 BFD_ASSERT (sec
->size
% entry_size
== 0);
10611 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10613 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10614 bfd_vma bytes_to_remove
, size
, actual_offset
;
10615 bfd_boolean remove_this_rel
;
10618 /* Find the first relocation for the entry at the current offset.
10619 Adjust the offsets of any extra relocations for the previous
10624 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10626 if ((irel
->r_offset
== offset
10627 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10628 || irel
->r_offset
> offset
)
10633 irel
->r_offset
-= removed_bytes
;
10637 /* Find the next relocation (if there are any left). */
10641 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10643 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10651 /* Check if there are relocations on the current entry. There
10652 should usually be a relocation on the offset field. If there
10653 are relocations on the size or flags, then we can't optimize
10654 this entry. Also, find the next relocation to examine on the
10658 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10660 next_rel
= offset_rel
;
10661 /* There are no relocations on the current entry, but we
10662 might still be able to remove it if the size is zero. */
10665 else if (offset_rel
->r_offset
> offset
10667 && extra_rel
->r_offset
< offset
+ entry_size
))
10669 /* There is a relocation on the size or flags, so we can't
10670 do anything with this entry. Continue with the next. */
10671 next_rel
= offset_rel
;
10676 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10677 offset_rel
->r_offset
-= removed_bytes
;
10678 next_rel
= offset_rel
+ 1;
10684 remove_this_rel
= FALSE
;
10685 bytes_to_remove
= 0;
10686 actual_offset
= offset
- removed_bytes
;
10687 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10689 if (is_full_prop_section
)
10690 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10692 flags
= predef_flags
;
10695 && (flags
& XTENSA_PROP_ALIGN
) == 0
10696 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10698 /* Always remove entries with zero size and no alignment. */
10699 bytes_to_remove
= entry_size
;
10701 remove_this_rel
= TRUE
;
10703 else if (offset_rel
10704 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10708 flagword old_flags
;
10710 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10711 bfd_vma old_address
=
10712 (last_irel
->r_addend
10713 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10714 bfd_vma new_address
=
10715 (offset_rel
->r_addend
10716 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10717 if (is_full_prop_section
)
10718 old_flags
= bfd_get_32
10719 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10721 old_flags
= predef_flags
;
10723 if ((ELF32_R_SYM (offset_rel
->r_info
)
10724 == ELF32_R_SYM (last_irel
->r_info
))
10725 && old_address
+ old_size
== new_address
10726 && old_flags
== flags
10727 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10728 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10730 /* Fix the old size. */
10731 bfd_put_32 (abfd
, old_size
+ size
,
10732 &contents
[last_irel
->r_offset
+ 4]);
10733 bytes_to_remove
= entry_size
;
10734 remove_this_rel
= TRUE
;
10737 last_irel
= offset_rel
;
10740 last_irel
= offset_rel
;
10743 if (remove_this_rel
)
10745 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10746 offset_rel
->r_offset
= 0;
10749 if (bytes_to_remove
!= 0)
10751 removed_bytes
+= bytes_to_remove
;
10752 if (offset
+ bytes_to_remove
< sec
->size
)
10753 memmove (&contents
[actual_offset
],
10754 &contents
[actual_offset
+ bytes_to_remove
],
10755 sec
->size
- offset
- bytes_to_remove
);
10761 /* Fix up any extra relocations on the last entry. */
10762 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10763 irel
->r_offset
-= removed_bytes
;
10765 /* Clear the removed bytes. */
10766 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10768 if (sec
->rawsize
== 0)
10769 sec
->rawsize
= sec
->size
;
10770 sec
->size
-= removed_bytes
;
10772 if (xtensa_is_littable_section (sec
))
10774 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10776 sgotloc
->size
-= removed_bytes
;
10782 release_internal_relocs (sec
, internal_relocs
);
10783 release_contents (sec
, contents
);
10788 /* Third relaxation pass. */
10790 /* Change symbol values to account for removed literals. */
10793 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10795 xtensa_relax_info
*relax_info
;
10796 unsigned int sec_shndx
;
10797 Elf_Internal_Shdr
*symtab_hdr
;
10798 Elf_Internal_Sym
*isymbuf
;
10799 unsigned i
, num_syms
, num_locals
;
10801 relax_info
= get_xtensa_relax_info (sec
);
10802 BFD_ASSERT (relax_info
);
10804 if (!relax_info
->is_relaxable_literal_section
10805 && !relax_info
->is_relaxable_asm_section
)
10808 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10810 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10811 isymbuf
= retrieve_local_syms (abfd
);
10813 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10814 num_locals
= symtab_hdr
->sh_info
;
10816 /* Adjust the local symbols defined in this section. */
10817 for (i
= 0; i
< num_locals
; i
++)
10819 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10821 if (isym
->st_shndx
== sec_shndx
)
10823 bfd_vma orig_addr
= isym
->st_value
;
10824 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10827 isym
->st_value
-= removed
;
10828 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10830 removed_by_actions_map (&relax_info
->action_list
,
10831 orig_addr
+ isym
->st_size
, FALSE
) -
10836 /* Now adjust the global symbols defined in this section. */
10837 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10839 struct elf_link_hash_entry
*sym_hash
;
10841 sym_hash
= elf_sym_hashes (abfd
)[i
];
10843 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10844 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10846 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10847 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10848 && sym_hash
->root
.u
.def
.section
== sec
)
10850 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10851 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10854 sym_hash
->root
.u
.def
.value
-= removed
;
10856 if (sym_hash
->type
== STT_FUNC
)
10858 removed_by_actions_map (&relax_info
->action_list
,
10859 orig_addr
+ sym_hash
->size
, FALSE
) -
10868 /* "Fix" handling functions, called while performing relocations. */
10871 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10873 asection
*input_section
,
10874 bfd_byte
*contents
)
10877 asection
*sec
, *old_sec
;
10878 bfd_vma old_offset
;
10879 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10880 reloc_bfd_fix
*fix
;
10882 if (r_type
== R_XTENSA_NONE
)
10885 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10889 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10890 bfd_get_section_limit (input_bfd
, input_section
));
10891 old_sec
= r_reloc_get_section (&r_rel
);
10892 old_offset
= r_rel
.target_offset
;
10894 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10896 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10899 /* xgettext:c-format */
10900 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10901 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10902 elf_howto_table
[r_type
].name
);
10905 /* Leave it be. Resolution will happen in a later stage. */
10909 sec
= fix
->target_sec
;
10910 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10911 - (old_sec
->output_offset
+ old_offset
));
10918 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10920 asection
*input_section
,
10921 bfd_byte
*contents
,
10922 bfd_vma
*relocationp
)
10925 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10926 reloc_bfd_fix
*fix
;
10927 bfd_vma fixup_diff
;
10929 if (r_type
== R_XTENSA_NONE
)
10932 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10936 sec
= fix
->target_sec
;
10938 fixup_diff
= rel
->r_addend
;
10939 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10941 bfd_vma inplace_val
;
10942 BFD_ASSERT (fix
->src_offset
10943 < bfd_get_section_limit (input_bfd
, input_section
));
10944 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10945 fixup_diff
+= inplace_val
;
10948 *relocationp
= (sec
->output_section
->vma
10949 + sec
->output_offset
10950 + fix
->target_offset
- fixup_diff
);
10954 /* Miscellaneous utility functions.... */
10957 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10963 return elf_hash_table (info
)->splt
;
10965 dynobj
= elf_hash_table (info
)->dynobj
;
10966 sprintf (plt_name
, ".plt.%u", chunk
);
10967 return bfd_get_linker_section (dynobj
, plt_name
);
10972 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10978 return elf_hash_table (info
)->sgotplt
;
10980 dynobj
= elf_hash_table (info
)->dynobj
;
10981 sprintf (got_name
, ".got.plt.%u", chunk
);
10982 return bfd_get_linker_section (dynobj
, got_name
);
10986 /* Get the input section for a given symbol index.
10988 . a section symbol, return the section;
10989 . a common symbol, return the common section;
10990 . an undefined symbol, return the undefined section;
10991 . an indirect symbol, follow the links;
10992 . an absolute value, return the absolute section. */
10995 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
10997 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10998 asection
*target_sec
= NULL
;
10999 if (r_symndx
< symtab_hdr
->sh_info
)
11001 Elf_Internal_Sym
*isymbuf
;
11002 unsigned int section_index
;
11004 isymbuf
= retrieve_local_syms (abfd
);
11005 section_index
= isymbuf
[r_symndx
].st_shndx
;
11007 if (section_index
== SHN_UNDEF
)
11008 target_sec
= bfd_und_section_ptr
;
11009 else if (section_index
== SHN_ABS
)
11010 target_sec
= bfd_abs_section_ptr
;
11011 else if (section_index
== SHN_COMMON
)
11012 target_sec
= bfd_com_section_ptr
;
11014 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
11018 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11019 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
11021 while (h
->root
.type
== bfd_link_hash_indirect
11022 || h
->root
.type
== bfd_link_hash_warning
)
11023 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11025 switch (h
->root
.type
)
11027 case bfd_link_hash_defined
:
11028 case bfd_link_hash_defweak
:
11029 target_sec
= h
->root
.u
.def
.section
;
11031 case bfd_link_hash_common
:
11032 target_sec
= bfd_com_section_ptr
;
11034 case bfd_link_hash_undefined
:
11035 case bfd_link_hash_undefweak
:
11036 target_sec
= bfd_und_section_ptr
;
11038 default: /* New indirect warning. */
11039 target_sec
= bfd_und_section_ptr
;
11047 static struct elf_link_hash_entry
*
11048 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
11050 unsigned long indx
;
11051 struct elf_link_hash_entry
*h
;
11052 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11054 if (r_symndx
< symtab_hdr
->sh_info
)
11057 indx
= r_symndx
- symtab_hdr
->sh_info
;
11058 h
= elf_sym_hashes (abfd
)[indx
];
11059 while (h
->root
.type
== bfd_link_hash_indirect
11060 || h
->root
.type
== bfd_link_hash_warning
)
11061 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11066 /* Get the section-relative offset for a symbol number. */
11069 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
11071 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11072 bfd_vma offset
= 0;
11074 if (r_symndx
< symtab_hdr
->sh_info
)
11076 Elf_Internal_Sym
*isymbuf
;
11077 isymbuf
= retrieve_local_syms (abfd
);
11078 offset
= isymbuf
[r_symndx
].st_value
;
11082 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11083 struct elf_link_hash_entry
*h
=
11084 elf_sym_hashes (abfd
)[indx
];
11086 while (h
->root
.type
== bfd_link_hash_indirect
11087 || h
->root
.type
== bfd_link_hash_warning
)
11088 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11089 if (h
->root
.type
== bfd_link_hash_defined
11090 || h
->root
.type
== bfd_link_hash_defweak
)
11091 offset
= h
->root
.u
.def
.value
;
11098 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
11100 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
11101 struct elf_link_hash_entry
*h
;
11103 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
11104 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
11111 pcrel_reloc_fits (xtensa_opcode opc
,
11113 bfd_vma self_address
,
11114 bfd_vma dest_address
)
11116 xtensa_isa isa
= xtensa_default_isa
;
11117 uint32 valp
= dest_address
;
11118 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
11119 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
11126 xtensa_is_property_section (asection
*sec
)
11128 if (xtensa_is_insntable_section (sec
)
11129 || xtensa_is_littable_section (sec
)
11130 || xtensa_is_proptable_section (sec
))
11138 xtensa_is_insntable_section (asection
*sec
)
11140 if (CONST_STRNEQ (sec
->name
, XTENSA_INSN_SEC_NAME
)
11141 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.x."))
11149 xtensa_is_littable_section (asection
*sec
)
11151 if (CONST_STRNEQ (sec
->name
, XTENSA_LIT_SEC_NAME
)
11152 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.p."))
11160 xtensa_is_proptable_section (asection
*sec
)
11162 if (CONST_STRNEQ (sec
->name
, XTENSA_PROP_SEC_NAME
)
11163 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.prop."))
11171 internal_reloc_compare (const void *ap
, const void *bp
)
11173 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11174 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11176 if (a
->r_offset
!= b
->r_offset
)
11177 return (a
->r_offset
- b
->r_offset
);
11179 /* We don't need to sort on these criteria for correctness,
11180 but enforcing a more strict ordering prevents unstable qsort
11181 from behaving differently with different implementations.
11182 Without the code below we get correct but different results
11183 on Solaris 2.7 and 2.8. We would like to always produce the
11184 same results no matter the host. */
11186 if (a
->r_info
!= b
->r_info
)
11187 return (a
->r_info
- b
->r_info
);
11189 return (a
->r_addend
- b
->r_addend
);
11194 internal_reloc_matches (const void *ap
, const void *bp
)
11196 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11197 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11199 /* Check if one entry overlaps with the other; this shouldn't happen
11200 except when searching for a match. */
11201 return (a
->r_offset
- b
->r_offset
);
11205 /* Predicate function used to look up a section in a particular group. */
11208 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
11210 const char *gname
= inf
;
11211 const char *group_name
= elf_group_name (sec
);
11213 return (group_name
== gname
11214 || (group_name
!= NULL
11216 && strcmp (group_name
, gname
) == 0));
11221 xtensa_add_names (const char *base
, const char *suffix
)
11225 size_t base_len
= strlen (base
);
11226 size_t suffix_len
= strlen (suffix
);
11227 char *str
= bfd_malloc (base_len
+ suffix_len
+ 1);
11229 memcpy (str
, base
, base_len
);
11230 memcpy (str
+ base_len
, suffix
, suffix_len
+ 1);
11235 return strdup (base
);
11239 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11242 xtensa_property_section_name (asection
*sec
, const char *base_name
,
11243 bfd_boolean separate_sections
)
11245 const char *suffix
, *group_name
;
11246 char *prop_sec_name
;
11248 group_name
= elf_group_name (sec
);
11251 suffix
= strrchr (sec
->name
, '.');
11252 if (suffix
== sec
->name
)
11254 prop_sec_name
= xtensa_add_names (base_name
, suffix
);
11256 else if (strncmp (sec
->name
, ".gnu.linkonce.", linkonce_len
) == 0)
11258 char *linkonce_kind
= 0;
11260 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11261 linkonce_kind
= "x.";
11262 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11263 linkonce_kind
= "p.";
11264 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11265 linkonce_kind
= "prop.";
11269 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11270 + strlen (linkonce_kind
) + 1);
11271 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11272 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11274 suffix
= sec
->name
+ linkonce_len
;
11275 /* For backward compatibility, replace "t." instead of inserting
11276 the new linkonce_kind (but not for "prop" sections). */
11277 if (CONST_STRNEQ (suffix
, "t.") && linkonce_kind
[1] == '.')
11279 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11283 prop_sec_name
= xtensa_add_names (base_name
,
11284 separate_sections
? sec
->name
: NULL
);
11287 return prop_sec_name
;
11292 xtensa_get_separate_property_section (asection
*sec
, const char *base_name
,
11293 bfd_boolean separate_section
)
11295 char *prop_sec_name
;
11296 asection
*prop_sec
;
11298 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11300 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11301 match_section_group
,
11302 (void *) elf_group_name (sec
));
11303 free (prop_sec_name
);
11308 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11310 asection
*prop_sec
;
11312 /* Try individual property section first. */
11313 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, TRUE
);
11315 /* Refer to a common property section if individual is not present. */
11317 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, FALSE
);
11324 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11326 char *prop_sec_name
;
11327 asection
*prop_sec
;
11329 /* Check if the section already exists. */
11330 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11331 elf32xtensa_separate_props
);
11332 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11333 match_section_group
,
11334 (void *) elf_group_name (sec
));
11335 /* If not, create it. */
11338 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11339 flags
|= (bfd_section_flags (sec
)
11340 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11342 prop_sec
= bfd_make_section_anyway_with_flags
11343 (sec
->owner
, strdup (prop_sec_name
), flags
);
11347 elf_group_name (prop_sec
) = elf_group_name (sec
);
11350 free (prop_sec_name
);
11356 xtensa_get_property_predef_flags (asection
*sec
)
11358 if (xtensa_is_insntable_section (sec
))
11359 return (XTENSA_PROP_INSN
11360 | XTENSA_PROP_NO_TRANSFORM
11361 | XTENSA_PROP_INSN_NO_REORDER
);
11363 if (xtensa_is_littable_section (sec
))
11364 return (XTENSA_PROP_LITERAL
11365 | XTENSA_PROP_NO_TRANSFORM
11366 | XTENSA_PROP_INSN_NO_REORDER
);
11372 /* Other functions called directly by the linker. */
11375 xtensa_callback_required_dependence (bfd
*abfd
,
11377 struct bfd_link_info
*link_info
,
11378 deps_callback_t callback
,
11381 Elf_Internal_Rela
*internal_relocs
;
11382 bfd_byte
*contents
;
11384 bfd_boolean ok
= TRUE
;
11385 bfd_size_type sec_size
;
11387 sec_size
= bfd_get_section_limit (abfd
, sec
);
11389 /* ".plt*" sections have no explicit relocations but they contain L32R
11390 instructions that reference the corresponding ".got.plt*" sections. */
11391 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11392 && CONST_STRNEQ (sec
->name
, ".plt"))
11396 /* Find the corresponding ".got.plt*" section. */
11397 if (sec
->name
[4] == '\0')
11398 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11404 BFD_ASSERT (sec
->name
[4] == '.');
11405 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11407 sprintf (got_name
, ".got.plt.%u", chunk
);
11408 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11410 BFD_ASSERT (sgotplt
);
11412 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11413 section referencing a literal at the very beginning of
11414 ".got.plt". This is very close to the real dependence, anyway. */
11415 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11418 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11419 when building uclibc, which runs "ld -b binary /dev/null". */
11420 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11423 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11424 link_info
->keep_memory
);
11425 if (internal_relocs
== NULL
11426 || sec
->reloc_count
== 0)
11429 /* Cache the contents for the duration of this scan. */
11430 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11431 if (contents
== NULL
&& sec_size
!= 0)
11437 if (!xtensa_default_isa
)
11438 xtensa_default_isa
= xtensa_isa_init (0, 0);
11440 for (i
= 0; i
< sec
->reloc_count
; i
++)
11442 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11443 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11446 asection
*target_sec
;
11447 bfd_vma target_offset
;
11449 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11452 /* L32Rs must be local to the input file. */
11453 if (r_reloc_is_defined (&l32r_rel
))
11455 target_sec
= r_reloc_get_section (&l32r_rel
);
11456 target_offset
= l32r_rel
.target_offset
;
11458 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11464 release_internal_relocs (sec
, internal_relocs
);
11465 release_contents (sec
, contents
);
11469 /* The default literal sections should always be marked as "code" (i.e.,
11470 SHF_EXECINSTR). This is particularly important for the Linux kernel
11471 module loader so that the literals are not placed after the text. */
11472 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11474 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11475 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11476 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11477 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11478 { NULL
, 0, 0, 0, 0 }
11481 #define ELF_TARGET_ID XTENSA_ELF_DATA
11483 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11484 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11485 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11486 #define TARGET_BIG_NAME "elf32-xtensa-be"
11487 #define ELF_ARCH bfd_arch_xtensa
11489 #define ELF_MACHINE_CODE EM_XTENSA
11490 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11492 #define ELF_MAXPAGESIZE 0x1000
11493 #endif /* ELF_ARCH */
11495 #define elf_backend_can_gc_sections 1
11496 #define elf_backend_can_refcount 1
11497 #define elf_backend_plt_readonly 1
11498 #define elf_backend_got_header_size 4
11499 #define elf_backend_want_dynbss 0
11500 #define elf_backend_want_got_plt 1
11501 #define elf_backend_dtrel_excludes_plt 1
11503 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11505 #define bfd_elf32_mkobject elf_xtensa_mkobject
11507 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11508 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11509 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11510 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11511 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11512 #define bfd_elf32_bfd_reloc_name_lookup \
11513 elf_xtensa_reloc_name_lookup
11514 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11515 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11517 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11518 #define elf_backend_check_relocs elf_xtensa_check_relocs
11519 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11520 #define elf_backend_discard_info elf_xtensa_discard_info
11521 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11522 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11523 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11524 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11525 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11526 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11527 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11528 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11529 #define elf_backend_object_p elf_xtensa_object_p
11530 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11531 #define elf_backend_relocate_section elf_xtensa_relocate_section
11532 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11533 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11534 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11535 #define elf_backend_special_sections elf_xtensa_special_sections
11536 #define elf_backend_action_discarded elf_xtensa_action_discarded
11537 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11539 #include "elf32-target.h"