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
->tlsbase
= elf_xtensa_hash_entry (tlsbase
);
770 ret
->tlsbase
->tls_type
= GOT_UNKNOWN
;
772 return &ret
->elf
.root
;
775 /* Copy the extra info we tack onto an elf_link_hash_entry. */
778 elf_xtensa_copy_indirect_symbol (struct bfd_link_info
*info
,
779 struct elf_link_hash_entry
*dir
,
780 struct elf_link_hash_entry
*ind
)
782 struct elf_xtensa_link_hash_entry
*edir
, *eind
;
784 edir
= elf_xtensa_hash_entry (dir
);
785 eind
= elf_xtensa_hash_entry (ind
);
787 if (ind
->root
.type
== bfd_link_hash_indirect
)
789 edir
->tlsfunc_refcount
+= eind
->tlsfunc_refcount
;
790 eind
->tlsfunc_refcount
= 0;
792 if (dir
->got
.refcount
<= 0)
794 edir
->tls_type
= eind
->tls_type
;
795 eind
->tls_type
= GOT_UNKNOWN
;
799 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
802 static inline bfd_boolean
803 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
804 struct bfd_link_info
*info
)
806 /* Check if we should do dynamic things to this symbol. The
807 "ignore_protected" argument need not be set, because Xtensa code
808 does not require special handling of STV_PROTECTED to make function
809 pointer comparisons work properly. The PLT addresses are never
810 used for function pointers. */
812 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
817 property_table_compare (const void *ap
, const void *bp
)
819 const property_table_entry
*a
= (const property_table_entry
*) ap
;
820 const property_table_entry
*b
= (const property_table_entry
*) bp
;
822 if (a
->address
== b
->address
)
824 if (a
->size
!= b
->size
)
825 return (a
->size
- b
->size
);
827 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
828 return ((b
->flags
& XTENSA_PROP_ALIGN
)
829 - (a
->flags
& XTENSA_PROP_ALIGN
));
831 if ((a
->flags
& XTENSA_PROP_ALIGN
)
832 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
833 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
834 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
835 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
837 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
838 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
839 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
840 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
842 return (a
->flags
- b
->flags
);
845 return (a
->address
- b
->address
);
850 property_table_matches (const void *ap
, const void *bp
)
852 const property_table_entry
*a
= (const property_table_entry
*) ap
;
853 const property_table_entry
*b
= (const property_table_entry
*) bp
;
855 /* Check if one entry overlaps with the other. */
856 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
857 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
860 return (a
->address
- b
->address
);
864 /* Get the literal table or property table entries for the given
865 section. Sets TABLE_P and returns the number of entries. On
866 error, returns a negative value. */
869 xtensa_read_table_entries (bfd
*abfd
,
871 property_table_entry
**table_p
,
872 const char *sec_name
,
873 bfd_boolean output_addr
)
875 asection
*table_section
;
876 bfd_size_type table_size
= 0;
877 bfd_byte
*table_data
;
878 property_table_entry
*blocks
;
879 int blk
, block_count
;
880 bfd_size_type num_records
;
881 Elf_Internal_Rela
*internal_relocs
, *irel
, *rel_end
;
882 bfd_vma section_addr
, off
;
883 flagword predef_flags
;
884 bfd_size_type table_entry_size
, section_limit
;
887 || !(section
->flags
& SEC_ALLOC
)
888 || (section
->flags
& SEC_DEBUGGING
))
894 table_section
= xtensa_get_property_section (section
, sec_name
);
896 table_size
= table_section
->size
;
904 predef_flags
= xtensa_get_property_predef_flags (table_section
);
905 table_entry_size
= 12;
907 table_entry_size
-= 4;
909 num_records
= table_size
/ table_entry_size
;
910 table_data
= retrieve_contents (abfd
, table_section
, TRUE
);
911 blocks
= (property_table_entry
*)
912 bfd_malloc (num_records
* sizeof (property_table_entry
));
916 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
918 section_addr
= section
->vma
;
920 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, TRUE
);
921 if (internal_relocs
&& !table_section
->reloc_done
)
923 qsort (internal_relocs
, table_section
->reloc_count
,
924 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
925 irel
= internal_relocs
;
930 section_limit
= bfd_get_section_limit (abfd
, section
);
931 rel_end
= internal_relocs
+ table_section
->reloc_count
;
933 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
935 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
937 /* Skip any relocations before the current offset. This should help
938 avoid confusion caused by unexpected relocations for the preceding
941 (irel
->r_offset
< off
942 || (irel
->r_offset
== off
943 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
950 if (irel
&& irel
->r_offset
== off
)
953 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
954 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
956 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
959 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
960 BFD_ASSERT (sym_off
== 0);
961 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
965 if (address
< section_addr
966 || address
>= section_addr
+ section_limit
)
970 blocks
[block_count
].address
= address
;
971 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
973 blocks
[block_count
].flags
= predef_flags
;
975 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
979 release_contents (table_section
, table_data
);
980 release_internal_relocs (table_section
, internal_relocs
);
984 /* Now sort them into address order for easy reference. */
985 qsort (blocks
, block_count
, sizeof (property_table_entry
),
986 property_table_compare
);
988 /* Check that the table contents are valid. Problems may occur,
989 for example, if an unrelocated object file is stripped. */
990 for (blk
= 1; blk
< block_count
; blk
++)
992 /* The only circumstance where two entries may legitimately
993 have the same address is when one of them is a zero-size
994 placeholder to mark a place where fill can be inserted.
995 The zero-size entry should come first. */
996 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
997 blocks
[blk
- 1].size
!= 0)
999 /* xgettext:c-format */
1000 _bfd_error_handler (_("%pB(%pA): invalid property table"),
1002 bfd_set_error (bfd_error_bad_value
);
1014 static property_table_entry
*
1015 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
1016 int property_table_size
,
1019 property_table_entry entry
;
1020 property_table_entry
*rv
;
1022 if (property_table_size
== 0)
1025 entry
.address
= addr
;
1029 rv
= bsearch (&entry
, property_table
, property_table_size
,
1030 sizeof (property_table_entry
), property_table_matches
);
1036 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
1040 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
1047 /* Look through the relocs for a section during the first phase, and
1048 calculate needed space in the dynamic reloc sections. */
1051 elf_xtensa_check_relocs (bfd
*abfd
,
1052 struct bfd_link_info
*info
,
1054 const Elf_Internal_Rela
*relocs
)
1056 struct elf_xtensa_link_hash_table
*htab
;
1057 Elf_Internal_Shdr
*symtab_hdr
;
1058 struct elf_link_hash_entry
**sym_hashes
;
1059 const Elf_Internal_Rela
*rel
;
1060 const Elf_Internal_Rela
*rel_end
;
1062 if (bfd_link_relocatable (info
))
1065 BFD_ASSERT (is_xtensa_elf (abfd
));
1067 htab
= elf_xtensa_hash_table (info
);
1071 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1072 sym_hashes
= elf_sym_hashes (abfd
);
1074 rel_end
= relocs
+ sec
->reloc_count
;
1075 for (rel
= relocs
; rel
< rel_end
; rel
++)
1077 unsigned int r_type
;
1079 struct elf_link_hash_entry
*h
= NULL
;
1080 struct elf_xtensa_link_hash_entry
*eh
;
1081 int tls_type
, old_tls_type
;
1082 bfd_boolean is_got
= FALSE
;
1083 bfd_boolean is_plt
= FALSE
;
1084 bfd_boolean is_tlsfunc
= FALSE
;
1086 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1087 r_type
= ELF32_R_TYPE (rel
->r_info
);
1089 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1091 /* xgettext:c-format */
1092 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1097 if (r_symndx
>= symtab_hdr
->sh_info
)
1099 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1100 while (h
->root
.type
== bfd_link_hash_indirect
1101 || h
->root
.type
== bfd_link_hash_warning
)
1102 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1104 eh
= elf_xtensa_hash_entry (h
);
1108 case R_XTENSA_TLSDESC_FN
:
1109 if (bfd_link_pic (info
))
1111 tls_type
= GOT_TLS_GD
;
1116 tls_type
= GOT_TLS_IE
;
1119 case R_XTENSA_TLSDESC_ARG
:
1120 if (bfd_link_pic (info
))
1122 tls_type
= GOT_TLS_GD
;
1127 tls_type
= GOT_TLS_IE
;
1128 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1133 case R_XTENSA_TLS_DTPOFF
:
1134 if (bfd_link_pic (info
))
1135 tls_type
= GOT_TLS_GD
;
1137 tls_type
= GOT_TLS_IE
;
1140 case R_XTENSA_TLS_TPOFF
:
1141 tls_type
= GOT_TLS_IE
;
1142 if (bfd_link_pic (info
))
1143 info
->flags
|= DF_STATIC_TLS
;
1144 if (bfd_link_pic (info
) || h
)
1149 tls_type
= GOT_NORMAL
;
1154 tls_type
= GOT_NORMAL
;
1158 case R_XTENSA_GNU_VTINHERIT
:
1159 /* This relocation describes the C++ object vtable hierarchy.
1160 Reconstruct it for later use during GC. */
1161 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1165 case R_XTENSA_GNU_VTENTRY
:
1166 /* This relocation describes which C++ vtable entries are actually
1167 used. Record for later use during GC. */
1168 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1173 /* Nothing to do for any other relocations. */
1181 if (h
->plt
.refcount
<= 0)
1184 h
->plt
.refcount
= 1;
1187 h
->plt
.refcount
+= 1;
1189 /* Keep track of the total PLT relocation count even if we
1190 don't yet know whether the dynamic sections will be
1192 htab
->plt_reloc_count
+= 1;
1194 if (elf_hash_table (info
)->dynamic_sections_created
)
1196 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1202 if (h
->got
.refcount
<= 0)
1203 h
->got
.refcount
= 1;
1205 h
->got
.refcount
+= 1;
1209 eh
->tlsfunc_refcount
+= 1;
1211 old_tls_type
= eh
->tls_type
;
1215 /* Allocate storage the first time. */
1216 if (elf_local_got_refcounts (abfd
) == NULL
)
1218 bfd_size_type size
= symtab_hdr
->sh_info
;
1221 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1224 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1226 mem
= bfd_zalloc (abfd
, size
);
1229 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1231 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1234 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1235 = (bfd_signed_vma
*) mem
;
1238 /* This is a global offset table entry for a local symbol. */
1239 if (is_got
|| is_plt
)
1240 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1243 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1245 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1248 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1249 tls_type
|= old_tls_type
;
1250 /* If a TLS symbol is accessed using IE at least once,
1251 there is no point to use a dynamic model for it. */
1252 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1253 && ((old_tls_type
& GOT_TLS_GD
) == 0
1254 || (tls_type
& GOT_TLS_IE
) == 0))
1256 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1257 tls_type
= old_tls_type
;
1258 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1259 tls_type
|= old_tls_type
;
1263 /* xgettext:c-format */
1264 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1266 h
? h
->root
.root
.string
: "<local>");
1271 if (old_tls_type
!= tls_type
)
1274 eh
->tls_type
= tls_type
;
1276 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1285 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1286 struct elf_link_hash_entry
*h
)
1288 if (bfd_link_pic (info
))
1290 if (h
->plt
.refcount
> 0)
1292 /* For shared objects, there's no need for PLT entries for local
1293 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1294 if (h
->got
.refcount
< 0)
1295 h
->got
.refcount
= 0;
1296 h
->got
.refcount
+= h
->plt
.refcount
;
1297 h
->plt
.refcount
= 0;
1302 /* Don't need any dynamic relocations at all. */
1303 h
->plt
.refcount
= 0;
1304 h
->got
.refcount
= 0;
1310 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1311 struct elf_link_hash_entry
*h
,
1312 bfd_boolean force_local
)
1314 /* For a shared link, move the plt refcount to the got refcount to leave
1315 space for RELATIVE relocs. */
1316 elf_xtensa_make_sym_local (info
, h
);
1318 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1322 /* Return the section that should be marked against GC for a given
1326 elf_xtensa_gc_mark_hook (asection
*sec
,
1327 struct bfd_link_info
*info
,
1328 Elf_Internal_Rela
*rel
,
1329 struct elf_link_hash_entry
*h
,
1330 Elf_Internal_Sym
*sym
)
1332 /* Property sections are marked "KEEP" in the linker scripts, but they
1333 should not cause other sections to be marked. (This approach relies
1334 on elf_xtensa_discard_info to remove property table entries that
1335 describe discarded sections. Alternatively, it might be more
1336 efficient to avoid using "KEEP" in the linker scripts and instead use
1337 the gc_mark_extra_sections hook to mark only the property sections
1338 that describe marked sections. That alternative does not work well
1339 with the current property table sections, which do not correspond
1340 one-to-one with the sections they describe, but that should be fixed
1342 if (xtensa_is_property_section (sec
))
1346 switch (ELF32_R_TYPE (rel
->r_info
))
1348 case R_XTENSA_GNU_VTINHERIT
:
1349 case R_XTENSA_GNU_VTENTRY
:
1353 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1357 /* Create all the dynamic sections. */
1360 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1362 struct elf_xtensa_link_hash_table
*htab
;
1363 flagword flags
, noalloc_flags
;
1365 htab
= elf_xtensa_hash_table (info
);
1369 /* First do all the standard stuff. */
1370 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1373 /* Create any extra PLT sections in case check_relocs has already
1374 been called on all the non-dynamic input files. */
1375 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1378 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1379 | SEC_LINKER_CREATED
| SEC_READONLY
);
1380 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1382 /* Mark the ".got.plt" section READONLY. */
1383 if (htab
->elf
.sgotplt
== NULL
1384 || !bfd_set_section_flags (htab
->elf
.sgotplt
, flags
))
1387 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1388 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1390 if (htab
->sgotloc
== NULL
1391 || !bfd_set_section_alignment (htab
->sgotloc
, 2))
1394 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1395 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1397 if (htab
->spltlittbl
== NULL
1398 || !bfd_set_section_alignment (htab
->spltlittbl
, 2))
1406 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1408 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1411 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1412 ".got.plt" sections. */
1413 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1419 /* Stop when we find a section has already been created. */
1420 if (elf_xtensa_get_plt_section (info
, chunk
))
1423 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1424 | SEC_LINKER_CREATED
| SEC_READONLY
);
1426 sname
= (char *) bfd_malloc (10);
1427 sprintf (sname
, ".plt.%u", chunk
);
1428 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1430 || !bfd_set_section_alignment (s
, 2))
1433 sname
= (char *) bfd_malloc (14);
1434 sprintf (sname
, ".got.plt.%u", chunk
);
1435 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1437 || !bfd_set_section_alignment (s
, 2))
1445 /* Adjust a symbol defined by a dynamic object and referenced by a
1446 regular object. The current definition is in some section of the
1447 dynamic object, but we're not including those sections. We have to
1448 change the definition to something the rest of the link can
1452 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1453 struct elf_link_hash_entry
*h
)
1455 /* If this is a weak symbol, and there is a real definition, the
1456 processor independent code will have arranged for us to see the
1457 real definition first, and we can just use the same value. */
1458 if (h
->is_weakalias
)
1460 struct elf_link_hash_entry
*def
= weakdef (h
);
1461 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1462 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1463 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1467 /* This is a reference to a symbol defined by a dynamic object. The
1468 reference must go through the GOT, so there's no need for COPY relocs,
1476 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1478 struct bfd_link_info
*info
;
1479 struct elf_xtensa_link_hash_table
*htab
;
1480 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1482 if (h
->root
.type
== bfd_link_hash_indirect
)
1485 info
= (struct bfd_link_info
*) arg
;
1486 htab
= elf_xtensa_hash_table (info
);
1490 /* If we saw any use of an IE model for this symbol, we can then optimize
1491 away GOT entries for any TLSDESC_FN relocs. */
1492 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1494 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1495 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1498 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1499 elf_xtensa_make_sym_local (info
, h
);
1501 if (! elf_xtensa_dynamic_symbol_p (h
, info
)
1502 && h
->root
.type
== bfd_link_hash_undefweak
)
1505 if (h
->plt
.refcount
> 0)
1506 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1508 if (h
->got
.refcount
> 0)
1509 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1516 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1518 struct elf_xtensa_link_hash_table
*htab
;
1521 htab
= elf_xtensa_hash_table (info
);
1525 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1527 bfd_signed_vma
*local_got_refcounts
;
1528 bfd_size_type j
, cnt
;
1529 Elf_Internal_Shdr
*symtab_hdr
;
1531 local_got_refcounts
= elf_local_got_refcounts (i
);
1532 if (!local_got_refcounts
)
1535 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1536 cnt
= symtab_hdr
->sh_info
;
1538 for (j
= 0; j
< cnt
; ++j
)
1540 /* If we saw any use of an IE model for this symbol, we can
1541 then optimize away GOT entries for any TLSDESC_FN relocs. */
1542 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1544 bfd_signed_vma
*tlsfunc_refcount
1545 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1546 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1547 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1550 if (local_got_refcounts
[j
] > 0)
1551 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1552 * sizeof (Elf32_External_Rela
));
1558 /* Set the sizes of the dynamic sections. */
1561 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1562 struct bfd_link_info
*info
)
1564 struct elf_xtensa_link_hash_table
*htab
;
1566 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1567 bfd_boolean relplt
, relgot
;
1568 int plt_entries
, plt_chunks
, chunk
;
1573 htab
= elf_xtensa_hash_table (info
);
1577 dynobj
= elf_hash_table (info
)->dynobj
;
1580 srelgot
= htab
->elf
.srelgot
;
1581 srelplt
= htab
->elf
.srelplt
;
1583 if (elf_hash_table (info
)->dynamic_sections_created
)
1585 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1586 && htab
->elf
.srelplt
!= NULL
1587 && htab
->elf
.sgot
!= NULL
1588 && htab
->spltlittbl
!= NULL
1589 && htab
->sgotloc
!= NULL
);
1591 /* Set the contents of the .interp section to the interpreter. */
1592 if (bfd_link_executable (info
) && !info
->nointerp
)
1594 s
= bfd_get_linker_section (dynobj
, ".interp");
1597 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1598 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1601 /* Allocate room for one word in ".got". */
1602 htab
->elf
.sgot
->size
= 4;
1604 /* Allocate space in ".rela.got" for literals that reference global
1605 symbols and space in ".rela.plt" for literals that have PLT
1607 elf_link_hash_traverse (elf_hash_table (info
),
1608 elf_xtensa_allocate_dynrelocs
,
1611 /* If we are generating a shared object, we also need space in
1612 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1613 reference local symbols. */
1614 if (bfd_link_pic (info
))
1615 elf_xtensa_allocate_local_got_size (info
);
1617 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1618 each PLT entry, we need the PLT code plus a 4-byte literal.
1619 For each chunk of ".plt", we also need two more 4-byte
1620 literals, two corresponding entries in ".rela.got", and an
1621 8-byte entry in ".xt.lit.plt". */
1622 spltlittbl
= htab
->spltlittbl
;
1623 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1625 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1627 /* Iterate over all the PLT chunks, including any extra sections
1628 created earlier because the initial count of PLT relocations
1629 was an overestimate. */
1631 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1636 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1637 BFD_ASSERT (sgotplt
!= NULL
);
1639 if (chunk
< plt_chunks
- 1)
1640 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1641 else if (chunk
== plt_chunks
- 1)
1642 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1646 if (chunk_entries
!= 0)
1648 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1649 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1650 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1651 spltlittbl
->size
+= 8;
1660 /* Allocate space in ".got.loc" to match the total size of all the
1662 sgotloc
= htab
->sgotloc
;
1663 sgotloc
->size
= spltlittbl
->size
;
1664 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1666 if (abfd
->flags
& DYNAMIC
)
1668 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1670 if (! discarded_section (s
)
1671 && xtensa_is_littable_section (s
)
1673 sgotloc
->size
+= s
->size
;
1678 /* Allocate memory for dynamic sections. */
1681 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1685 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1688 /* It's OK to base decisions on the section name, because none
1689 of the dynobj section names depend upon the input files. */
1690 name
= bfd_section_name (s
);
1692 if (CONST_STRNEQ (name
, ".rela"))
1696 if (strcmp (name
, ".rela.plt") == 0)
1698 else if (strcmp (name
, ".rela.got") == 0)
1701 /* We use the reloc_count field as a counter if we need
1702 to copy relocs into the output file. */
1706 else if (! CONST_STRNEQ (name
, ".plt.")
1707 && ! CONST_STRNEQ (name
, ".got.plt.")
1708 && strcmp (name
, ".got") != 0
1709 && strcmp (name
, ".plt") != 0
1710 && strcmp (name
, ".got.plt") != 0
1711 && strcmp (name
, ".xt.lit.plt") != 0
1712 && strcmp (name
, ".got.loc") != 0)
1714 /* It's not one of our sections, so don't allocate space. */
1720 /* If we don't need this section, strip it from the output
1721 file. We must create the ".plt*" and ".got.plt*"
1722 sections in create_dynamic_sections and/or check_relocs
1723 based on a conservative estimate of the PLT relocation
1724 count, because the sections must be created before the
1725 linker maps input sections to output sections. The
1726 linker does that before size_dynamic_sections, where we
1727 compute the exact size of the PLT, so there may be more
1728 of these sections than are actually needed. */
1729 s
->flags
|= SEC_EXCLUDE
;
1731 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1733 /* Allocate memory for the section contents. */
1734 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1735 if (s
->contents
== NULL
)
1740 if (elf_hash_table (info
)->dynamic_sections_created
)
1742 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1743 known until finish_dynamic_sections, but we need to get the relocs
1744 in place before they are sorted. */
1745 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1747 Elf_Internal_Rela irela
;
1751 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1754 loc
= (srelgot
->contents
1755 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1756 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1757 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1758 loc
+ sizeof (Elf32_External_Rela
));
1759 srelgot
->reloc_count
+= 2;
1762 /* Add some entries to the .dynamic section. We fill in the
1763 values later, in elf_xtensa_finish_dynamic_sections, but we
1764 must add the entries now so that we get the correct size for
1765 the .dynamic section. The DT_DEBUG entry is filled in by the
1766 dynamic linker and used by the debugger. */
1767 #define add_dynamic_entry(TAG, VAL) \
1768 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1770 if (bfd_link_executable (info
))
1772 if (!add_dynamic_entry (DT_DEBUG
, 0))
1778 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1779 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1780 || !add_dynamic_entry (DT_JMPREL
, 0))
1786 if (!add_dynamic_entry (DT_RELA
, 0)
1787 || !add_dynamic_entry (DT_RELASZ
, 0)
1788 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1792 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1793 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1794 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1797 #undef add_dynamic_entry
1803 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1804 struct bfd_link_info
*info
)
1806 struct elf_xtensa_link_hash_table
*htab
;
1809 htab
= elf_xtensa_hash_table (info
);
1813 tls_sec
= htab
->elf
.tls_sec
;
1815 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1817 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1818 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1819 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1821 tlsbase
->type
= STT_TLS
;
1822 if (!(_bfd_generic_link_add_one_symbol
1823 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1824 tls_sec
, 0, NULL
, FALSE
,
1825 bed
->collect
, &bh
)))
1827 tlsbase
->def_regular
= 1;
1828 tlsbase
->other
= STV_HIDDEN
;
1829 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1836 /* Return the base VMA address which should be subtracted from real addresses
1837 when resolving @dtpoff relocation.
1838 This is PT_TLS segment p_vaddr. */
1841 dtpoff_base (struct bfd_link_info
*info
)
1843 /* If tls_sec is NULL, we should have signalled an error already. */
1844 if (elf_hash_table (info
)->tls_sec
== NULL
)
1846 return elf_hash_table (info
)->tls_sec
->vma
;
1849 /* Return the relocation value for @tpoff relocation
1850 if STT_TLS virtual address is ADDRESS. */
1853 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1855 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1858 /* If tls_sec is NULL, we should have signalled an error already. */
1859 if (htab
->tls_sec
== NULL
)
1861 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1862 return address
- htab
->tls_sec
->vma
+ base
;
1865 /* Perform the specified relocation. The instruction at (contents + address)
1866 is modified to set one operand to represent the value in "relocation". The
1867 operand position is determined by the relocation type recorded in the
1870 #define CALL_SEGMENT_BITS (30)
1871 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1873 static bfd_reloc_status_type
1874 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1876 asection
*input_section
,
1880 bfd_boolean is_weak_undef
,
1881 char **error_message
)
1884 xtensa_opcode opcode
;
1885 xtensa_isa isa
= xtensa_default_isa
;
1886 static xtensa_insnbuf ibuff
= NULL
;
1887 static xtensa_insnbuf sbuff
= NULL
;
1888 bfd_vma self_address
;
1889 bfd_size_type input_size
;
1895 ibuff
= xtensa_insnbuf_alloc (isa
);
1896 sbuff
= xtensa_insnbuf_alloc (isa
);
1899 input_size
= bfd_get_section_limit (abfd
, input_section
);
1901 /* Calculate the PC address for this instruction. */
1902 self_address
= (input_section
->output_section
->vma
1903 + input_section
->output_offset
1906 switch (howto
->type
)
1909 case R_XTENSA_DIFF8
:
1910 case R_XTENSA_DIFF16
:
1911 case R_XTENSA_DIFF32
:
1912 case R_XTENSA_PDIFF8
:
1913 case R_XTENSA_PDIFF16
:
1914 case R_XTENSA_PDIFF32
:
1915 case R_XTENSA_NDIFF8
:
1916 case R_XTENSA_NDIFF16
:
1917 case R_XTENSA_NDIFF32
:
1918 case R_XTENSA_TLS_FUNC
:
1919 case R_XTENSA_TLS_ARG
:
1920 case R_XTENSA_TLS_CALL
:
1921 return bfd_reloc_ok
;
1923 case R_XTENSA_ASM_EXPAND
:
1926 /* Check for windowed CALL across a 1GB boundary. */
1927 opcode
= get_expanded_call_opcode (contents
+ address
,
1928 input_size
- address
, 0);
1929 if (is_windowed_call_opcode (opcode
))
1931 if ((self_address
>> CALL_SEGMENT_BITS
)
1932 != (relocation
>> CALL_SEGMENT_BITS
))
1934 *error_message
= "windowed longcall crosses 1GB boundary; "
1936 return bfd_reloc_dangerous
;
1940 return bfd_reloc_ok
;
1942 case R_XTENSA_ASM_SIMPLIFY
:
1944 /* Convert the L32R/CALLX to CALL. */
1945 bfd_reloc_status_type retval
=
1946 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1948 if (retval
!= bfd_reloc_ok
)
1949 return bfd_reloc_dangerous
;
1951 /* The CALL needs to be relocated. Continue below for that part. */
1954 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1961 x
= bfd_get_32 (abfd
, contents
+ address
);
1963 bfd_put_32 (abfd
, x
, contents
+ address
);
1965 return bfd_reloc_ok
;
1967 case R_XTENSA_32_PCREL
:
1968 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1969 return bfd_reloc_ok
;
1972 case R_XTENSA_TLSDESC_FN
:
1973 case R_XTENSA_TLSDESC_ARG
:
1974 case R_XTENSA_TLS_DTPOFF
:
1975 case R_XTENSA_TLS_TPOFF
:
1976 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1977 return bfd_reloc_ok
;
1980 /* Only instruction slot-specific relocations handled below.... */
1981 slot
= get_relocation_slot (howto
->type
);
1982 if (slot
== XTENSA_UNDEFINED
)
1984 *error_message
= "unexpected relocation";
1985 return bfd_reloc_dangerous
;
1988 /* Read the instruction into a buffer and decode the opcode. */
1989 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1990 input_size
- address
);
1991 fmt
= xtensa_format_decode (isa
, ibuff
);
1992 if (fmt
== XTENSA_UNDEFINED
)
1994 *error_message
= "cannot decode instruction format";
1995 return bfd_reloc_dangerous
;
1998 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2000 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
2001 if (opcode
== XTENSA_UNDEFINED
)
2003 *error_message
= "cannot decode instruction opcode";
2004 return bfd_reloc_dangerous
;
2007 /* Check for opcode-specific "alternate" relocations. */
2008 if (is_alt_relocation (howto
->type
))
2010 if (opcode
== get_l32r_opcode ())
2012 /* Handle the special-case of non-PC-relative L32R instructions. */
2013 bfd
*output_bfd
= input_section
->output_section
->owner
;
2014 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
2017 *error_message
= "relocation references missing .lit4 section";
2018 return bfd_reloc_dangerous
;
2020 self_address
= ((lit4_sec
->vma
& ~0xfff)
2021 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2022 newval
= relocation
;
2025 else if (opcode
== get_const16_opcode ())
2027 /* ALT used for high 16 bits.
2028 Ignore 32-bit overflow. */
2029 newval
= (relocation
>> 16) & 0xffff;
2034 /* No other "alternate" relocations currently defined. */
2035 *error_message
= "unexpected relocation";
2036 return bfd_reloc_dangerous
;
2039 else /* Not an "alternate" relocation.... */
2041 if (opcode
== get_const16_opcode ())
2043 newval
= relocation
& 0xffff;
2048 /* ...normal PC-relative relocation.... */
2050 /* Determine which operand is being relocated. */
2051 opnd
= get_relocation_opnd (opcode
, howto
->type
);
2052 if (opnd
== XTENSA_UNDEFINED
)
2054 *error_message
= "unexpected relocation";
2055 return bfd_reloc_dangerous
;
2058 if (!howto
->pc_relative
)
2060 *error_message
= "expected PC-relative relocation";
2061 return bfd_reloc_dangerous
;
2064 newval
= relocation
;
2068 /* Apply the relocation. */
2069 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
2070 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
2071 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2074 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2077 msg
= "cannot encode";
2078 if (is_direct_call_opcode (opcode
))
2080 if ((relocation
& 0x3) != 0)
2081 msg
= "misaligned call target";
2083 msg
= "call target out of range";
2085 else if (opcode
== get_l32r_opcode ())
2087 if ((relocation
& 0x3) != 0)
2088 msg
= "misaligned literal target";
2089 else if (is_alt_relocation (howto
->type
))
2090 msg
= "literal target out of range (too many literals)";
2091 else if (self_address
> relocation
)
2092 msg
= "literal target out of range (try using text-section-literals)";
2094 msg
= "literal placed after use";
2097 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2098 return bfd_reloc_dangerous
;
2101 /* Check for calls across 1GB boundaries. */
2102 if (is_direct_call_opcode (opcode
)
2103 && is_windowed_call_opcode (opcode
))
2105 if ((self_address
>> CALL_SEGMENT_BITS
)
2106 != (relocation
>> CALL_SEGMENT_BITS
))
2109 "windowed call crosses 1GB boundary; return may fail";
2110 return bfd_reloc_dangerous
;
2114 /* Write the modified instruction back out of the buffer. */
2115 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2116 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2117 input_size
- address
);
2118 return bfd_reloc_ok
;
2123 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2125 /* To reduce the size of the memory leak,
2126 we only use a single message buffer. */
2127 static bfd_size_type alloc_size
= 0;
2128 static char *message
= NULL
;
2129 bfd_size_type orig_len
, len
= 0;
2130 bfd_boolean is_append
;
2133 va_start (ap
, arglen
);
2135 is_append
= (origmsg
== message
);
2137 orig_len
= strlen (origmsg
);
2138 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2139 if (len
> alloc_size
)
2141 message
= (char *) bfd_realloc_or_free (message
, len
);
2144 if (message
!= NULL
)
2147 memcpy (message
, origmsg
, orig_len
);
2148 vsprintf (message
+ orig_len
, fmt
, ap
);
2155 /* This function is registered as the "special_function" in the
2156 Xtensa howto for handling simplify operations.
2157 bfd_perform_relocation / bfd_install_relocation use it to
2158 perform (install) the specified relocation. Since this replaces the code
2159 in bfd_perform_relocation, it is basically an Xtensa-specific,
2160 stripped-down version of bfd_perform_relocation. */
2162 static bfd_reloc_status_type
2163 bfd_elf_xtensa_reloc (bfd
*abfd
,
2164 arelent
*reloc_entry
,
2167 asection
*input_section
,
2169 char **error_message
)
2172 bfd_reloc_status_type flag
;
2173 bfd_size_type octets
= (reloc_entry
->address
2174 * OCTETS_PER_BYTE (abfd
, input_section
));
2175 bfd_vma output_base
= 0;
2176 reloc_howto_type
*howto
= reloc_entry
->howto
;
2177 asection
*reloc_target_output_section
;
2178 bfd_boolean is_weak_undef
;
2180 if (!xtensa_default_isa
)
2181 xtensa_default_isa
= xtensa_isa_init (0, 0);
2183 /* ELF relocs are against symbols. If we are producing relocatable
2184 output, and the reloc is against an external symbol, the resulting
2185 reloc will also be against the same symbol. In such a case, we
2186 don't want to change anything about the way the reloc is handled,
2187 since it will all be done at final link time. This test is similar
2188 to what bfd_elf_generic_reloc does except that it lets relocs with
2189 howto->partial_inplace go through even if the addend is non-zero.
2190 (The real problem is that partial_inplace is set for XTENSA_32
2191 relocs to begin with, but that's a long story and there's little we
2192 can do about it now....) */
2194 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2196 reloc_entry
->address
+= input_section
->output_offset
;
2197 return bfd_reloc_ok
;
2200 /* Is the address of the relocation really within the section? */
2201 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2202 return bfd_reloc_outofrange
;
2204 /* Work out which section the relocation is targeted at and the
2205 initial relocation command value. */
2207 /* Get symbol value. (Common symbols are special.) */
2208 if (bfd_is_com_section (symbol
->section
))
2211 relocation
= symbol
->value
;
2213 reloc_target_output_section
= symbol
->section
->output_section
;
2215 /* Convert input-section-relative symbol value to absolute. */
2216 if ((output_bfd
&& !howto
->partial_inplace
)
2217 || reloc_target_output_section
== NULL
)
2220 output_base
= reloc_target_output_section
->vma
;
2222 relocation
+= output_base
+ symbol
->section
->output_offset
;
2224 /* Add in supplied addend. */
2225 relocation
+= reloc_entry
->addend
;
2227 /* Here the variable relocation holds the final address of the
2228 symbol we are relocating against, plus any addend. */
2231 if (!howto
->partial_inplace
)
2233 /* This is a partial relocation, and we want to apply the relocation
2234 to the reloc entry rather than the raw data. Everything except
2235 relocations against section symbols has already been handled
2238 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2239 reloc_entry
->addend
= relocation
;
2240 reloc_entry
->address
+= input_section
->output_offset
;
2241 return bfd_reloc_ok
;
2245 reloc_entry
->address
+= input_section
->output_offset
;
2246 reloc_entry
->addend
= 0;
2250 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2251 && (symbol
->flags
& BSF_WEAK
) != 0);
2252 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2253 (bfd_byte
*) data
, (bfd_vma
) octets
,
2254 is_weak_undef
, error_message
);
2256 if (flag
== bfd_reloc_dangerous
)
2258 /* Add the symbol name to the error message. */
2259 if (! *error_message
)
2260 *error_message
= "";
2261 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2262 strlen (symbol
->name
) + 17,
2264 (unsigned long) reloc_entry
->addend
);
2270 int xtensa_abi_choice (void)
2272 if (elf32xtensa_abi
== XTHAL_ABI_UNDEFINED
)
2275 return elf32xtensa_abi
;
2278 /* Set up an entry in the procedure linkage table. */
2281 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2283 unsigned reloc_index
)
2285 asection
*splt
, *sgotplt
;
2286 bfd_vma plt_base
, got_base
;
2287 bfd_vma code_offset
, lit_offset
, abi_offset
;
2289 int abi
= xtensa_abi_choice ();
2291 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2292 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2293 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2294 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2296 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2297 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2299 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2300 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2302 /* Fill in the literal entry. This is the offset of the dynamic
2303 relocation entry. */
2304 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2305 sgotplt
->contents
+ lit_offset
);
2307 /* Fill in the entry in the procedure linkage table. */
2308 memcpy (splt
->contents
+ code_offset
,
2309 (bfd_big_endian (output_bfd
)
2310 ? elf_xtensa_be_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]
2311 : elf_xtensa_le_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]),
2313 abi_offset
= abi
== XTHAL_ABI_WINDOWED
? 3 : 0;
2314 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2315 plt_base
+ code_offset
+ abi_offset
),
2316 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2317 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2318 plt_base
+ code_offset
+ abi_offset
+ 3),
2319 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2320 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2321 plt_base
+ code_offset
+ abi_offset
+ 6),
2322 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2324 return plt_base
+ code_offset
;
2328 static bfd_boolean
get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2331 replace_tls_insn (Elf_Internal_Rela
*rel
,
2333 asection
*input_section
,
2335 bfd_boolean is_ld_model
,
2336 char **error_message
)
2338 static xtensa_insnbuf ibuff
= NULL
;
2339 static xtensa_insnbuf sbuff
= NULL
;
2340 xtensa_isa isa
= xtensa_default_isa
;
2342 xtensa_opcode old_op
, new_op
;
2343 bfd_size_type input_size
;
2345 unsigned dest_reg
, src_reg
;
2349 ibuff
= xtensa_insnbuf_alloc (isa
);
2350 sbuff
= xtensa_insnbuf_alloc (isa
);
2353 input_size
= bfd_get_section_limit (abfd
, input_section
);
2355 /* Read the instruction into a buffer and decode the opcode. */
2356 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2357 input_size
- rel
->r_offset
);
2358 fmt
= xtensa_format_decode (isa
, ibuff
);
2359 if (fmt
== XTENSA_UNDEFINED
)
2361 *error_message
= "cannot decode instruction format";
2365 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2366 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2368 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2369 if (old_op
== XTENSA_UNDEFINED
)
2371 *error_message
= "cannot decode instruction opcode";
2375 r_type
= ELF32_R_TYPE (rel
->r_info
);
2378 case R_XTENSA_TLS_FUNC
:
2379 case R_XTENSA_TLS_ARG
:
2380 if (old_op
!= get_l32r_opcode ()
2381 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2382 sbuff
, &dest_reg
) != 0)
2384 *error_message
= "cannot extract L32R destination for TLS access";
2389 case R_XTENSA_TLS_CALL
:
2390 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2391 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2392 sbuff
, &src_reg
) != 0)
2394 *error_message
= "cannot extract CALLXn operands for TLS access";
2407 case R_XTENSA_TLS_FUNC
:
2408 case R_XTENSA_TLS_ARG
:
2409 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2410 versions of Xtensa). */
2411 new_op
= xtensa_opcode_lookup (isa
, "nop");
2412 if (new_op
== XTENSA_UNDEFINED
)
2414 new_op
= xtensa_opcode_lookup (isa
, "or");
2415 if (new_op
== XTENSA_UNDEFINED
2416 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2417 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2419 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2421 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2424 *error_message
= "cannot encode OR for TLS access";
2430 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2432 *error_message
= "cannot encode NOP for TLS access";
2438 case R_XTENSA_TLS_CALL
:
2439 /* Read THREADPTR into the CALLX's return value register. */
2440 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2441 if (new_op
== XTENSA_UNDEFINED
2442 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2443 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2444 sbuff
, dest_reg
+ 2) != 0)
2446 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2456 case R_XTENSA_TLS_FUNC
:
2457 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2458 if (new_op
== XTENSA_UNDEFINED
2459 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2460 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2461 sbuff
, dest_reg
) != 0)
2463 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2468 case R_XTENSA_TLS_ARG
:
2469 /* Nothing to do. Keep the original L32R instruction. */
2472 case R_XTENSA_TLS_CALL
:
2473 /* Add the CALLX's src register (holding the THREADPTR value)
2474 to the first argument register (holding the offset) and put
2475 the result in the CALLX's return value register. */
2476 new_op
= xtensa_opcode_lookup (isa
, "add");
2477 if (new_op
== XTENSA_UNDEFINED
2478 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2479 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2480 sbuff
, dest_reg
+ 2) != 0
2481 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2482 sbuff
, dest_reg
+ 2) != 0
2483 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2484 sbuff
, src_reg
) != 0)
2486 *error_message
= "cannot encode ADD for TLS access";
2493 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2494 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2495 input_size
- rel
->r_offset
);
2501 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2502 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2503 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2504 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2505 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2506 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2507 || (R_TYPE) == R_XTENSA_TLS_ARG \
2508 || (R_TYPE) == R_XTENSA_TLS_CALL)
2510 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2511 both relocatable and final links. */
2514 elf_xtensa_relocate_section (bfd
*output_bfd
,
2515 struct bfd_link_info
*info
,
2517 asection
*input_section
,
2519 Elf_Internal_Rela
*relocs
,
2520 Elf_Internal_Sym
*local_syms
,
2521 asection
**local_sections
)
2523 struct elf_xtensa_link_hash_table
*htab
;
2524 Elf_Internal_Shdr
*symtab_hdr
;
2525 Elf_Internal_Rela
*rel
;
2526 Elf_Internal_Rela
*relend
;
2527 struct elf_link_hash_entry
**sym_hashes
;
2528 property_table_entry
*lit_table
= 0;
2530 char *local_got_tls_types
;
2531 char *error_message
= NULL
;
2532 bfd_size_type input_size
;
2535 if (!xtensa_default_isa
)
2536 xtensa_default_isa
= xtensa_isa_init (0, 0);
2538 if (!is_xtensa_elf (input_bfd
))
2540 bfd_set_error (bfd_error_wrong_format
);
2544 htab
= elf_xtensa_hash_table (info
);
2548 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2549 sym_hashes
= elf_sym_hashes (input_bfd
);
2550 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2552 if (elf_hash_table (info
)->dynamic_sections_created
)
2554 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2555 &lit_table
, XTENSA_LIT_SEC_NAME
,
2561 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2564 relend
= relocs
+ input_section
->reloc_count
;
2565 for (; rel
< relend
; rel
++)
2568 reloc_howto_type
*howto
;
2569 unsigned long r_symndx
;
2570 struct elf_link_hash_entry
*h
;
2571 Elf_Internal_Sym
*sym
;
2576 bfd_reloc_status_type r
;
2577 bfd_boolean is_weak_undef
;
2578 bfd_boolean unresolved_reloc
;
2580 bfd_boolean dynamic_symbol
;
2582 r_type
= ELF32_R_TYPE (rel
->r_info
);
2583 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2584 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2587 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2589 bfd_set_error (bfd_error_bad_value
);
2592 howto
= &elf_howto_table
[r_type
];
2594 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2599 is_weak_undef
= FALSE
;
2600 unresolved_reloc
= FALSE
;
2603 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2605 /* Because R_XTENSA_32 was made partial_inplace to fix some
2606 problems with DWARF info in partial links, there may be
2607 an addend stored in the contents. Take it out of there
2608 and move it back into the addend field of the reloc. */
2609 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2610 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2613 if (r_symndx
< symtab_hdr
->sh_info
)
2615 sym
= local_syms
+ r_symndx
;
2616 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2617 sec
= local_sections
[r_symndx
];
2618 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2622 bfd_boolean ignored
;
2624 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2625 r_symndx
, symtab_hdr
, sym_hashes
,
2627 unresolved_reloc
, warned
, ignored
);
2630 && !unresolved_reloc
2631 && h
->root
.type
== bfd_link_hash_undefweak
)
2632 is_weak_undef
= TRUE
;
2637 if (sec
!= NULL
&& discarded_section (sec
))
2638 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2639 rel
, 1, relend
, howto
, 0, contents
);
2641 if (bfd_link_relocatable (info
))
2644 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2646 /* This is a relocatable link.
2647 1) If the reloc is against a section symbol, adjust
2648 according to the output section.
2649 2) If there is a new target for this relocation,
2650 the new target will be in the same output section.
2651 We adjust the relocation by the output section
2654 if (relaxing_section
)
2656 /* Check if this references a section in another input file. */
2657 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2662 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2663 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2665 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2667 error_message
= NULL
;
2668 /* Convert ASM_SIMPLIFY into the simpler relocation
2669 so that they never escape a relaxing link. */
2670 r
= contract_asm_expansion (contents
, input_size
, rel
,
2672 if (r
!= bfd_reloc_ok
)
2673 (*info
->callbacks
->reloc_dangerous
)
2674 (info
, error_message
,
2675 input_bfd
, input_section
, rel
->r_offset
);
2677 r_type
= ELF32_R_TYPE (rel
->r_info
);
2680 /* This is a relocatable link, so we don't have to change
2681 anything unless the reloc is against a section symbol,
2682 in which case we have to adjust according to where the
2683 section symbol winds up in the output section. */
2684 if (r_symndx
< symtab_hdr
->sh_info
)
2686 sym
= local_syms
+ r_symndx
;
2687 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2689 sec
= local_sections
[r_symndx
];
2690 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2694 /* If there is an addend with a partial_inplace howto,
2695 then move the addend to the contents. This is a hack
2696 to work around problems with DWARF in relocatable links
2697 with some previous version of BFD. Now we can't easily get
2698 rid of the hack without breaking backward compatibility.... */
2700 howto
= &elf_howto_table
[r_type
];
2701 if (howto
->partial_inplace
&& rel
->r_addend
)
2703 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2704 rel
->r_addend
, contents
,
2705 rel
->r_offset
, FALSE
,
2711 /* Put the correct bits in the target instruction, even
2712 though the relocation will still be present in the output
2713 file. This makes disassembly clearer, as well as
2714 allowing loadable kernel modules to work without needing
2715 relocations on anything other than calls and l32r's. */
2717 /* If it is not in the same section, there is nothing we can do. */
2718 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2719 sym_sec
->output_section
== input_section
->output_section
)
2721 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2722 dest_addr
, contents
,
2723 rel
->r_offset
, FALSE
,
2727 if (r
!= bfd_reloc_ok
)
2728 (*info
->callbacks
->reloc_dangerous
)
2729 (info
, error_message
,
2730 input_bfd
, input_section
, rel
->r_offset
);
2732 /* Done with work for relocatable link; continue with next reloc. */
2736 /* This is a final link. */
2738 if (relaxing_section
)
2740 /* Check if this references a section in another input file. */
2741 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2745 /* Sanity check the address. */
2746 if (rel
->r_offset
>= input_size
2747 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2750 /* xgettext:c-format */
2751 (_("%pB(%pA+%#" PRIx64
"): "
2752 "relocation offset out of range (size=%#" PRIx64
")"),
2753 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2754 (uint64_t) input_size
);
2755 bfd_set_error (bfd_error_bad_value
);
2760 name
= h
->root
.root
.string
;
2763 name
= (bfd_elf_string_from_elf_section
2764 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2765 if (name
== NULL
|| *name
== '\0')
2766 name
= bfd_section_name (sec
);
2769 if (r_symndx
!= STN_UNDEF
2770 && r_type
!= R_XTENSA_NONE
2772 || h
->root
.type
== bfd_link_hash_defined
2773 || h
->root
.type
== bfd_link_hash_defweak
)
2774 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2777 ((sym_type
== STT_TLS
2778 /* xgettext:c-format */
2779 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2780 /* xgettext:c-format */
2781 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2784 (uint64_t) rel
->r_offset
,
2789 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2791 tls_type
= GOT_UNKNOWN
;
2793 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2794 else if (local_got_tls_types
)
2795 tls_type
= local_got_tls_types
[r_symndx
];
2801 if (elf_hash_table (info
)->dynamic_sections_created
2802 && (input_section
->flags
& SEC_ALLOC
) != 0
2803 && (dynamic_symbol
|| bfd_link_pic (info
)))
2805 Elf_Internal_Rela outrel
;
2809 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2810 srel
= htab
->elf
.srelplt
;
2812 srel
= htab
->elf
.srelgot
;
2814 BFD_ASSERT (srel
!= NULL
);
2817 _bfd_elf_section_offset (output_bfd
, info
,
2818 input_section
, rel
->r_offset
);
2820 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2821 memset (&outrel
, 0, sizeof outrel
);
2824 outrel
.r_offset
+= (input_section
->output_section
->vma
2825 + input_section
->output_offset
);
2827 /* Complain if the relocation is in a read-only section
2828 and not in a literal pool. */
2829 if ((input_section
->flags
& SEC_READONLY
) != 0
2830 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2834 _("dynamic relocation in read-only section");
2835 (*info
->callbacks
->reloc_dangerous
)
2836 (info
, error_message
,
2837 input_bfd
, input_section
, rel
->r_offset
);
2842 outrel
.r_addend
= rel
->r_addend
;
2845 if (r_type
== R_XTENSA_32
)
2848 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2851 else /* r_type == R_XTENSA_PLT */
2854 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2856 /* Create the PLT entry and set the initial
2857 contents of the literal entry to the address of
2860 elf_xtensa_create_plt_entry (info
, output_bfd
,
2863 unresolved_reloc
= FALSE
;
2865 else if (!is_weak_undef
)
2867 /* Generate a RELATIVE relocation. */
2868 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2869 outrel
.r_addend
= 0;
2877 loc
= (srel
->contents
2878 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2879 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2880 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2883 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2885 /* This should only happen for non-PIC code, which is not
2886 supposed to be used on systems with dynamic linking.
2887 Just ignore these relocations. */
2892 case R_XTENSA_TLS_TPOFF
:
2893 /* Switch to LE model for local symbols in an executable. */
2894 if (! bfd_link_pic (info
) && ! dynamic_symbol
)
2896 relocation
= tpoff (info
, relocation
);
2901 case R_XTENSA_TLSDESC_FN
:
2902 case R_XTENSA_TLSDESC_ARG
:
2904 if (r_type
== R_XTENSA_TLSDESC_FN
)
2906 if (! bfd_link_pic (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2907 r_type
= R_XTENSA_NONE
;
2909 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2911 if (bfd_link_pic (info
))
2913 if ((tls_type
& GOT_TLS_IE
) != 0)
2914 r_type
= R_XTENSA_TLS_TPOFF
;
2918 r_type
= R_XTENSA_TLS_TPOFF
;
2919 if (! dynamic_symbol
)
2921 relocation
= tpoff (info
, relocation
);
2927 if (r_type
== R_XTENSA_NONE
)
2928 /* Nothing to do here; skip to the next reloc. */
2931 if (! elf_hash_table (info
)->dynamic_sections_created
)
2934 _("TLS relocation invalid without dynamic sections");
2935 (*info
->callbacks
->reloc_dangerous
)
2936 (info
, error_message
,
2937 input_bfd
, input_section
, rel
->r_offset
);
2941 Elf_Internal_Rela outrel
;
2943 asection
*srel
= htab
->elf
.srelgot
;
2946 outrel
.r_offset
= (input_section
->output_section
->vma
2947 + input_section
->output_offset
2950 /* Complain if the relocation is in a read-only section
2951 and not in a literal pool. */
2952 if ((input_section
->flags
& SEC_READONLY
) != 0
2953 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2957 _("dynamic relocation in read-only section");
2958 (*info
->callbacks
->reloc_dangerous
)
2959 (info
, error_message
,
2960 input_bfd
, input_section
, rel
->r_offset
);
2963 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2965 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2967 outrel
.r_addend
= 0;
2970 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2972 unresolved_reloc
= FALSE
;
2975 loc
= (srel
->contents
2976 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2977 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2978 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2984 case R_XTENSA_TLS_DTPOFF
:
2985 if (! bfd_link_pic (info
))
2986 /* Switch from LD model to LE model. */
2987 relocation
= tpoff (info
, relocation
);
2989 relocation
-= dtpoff_base (info
);
2992 case R_XTENSA_TLS_FUNC
:
2993 case R_XTENSA_TLS_ARG
:
2994 case R_XTENSA_TLS_CALL
:
2995 /* Check if optimizing to IE or LE model. */
2996 if ((tls_type
& GOT_TLS_IE
) != 0)
2998 bfd_boolean is_ld_model
=
2999 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
3000 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
3001 is_ld_model
, &error_message
))
3002 (*info
->callbacks
->reloc_dangerous
)
3003 (info
, error_message
,
3004 input_bfd
, input_section
, rel
->r_offset
);
3006 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
3008 /* Skip subsequent relocations on the same instruction. */
3009 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
3016 if (elf_hash_table (info
)->dynamic_sections_created
3017 && dynamic_symbol
&& (is_operand_relocation (r_type
)
3018 || r_type
== R_XTENSA_32_PCREL
))
3021 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3022 strlen (name
) + 2, name
);
3023 (*info
->callbacks
->reloc_dangerous
)
3024 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3030 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3031 because such sections are not SEC_ALLOC and thus ld.so will
3032 not process them. */
3033 if (unresolved_reloc
3034 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3036 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3037 rel
->r_offset
) != (bfd_vma
) -1)
3040 /* xgettext:c-format */
3041 (_("%pB(%pA+%#" PRIx64
"): "
3042 "unresolvable %s relocation against symbol `%s'"),
3045 (uint64_t) rel
->r_offset
,
3051 /* TLS optimizations may have changed r_type; update "howto". */
3052 howto
= &elf_howto_table
[r_type
];
3054 /* There's no point in calling bfd_perform_relocation here.
3055 Just go directly to our "special function". */
3056 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
3057 relocation
+ rel
->r_addend
,
3058 contents
, rel
->r_offset
, is_weak_undef
,
3061 if (r
!= bfd_reloc_ok
&& !warned
)
3063 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
3064 BFD_ASSERT (error_message
!= NULL
);
3066 if (rel
->r_addend
== 0)
3067 error_message
= vsprint_msg (error_message
, ": %s",
3068 strlen (name
) + 2, name
);
3070 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
3072 name
, (int) rel
->r_addend
);
3074 (*info
->callbacks
->reloc_dangerous
)
3075 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3080 input_section
->reloc_done
= TRUE
;
3086 /* Finish up dynamic symbol handling. There's not much to do here since
3087 the PLT and GOT entries are all set up by relocate_section. */
3090 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3091 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3092 struct elf_link_hash_entry
*h
,
3093 Elf_Internal_Sym
*sym
)
3095 if (h
->needs_plt
&& !h
->def_regular
)
3097 /* Mark the symbol as undefined, rather than as defined in
3098 the .plt section. Leave the value alone. */
3099 sym
->st_shndx
= SHN_UNDEF
;
3100 /* If the symbol is weak, we do need to clear the value.
3101 Otherwise, the PLT entry would provide a definition for
3102 the symbol even if the symbol wasn't defined anywhere,
3103 and so the symbol would never be NULL. */
3104 if (!h
->ref_regular_nonweak
)
3108 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3109 if (h
== elf_hash_table (info
)->hdynamic
3110 || h
== elf_hash_table (info
)->hgot
)
3111 sym
->st_shndx
= SHN_ABS
;
3117 /* Combine adjacent literal table entries in the output. Adjacent
3118 entries within each input section may have been removed during
3119 relaxation, but we repeat the process here, even though it's too late
3120 to shrink the output section, because it's important to minimize the
3121 number of literal table entries to reduce the start-up work for the
3122 runtime linker. Returns the number of remaining table entries or -1
3126 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3131 property_table_entry
*table
;
3132 bfd_size_type section_size
, sgotloc_size
;
3136 section_size
= sxtlit
->size
;
3137 BFD_ASSERT (section_size
% 8 == 0);
3138 num
= section_size
/ 8;
3140 sgotloc_size
= sgotloc
->size
;
3141 if (sgotloc_size
!= section_size
)
3144 (_("internal inconsistency in size of .got.loc section"));
3148 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3152 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3153 propagates to the output section, where it doesn't really apply and
3154 where it breaks the following call to bfd_malloc_and_get_section. */
3155 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3157 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3164 /* There should never be any relocations left at this point, so this
3165 is quite a bit easier than what is done during relaxation. */
3167 /* Copy the raw contents into a property table array and sort it. */
3169 for (n
= 0; n
< num
; n
++)
3171 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3172 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3175 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3177 for (n
= 0; n
< num
; n
++)
3179 bfd_boolean remove_entry
= FALSE
;
3181 if (table
[n
].size
== 0)
3182 remove_entry
= TRUE
;
3184 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3186 table
[n
-1].size
+= table
[n
].size
;
3187 remove_entry
= TRUE
;
3192 for (m
= n
; m
< num
- 1; m
++)
3194 table
[m
].address
= table
[m
+1].address
;
3195 table
[m
].size
= table
[m
+1].size
;
3203 /* Copy the data back to the raw contents. */
3205 for (n
= 0; n
< num
; n
++)
3207 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3208 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3212 /* Clear the removed bytes. */
3213 if ((bfd_size_type
) (num
* 8) < section_size
)
3214 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3216 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3220 /* Copy the contents to ".got.loc". */
3221 memcpy (sgotloc
->contents
, contents
, section_size
);
3229 /* Finish up the dynamic sections. */
3232 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3233 struct bfd_link_info
*info
)
3235 struct elf_xtensa_link_hash_table
*htab
;
3237 asection
*sdyn
, *srelplt
, *srelgot
, *sgot
, *sxtlit
, *sgotloc
;
3238 Elf32_External_Dyn
*dyncon
, *dynconend
;
3239 int num_xtlit_entries
= 0;
3241 if (! elf_hash_table (info
)->dynamic_sections_created
)
3244 htab
= elf_xtensa_hash_table (info
);
3248 dynobj
= elf_hash_table (info
)->dynobj
;
3249 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3250 BFD_ASSERT (sdyn
!= NULL
);
3252 /* Set the first entry in the global offset table to the address of
3253 the dynamic section. */
3254 sgot
= htab
->elf
.sgot
;
3257 BFD_ASSERT (sgot
->size
== 4);
3259 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3261 bfd_put_32 (output_bfd
,
3262 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3266 srelplt
= htab
->elf
.srelplt
;
3267 srelgot
= htab
->elf
.srelgot
;
3268 if (srelplt
&& srelplt
->size
!= 0)
3270 asection
*sgotplt
, *spltlittbl
;
3271 int chunk
, plt_chunks
, plt_entries
;
3272 Elf_Internal_Rela irela
;
3274 unsigned rtld_reloc
;
3276 spltlittbl
= htab
->spltlittbl
;
3277 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3279 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3280 of them follow immediately after.... */
3281 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3283 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3284 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3285 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3288 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3290 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3292 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3294 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3296 int chunk_entries
= 0;
3298 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3299 BFD_ASSERT (sgotplt
!= NULL
);
3301 /* Emit special RTLD relocations for the first two entries in
3302 each chunk of the .got.plt section. */
3304 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3305 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3306 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3307 irela
.r_offset
= (sgotplt
->output_section
->vma
3308 + sgotplt
->output_offset
);
3309 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3310 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3312 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3314 /* Next literal immediately follows the first. */
3315 loc
+= sizeof (Elf32_External_Rela
);
3316 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3317 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3318 irela
.r_offset
= (sgotplt
->output_section
->vma
3319 + sgotplt
->output_offset
+ 4);
3320 /* Tell rtld to set value to object's link map. */
3322 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3324 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3326 /* Fill in the literal table. */
3327 if (chunk
< plt_chunks
- 1)
3328 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3330 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3332 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3333 bfd_put_32 (output_bfd
,
3334 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3335 spltlittbl
->contents
+ (chunk
* 8) + 0);
3336 bfd_put_32 (output_bfd
,
3337 8 + (chunk_entries
* 4),
3338 spltlittbl
->contents
+ (chunk
* 8) + 4);
3341 /* The .xt.lit.plt section has just been modified. This must
3342 happen before the code below which combines adjacent literal
3343 table entries, and the .xt.lit.plt contents have to be forced to
3345 if (! bfd_set_section_contents (output_bfd
,
3346 spltlittbl
->output_section
,
3347 spltlittbl
->contents
,
3348 spltlittbl
->output_offset
,
3351 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3352 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3355 /* All the dynamic relocations have been emitted at this point.
3356 Make sure the relocation sections are the correct size. */
3357 if ((srelgot
&& srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3358 * srelgot
->reloc_count
))
3359 || (srelplt
&& srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3360 * srelplt
->reloc_count
)))
3363 /* Combine adjacent literal table entries. */
3364 BFD_ASSERT (! bfd_link_relocatable (info
));
3365 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3366 sgotloc
= htab
->sgotloc
;
3367 BFD_ASSERT (sgotloc
);
3371 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3372 if (num_xtlit_entries
< 0)
3376 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3377 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3378 for (; dyncon
< dynconend
; dyncon
++)
3380 Elf_Internal_Dyn dyn
;
3382 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3389 case DT_XTENSA_GOT_LOC_SZ
:
3390 dyn
.d_un
.d_val
= num_xtlit_entries
;
3393 case DT_XTENSA_GOT_LOC_OFF
:
3394 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3395 + htab
->sgotloc
->output_offset
);
3399 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3400 + htab
->elf
.sgot
->output_offset
);
3404 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3405 + htab
->elf
.srelplt
->output_offset
);
3409 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3413 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3420 /* Functions for dealing with the e_flags field. */
3422 /* Merge backend specific data from an object file to the output
3423 object file when linking. */
3426 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3428 bfd
*obfd
= info
->output_bfd
;
3429 unsigned out_mach
, in_mach
;
3430 flagword out_flag
, in_flag
;
3432 /* Check if we have the same endianness. */
3433 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3436 /* Don't even pretend to support mixed-format linking. */
3437 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3438 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3441 out_flag
= elf_elfheader (obfd
)->e_flags
;
3442 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3444 out_mach
= out_flag
& EF_XTENSA_MACH
;
3445 in_mach
= in_flag
& EF_XTENSA_MACH
;
3446 if (out_mach
!= in_mach
)
3449 /* xgettext:c-format */
3450 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3451 ibfd
, out_mach
, in_mach
);
3452 bfd_set_error (bfd_error_wrong_format
);
3456 if (! elf_flags_init (obfd
))
3458 elf_flags_init (obfd
) = TRUE
;
3459 elf_elfheader (obfd
)->e_flags
= in_flag
;
3461 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3462 && bfd_get_arch_info (obfd
)->the_default
)
3463 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3464 bfd_get_mach (ibfd
));
3469 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3470 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3472 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3473 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3480 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3482 BFD_ASSERT (!elf_flags_init (abfd
)
3483 || elf_elfheader (abfd
)->e_flags
== flags
);
3485 elf_elfheader (abfd
)->e_flags
|= flags
;
3486 elf_flags_init (abfd
) = TRUE
;
3493 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3495 FILE *f
= (FILE *) farg
;
3496 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3498 fprintf (f
, "\nXtensa header:\n");
3499 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3500 fprintf (f
, "\nMachine = Base\n");
3502 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3504 fprintf (f
, "Insn tables = %s\n",
3505 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3507 fprintf (f
, "Literal tables = %s\n",
3508 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3510 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3514 /* Set the right machine number for an Xtensa ELF file. */
3517 elf_xtensa_object_p (bfd
*abfd
)
3520 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3525 mach
= bfd_mach_xtensa
;
3531 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3536 /* The final processing done just before writing out an Xtensa ELF object
3537 file. This gets the Xtensa architecture right based on the machine
3541 elf_xtensa_final_write_processing (bfd
*abfd
)
3544 unsigned long val
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3546 switch (mach
= bfd_get_mach (abfd
))
3548 case bfd_mach_xtensa
:
3549 val
= E_XTENSA_MACH
;
3555 elf_elfheader (abfd
)->e_flags
&= ~EF_XTENSA_MACH
;
3556 elf_elfheader (abfd
)->e_flags
|= val
;
3557 return _bfd_elf_final_write_processing (abfd
);
3561 static enum elf_reloc_type_class
3562 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3563 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3564 const Elf_Internal_Rela
*rela
)
3566 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3568 case R_XTENSA_RELATIVE
:
3569 return reloc_class_relative
;
3570 case R_XTENSA_JMP_SLOT
:
3571 return reloc_class_plt
;
3573 return reloc_class_normal
;
3579 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3580 struct elf_reloc_cookie
*cookie
,
3581 struct bfd_link_info
*info
,
3585 bfd_vma offset
, actual_offset
;
3586 bfd_size_type removed_bytes
= 0;
3587 bfd_size_type entry_size
;
3589 if (sec
->output_section
3590 && bfd_is_abs_section (sec
->output_section
))
3593 if (xtensa_is_proptable_section (sec
))
3598 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3601 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3605 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3608 release_contents (sec
, contents
);
3612 /* Sort the relocations. They should already be in order when
3613 relaxation is enabled, but it might not be. */
3614 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3615 internal_reloc_compare
);
3617 cookie
->rel
= cookie
->rels
;
3618 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3620 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3622 actual_offset
= offset
- removed_bytes
;
3624 /* The ...symbol_deleted_p function will skip over relocs but it
3625 won't adjust their offsets, so do that here. */
3626 while (cookie
->rel
< cookie
->relend
3627 && cookie
->rel
->r_offset
< offset
)
3629 cookie
->rel
->r_offset
-= removed_bytes
;
3633 while (cookie
->rel
< cookie
->relend
3634 && cookie
->rel
->r_offset
== offset
)
3636 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3638 /* Remove the table entry. (If the reloc type is NONE, then
3639 the entry has already been merged with another and deleted
3640 during relaxation.) */
3641 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3643 /* Shift the contents up. */
3644 if (offset
+ entry_size
< sec
->size
)
3645 memmove (&contents
[actual_offset
],
3646 &contents
[actual_offset
+ entry_size
],
3647 sec
->size
- offset
- entry_size
);
3648 removed_bytes
+= entry_size
;
3651 /* Remove this relocation. */
3652 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3655 /* Adjust the relocation offset for previous removals. This
3656 should not be done before calling ...symbol_deleted_p
3657 because it might mess up the offset comparisons there.
3658 Make sure the offset doesn't underflow in the case where
3659 the first entry is removed. */
3660 if (cookie
->rel
->r_offset
>= removed_bytes
)
3661 cookie
->rel
->r_offset
-= removed_bytes
;
3663 cookie
->rel
->r_offset
= 0;
3669 if (removed_bytes
!= 0)
3671 /* Adjust any remaining relocs (shouldn't be any). */
3672 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3674 if (cookie
->rel
->r_offset
>= removed_bytes
)
3675 cookie
->rel
->r_offset
-= removed_bytes
;
3677 cookie
->rel
->r_offset
= 0;
3680 /* Clear the removed bytes. */
3681 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3683 pin_contents (sec
, contents
);
3684 pin_internal_relocs (sec
, cookie
->rels
);
3687 if (sec
->rawsize
== 0)
3688 sec
->rawsize
= sec
->size
;
3689 sec
->size
-= removed_bytes
;
3691 if (xtensa_is_littable_section (sec
))
3693 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3695 sgotloc
->size
-= removed_bytes
;
3700 release_contents (sec
, contents
);
3701 release_internal_relocs (sec
, cookie
->rels
);
3704 return (removed_bytes
!= 0);
3709 elf_xtensa_discard_info (bfd
*abfd
,
3710 struct elf_reloc_cookie
*cookie
,
3711 struct bfd_link_info
*info
)
3714 bfd_boolean changed
= FALSE
;
3716 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3718 if (xtensa_is_property_section (sec
))
3720 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3730 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3732 return xtensa_is_property_section (sec
);
3737 elf_xtensa_action_discarded (asection
*sec
)
3739 if (strcmp (".xt_except_table", sec
->name
) == 0)
3742 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3745 return _bfd_elf_default_action_discarded (sec
);
3749 /* Support for core dump NOTE sections. */
3752 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3757 /* The size for Xtensa is variable, so don't try to recognize the format
3758 based on the size. Just assume this is GNU/Linux. */
3761 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3764 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3768 size
= note
->descsz
- offset
- 4;
3770 /* Make a ".reg/999" section. */
3771 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3772 size
, note
->descpos
+ offset
);
3777 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3779 switch (note
->descsz
)
3784 case 128: /* GNU/Linux elf_prpsinfo */
3785 elf_tdata (abfd
)->core
->program
3786 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3787 elf_tdata (abfd
)->core
->command
3788 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3791 /* Note that for some reason, a spurious space is tacked
3792 onto the end of the args in some (at least one anyway)
3793 implementations, so strip it off if it exists. */
3796 char *command
= elf_tdata (abfd
)->core
->command
;
3797 int n
= strlen (command
);
3799 if (0 < n
&& command
[n
- 1] == ' ')
3800 command
[n
- 1] = '\0';
3807 /* Generic Xtensa configurability stuff. */
3809 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3810 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3811 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3812 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3813 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3814 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3815 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3816 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3819 init_call_opcodes (void)
3821 if (callx0_op
== XTENSA_UNDEFINED
)
3823 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3824 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3825 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3826 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3827 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3828 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3829 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3830 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3836 is_indirect_call_opcode (xtensa_opcode opcode
)
3838 init_call_opcodes ();
3839 return (opcode
== callx0_op
3840 || opcode
== callx4_op
3841 || opcode
== callx8_op
3842 || opcode
== callx12_op
);
3847 is_direct_call_opcode (xtensa_opcode opcode
)
3849 init_call_opcodes ();
3850 return (opcode
== call0_op
3851 || opcode
== call4_op
3852 || opcode
== call8_op
3853 || opcode
== call12_op
);
3858 is_windowed_call_opcode (xtensa_opcode opcode
)
3860 init_call_opcodes ();
3861 return (opcode
== call4_op
3862 || opcode
== call8_op
3863 || opcode
== call12_op
3864 || opcode
== callx4_op
3865 || opcode
== callx8_op
3866 || opcode
== callx12_op
);
3871 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3873 unsigned dst
= (unsigned) -1;
3875 init_call_opcodes ();
3876 if (opcode
== callx0_op
)
3878 else if (opcode
== callx4_op
)
3880 else if (opcode
== callx8_op
)
3882 else if (opcode
== callx12_op
)
3885 if (dst
== (unsigned) -1)
3893 static xtensa_opcode
3894 get_const16_opcode (void)
3896 static bfd_boolean done_lookup
= FALSE
;
3897 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3900 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3903 return const16_opcode
;
3907 static xtensa_opcode
3908 get_l32r_opcode (void)
3910 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3911 static bfd_boolean done_lookup
= FALSE
;
3915 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3923 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3927 offset
= addr
- ((pc
+3) & -4);
3928 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3929 offset
= (signed int) offset
>> 2;
3930 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3935 static xtensa_opcode
3936 get_rsr_lend_opcode (void)
3938 static xtensa_opcode rsr_lend_opcode
= XTENSA_UNDEFINED
;
3939 static bfd_boolean done_lookup
= FALSE
;
3942 rsr_lend_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "rsr.lend");
3945 return rsr_lend_opcode
;
3948 static xtensa_opcode
3949 get_wsr_lbeg_opcode (void)
3951 static xtensa_opcode wsr_lbeg_opcode
= XTENSA_UNDEFINED
;
3952 static bfd_boolean done_lookup
= FALSE
;
3955 wsr_lbeg_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "wsr.lbeg");
3958 return wsr_lbeg_opcode
;
3963 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3965 xtensa_isa isa
= xtensa_default_isa
;
3966 int last_immed
, last_opnd
, opi
;
3968 if (opcode
== XTENSA_UNDEFINED
)
3969 return XTENSA_UNDEFINED
;
3971 /* Find the last visible PC-relative immediate operand for the opcode.
3972 If there are no PC-relative immediates, then choose the last visible
3973 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3974 last_immed
= XTENSA_UNDEFINED
;
3975 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3976 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3978 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3980 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3985 if (last_immed
== XTENSA_UNDEFINED
3986 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3990 return XTENSA_UNDEFINED
;
3992 /* If the operand number was specified in an old-style relocation,
3993 check for consistency with the operand computed above. */
3994 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3996 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3997 if (reloc_opnd
!= last_immed
)
3998 return XTENSA_UNDEFINED
;
4006 get_relocation_slot (int r_type
)
4016 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4017 return r_type
- R_XTENSA_SLOT0_OP
;
4018 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4019 return r_type
- R_XTENSA_SLOT0_ALT
;
4023 return XTENSA_UNDEFINED
;
4027 /* Get the opcode for a relocation. */
4029 static xtensa_opcode
4030 get_relocation_opcode (bfd
*abfd
,
4033 Elf_Internal_Rela
*irel
)
4035 static xtensa_insnbuf ibuff
= NULL
;
4036 static xtensa_insnbuf sbuff
= NULL
;
4037 xtensa_isa isa
= xtensa_default_isa
;
4041 if (contents
== NULL
)
4042 return XTENSA_UNDEFINED
;
4044 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
4045 return XTENSA_UNDEFINED
;
4049 ibuff
= xtensa_insnbuf_alloc (isa
);
4050 sbuff
= xtensa_insnbuf_alloc (isa
);
4053 /* Decode the instruction. */
4054 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
4055 sec
->size
- irel
->r_offset
);
4056 fmt
= xtensa_format_decode (isa
, ibuff
);
4057 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
4058 if (slot
== XTENSA_UNDEFINED
)
4059 return XTENSA_UNDEFINED
;
4060 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
4061 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
4066 is_l32r_relocation (bfd
*abfd
,
4069 Elf_Internal_Rela
*irel
)
4071 xtensa_opcode opcode
;
4072 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
4074 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
4075 return (opcode
== get_l32r_opcode ());
4079 static bfd_size_type
4080 get_asm_simplify_size (bfd_byte
*contents
,
4081 bfd_size_type content_len
,
4082 bfd_size_type offset
)
4084 bfd_size_type insnlen
, size
= 0;
4086 /* Decode the size of the next two instructions. */
4087 insnlen
= insn_decode_len (contents
, content_len
, offset
);
4093 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
4103 is_alt_relocation (int r_type
)
4105 return (r_type
>= R_XTENSA_SLOT0_ALT
4106 && r_type
<= R_XTENSA_SLOT14_ALT
);
4111 is_operand_relocation (int r_type
)
4121 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4123 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4132 #define MIN_INSN_LENGTH 2
4134 /* Return 0 if it fails to decode. */
4137 insn_decode_len (bfd_byte
*contents
,
4138 bfd_size_type content_len
,
4139 bfd_size_type offset
)
4142 xtensa_isa isa
= xtensa_default_isa
;
4144 static xtensa_insnbuf ibuff
= NULL
;
4146 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4150 ibuff
= xtensa_insnbuf_alloc (isa
);
4151 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4152 content_len
- offset
);
4153 fmt
= xtensa_format_decode (isa
, ibuff
);
4154 if (fmt
== XTENSA_UNDEFINED
)
4156 insn_len
= xtensa_format_length (isa
, fmt
);
4157 if (insn_len
== XTENSA_UNDEFINED
)
4163 insn_num_slots (bfd_byte
*contents
,
4164 bfd_size_type content_len
,
4165 bfd_size_type offset
)
4167 xtensa_isa isa
= xtensa_default_isa
;
4169 static xtensa_insnbuf ibuff
= NULL
;
4171 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4172 return XTENSA_UNDEFINED
;
4175 ibuff
= xtensa_insnbuf_alloc (isa
);
4176 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4177 content_len
- offset
);
4178 fmt
= xtensa_format_decode (isa
, ibuff
);
4179 if (fmt
== XTENSA_UNDEFINED
)
4180 return XTENSA_UNDEFINED
;
4181 return xtensa_format_num_slots (isa
, fmt
);
4185 /* Decode the opcode for a single slot instruction.
4186 Return 0 if it fails to decode or the instruction is multi-slot. */
4189 insn_decode_opcode (bfd_byte
*contents
,
4190 bfd_size_type content_len
,
4191 bfd_size_type offset
,
4194 xtensa_isa isa
= xtensa_default_isa
;
4196 static xtensa_insnbuf insnbuf
= NULL
;
4197 static xtensa_insnbuf slotbuf
= NULL
;
4199 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4200 return XTENSA_UNDEFINED
;
4202 if (insnbuf
== NULL
)
4204 insnbuf
= xtensa_insnbuf_alloc (isa
);
4205 slotbuf
= xtensa_insnbuf_alloc (isa
);
4208 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4209 content_len
- offset
);
4210 fmt
= xtensa_format_decode (isa
, insnbuf
);
4211 if (fmt
== XTENSA_UNDEFINED
)
4212 return XTENSA_UNDEFINED
;
4214 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4215 return XTENSA_UNDEFINED
;
4217 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4218 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4222 /* The offset is the offset in the contents.
4223 The address is the address of that offset. */
4226 check_branch_target_aligned (bfd_byte
*contents
,
4227 bfd_size_type content_length
,
4231 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4234 return check_branch_target_aligned_address (address
, insn_len
);
4239 check_loop_aligned (bfd_byte
*contents
,
4240 bfd_size_type content_length
,
4244 bfd_size_type loop_len
, insn_len
;
4245 xtensa_opcode opcode
;
4247 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4248 if (opcode
== XTENSA_UNDEFINED
4249 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4255 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4256 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4257 if (loop_len
== 0 || insn_len
== 0)
4263 /* If this is relaxed loop, analyze first instruction of the actual loop
4264 body. It must be at offset 27 from the loop instruction address. */
4266 && insn_num_slots (contents
, content_length
, offset
+ loop_len
) == 1
4267 && insn_decode_opcode (contents
, content_length
,
4268 offset
+ loop_len
, 0) == get_rsr_lend_opcode()
4269 && insn_decode_len (contents
, content_length
, offset
+ loop_len
+ 3) == 3
4270 && insn_num_slots (contents
, content_length
, offset
+ loop_len
+ 3) == 1
4271 && insn_decode_opcode (contents
, content_length
,
4272 offset
+ loop_len
+ 3, 0) == get_wsr_lbeg_opcode())
4275 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4277 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4282 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4285 return (addr
% 8 == 0);
4286 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4290 /* Instruction widening and narrowing. */
4292 /* When FLIX is available we need to access certain instructions only
4293 when they are 16-bit or 24-bit instructions. This table caches
4294 information about such instructions by walking through all the
4295 opcodes and finding the smallest single-slot format into which each
4298 static xtensa_format
*op_single_fmt_table
= NULL
;
4302 init_op_single_format_table (void)
4304 xtensa_isa isa
= xtensa_default_isa
;
4305 xtensa_insnbuf ibuf
;
4306 xtensa_opcode opcode
;
4310 if (op_single_fmt_table
)
4313 ibuf
= xtensa_insnbuf_alloc (isa
);
4314 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4316 op_single_fmt_table
= (xtensa_format
*)
4317 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4318 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4320 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4321 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4323 if (xtensa_format_num_slots (isa
, fmt
) == 1
4324 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4326 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4327 int fmt_length
= xtensa_format_length (isa
, fmt
);
4328 if (old_fmt
== XTENSA_UNDEFINED
4329 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4330 op_single_fmt_table
[opcode
] = fmt
;
4334 xtensa_insnbuf_free (isa
, ibuf
);
4338 static xtensa_format
4339 get_single_format (xtensa_opcode opcode
)
4341 init_op_single_format_table ();
4342 return op_single_fmt_table
[opcode
];
4346 /* For the set of narrowable instructions we do NOT include the
4347 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4348 involved during linker relaxation that may require these to
4349 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4350 requires special case code to ensure it only works when op1 == op2. */
4358 struct string_pair narrowable
[] =
4361 { "addi", "addi.n" },
4362 { "addmi", "addi.n" },
4363 { "l32i", "l32i.n" },
4364 { "movi", "movi.n" },
4366 { "retw", "retw.n" },
4367 { "s32i", "s32i.n" },
4368 { "or", "mov.n" } /* special case only when op1 == op2 */
4371 struct string_pair widenable
[] =
4374 { "addi", "addi.n" },
4375 { "addmi", "addi.n" },
4376 { "beqz", "beqz.n" },
4377 { "bnez", "bnez.n" },
4378 { "l32i", "l32i.n" },
4379 { "movi", "movi.n" },
4381 { "retw", "retw.n" },
4382 { "s32i", "s32i.n" },
4383 { "or", "mov.n" } /* special case only when op1 == op2 */
4387 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4388 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4389 return the instruction buffer holding the narrow instruction. Otherwise,
4390 return 0. The set of valid narrowing are specified by a string table
4391 but require some special case operand checks in some cases. */
4393 static xtensa_insnbuf
4394 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4396 xtensa_opcode opcode
)
4398 xtensa_isa isa
= xtensa_default_isa
;
4399 xtensa_format o_fmt
;
4402 static xtensa_insnbuf o_insnbuf
= NULL
;
4403 static xtensa_insnbuf o_slotbuf
= NULL
;
4405 if (o_insnbuf
== NULL
)
4407 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4408 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4411 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4413 bfd_boolean is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4415 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4417 uint32 value
, newval
;
4418 int i
, operand_count
, o_operand_count
;
4419 xtensa_opcode o_opcode
;
4421 /* Address does not matter in this case. We might need to
4422 fix it to handle branches/jumps. */
4423 bfd_vma self_address
= 0;
4425 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4426 if (o_opcode
== XTENSA_UNDEFINED
)
4428 o_fmt
= get_single_format (o_opcode
);
4429 if (o_fmt
== XTENSA_UNDEFINED
)
4432 if (xtensa_format_length (isa
, fmt
) != 3
4433 || xtensa_format_length (isa
, o_fmt
) != 2)
4436 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4437 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4438 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4440 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4445 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4450 uint32 rawval0
, rawval1
, rawval2
;
4452 if (o_operand_count
+ 1 != operand_count
4453 || xtensa_operand_get_field (isa
, opcode
, 0,
4454 fmt
, 0, slotbuf
, &rawval0
) != 0
4455 || xtensa_operand_get_field (isa
, opcode
, 1,
4456 fmt
, 0, slotbuf
, &rawval1
) != 0
4457 || xtensa_operand_get_field (isa
, opcode
, 2,
4458 fmt
, 0, slotbuf
, &rawval2
) != 0
4459 || rawval1
!= rawval2
4460 || rawval0
== rawval1
/* it is a nop */)
4464 for (i
= 0; i
< o_operand_count
; ++i
)
4466 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4468 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4471 /* PC-relative branches need adjustment, but
4472 the PC-rel operand will always have a relocation. */
4474 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4476 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4477 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4482 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4492 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4493 the action in-place directly into the contents and return TRUE. Otherwise,
4494 the return value is FALSE and the contents are not modified. */
4497 narrow_instruction (bfd_byte
*contents
,
4498 bfd_size_type content_length
,
4499 bfd_size_type offset
)
4501 xtensa_opcode opcode
;
4502 bfd_size_type insn_len
;
4503 xtensa_isa isa
= xtensa_default_isa
;
4505 xtensa_insnbuf o_insnbuf
;
4507 static xtensa_insnbuf insnbuf
= NULL
;
4508 static xtensa_insnbuf slotbuf
= NULL
;
4510 if (insnbuf
== NULL
)
4512 insnbuf
= xtensa_insnbuf_alloc (isa
);
4513 slotbuf
= xtensa_insnbuf_alloc (isa
);
4516 BFD_ASSERT (offset
< content_length
);
4518 if (content_length
< 2)
4521 /* We will hand-code a few of these for a little while.
4522 These have all been specified in the assembler aleady. */
4523 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4524 content_length
- offset
);
4525 fmt
= xtensa_format_decode (isa
, insnbuf
);
4526 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4529 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4532 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4533 if (opcode
== XTENSA_UNDEFINED
)
4535 insn_len
= xtensa_format_length (isa
, fmt
);
4536 if (insn_len
> content_length
)
4539 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4542 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4543 content_length
- offset
);
4551 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4552 "density" instruction to a standard 3-byte instruction. If it is valid,
4553 return the instruction buffer holding the wide instruction. Otherwise,
4554 return 0. The set of valid widenings are specified by a string table
4555 but require some special case operand checks in some cases. */
4557 static xtensa_insnbuf
4558 can_widen_instruction (xtensa_insnbuf slotbuf
,
4560 xtensa_opcode opcode
)
4562 xtensa_isa isa
= xtensa_default_isa
;
4563 xtensa_format o_fmt
;
4566 static xtensa_insnbuf o_insnbuf
= NULL
;
4567 static xtensa_insnbuf o_slotbuf
= NULL
;
4569 if (o_insnbuf
== NULL
)
4571 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4572 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4575 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4577 bfd_boolean is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4578 bfd_boolean is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4579 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4581 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4583 uint32 value
, newval
;
4584 int i
, operand_count
, o_operand_count
, check_operand_count
;
4585 xtensa_opcode o_opcode
;
4587 /* Address does not matter in this case. We might need to fix it
4588 to handle branches/jumps. */
4589 bfd_vma self_address
= 0;
4591 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4592 if (o_opcode
== XTENSA_UNDEFINED
)
4594 o_fmt
= get_single_format (o_opcode
);
4595 if (o_fmt
== XTENSA_UNDEFINED
)
4598 if (xtensa_format_length (isa
, fmt
) != 2
4599 || xtensa_format_length (isa
, o_fmt
) != 3)
4602 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4603 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4604 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4605 check_operand_count
= o_operand_count
;
4607 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4612 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4617 uint32 rawval0
, rawval1
;
4619 if (o_operand_count
!= operand_count
+ 1
4620 || xtensa_operand_get_field (isa
, opcode
, 0,
4621 fmt
, 0, slotbuf
, &rawval0
) != 0
4622 || xtensa_operand_get_field (isa
, opcode
, 1,
4623 fmt
, 0, slotbuf
, &rawval1
) != 0
4624 || rawval0
== rawval1
/* it is a nop */)
4628 check_operand_count
--;
4630 for (i
= 0; i
< check_operand_count
; i
++)
4633 if (is_or
&& i
== o_operand_count
- 1)
4635 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4637 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4640 /* PC-relative branches need adjustment, but
4641 the PC-rel operand will always have a relocation. */
4643 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4645 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4646 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4651 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4661 /* Attempt to widen an instruction. If the widening is valid, perform
4662 the action in-place directly into the contents and return TRUE. Otherwise,
4663 the return value is FALSE and the contents are not modified. */
4666 widen_instruction (bfd_byte
*contents
,
4667 bfd_size_type content_length
,
4668 bfd_size_type offset
)
4670 xtensa_opcode opcode
;
4671 bfd_size_type insn_len
;
4672 xtensa_isa isa
= xtensa_default_isa
;
4674 xtensa_insnbuf o_insnbuf
;
4676 static xtensa_insnbuf insnbuf
= NULL
;
4677 static xtensa_insnbuf slotbuf
= NULL
;
4679 if (insnbuf
== NULL
)
4681 insnbuf
= xtensa_insnbuf_alloc (isa
);
4682 slotbuf
= xtensa_insnbuf_alloc (isa
);
4685 BFD_ASSERT (offset
< content_length
);
4687 if (content_length
< 2)
4690 /* We will hand-code a few of these for a little while.
4691 These have all been specified in the assembler aleady. */
4692 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4693 content_length
- offset
);
4694 fmt
= xtensa_format_decode (isa
, insnbuf
);
4695 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4698 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4701 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4702 if (opcode
== XTENSA_UNDEFINED
)
4704 insn_len
= xtensa_format_length (isa
, fmt
);
4705 if (insn_len
> content_length
)
4708 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4711 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4712 content_length
- offset
);
4719 /* Code for transforming CALLs at link-time. */
4721 static bfd_reloc_status_type
4722 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4724 bfd_vma content_length
,
4725 char **error_message
)
4727 static xtensa_insnbuf insnbuf
= NULL
;
4728 static xtensa_insnbuf slotbuf
= NULL
;
4729 xtensa_format core_format
= XTENSA_UNDEFINED
;
4730 xtensa_opcode opcode
;
4731 xtensa_opcode direct_call_opcode
;
4732 xtensa_isa isa
= xtensa_default_isa
;
4733 bfd_byte
*chbuf
= contents
+ address
;
4736 if (insnbuf
== NULL
)
4738 insnbuf
= xtensa_insnbuf_alloc (isa
);
4739 slotbuf
= xtensa_insnbuf_alloc (isa
);
4742 if (content_length
< address
)
4744 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4745 return bfd_reloc_other
;
4748 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4749 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4750 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4752 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4753 return bfd_reloc_other
;
4756 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4757 core_format
= xtensa_format_lookup (isa
, "x24");
4758 opcode
= xtensa_opcode_lookup (isa
, "or");
4759 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4760 for (opn
= 0; opn
< 3; opn
++)
4763 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4764 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4767 xtensa_format_encode (isa
, core_format
, insnbuf
);
4768 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4769 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4771 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4772 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4773 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4775 xtensa_format_encode (isa
, core_format
, insnbuf
);
4776 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4777 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4778 content_length
- address
- 3);
4780 return bfd_reloc_ok
;
4784 static bfd_reloc_status_type
4785 contract_asm_expansion (bfd_byte
*contents
,
4786 bfd_vma content_length
,
4787 Elf_Internal_Rela
*irel
,
4788 char **error_message
)
4790 bfd_reloc_status_type retval
=
4791 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4794 if (retval
!= bfd_reloc_ok
)
4795 return bfd_reloc_dangerous
;
4797 /* Update the irel->r_offset field so that the right immediate and
4798 the right instruction are modified during the relocation. */
4799 irel
->r_offset
+= 3;
4800 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4801 return bfd_reloc_ok
;
4805 static xtensa_opcode
4806 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4808 init_call_opcodes ();
4810 if (opcode
== callx0_op
) return call0_op
;
4811 if (opcode
== callx4_op
) return call4_op
;
4812 if (opcode
== callx8_op
) return call8_op
;
4813 if (opcode
== callx12_op
) return call12_op
;
4815 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4816 return XTENSA_UNDEFINED
;
4820 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4821 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4822 If not, return XTENSA_UNDEFINED. */
4824 #define L32R_TARGET_REG_OPERAND 0
4825 #define CONST16_TARGET_REG_OPERAND 0
4826 #define CALLN_SOURCE_OPERAND 0
4828 static xtensa_opcode
4829 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bfd_boolean
*p_uses_l32r
)
4831 static xtensa_insnbuf insnbuf
= NULL
;
4832 static xtensa_insnbuf slotbuf
= NULL
;
4834 xtensa_opcode opcode
;
4835 xtensa_isa isa
= xtensa_default_isa
;
4836 uint32 regno
, const16_regno
, call_regno
;
4839 if (insnbuf
== NULL
)
4841 insnbuf
= xtensa_insnbuf_alloc (isa
);
4842 slotbuf
= xtensa_insnbuf_alloc (isa
);
4845 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4846 fmt
= xtensa_format_decode (isa
, insnbuf
);
4847 if (fmt
== XTENSA_UNDEFINED
4848 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4849 return XTENSA_UNDEFINED
;
4851 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4852 if (opcode
== XTENSA_UNDEFINED
)
4853 return XTENSA_UNDEFINED
;
4855 if (opcode
== get_l32r_opcode ())
4858 *p_uses_l32r
= TRUE
;
4859 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4860 fmt
, 0, slotbuf
, ®no
)
4861 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4863 return XTENSA_UNDEFINED
;
4865 else if (opcode
== get_const16_opcode ())
4868 *p_uses_l32r
= FALSE
;
4869 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4870 fmt
, 0, slotbuf
, ®no
)
4871 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4873 return XTENSA_UNDEFINED
;
4875 /* Check that the next instruction is also CONST16. */
4876 offset
+= xtensa_format_length (isa
, fmt
);
4877 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4878 fmt
= xtensa_format_decode (isa
, insnbuf
);
4879 if (fmt
== XTENSA_UNDEFINED
4880 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4881 return XTENSA_UNDEFINED
;
4882 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4883 if (opcode
!= get_const16_opcode ())
4884 return XTENSA_UNDEFINED
;
4886 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4887 fmt
, 0, slotbuf
, &const16_regno
)
4888 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4890 || const16_regno
!= regno
)
4891 return XTENSA_UNDEFINED
;
4894 return XTENSA_UNDEFINED
;
4896 /* Next instruction should be an CALLXn with operand 0 == regno. */
4897 offset
+= xtensa_format_length (isa
, fmt
);
4898 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4899 fmt
= xtensa_format_decode (isa
, insnbuf
);
4900 if (fmt
== XTENSA_UNDEFINED
4901 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4902 return XTENSA_UNDEFINED
;
4903 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4904 if (opcode
== XTENSA_UNDEFINED
4905 || !is_indirect_call_opcode (opcode
))
4906 return XTENSA_UNDEFINED
;
4908 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4909 fmt
, 0, slotbuf
, &call_regno
)
4910 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4912 return XTENSA_UNDEFINED
;
4914 if (call_regno
!= regno
)
4915 return XTENSA_UNDEFINED
;
4921 /* Data structures used during relaxation. */
4923 /* r_reloc: relocation values. */
4925 /* Through the relaxation process, we need to keep track of the values
4926 that will result from evaluating relocations. The standard ELF
4927 relocation structure is not sufficient for this purpose because we're
4928 operating on multiple input files at once, so we need to know which
4929 input file a relocation refers to. The r_reloc structure thus
4930 records both the input file (bfd) and ELF relocation.
4932 For efficiency, an r_reloc also contains a "target_offset" field to
4933 cache the target-section-relative offset value that is represented by
4936 The r_reloc also contains a virtual offset that allows multiple
4937 inserted literals to be placed at the same "address" with
4938 different offsets. */
4940 typedef struct r_reloc_struct r_reloc
;
4942 struct r_reloc_struct
4945 Elf_Internal_Rela rela
;
4946 bfd_vma target_offset
;
4947 bfd_vma virtual_offset
;
4951 /* The r_reloc structure is included by value in literal_value, but not
4952 every literal_value has an associated relocation -- some are simple
4953 constants. In such cases, we set all the fields in the r_reloc
4954 struct to zero. The r_reloc_is_const function should be used to
4955 detect this case. */
4958 r_reloc_is_const (const r_reloc
*r_rel
)
4960 return (r_rel
->abfd
== NULL
);
4965 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4967 bfd_vma target_offset
;
4968 unsigned long r_symndx
;
4970 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4971 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4972 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4973 return (target_offset
+ r_rel
->rela
.r_addend
);
4977 static struct elf_link_hash_entry
*
4978 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4980 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4981 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4986 r_reloc_get_section (const r_reloc
*r_rel
)
4988 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4989 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4994 r_reloc_is_defined (const r_reloc
*r_rel
)
5000 sec
= r_reloc_get_section (r_rel
);
5001 if (sec
== bfd_abs_section_ptr
5002 || sec
== bfd_com_section_ptr
5003 || sec
== bfd_und_section_ptr
)
5010 r_reloc_init (r_reloc
*r_rel
,
5012 Elf_Internal_Rela
*irel
,
5014 bfd_size_type content_length
)
5017 reloc_howto_type
*howto
;
5021 r_rel
->rela
= *irel
;
5023 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
5024 r_rel
->virtual_offset
= 0;
5025 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
5026 howto
= &elf_howto_table
[r_type
];
5027 if (howto
->partial_inplace
)
5029 bfd_vma inplace_val
;
5030 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
5032 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
5033 r_rel
->target_offset
+= inplace_val
;
5037 memset (r_rel
, 0, sizeof (r_reloc
));
5044 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
5046 if (r_reloc_is_defined (r_rel
))
5048 asection
*sec
= r_reloc_get_section (r_rel
);
5049 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
5051 else if (r_reloc_get_hash_entry (r_rel
))
5052 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
5054 fprintf (fp
, " ?? + ");
5056 fprintf_vma (fp
, r_rel
->target_offset
);
5057 if (r_rel
->virtual_offset
)
5059 fprintf (fp
, " + ");
5060 fprintf_vma (fp
, r_rel
->virtual_offset
);
5069 /* source_reloc: relocations that reference literals. */
5071 /* To determine whether literals can be coalesced, we need to first
5072 record all the relocations that reference the literals. The
5073 source_reloc structure below is used for this purpose. The
5074 source_reloc entries are kept in a per-literal-section array, sorted
5075 by offset within the literal section (i.e., target offset).
5077 The source_sec and r_rel.rela.r_offset fields identify the source of
5078 the relocation. The r_rel field records the relocation value, i.e.,
5079 the offset of the literal being referenced. The opnd field is needed
5080 to determine the range of the immediate field to which the relocation
5081 applies, so we can determine whether another literal with the same
5082 value is within range. The is_null field is true when the relocation
5083 is being removed (e.g., when an L32R is being removed due to a CALLX
5084 that is converted to a direct CALL). */
5086 typedef struct source_reloc_struct source_reloc
;
5088 struct source_reloc_struct
5090 asection
*source_sec
;
5092 xtensa_opcode opcode
;
5094 bfd_boolean is_null
;
5095 bfd_boolean is_abs_literal
;
5100 init_source_reloc (source_reloc
*reloc
,
5101 asection
*source_sec
,
5102 const r_reloc
*r_rel
,
5103 xtensa_opcode opcode
,
5105 bfd_boolean is_abs_literal
)
5107 reloc
->source_sec
= source_sec
;
5108 reloc
->r_rel
= *r_rel
;
5109 reloc
->opcode
= opcode
;
5111 reloc
->is_null
= FALSE
;
5112 reloc
->is_abs_literal
= is_abs_literal
;
5116 /* Find the source_reloc for a particular source offset and relocation
5117 type. Note that the array is sorted by _target_ offset, so this is
5118 just a linear search. */
5120 static source_reloc
*
5121 find_source_reloc (source_reloc
*src_relocs
,
5124 Elf_Internal_Rela
*irel
)
5128 for (i
= 0; i
< src_count
; i
++)
5130 if (src_relocs
[i
].source_sec
== sec
5131 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
5132 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
5133 == ELF32_R_TYPE (irel
->r_info
)))
5134 return &src_relocs
[i
];
5142 source_reloc_compare (const void *ap
, const void *bp
)
5144 const source_reloc
*a
= (const source_reloc
*) ap
;
5145 const source_reloc
*b
= (const source_reloc
*) bp
;
5147 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
5148 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5150 /* We don't need to sort on these criteria for correctness,
5151 but enforcing a more strict ordering prevents unstable qsort
5152 from behaving differently with different implementations.
5153 Without the code below we get correct but different results
5154 on Solaris 2.7 and 2.8. We would like to always produce the
5155 same results no matter the host. */
5157 if ((!a
->is_null
) - (!b
->is_null
))
5158 return ((!a
->is_null
) - (!b
->is_null
));
5159 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5163 /* Literal values and value hash tables. */
5165 /* Literals with the same value can be coalesced. The literal_value
5166 structure records the value of a literal: the "r_rel" field holds the
5167 information from the relocation on the literal (if there is one) and
5168 the "value" field holds the contents of the literal word itself.
5170 The value_map structure records a literal value along with the
5171 location of a literal holding that value. The value_map hash table
5172 is indexed by the literal value, so that we can quickly check if a
5173 particular literal value has been seen before and is thus a candidate
5176 typedef struct literal_value_struct literal_value
;
5177 typedef struct value_map_struct value_map
;
5178 typedef struct value_map_hash_table_struct value_map_hash_table
;
5180 struct literal_value_struct
5183 unsigned long value
;
5184 bfd_boolean is_abs_literal
;
5187 struct value_map_struct
5189 literal_value val
; /* The literal value. */
5190 r_reloc loc
; /* Location of the literal. */
5194 struct value_map_hash_table_struct
5196 unsigned bucket_count
;
5197 value_map
**buckets
;
5199 bfd_boolean has_last_loc
;
5205 init_literal_value (literal_value
*lit
,
5206 const r_reloc
*r_rel
,
5207 unsigned long value
,
5208 bfd_boolean is_abs_literal
)
5210 lit
->r_rel
= *r_rel
;
5212 lit
->is_abs_literal
= is_abs_literal
;
5217 literal_value_equal (const literal_value
*src1
,
5218 const literal_value
*src2
,
5219 bfd_boolean final_static_link
)
5221 struct elf_link_hash_entry
*h1
, *h2
;
5223 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5226 if (r_reloc_is_const (&src1
->r_rel
))
5227 return (src1
->value
== src2
->value
);
5229 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5230 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5233 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5236 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5239 if (src1
->value
!= src2
->value
)
5242 /* Now check for the same section (if defined) or the same elf_hash
5243 (if undefined or weak). */
5244 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5245 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5246 if (r_reloc_is_defined (&src1
->r_rel
)
5247 && (final_static_link
5248 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5249 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5251 if (r_reloc_get_section (&src1
->r_rel
)
5252 != r_reloc_get_section (&src2
->r_rel
))
5257 /* Require that the hash entries (i.e., symbols) be identical. */
5258 if (h1
!= h2
|| h1
== 0)
5262 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5269 /* Must be power of 2. */
5270 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5272 static value_map_hash_table
*
5273 value_map_hash_table_init (void)
5275 value_map_hash_table
*values
;
5277 values
= (value_map_hash_table
*)
5278 bfd_zmalloc (sizeof (value_map_hash_table
));
5279 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5281 values
->buckets
= (value_map
**)
5282 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5283 if (values
->buckets
== NULL
)
5288 values
->has_last_loc
= FALSE
;
5295 value_map_hash_table_delete (value_map_hash_table
*table
)
5297 free (table
->buckets
);
5303 hash_bfd_vma (bfd_vma val
)
5305 return (val
>> 2) + (val
>> 10);
5310 literal_value_hash (const literal_value
*src
)
5314 hash_val
= hash_bfd_vma (src
->value
);
5315 if (!r_reloc_is_const (&src
->r_rel
))
5319 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5320 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5321 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5323 /* Now check for the same section and the same elf_hash. */
5324 if (r_reloc_is_defined (&src
->r_rel
))
5325 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5327 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5328 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5334 /* Check if the specified literal_value has been seen before. */
5337 value_map_get_cached_value (value_map_hash_table
*map
,
5338 const literal_value
*val
,
5339 bfd_boolean final_static_link
)
5345 idx
= literal_value_hash (val
);
5346 idx
= idx
& (map
->bucket_count
- 1);
5347 bucket
= map
->buckets
[idx
];
5348 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5350 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5357 /* Record a new literal value. It is illegal to call this if VALUE
5358 already has an entry here. */
5361 add_value_map (value_map_hash_table
*map
,
5362 const literal_value
*val
,
5364 bfd_boolean final_static_link
)
5366 value_map
**bucket_p
;
5369 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5372 bfd_set_error (bfd_error_no_memory
);
5376 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5380 idx
= literal_value_hash (val
);
5381 idx
= idx
& (map
->bucket_count
- 1);
5382 bucket_p
= &map
->buckets
[idx
];
5384 val_e
->next
= *bucket_p
;
5387 /* FIXME: Consider resizing the hash table if we get too many entries. */
5393 /* Lists of text actions (ta_) for narrowing, widening, longcall
5394 conversion, space fill, code & literal removal, etc. */
5396 /* The following text actions are generated:
5398 "ta_remove_insn" remove an instruction or instructions
5399 "ta_remove_longcall" convert longcall to call
5400 "ta_convert_longcall" convert longcall to nop/call
5401 "ta_narrow_insn" narrow a wide instruction
5402 "ta_widen" widen a narrow instruction
5403 "ta_fill" add fill or remove fill
5404 removed < 0 is a fill; branches to the fill address will be
5405 changed to address + fill size (e.g., address - removed)
5406 removed >= 0 branches to the fill address will stay unchanged
5407 "ta_remove_literal" remove a literal; this action is
5408 indicated when a literal is removed
5410 "ta_add_literal" insert a new literal; this action is
5411 indicated when a literal has been moved.
5412 It may use a virtual_offset because
5413 multiple literals can be placed at the
5416 For each of these text actions, we also record the number of bytes
5417 removed by performing the text action. In the case of a "ta_widen"
5418 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5420 typedef struct text_action_struct text_action
;
5421 typedef struct text_action_list_struct text_action_list
;
5422 typedef enum text_action_enum_t text_action_t
;
5424 enum text_action_enum_t
5427 ta_remove_insn
, /* removed = -size */
5428 ta_remove_longcall
, /* removed = -size */
5429 ta_convert_longcall
, /* removed = 0 */
5430 ta_narrow_insn
, /* removed = -1 */
5431 ta_widen_insn
, /* removed = +1 */
5432 ta_fill
, /* removed = +size */
5438 /* Structure for a text action record. */
5439 struct text_action_struct
5441 text_action_t action
;
5442 asection
*sec
; /* Optional */
5444 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5446 literal_value value
; /* Only valid when adding literals. */
5449 struct removal_by_action_entry_struct
5454 int eq_removed_before_fill
;
5456 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5458 struct removal_by_action_map_struct
5461 removal_by_action_entry
*entry
;
5463 typedef struct removal_by_action_map_struct removal_by_action_map
;
5466 /* List of all of the actions taken on a text section. */
5467 struct text_action_list_struct
5471 removal_by_action_map map
;
5475 static text_action
*
5476 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5480 /* It is not necessary to fill at the end of a section. */
5481 if (sec
->size
== offset
)
5487 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5489 return (text_action
*)node
->value
;
5495 compute_removed_action_diff (const text_action
*ta
,
5499 int removable_space
)
5502 int current_removed
= 0;
5505 current_removed
= ta
->removed_bytes
;
5507 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5508 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5510 /* It is not necessary to fill at the end of a section. Clean this up. */
5511 if (sec
->size
== offset
)
5512 new_removed
= removable_space
- 0;
5516 int added
= -removed
- current_removed
;
5517 /* Ignore multiples of the section alignment. */
5518 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5519 new_removed
= (-added
);
5521 /* Modify for removable. */
5522 space
= removable_space
- new_removed
;
5523 new_removed
= (removable_space
5524 - (((1 << sec
->alignment_power
) - 1) & space
));
5526 return (new_removed
- current_removed
);
5531 adjust_fill_action (text_action
*ta
, int fill_diff
)
5533 ta
->removed_bytes
+= fill_diff
;
5538 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5540 text_action
*pa
= (text_action
*)a
;
5541 text_action
*pb
= (text_action
*)b
;
5542 static const int action_priority
[] =
5546 [ta_convert_longcall
] = 2,
5547 [ta_narrow_insn
] = 3,
5548 [ta_remove_insn
] = 4,
5549 [ta_remove_longcall
] = 5,
5550 [ta_remove_literal
] = 6,
5551 [ta_widen_insn
] = 7,
5552 [ta_add_literal
] = 8,
5555 if (pa
->offset
== pb
->offset
)
5557 if (pa
->action
== pb
->action
)
5559 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5562 return pa
->offset
< pb
->offset
? -1 : 1;
5565 static text_action
*
5566 action_first (text_action_list
*action_list
)
5568 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5569 return node
? (text_action
*)node
->value
: NULL
;
5572 static text_action
*
5573 action_next (text_action_list
*action_list
, text_action
*action
)
5575 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5576 (splay_tree_key
)action
);
5577 return node
? (text_action
*)node
->value
: NULL
;
5580 /* Add a modification action to the text. For the case of adding or
5581 removing space, modify any current fill and assume that
5582 "unreachable_space" bytes can be freely contracted. Note that a
5583 negative removed value is a fill. */
5586 text_action_add (text_action_list
*l
,
5587 text_action_t action
,
5595 /* It is not necessary to fill at the end of a section. */
5596 if (action
== ta_fill
&& sec
->size
== offset
)
5599 /* It is not necessary to fill 0 bytes. */
5600 if (action
== ta_fill
&& removed
== 0)
5606 if (action
== ta_fill
)
5608 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5612 ta
= (text_action
*)node
->value
;
5613 ta
->removed_bytes
+= removed
;
5618 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5620 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5621 ta
->action
= action
;
5623 ta
->offset
= offset
;
5624 ta
->removed_bytes
= removed
;
5625 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5631 text_action_add_literal (text_action_list
*l
,
5632 text_action_t action
,
5634 const literal_value
*value
,
5638 asection
*sec
= r_reloc_get_section (loc
);
5639 bfd_vma offset
= loc
->target_offset
;
5640 bfd_vma virtual_offset
= loc
->virtual_offset
;
5642 BFD_ASSERT (action
== ta_add_literal
);
5644 /* Create a new record and fill it up. */
5645 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5646 ta
->action
= action
;
5648 ta
->offset
= offset
;
5649 ta
->virtual_offset
= virtual_offset
;
5651 ta
->removed_bytes
= removed
;
5653 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5654 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5659 /* Find the total offset adjustment for the relaxations specified by
5660 text_actions, beginning from a particular starting action. This is
5661 typically used from offset_with_removed_text to search an entire list of
5662 actions, but it may also be called directly when adjusting adjacent offsets
5663 so that each search may begin where the previous one left off. */
5666 removed_by_actions (text_action_list
*action_list
,
5667 text_action
**p_start_action
,
5669 bfd_boolean before_fill
)
5674 r
= *p_start_action
;
5677 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5679 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5684 if (r
->offset
> offset
)
5687 if (r
->offset
== offset
5688 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5691 removed
+= r
->removed_bytes
;
5693 r
= action_next (action_list
, r
);
5696 *p_start_action
= r
;
5702 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5704 text_action
*r
= action_first (action_list
);
5706 return offset
- removed_by_actions (action_list
, &r
, offset
, FALSE
);
5711 action_list_count (text_action_list
*action_list
)
5713 return action_list
->count
;
5716 typedef struct map_action_fn_context_struct map_action_fn_context
;
5717 struct map_action_fn_context_struct
5720 removal_by_action_map map
;
5721 bfd_boolean eq_complete
;
5725 map_action_fn (splay_tree_node node
, void *p
)
5727 map_action_fn_context
*ctx
= p
;
5728 text_action
*r
= (text_action
*)node
->value
;
5729 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5731 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5737 ++ctx
->map
.n_entries
;
5738 ctx
->eq_complete
= FALSE
;
5739 ientry
->offset
= r
->offset
;
5740 ientry
->eq_removed_before_fill
= ctx
->removed
;
5743 if (!ctx
->eq_complete
)
5745 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5747 ientry
->eq_removed
= ctx
->removed
;
5748 ctx
->eq_complete
= TRUE
;
5751 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5754 ctx
->removed
+= r
->removed_bytes
;
5755 ientry
->removed
= ctx
->removed
;
5760 map_removal_by_action (text_action_list
*action_list
)
5762 map_action_fn_context ctx
;
5765 ctx
.map
.n_entries
= 0;
5766 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5767 sizeof (removal_by_action_entry
));
5768 ctx
.eq_complete
= FALSE
;
5770 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5771 action_list
->map
= ctx
.map
;
5775 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5776 bfd_boolean before_fill
)
5780 if (!action_list
->map
.entry
)
5781 map_removal_by_action (action_list
);
5783 if (!action_list
->map
.n_entries
)
5787 b
= action_list
->map
.n_entries
;
5791 unsigned c
= (a
+ b
) / 2;
5793 if (action_list
->map
.entry
[c
].offset
<= offset
)
5799 if (action_list
->map
.entry
[a
].offset
< offset
)
5801 return action_list
->map
.entry
[a
].removed
;
5803 else if (action_list
->map
.entry
[a
].offset
== offset
)
5805 return before_fill
?
5806 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5807 action_list
->map
.entry
[a
].eq_removed
;
5816 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5818 int removed
= removed_by_actions_map (action_list
, offset
, FALSE
);
5819 return offset
- removed
;
5823 /* The find_insn_action routine will only find non-fill actions. */
5825 static text_action
*
5826 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5828 static const text_action_t action
[] =
5830 ta_convert_longcall
,
5840 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5842 splay_tree_node node
;
5844 a
.action
= action
[i
];
5845 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5847 return (text_action
*)node
->value
;
5856 print_action (FILE *fp
, text_action
*r
)
5858 const char *t
= "unknown";
5861 case ta_remove_insn
:
5862 t
= "remove_insn"; break;
5863 case ta_remove_longcall
:
5864 t
= "remove_longcall"; break;
5865 case ta_convert_longcall
:
5866 t
= "convert_longcall"; break;
5867 case ta_narrow_insn
:
5868 t
= "narrow_insn"; break;
5870 t
= "widen_insn"; break;
5875 case ta_remove_literal
:
5876 t
= "remove_literal"; break;
5877 case ta_add_literal
:
5878 t
= "add_literal"; break;
5881 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5882 r
->sec
->owner
->filename
,
5883 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5887 print_action_list_fn (splay_tree_node node
, void *p
)
5889 text_action
*r
= (text_action
*)node
->value
;
5891 print_action (p
, r
);
5896 print_action_list (FILE *fp
, text_action_list
*action_list
)
5898 fprintf (fp
, "Text Action\n");
5899 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5905 /* Lists of literals being coalesced or removed. */
5907 /* In the usual case, the literal identified by "from" is being
5908 coalesced with another literal identified by "to". If the literal is
5909 unused and is being removed altogether, "to.abfd" will be NULL.
5910 The removed_literal entries are kept on a per-section list, sorted
5911 by the "from" offset field. */
5913 typedef struct removed_literal_struct removed_literal
;
5914 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5915 typedef struct removed_literal_list_struct removed_literal_list
;
5917 struct removed_literal_struct
5921 removed_literal
*next
;
5924 struct removed_literal_map_entry_struct
5927 removed_literal
*literal
;
5930 struct removed_literal_list_struct
5932 removed_literal
*head
;
5933 removed_literal
*tail
;
5936 removed_literal_map_entry
*map
;
5940 /* Record that the literal at "from" is being removed. If "to" is not
5941 NULL, the "from" literal is being coalesced with the "to" literal. */
5944 add_removed_literal (removed_literal_list
*removed_list
,
5945 const r_reloc
*from
,
5948 removed_literal
*r
, *new_r
, *next_r
;
5950 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5952 new_r
->from
= *from
;
5956 new_r
->to
.abfd
= NULL
;
5959 r
= removed_list
->head
;
5962 removed_list
->head
= new_r
;
5963 removed_list
->tail
= new_r
;
5965 /* Special check for common case of append. */
5966 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5968 removed_list
->tail
->next
= new_r
;
5969 removed_list
->tail
= new_r
;
5973 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5979 new_r
->next
= next_r
;
5981 removed_list
->tail
= new_r
;
5986 map_removed_literal (removed_literal_list
*removed_list
)
5990 removed_literal_map_entry
*map
= NULL
;
5991 removed_literal
*r
= removed_list
->head
;
5993 for (i
= 0; r
; ++i
, r
= r
->next
)
5997 n_map
= (n_map
* 2) + 2;
5998 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
6000 map
[i
].addr
= r
->from
.target_offset
;
6003 removed_list
->map
= map
;
6004 removed_list
->n_map
= i
;
6008 removed_literal_compare (const void *a
, const void *b
)
6010 const removed_literal_map_entry
*pa
= a
;
6011 const removed_literal_map_entry
*pb
= b
;
6013 if (pa
->addr
== pb
->addr
)
6016 return pa
->addr
< pb
->addr
? -1 : 1;
6019 /* Check if the list of removed literals contains an entry for the
6020 given address. Return the entry if found. */
6022 static removed_literal
*
6023 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
6025 removed_literal_map_entry
*p
;
6026 removed_literal
*r
= NULL
;
6028 if (removed_list
->map
== NULL
)
6029 map_removed_literal (removed_list
);
6031 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
6032 sizeof (*removed_list
->map
), removed_literal_compare
);
6035 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
6046 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
6049 r
= removed_list
->head
;
6051 fprintf (fp
, "Removed Literals\n");
6052 for (; r
!= NULL
; r
= r
->next
)
6054 print_r_reloc (fp
, &r
->from
);
6055 fprintf (fp
, " => ");
6056 if (r
->to
.abfd
== NULL
)
6057 fprintf (fp
, "REMOVED");
6059 print_r_reloc (fp
, &r
->to
);
6067 /* Per-section data for relaxation. */
6069 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
6071 struct xtensa_relax_info_struct
6073 bfd_boolean is_relaxable_literal_section
;
6074 bfd_boolean is_relaxable_asm_section
;
6075 int visited
; /* Number of times visited. */
6077 source_reloc
*src_relocs
; /* Array[src_count]. */
6079 int src_next
; /* Next src_relocs entry to assign. */
6081 removed_literal_list removed_list
;
6082 text_action_list action_list
;
6084 reloc_bfd_fix
*fix_list
;
6085 reloc_bfd_fix
*fix_array
;
6086 unsigned fix_array_count
;
6088 /* Support for expanding the reloc array that is stored
6089 in the section structure. If the relocations have been
6090 reallocated, the newly allocated relocations will be referenced
6091 here along with the actual size allocated. The relocation
6092 count will always be found in the section structure. */
6093 Elf_Internal_Rela
*allocated_relocs
;
6094 unsigned relocs_count
;
6095 unsigned allocated_relocs_count
;
6098 struct elf_xtensa_section_data
6100 struct bfd_elf_section_data elf
;
6101 xtensa_relax_info relax_info
;
6106 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
6108 if (!sec
->used_by_bfd
)
6110 struct elf_xtensa_section_data
*sdata
;
6111 size_t amt
= sizeof (*sdata
);
6113 sdata
= bfd_zalloc (abfd
, amt
);
6116 sec
->used_by_bfd
= sdata
;
6119 return _bfd_elf_new_section_hook (abfd
, sec
);
6123 static xtensa_relax_info
*
6124 get_xtensa_relax_info (asection
*sec
)
6126 struct elf_xtensa_section_data
*section_data
;
6128 /* No info available if no section or if it is an output section. */
6129 if (!sec
|| sec
== sec
->output_section
)
6132 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
6133 return §ion_data
->relax_info
;
6138 init_xtensa_relax_info (asection
*sec
)
6140 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6142 relax_info
->is_relaxable_literal_section
= FALSE
;
6143 relax_info
->is_relaxable_asm_section
= FALSE
;
6144 relax_info
->visited
= 0;
6146 relax_info
->src_relocs
= NULL
;
6147 relax_info
->src_count
= 0;
6148 relax_info
->src_next
= 0;
6150 relax_info
->removed_list
.head
= NULL
;
6151 relax_info
->removed_list
.tail
= NULL
;
6153 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6155 relax_info
->action_list
.map
.n_entries
= 0;
6156 relax_info
->action_list
.map
.entry
= NULL
;
6158 relax_info
->fix_list
= NULL
;
6159 relax_info
->fix_array
= NULL
;
6160 relax_info
->fix_array_count
= 0;
6162 relax_info
->allocated_relocs
= NULL
;
6163 relax_info
->relocs_count
= 0;
6164 relax_info
->allocated_relocs_count
= 0;
6168 /* Coalescing literals may require a relocation to refer to a section in
6169 a different input file, but the standard relocation information
6170 cannot express that. Instead, the reloc_bfd_fix structures are used
6171 to "fix" the relocations that refer to sections in other input files.
6172 These structures are kept on per-section lists. The "src_type" field
6173 records the relocation type in case there are multiple relocations on
6174 the same location. FIXME: This is ugly; an alternative might be to
6175 add new symbols with the "owner" field to some other input file. */
6177 struct reloc_bfd_fix_struct
6181 unsigned src_type
; /* Relocation type. */
6183 asection
*target_sec
;
6184 bfd_vma target_offset
;
6185 bfd_boolean translated
;
6187 reloc_bfd_fix
*next
;
6191 static reloc_bfd_fix
*
6192 reloc_bfd_fix_init (asection
*src_sec
,
6195 asection
*target_sec
,
6196 bfd_vma target_offset
,
6197 bfd_boolean translated
)
6201 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6202 fix
->src_sec
= src_sec
;
6203 fix
->src_offset
= src_offset
;
6204 fix
->src_type
= src_type
;
6205 fix
->target_sec
= target_sec
;
6206 fix
->target_offset
= target_offset
;
6207 fix
->translated
= translated
;
6214 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6216 xtensa_relax_info
*relax_info
;
6218 relax_info
= get_xtensa_relax_info (src_sec
);
6219 fix
->next
= relax_info
->fix_list
;
6220 relax_info
->fix_list
= fix
;
6225 fix_compare (const void *ap
, const void *bp
)
6227 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6228 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6230 if (a
->src_offset
!= b
->src_offset
)
6231 return (a
->src_offset
- b
->src_offset
);
6232 return (a
->src_type
- b
->src_type
);
6237 cache_fix_array (asection
*sec
)
6239 unsigned i
, count
= 0;
6241 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6243 if (relax_info
== NULL
)
6245 if (relax_info
->fix_list
== NULL
)
6248 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6251 relax_info
->fix_array
=
6252 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6253 relax_info
->fix_array_count
= count
;
6255 r
= relax_info
->fix_list
;
6256 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6258 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6259 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6262 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6263 sizeof (reloc_bfd_fix
), fix_compare
);
6267 static reloc_bfd_fix
*
6268 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6270 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6274 if (relax_info
== NULL
)
6276 if (relax_info
->fix_list
== NULL
)
6279 if (relax_info
->fix_array
== NULL
)
6280 cache_fix_array (sec
);
6282 key
.src_offset
= offset
;
6283 key
.src_type
= type
;
6284 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6285 sizeof (reloc_bfd_fix
), fix_compare
);
6290 /* Section caching. */
6292 typedef struct section_cache_struct section_cache_t
;
6294 struct section_cache_struct
6298 bfd_byte
*contents
; /* Cache of the section contents. */
6299 bfd_size_type content_length
;
6301 property_table_entry
*ptbl
; /* Cache of the section property table. */
6304 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6305 unsigned reloc_count
;
6310 init_section_cache (section_cache_t
*sec_cache
)
6312 memset (sec_cache
, 0, sizeof (*sec_cache
));
6317 free_section_cache (section_cache_t
*sec_cache
)
6321 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6322 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6323 free (sec_cache
->ptbl
);
6329 section_cache_section (section_cache_t
*sec_cache
,
6331 struct bfd_link_info
*link_info
)
6334 property_table_entry
*prop_table
= NULL
;
6336 bfd_byte
*contents
= NULL
;
6337 Elf_Internal_Rela
*internal_relocs
= NULL
;
6338 bfd_size_type sec_size
;
6342 if (sec
== sec_cache
->sec
)
6346 sec_size
= bfd_get_section_limit (abfd
, sec
);
6348 /* Get the contents. */
6349 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6350 if (contents
== NULL
&& sec_size
!= 0)
6353 /* Get the relocations. */
6354 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6355 link_info
->keep_memory
);
6357 /* Get the entry table. */
6358 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6359 XTENSA_PROP_SEC_NAME
, FALSE
);
6363 /* Fill in the new section cache. */
6364 free_section_cache (sec_cache
);
6365 init_section_cache (sec_cache
);
6367 sec_cache
->sec
= sec
;
6368 sec_cache
->contents
= contents
;
6369 sec_cache
->content_length
= sec_size
;
6370 sec_cache
->relocs
= internal_relocs
;
6371 sec_cache
->reloc_count
= sec
->reloc_count
;
6372 sec_cache
->pte_count
= ptblsize
;
6373 sec_cache
->ptbl
= prop_table
;
6378 release_contents (sec
, contents
);
6379 release_internal_relocs (sec
, internal_relocs
);
6385 /* Extended basic blocks. */
6387 /* An ebb_struct represents an Extended Basic Block. Within this
6388 range, we guarantee that all instructions are decodable, the
6389 property table entries are contiguous, and no property table
6390 specifies a segment that cannot have instructions moved. This
6391 structure contains caches of the contents, property table and
6392 relocations for the specified section for easy use. The range is
6393 specified by ranges of indices for the byte offset, property table
6394 offsets and relocation offsets. These must be consistent. */
6396 typedef struct ebb_struct ebb_t
;
6402 bfd_byte
*contents
; /* Cache of the section contents. */
6403 bfd_size_type content_length
;
6405 property_table_entry
*ptbl
; /* Cache of the section property table. */
6408 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6409 unsigned reloc_count
;
6411 bfd_vma start_offset
; /* Offset in section. */
6412 unsigned start_ptbl_idx
; /* Offset in the property table. */
6413 unsigned start_reloc_idx
; /* Offset in the relocations. */
6416 unsigned end_ptbl_idx
;
6417 unsigned end_reloc_idx
;
6419 bfd_boolean ends_section
; /* Is this the last ebb in a section? */
6421 /* The unreachable property table at the end of this set of blocks;
6422 NULL if the end is not an unreachable block. */
6423 property_table_entry
*ends_unreachable
;
6427 enum ebb_target_enum
6430 EBB_DESIRE_TGT_ALIGN
,
6431 EBB_REQUIRE_TGT_ALIGN
,
6432 EBB_REQUIRE_LOOP_ALIGN
,
6437 /* proposed_action_struct is similar to the text_action_struct except
6438 that is represents a potential transformation, not one that will
6439 occur. We build a list of these for an extended basic block
6440 and use them to compute the actual actions desired. We must be
6441 careful that the entire set of actual actions we perform do not
6442 break any relocations that would fit if the actions were not
6445 typedef struct proposed_action_struct proposed_action
;
6447 struct proposed_action_struct
6449 enum ebb_target_enum align_type
; /* for the target alignment */
6450 bfd_vma alignment_pow
;
6451 text_action_t action
;
6454 bfd_boolean do_action
; /* If false, then we will not perform the action. */
6458 /* The ebb_constraint_struct keeps a set of proposed actions for an
6459 extended basic block. */
6461 typedef struct ebb_constraint_struct ebb_constraint
;
6463 struct ebb_constraint_struct
6466 bfd_boolean start_movable
;
6468 /* Bytes of extra space at the beginning if movable. */
6469 int start_extra_space
;
6471 enum ebb_target_enum start_align
;
6473 bfd_boolean end_movable
;
6475 /* Bytes of extra space at the end if movable. */
6476 int end_extra_space
;
6478 unsigned action_count
;
6479 unsigned action_allocated
;
6481 /* Array of proposed actions. */
6482 proposed_action
*actions
;
6484 /* Action alignments -- one for each proposed action. */
6485 enum ebb_target_enum
*action_aligns
;
6490 init_ebb_constraint (ebb_constraint
*c
)
6492 memset (c
, 0, sizeof (ebb_constraint
));
6497 free_ebb_constraint (ebb_constraint
*c
)
6504 init_ebb (ebb_t
*ebb
,
6507 bfd_size_type content_length
,
6508 property_table_entry
*prop_table
,
6510 Elf_Internal_Rela
*internal_relocs
,
6511 unsigned reloc_count
)
6513 memset (ebb
, 0, sizeof (ebb_t
));
6515 ebb
->contents
= contents
;
6516 ebb
->content_length
= content_length
;
6517 ebb
->ptbl
= prop_table
;
6518 ebb
->pte_count
= ptblsize
;
6519 ebb
->relocs
= internal_relocs
;
6520 ebb
->reloc_count
= reloc_count
;
6521 ebb
->start_offset
= 0;
6522 ebb
->end_offset
= ebb
->content_length
- 1;
6523 ebb
->start_ptbl_idx
= 0;
6524 ebb
->end_ptbl_idx
= ptblsize
;
6525 ebb
->start_reloc_idx
= 0;
6526 ebb
->end_reloc_idx
= reloc_count
;
6530 /* Extend the ebb to all decodable contiguous sections. The algorithm
6531 for building a basic block around an instruction is to push it
6532 forward until we hit the end of a section, an unreachable block or
6533 a block that cannot be transformed. Then we push it backwards
6534 searching for similar conditions. */
6536 static bfd_boolean
extend_ebb_bounds_forward (ebb_t
*);
6537 static bfd_boolean
extend_ebb_bounds_backward (ebb_t
*);
6538 static bfd_size_type insn_block_decodable_len
6539 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6542 extend_ebb_bounds (ebb_t
*ebb
)
6544 if (!extend_ebb_bounds_forward (ebb
))
6546 if (!extend_ebb_bounds_backward (ebb
))
6553 extend_ebb_bounds_forward (ebb_t
*ebb
)
6555 property_table_entry
*the_entry
, *new_entry
;
6557 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6559 /* Stop when (1) we cannot decode an instruction, (2) we are at
6560 the end of the property tables, (3) we hit a non-contiguous property
6561 table entry, (4) we hit a NO_TRANSFORM region. */
6566 bfd_size_type insn_block_len
;
6568 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6570 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6572 entry_end
- ebb
->end_offset
);
6573 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6576 /* xgettext:c-format */
6577 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6578 "possible configuration mismatch"),
6579 ebb
->sec
->owner
, ebb
->sec
,
6580 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6583 ebb
->end_offset
+= insn_block_len
;
6585 if (ebb
->end_offset
== ebb
->sec
->size
)
6586 ebb
->ends_section
= TRUE
;
6588 /* Update the reloc counter. */
6589 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6590 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6593 ebb
->end_reloc_idx
++;
6596 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6599 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6600 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6601 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6602 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6605 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6608 the_entry
= new_entry
;
6609 ebb
->end_ptbl_idx
++;
6612 /* Quick check for an unreachable or end of file just at the end. */
6613 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6615 if (ebb
->end_offset
== ebb
->content_length
)
6616 ebb
->ends_section
= TRUE
;
6620 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6621 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6622 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6623 ebb
->ends_unreachable
= new_entry
;
6626 /* Any other ending requires exact alignment. */
6632 extend_ebb_bounds_backward (ebb_t
*ebb
)
6634 property_table_entry
*the_entry
, *new_entry
;
6636 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6638 /* Stop when (1) we cannot decode the instructions in the current entry.
6639 (2) we are at the beginning of the property tables, (3) we hit a
6640 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6644 bfd_vma block_begin
;
6645 bfd_size_type insn_block_len
;
6647 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6649 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6651 ebb
->start_offset
- block_begin
);
6652 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6655 /* xgettext:c-format */
6656 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6657 "possible configuration mismatch"),
6658 ebb
->sec
->owner
, ebb
->sec
,
6659 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6662 ebb
->start_offset
-= insn_block_len
;
6664 /* Update the reloc counter. */
6665 while (ebb
->start_reloc_idx
> 0
6666 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6667 >= ebb
->start_offset
))
6669 ebb
->start_reloc_idx
--;
6672 if (ebb
->start_ptbl_idx
== 0)
6675 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6676 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6677 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6678 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6680 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6683 the_entry
= new_entry
;
6684 ebb
->start_ptbl_idx
--;
6690 static bfd_size_type
6691 insn_block_decodable_len (bfd_byte
*contents
,
6692 bfd_size_type content_len
,
6693 bfd_vma block_offset
,
6694 bfd_size_type block_len
)
6696 bfd_vma offset
= block_offset
;
6698 while (offset
< block_offset
+ block_len
)
6700 bfd_size_type insn_len
= 0;
6702 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6704 return (offset
- block_offset
);
6707 return (offset
- block_offset
);
6712 ebb_propose_action (ebb_constraint
*c
,
6713 enum ebb_target_enum align_type
,
6714 bfd_vma alignment_pow
,
6715 text_action_t action
,
6718 bfd_boolean do_action
)
6720 proposed_action
*act
;
6722 if (c
->action_allocated
<= c
->action_count
)
6724 unsigned new_allocated
, i
;
6725 proposed_action
*new_actions
;
6727 new_allocated
= (c
->action_count
+ 2) * 2;
6728 new_actions
= (proposed_action
*)
6729 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6731 for (i
= 0; i
< c
->action_count
; i
++)
6732 new_actions
[i
] = c
->actions
[i
];
6734 c
->actions
= new_actions
;
6735 c
->action_allocated
= new_allocated
;
6738 act
= &c
->actions
[c
->action_count
];
6739 act
->align_type
= align_type
;
6740 act
->alignment_pow
= alignment_pow
;
6741 act
->action
= action
;
6742 act
->offset
= offset
;
6743 act
->removed_bytes
= removed_bytes
;
6744 act
->do_action
= do_action
;
6750 /* Access to internal relocations, section contents and symbols. */
6752 /* During relaxation, we need to modify relocations, section contents,
6753 and symbol definitions, and we need to keep the original values from
6754 being reloaded from the input files, i.e., we need to "pin" the
6755 modified values in memory. We also want to continue to observe the
6756 setting of the "keep-memory" flag. The following functions wrap the
6757 standard BFD functions to take care of this for us. */
6759 static Elf_Internal_Rela
*
6760 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6762 Elf_Internal_Rela
*internal_relocs
;
6764 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6767 internal_relocs
= elf_section_data (sec
)->relocs
;
6768 if (internal_relocs
== NULL
)
6769 internal_relocs
= (_bfd_elf_link_read_relocs
6770 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6771 return internal_relocs
;
6776 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6778 elf_section_data (sec
)->relocs
= internal_relocs
;
6783 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6785 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
6786 free (internal_relocs
);
6791 retrieve_contents (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6794 bfd_size_type sec_size
;
6796 sec_size
= bfd_get_section_limit (abfd
, sec
);
6797 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6799 if (contents
== NULL
&& sec_size
!= 0)
6801 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6807 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6814 pin_contents (asection
*sec
, bfd_byte
*contents
)
6816 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6821 release_contents (asection
*sec
, bfd_byte
*contents
)
6823 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6828 static Elf_Internal_Sym
*
6829 retrieve_local_syms (bfd
*input_bfd
)
6831 Elf_Internal_Shdr
*symtab_hdr
;
6832 Elf_Internal_Sym
*isymbuf
;
6835 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6836 locsymcount
= symtab_hdr
->sh_info
;
6838 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6839 if (isymbuf
== NULL
&& locsymcount
!= 0)
6840 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6843 /* Save the symbols for this input file so they won't be read again. */
6844 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6845 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6851 /* Code for link-time relaxation. */
6853 /* Initialization for relaxation: */
6854 static bfd_boolean
analyze_relocations (struct bfd_link_info
*);
6855 static bfd_boolean find_relaxable_sections
6856 (bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*);
6857 static bfd_boolean collect_source_relocs
6858 (bfd
*, asection
*, struct bfd_link_info
*);
6859 static bfd_boolean is_resolvable_asm_expansion
6860 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6862 static Elf_Internal_Rela
*find_associated_l32r_irel
6863 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6864 static bfd_boolean compute_text_actions
6865 (bfd
*, asection
*, struct bfd_link_info
*);
6866 static bfd_boolean
compute_ebb_proposed_actions (ebb_constraint
*);
6867 static bfd_boolean
compute_ebb_actions (ebb_constraint
*);
6868 typedef struct reloc_range_list_struct reloc_range_list
;
6869 static bfd_boolean check_section_ebb_pcrels_fit
6870 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6871 reloc_range_list
*, const ebb_constraint
*,
6872 const xtensa_opcode
*);
6873 static bfd_boolean
check_section_ebb_reduces (const ebb_constraint
*);
6874 static void text_action_add_proposed
6875 (text_action_list
*, const ebb_constraint
*, asection
*);
6878 static bfd_boolean compute_removed_literals
6879 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6880 static Elf_Internal_Rela
*get_irel_at_offset
6881 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6882 static bfd_boolean is_removable_literal
6883 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6884 property_table_entry
*, int);
6885 static bfd_boolean remove_dead_literal
6886 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6887 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6888 static bfd_boolean identify_literal_placement
6889 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6890 value_map_hash_table
*, bfd_boolean
*, Elf_Internal_Rela
*, int,
6891 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6893 static bfd_boolean
relocations_reach (source_reloc
*, int, const r_reloc
*);
6894 static bfd_boolean coalesce_shared_literal
6895 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6896 static bfd_boolean move_shared_literal
6897 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6898 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6901 static bfd_boolean
relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6902 static bfd_boolean
translate_section_fixes (asection
*);
6903 static bfd_boolean
translate_reloc_bfd_fix (reloc_bfd_fix
*);
6904 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6905 static void shrink_dynamic_reloc_sections
6906 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6907 static bfd_boolean move_literal
6908 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6909 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6910 static bfd_boolean relax_property_section
6911 (bfd
*, asection
*, struct bfd_link_info
*);
6914 static bfd_boolean
relax_section_symbols (bfd
*, asection
*);
6918 elf_xtensa_relax_section (bfd
*abfd
,
6920 struct bfd_link_info
*link_info
,
6923 static value_map_hash_table
*values
= NULL
;
6924 static bfd_boolean relocations_analyzed
= FALSE
;
6925 xtensa_relax_info
*relax_info
;
6927 if (!relocations_analyzed
)
6929 /* Do some overall initialization for relaxation. */
6930 values
= value_map_hash_table_init ();
6933 relaxing_section
= TRUE
;
6934 if (!analyze_relocations (link_info
))
6936 relocations_analyzed
= TRUE
;
6940 /* Don't mess with linker-created sections. */
6941 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6944 relax_info
= get_xtensa_relax_info (sec
);
6945 BFD_ASSERT (relax_info
!= NULL
);
6947 switch (relax_info
->visited
)
6950 /* Note: It would be nice to fold this pass into
6951 analyze_relocations, but it is important for this step that the
6952 sections be examined in link order. */
6953 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6960 value_map_hash_table_delete (values
);
6962 if (!relax_section (abfd
, sec
, link_info
))
6968 if (!relax_section_symbols (abfd
, sec
))
6973 relax_info
->visited
++;
6978 /* Initialization for relaxation. */
6980 /* This function is called once at the start of relaxation. It scans
6981 all the input sections and marks the ones that are relaxable (i.e.,
6982 literal sections with L32R relocations against them), and then
6983 collects source_reloc information for all the relocations against
6984 those relaxable sections. During this process, it also detects
6985 longcalls, i.e., calls relaxed by the assembler into indirect
6986 calls, that can be optimized back into direct calls. Within each
6987 extended basic block (ebb) containing an optimized longcall, it
6988 computes a set of "text actions" that can be performed to remove
6989 the L32R associated with the longcall while optionally preserving
6990 branch target alignments. */
6993 analyze_relocations (struct bfd_link_info
*link_info
)
6997 bfd_boolean is_relaxable
= FALSE
;
6999 /* Initialize the per-section relaxation info. */
7000 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7001 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7003 init_xtensa_relax_info (sec
);
7006 /* Mark relaxable sections (and count relocations against each one). */
7007 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7008 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7010 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
7014 /* Bail out if there are no relaxable sections. */
7018 /* Allocate space for source_relocs. */
7019 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7020 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7022 xtensa_relax_info
*relax_info
;
7024 relax_info
= get_xtensa_relax_info (sec
);
7025 if (relax_info
->is_relaxable_literal_section
7026 || relax_info
->is_relaxable_asm_section
)
7028 relax_info
->src_relocs
= (source_reloc
*)
7029 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
7032 relax_info
->src_count
= 0;
7035 /* Collect info on relocations against each relaxable section. */
7036 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7037 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7039 if (!collect_source_relocs (abfd
, sec
, link_info
))
7043 /* Compute the text actions. */
7044 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7045 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7047 if (!compute_text_actions (abfd
, sec
, link_info
))
7055 /* Find all the sections that might be relaxed. The motivation for
7056 this pass is that collect_source_relocs() needs to record _all_ the
7057 relocations that target each relaxable section. That is expensive
7058 and unnecessary unless the target section is actually going to be
7059 relaxed. This pass identifies all such sections by checking if
7060 they have L32Rs pointing to them. In the process, the total number
7061 of relocations targeting each section is also counted so that we
7062 know how much space to allocate for source_relocs against each
7063 relaxable literal section. */
7066 find_relaxable_sections (bfd
*abfd
,
7068 struct bfd_link_info
*link_info
,
7069 bfd_boolean
*is_relaxable_p
)
7071 Elf_Internal_Rela
*internal_relocs
;
7073 bfd_boolean ok
= TRUE
;
7075 xtensa_relax_info
*source_relax_info
;
7076 bfd_boolean is_l32r_reloc
;
7078 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7079 link_info
->keep_memory
);
7080 if (internal_relocs
== NULL
)
7083 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7084 if (contents
== NULL
&& sec
->size
!= 0)
7090 source_relax_info
= get_xtensa_relax_info (sec
);
7091 for (i
= 0; i
< sec
->reloc_count
; i
++)
7093 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7095 asection
*target_sec
;
7096 xtensa_relax_info
*target_relax_info
;
7098 /* If this section has not already been marked as "relaxable", and
7099 if it contains any ASM_EXPAND relocations (marking expanded
7100 longcalls) that can be optimized into direct calls, then mark
7101 the section as "relaxable". */
7102 if (source_relax_info
7103 && !source_relax_info
->is_relaxable_asm_section
7104 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
7106 bfd_boolean is_reachable
= FALSE
;
7107 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
7108 link_info
, &is_reachable
)
7111 source_relax_info
->is_relaxable_asm_section
= TRUE
;
7112 *is_relaxable_p
= TRUE
;
7116 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7117 bfd_get_section_limit (abfd
, sec
));
7119 target_sec
= r_reloc_get_section (&r_rel
);
7120 target_relax_info
= get_xtensa_relax_info (target_sec
);
7121 if (!target_relax_info
)
7124 /* Count PC-relative operand relocations against the target section.
7125 Note: The conditions tested here must match the conditions under
7126 which init_source_reloc is called in collect_source_relocs(). */
7127 is_l32r_reloc
= FALSE
;
7128 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7130 xtensa_opcode opcode
=
7131 get_relocation_opcode (abfd
, sec
, contents
, irel
);
7132 if (opcode
!= XTENSA_UNDEFINED
)
7134 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
7135 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
7137 target_relax_info
->src_count
++;
7141 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7143 /* Mark the target section as relaxable. */
7144 target_relax_info
->is_relaxable_literal_section
= TRUE
;
7145 *is_relaxable_p
= TRUE
;
7150 release_contents (sec
, contents
);
7151 release_internal_relocs (sec
, internal_relocs
);
7156 /* Record _all_ the relocations that point to relaxable sections, and
7157 get rid of ASM_EXPAND relocs by either converting them to
7158 ASM_SIMPLIFY or by removing them. */
7161 collect_source_relocs (bfd
*abfd
,
7163 struct bfd_link_info
*link_info
)
7165 Elf_Internal_Rela
*internal_relocs
;
7167 bfd_boolean ok
= TRUE
;
7169 bfd_size_type sec_size
;
7171 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7172 link_info
->keep_memory
);
7173 if (internal_relocs
== NULL
)
7176 sec_size
= bfd_get_section_limit (abfd
, sec
);
7177 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7178 if (contents
== NULL
&& sec_size
!= 0)
7184 /* Record relocations against relaxable literal sections. */
7185 for (i
= 0; i
< sec
->reloc_count
; i
++)
7187 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7189 asection
*target_sec
;
7190 xtensa_relax_info
*target_relax_info
;
7192 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7194 target_sec
= r_reloc_get_section (&r_rel
);
7195 target_relax_info
= get_xtensa_relax_info (target_sec
);
7197 if (target_relax_info
7198 && (target_relax_info
->is_relaxable_literal_section
7199 || target_relax_info
->is_relaxable_asm_section
))
7201 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7203 bfd_boolean is_abs_literal
= FALSE
;
7205 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7207 /* None of the current alternate relocs are PC-relative,
7208 and only PC-relative relocs matter here. However, we
7209 still need to record the opcode for literal
7211 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7212 if (opcode
== get_l32r_opcode ())
7214 is_abs_literal
= TRUE
;
7218 opcode
= XTENSA_UNDEFINED
;
7220 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7222 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7223 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7226 if (opcode
!= XTENSA_UNDEFINED
)
7228 int src_next
= target_relax_info
->src_next
++;
7229 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7231 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7237 /* Now get rid of ASM_EXPAND relocations. At this point, the
7238 src_relocs array for the target literal section may still be
7239 incomplete, but it must at least contain the entries for the L32R
7240 relocations associated with ASM_EXPANDs because they were just
7241 added in the preceding loop over the relocations. */
7243 for (i
= 0; i
< sec
->reloc_count
; i
++)
7245 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7246 bfd_boolean is_reachable
;
7248 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7254 Elf_Internal_Rela
*l32r_irel
;
7256 asection
*target_sec
;
7257 xtensa_relax_info
*target_relax_info
;
7259 /* Mark the source_reloc for the L32R so that it will be
7260 removed in compute_removed_literals(), along with the
7261 associated literal. */
7262 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7263 irel
, internal_relocs
);
7264 if (l32r_irel
== NULL
)
7267 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7269 target_sec
= r_reloc_get_section (&r_rel
);
7270 target_relax_info
= get_xtensa_relax_info (target_sec
);
7272 if (target_relax_info
7273 && (target_relax_info
->is_relaxable_literal_section
7274 || target_relax_info
->is_relaxable_asm_section
))
7276 source_reloc
*s_reloc
;
7278 /* Search the source_relocs for the entry corresponding to
7279 the l32r_irel. Note: The src_relocs array is not yet
7280 sorted, but it wouldn't matter anyway because we're
7281 searching by source offset instead of target offset. */
7282 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7283 target_relax_info
->src_next
,
7285 BFD_ASSERT (s_reloc
);
7286 s_reloc
->is_null
= TRUE
;
7289 /* Convert this reloc to ASM_SIMPLIFY. */
7290 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7291 R_XTENSA_ASM_SIMPLIFY
);
7292 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7294 pin_internal_relocs (sec
, internal_relocs
);
7298 /* It is resolvable but doesn't reach. We resolve now
7299 by eliminating the relocation -- the call will remain
7300 expanded into L32R/CALLX. */
7301 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7302 pin_internal_relocs (sec
, internal_relocs
);
7307 release_contents (sec
, contents
);
7308 release_internal_relocs (sec
, internal_relocs
);
7313 /* Return TRUE if the asm expansion can be resolved. Generally it can
7314 be resolved on a final link or when a partial link locates it in the
7315 same section as the target. Set "is_reachable" flag if the target of
7316 the call is within the range of a direct call, given the current VMA
7317 for this section and the target section. */
7320 is_resolvable_asm_expansion (bfd
*abfd
,
7323 Elf_Internal_Rela
*irel
,
7324 struct bfd_link_info
*link_info
,
7325 bfd_boolean
*is_reachable_p
)
7327 asection
*target_sec
;
7331 unsigned int first_align
;
7332 unsigned int adjust
;
7333 bfd_vma target_offset
;
7335 xtensa_opcode opcode
, direct_call_opcode
;
7336 bfd_vma self_address
;
7337 bfd_vma dest_address
;
7338 bfd_boolean uses_l32r
;
7339 bfd_size_type sec_size
;
7341 *is_reachable_p
= FALSE
;
7343 if (contents
== NULL
)
7346 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7349 sec_size
= bfd_get_section_limit (abfd
, sec
);
7350 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7351 sec_size
- irel
->r_offset
, &uses_l32r
);
7352 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7356 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7357 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7360 /* Check and see that the target resolves. */
7361 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7362 if (!r_reloc_is_defined (&r_rel
))
7365 target_sec
= r_reloc_get_section (&r_rel
);
7366 target_offset
= r_rel
.target_offset
;
7368 /* If the target is in a shared library, then it doesn't reach. This
7369 isn't supposed to come up because the compiler should never generate
7370 non-PIC calls on systems that use shared libraries, but the linker
7371 shouldn't crash regardless. */
7372 if (!target_sec
->output_section
)
7375 /* For relocatable sections, we can only simplify when the output
7376 section of the target is the same as the output section of the
7378 if (bfd_link_relocatable (link_info
)
7379 && (target_sec
->output_section
!= sec
->output_section
7380 || is_reloc_sym_weak (abfd
, irel
)))
7383 if (target_sec
->output_section
!= sec
->output_section
)
7385 /* If the two sections are sufficiently far away that relaxation
7386 might take the call out of range, we can't simplify. For
7387 example, a positive displacement call into another memory
7388 could get moved to a lower address due to literal removal,
7389 but the destination won't move, and so the displacment might
7392 If the displacement is negative, assume the destination could
7393 move as far back as the start of the output section. The
7394 self_address will be at least as far into the output section
7395 as it is prior to relaxation.
7397 If the displacement is postive, assume the destination will be in
7398 it's pre-relaxed location (because relaxation only makes sections
7399 smaller). The self_address could go all the way to the beginning
7400 of the output section. */
7402 dest_address
= target_sec
->output_section
->vma
;
7403 self_address
= sec
->output_section
->vma
;
7405 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7406 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7408 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7409 /* Call targets should be four-byte aligned. */
7410 dest_address
= (dest_address
+ 3) & ~3;
7415 self_address
= (sec
->output_section
->vma
7416 + sec
->output_offset
+ irel
->r_offset
+ 3);
7417 dest_address
= (target_sec
->output_section
->vma
7418 + target_sec
->output_offset
+ target_offset
);
7421 /* Adjust addresses with alignments for the worst case to see if call insn
7422 can fit. Don't relax l32r + callx to call if the target can be out of
7423 range due to alignment.
7424 Caller and target addresses are highest and lowest address.
7425 Search all sections between caller and target, looking for max alignment.
7426 The adjustment is max alignment bytes. If the alignment at the lowest
7427 address is less than the adjustment, apply the adjustment to highest
7430 /* Start from lowest address.
7431 Lowest address aligmnet is from input section.
7432 Initial alignment (adjust) is from input section. */
7433 if (dest_address
> self_address
)
7435 s
= sec
->output_section
;
7436 last_vma
= dest_address
;
7437 first_align
= sec
->alignment_power
;
7438 adjust
= target_sec
->alignment_power
;
7442 s
= target_sec
->output_section
;
7443 last_vma
= self_address
;
7444 first_align
= target_sec
->alignment_power
;
7445 adjust
= sec
->alignment_power
;
7450 /* Find the largest alignment in output section list. */
7451 for (; s
&& s
->vma
>= first_vma
&& s
->vma
<= last_vma
; s
= s
->next
)
7453 if (s
->alignment_power
> adjust
)
7454 adjust
= s
->alignment_power
;
7457 if (adjust
> first_align
)
7459 /* Alignment may enlarge the range, adjust highest address. */
7460 adjust
= 1 << adjust
;
7461 if (dest_address
> self_address
)
7463 dest_address
+= adjust
;
7467 self_address
+= adjust
;
7471 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7472 self_address
, dest_address
);
7474 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7475 (dest_address
>> CALL_SEGMENT_BITS
))
7482 static Elf_Internal_Rela
*
7483 find_associated_l32r_irel (bfd
*abfd
,
7486 Elf_Internal_Rela
*other_irel
,
7487 Elf_Internal_Rela
*internal_relocs
)
7491 for (i
= 0; i
< sec
->reloc_count
; i
++)
7493 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7495 if (irel
== other_irel
)
7497 if (irel
->r_offset
!= other_irel
->r_offset
)
7499 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7507 static xtensa_opcode
*
7508 build_reloc_opcodes (bfd
*abfd
,
7511 Elf_Internal_Rela
*internal_relocs
)
7514 xtensa_opcode
*reloc_opcodes
=
7515 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7516 for (i
= 0; i
< sec
->reloc_count
; i
++)
7518 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7519 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7521 return reloc_opcodes
;
7524 struct reloc_range_struct
7527 bfd_boolean add
; /* TRUE if start of a range, FALSE otherwise. */
7528 /* Original irel index in the array of relocations for a section. */
7529 unsigned irel_index
;
7531 typedef struct reloc_range_struct reloc_range
;
7533 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7534 struct reloc_range_list_entry_struct
7536 reloc_range_list_entry
*next
;
7537 reloc_range_list_entry
*prev
;
7538 Elf_Internal_Rela
*irel
;
7539 xtensa_opcode opcode
;
7543 struct reloc_range_list_struct
7545 /* The rest of the structure is only meaningful when ok is TRUE. */
7548 unsigned n_range
; /* Number of range markers. */
7549 reloc_range
*range
; /* Sorted range markers. */
7551 unsigned first
; /* Index of a first range element in the list. */
7552 unsigned last
; /* One past index of a last range element in the list. */
7554 unsigned n_list
; /* Number of list elements. */
7555 reloc_range_list_entry
*reloc
; /* */
7556 reloc_range_list_entry list_root
;
7560 reloc_range_compare (const void *a
, const void *b
)
7562 const reloc_range
*ra
= a
;
7563 const reloc_range
*rb
= b
;
7565 if (ra
->addr
!= rb
->addr
)
7566 return ra
->addr
< rb
->addr
? -1 : 1;
7567 if (ra
->add
!= rb
->add
)
7568 return ra
->add
? -1 : 1;
7573 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7575 Elf_Internal_Rela
*internal_relocs
,
7576 xtensa_opcode
*reloc_opcodes
,
7577 reloc_range_list
*list
)
7582 reloc_range
*ranges
= NULL
;
7583 reloc_range_list_entry
*reloc
=
7584 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7586 memset (list
, 0, sizeof (*list
));
7589 for (i
= 0; i
< sec
->reloc_count
; i
++)
7591 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7592 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7593 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7596 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7597 || r_type
== R_XTENSA_32_PCREL
7598 || !howto
->pc_relative
)
7601 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7602 bfd_get_section_limit (abfd
, sec
));
7604 if (r_reloc_get_section (&r_rel
) != sec
)
7609 max_n
= (max_n
+ 2) * 2;
7610 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7613 ranges
[n
].addr
= irel
->r_offset
;
7614 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7616 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7617 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7619 ranges
[n
].irel_index
= i
;
7620 ranges
[n
+ 1].irel_index
= i
;
7624 reloc
[i
].irel
= irel
;
7626 /* Every relocation won't possibly be checked in the optimized version of
7627 check_section_ebb_pcrels_fit, so this needs to be done here. */
7628 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7630 /* None of the current alternate relocs are PC-relative,
7631 and only PC-relative relocs matter here. */
7635 xtensa_opcode opcode
;
7639 opcode
= reloc_opcodes
[i
];
7641 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7643 if (opcode
== XTENSA_UNDEFINED
)
7649 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7650 if (opnum
== XTENSA_UNDEFINED
)
7656 /* Record relocation opcode and opnum as we've calculated them
7657 anyway and they won't change. */
7658 reloc
[i
].opcode
= opcode
;
7659 reloc
[i
].opnum
= opnum
;
7665 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7666 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7669 list
->range
= ranges
;
7670 list
->reloc
= reloc
;
7671 list
->list_root
.prev
= &list
->list_root
;
7672 list
->list_root
.next
= &list
->list_root
;
7681 static void reloc_range_list_append (reloc_range_list
*list
,
7682 unsigned irel_index
)
7684 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7686 entry
->prev
= list
->list_root
.prev
;
7687 entry
->next
= &list
->list_root
;
7688 entry
->prev
->next
= entry
;
7689 entry
->next
->prev
= entry
;
7693 static void reloc_range_list_remove (reloc_range_list
*list
,
7694 unsigned irel_index
)
7696 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7698 entry
->next
->prev
= entry
->prev
;
7699 entry
->prev
->next
= entry
->next
;
7703 /* Update relocation list object so that it lists all relocations that cross
7704 [first; last] range. Range bounds should not decrease with successive
7706 static void reloc_range_list_update_range (reloc_range_list
*list
,
7707 bfd_vma first
, bfd_vma last
)
7709 /* This should not happen: EBBs are iterated from lower addresses to higher.
7710 But even if that happens there's no need to break: just flush current list
7711 and start from scratch. */
7712 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7713 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7718 list
->list_root
.next
= &list
->list_root
;
7719 list
->list_root
.prev
= &list
->list_root
;
7720 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7723 for (; list
->last
< list
->n_range
&&
7724 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7725 if (list
->range
[list
->last
].add
)
7726 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7728 for (; list
->first
< list
->n_range
&&
7729 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7730 if (!list
->range
[list
->first
].add
)
7731 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7734 static void free_reloc_range_list (reloc_range_list
*list
)
7740 /* The compute_text_actions function will build a list of potential
7741 transformation actions for code in the extended basic block of each
7742 longcall that is optimized to a direct call. From this list we
7743 generate a set of actions to actually perform that optimizes for
7744 space and, if not using size_opt, maintains branch target
7747 These actions to be performed are placed on a per-section list.
7748 The actual changes are performed by relax_section() in the second
7752 compute_text_actions (bfd
*abfd
,
7754 struct bfd_link_info
*link_info
)
7756 xtensa_opcode
*reloc_opcodes
= NULL
;
7757 xtensa_relax_info
*relax_info
;
7759 Elf_Internal_Rela
*internal_relocs
;
7760 bfd_boolean ok
= TRUE
;
7762 property_table_entry
*prop_table
= 0;
7764 bfd_size_type sec_size
;
7765 reloc_range_list relevant_relocs
;
7767 relax_info
= get_xtensa_relax_info (sec
);
7768 BFD_ASSERT (relax_info
);
7769 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7771 /* Do nothing if the section contains no optimized longcalls. */
7772 if (!relax_info
->is_relaxable_asm_section
)
7775 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7776 link_info
->keep_memory
);
7778 if (internal_relocs
)
7779 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7780 internal_reloc_compare
);
7782 sec_size
= bfd_get_section_limit (abfd
, sec
);
7783 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7784 if (contents
== NULL
&& sec_size
!= 0)
7790 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7791 XTENSA_PROP_SEC_NAME
, FALSE
);
7798 /* Precompute the opcode for each relocation. */
7799 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7801 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7804 for (i
= 0; i
< sec
->reloc_count
; i
++)
7806 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7808 property_table_entry
*the_entry
;
7811 ebb_constraint ebb_table
;
7812 bfd_size_type simplify_size
;
7814 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7816 r_offset
= irel
->r_offset
;
7818 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7819 if (simplify_size
== 0)
7822 /* xgettext:c-format */
7823 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7824 "XTENSA_ASM_SIMPLIFY relocation; "
7825 "possible configuration mismatch"),
7826 sec
->owner
, sec
, (uint64_t) r_offset
);
7830 /* If the instruction table is not around, then don't do this
7832 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7833 sec
->vma
+ irel
->r_offset
);
7834 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7836 text_action_add (&relax_info
->action_list
,
7837 ta_convert_longcall
, sec
, r_offset
,
7842 /* If the next longcall happens to be at the same address as an
7843 unreachable section of size 0, then skip forward. */
7844 ptbl_idx
= the_entry
- prop_table
;
7845 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7846 && the_entry
->size
== 0
7847 && ptbl_idx
+ 1 < ptblsize
7848 && (prop_table
[ptbl_idx
+ 1].address
7849 == prop_table
[ptbl_idx
].address
))
7855 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7856 /* NO_REORDER is OK */
7859 init_ebb_constraint (&ebb_table
);
7860 ebb
= &ebb_table
.ebb
;
7861 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7862 internal_relocs
, sec
->reloc_count
);
7863 ebb
->start_offset
= r_offset
+ simplify_size
;
7864 ebb
->end_offset
= r_offset
+ simplify_size
;
7865 ebb
->start_ptbl_idx
= ptbl_idx
;
7866 ebb
->end_ptbl_idx
= ptbl_idx
;
7867 ebb
->start_reloc_idx
= i
;
7868 ebb
->end_reloc_idx
= i
;
7870 if (!extend_ebb_bounds (ebb
)
7871 || !compute_ebb_proposed_actions (&ebb_table
)
7872 || !compute_ebb_actions (&ebb_table
)
7873 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7876 &ebb_table
, reloc_opcodes
)
7877 || !check_section_ebb_reduces (&ebb_table
))
7879 /* If anything goes wrong or we get unlucky and something does
7880 not fit, with our plan because of expansion between
7881 critical branches, just convert to a NOP. */
7883 text_action_add (&relax_info
->action_list
,
7884 ta_convert_longcall
, sec
, r_offset
, 0);
7885 i
= ebb_table
.ebb
.end_reloc_idx
;
7886 free_ebb_constraint (&ebb_table
);
7890 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7892 /* Update the index so we do not go looking at the relocations
7893 we have already processed. */
7894 i
= ebb_table
.ebb
.end_reloc_idx
;
7895 free_ebb_constraint (&ebb_table
);
7898 free_reloc_range_list (&relevant_relocs
);
7901 if (action_list_count (&relax_info
->action_list
))
7902 print_action_list (stderr
, &relax_info
->action_list
);
7906 release_contents (sec
, contents
);
7907 release_internal_relocs (sec
, internal_relocs
);
7909 free (reloc_opcodes
);
7915 /* Do not widen an instruction if it is preceeded by a
7916 loop opcode. It might cause misalignment. */
7919 prev_instr_is_a_loop (bfd_byte
*contents
,
7920 bfd_size_type content_length
,
7921 bfd_size_type offset
)
7923 xtensa_opcode prev_opcode
;
7927 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7928 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7932 /* Find all of the possible actions for an extended basic block. */
7935 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7937 const ebb_t
*ebb
= &ebb_table
->ebb
;
7938 unsigned rel_idx
= ebb
->start_reloc_idx
;
7939 property_table_entry
*entry
, *start_entry
, *end_entry
;
7941 xtensa_isa isa
= xtensa_default_isa
;
7943 static xtensa_insnbuf insnbuf
= NULL
;
7944 static xtensa_insnbuf slotbuf
= NULL
;
7946 if (insnbuf
== NULL
)
7948 insnbuf
= xtensa_insnbuf_alloc (isa
);
7949 slotbuf
= xtensa_insnbuf_alloc (isa
);
7952 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7953 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7955 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7957 bfd_vma start_offset
, end_offset
;
7958 bfd_size_type insn_len
;
7960 start_offset
= entry
->address
- ebb
->sec
->vma
;
7961 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7963 if (entry
== start_entry
)
7964 start_offset
= ebb
->start_offset
;
7965 if (entry
== end_entry
)
7966 end_offset
= ebb
->end_offset
;
7967 offset
= start_offset
;
7969 if (offset
== entry
->address
- ebb
->sec
->vma
7970 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7972 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7973 BFD_ASSERT (offset
!= end_offset
);
7974 if (offset
== end_offset
)
7977 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7982 if (check_branch_target_aligned_address (offset
, insn_len
))
7983 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7985 ebb_propose_action (ebb_table
, align_type
, 0,
7986 ta_none
, offset
, 0, TRUE
);
7989 while (offset
!= end_offset
)
7991 Elf_Internal_Rela
*irel
;
7992 xtensa_opcode opcode
;
7994 while (rel_idx
< ebb
->end_reloc_idx
7995 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7996 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7997 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
7998 != R_XTENSA_ASM_SIMPLIFY
))))
8001 /* Check for longcall. */
8002 irel
= &ebb
->relocs
[rel_idx
];
8003 if (irel
->r_offset
== offset
8004 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
8006 bfd_size_type simplify_size
;
8008 simplify_size
= get_asm_simplify_size (ebb
->contents
,
8009 ebb
->content_length
,
8011 if (simplify_size
== 0)
8014 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8015 ta_convert_longcall
, offset
, 0, TRUE
);
8017 offset
+= simplify_size
;
8021 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
8023 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
8024 ebb
->content_length
- offset
);
8025 fmt
= xtensa_format_decode (isa
, insnbuf
);
8026 if (fmt
== XTENSA_UNDEFINED
)
8028 insn_len
= xtensa_format_length (isa
, fmt
);
8029 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
8032 if (xtensa_format_num_slots (isa
, fmt
) != 1)
8038 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
8039 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
8040 if (opcode
== XTENSA_UNDEFINED
)
8043 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
8044 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8045 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
8047 /* Add an instruction narrow action. */
8048 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8049 ta_narrow_insn
, offset
, 0, FALSE
);
8051 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8052 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
8053 && ! prev_instr_is_a_loop (ebb
->contents
,
8054 ebb
->content_length
, offset
))
8056 /* Add an instruction widen action. */
8057 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8058 ta_widen_insn
, offset
, 0, FALSE
);
8060 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
8062 /* Check for branch targets. */
8063 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
8064 ta_none
, offset
, 0, TRUE
);
8071 if (ebb
->ends_unreachable
)
8073 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8074 ta_fill
, ebb
->end_offset
, 0, TRUE
);
8081 /* xgettext:c-format */
8082 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
8083 "possible configuration mismatch"),
8084 ebb
->sec
->owner
, ebb
->sec
, (uint64_t) offset
);
8089 /* After all of the information has collected about the
8090 transformations possible in an EBB, compute the appropriate actions
8091 here in compute_ebb_actions. We still must check later to make
8092 sure that the actions do not break any relocations. The algorithm
8093 used here is pretty greedy. Basically, it removes as many no-ops
8094 as possible so that the end of the EBB has the same alignment
8095 characteristics as the original. First, it uses narrowing, then
8096 fill space at the end of the EBB, and finally widenings. If that
8097 does not work, it tries again with one fewer no-op removed. The
8098 optimization will only be performed if all of the branch targets
8099 that were aligned before transformation are also aligned after the
8102 When the size_opt flag is set, ignore the branch target alignments,
8103 narrow all wide instructions, and remove all no-ops unless the end
8104 of the EBB prevents it. */
8107 compute_ebb_actions (ebb_constraint
*ebb_table
)
8111 int removed_bytes
= 0;
8112 ebb_t
*ebb
= &ebb_table
->ebb
;
8113 unsigned seg_idx_start
= 0;
8114 unsigned seg_idx_end
= 0;
8116 /* We perform this like the assembler relaxation algorithm: Start by
8117 assuming all instructions are narrow and all no-ops removed; then
8120 /* For each segment of this that has a solid constraint, check to
8121 see if there are any combinations that will keep the constraint.
8123 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
8125 bfd_boolean requires_text_end_align
= FALSE
;
8126 unsigned longcall_count
= 0;
8127 unsigned longcall_convert_count
= 0;
8128 unsigned narrowable_count
= 0;
8129 unsigned narrowable_convert_count
= 0;
8130 unsigned widenable_count
= 0;
8131 unsigned widenable_convert_count
= 0;
8133 proposed_action
*action
= NULL
;
8134 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
8136 seg_idx_start
= seg_idx_end
;
8138 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
8140 action
= &ebb_table
->actions
[i
];
8141 if (action
->action
== ta_convert_longcall
)
8143 if (action
->action
== ta_narrow_insn
)
8145 if (action
->action
== ta_widen_insn
)
8147 if (action
->action
== ta_fill
)
8149 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8151 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
8152 && !elf32xtensa_size_opt
)
8157 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
8158 requires_text_end_align
= TRUE
;
8160 if (elf32xtensa_size_opt
&& !requires_text_end_align
8161 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
8162 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
8164 longcall_convert_count
= longcall_count
;
8165 narrowable_convert_count
= narrowable_count
;
8166 widenable_convert_count
= 0;
8170 /* There is a constraint. Convert the max number of longcalls. */
8171 narrowable_convert_count
= 0;
8172 longcall_convert_count
= 0;
8173 widenable_convert_count
= 0;
8175 for (j
= 0; j
< longcall_count
; j
++)
8177 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
8178 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
8179 unsigned desire_widen
= removed
;
8180 if (desire_narrow
<= narrowable_count
)
8182 narrowable_convert_count
= desire_narrow
;
8183 narrowable_convert_count
+=
8184 (align
* ((narrowable_count
- narrowable_convert_count
)
8186 longcall_convert_count
= (longcall_count
- j
);
8187 widenable_convert_count
= 0;
8190 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
8192 narrowable_convert_count
= 0;
8193 longcall_convert_count
= longcall_count
- j
;
8194 widenable_convert_count
= desire_widen
;
8200 /* Now the number of conversions are saved. Do them. */
8201 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
8203 action
= &ebb_table
->actions
[i
];
8204 switch (action
->action
)
8206 case ta_convert_longcall
:
8207 if (longcall_convert_count
!= 0)
8209 action
->action
= ta_remove_longcall
;
8210 action
->do_action
= TRUE
;
8211 action
->removed_bytes
+= 3;
8212 longcall_convert_count
--;
8215 case ta_narrow_insn
:
8216 if (narrowable_convert_count
!= 0)
8218 action
->do_action
= TRUE
;
8219 action
->removed_bytes
+= 1;
8220 narrowable_convert_count
--;
8224 if (widenable_convert_count
!= 0)
8226 action
->do_action
= TRUE
;
8227 action
->removed_bytes
-= 1;
8228 widenable_convert_count
--;
8237 /* Now we move on to some local opts. Try to remove each of the
8238 remaining longcalls. */
8240 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8243 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8245 int old_removed_bytes
= removed_bytes
;
8246 proposed_action
*action
= &ebb_table
->actions
[i
];
8248 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8250 bfd_boolean bad_alignment
= FALSE
;
8252 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8254 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8255 bfd_vma offset
= new_action
->offset
;
8256 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8258 if (!check_branch_target_aligned
8259 (ebb_table
->ebb
.contents
,
8260 ebb_table
->ebb
.content_length
,
8261 offset
, offset
- removed_bytes
))
8263 bad_alignment
= TRUE
;
8267 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8269 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8270 ebb_table
->ebb
.content_length
,
8272 offset
- removed_bytes
))
8274 bad_alignment
= TRUE
;
8278 if (new_action
->action
== ta_narrow_insn
8279 && !new_action
->do_action
8280 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8282 /* Narrow an instruction and we are done. */
8283 new_action
->do_action
= TRUE
;
8284 new_action
->removed_bytes
+= 1;
8285 bad_alignment
= FALSE
;
8288 if (new_action
->action
== ta_widen_insn
8289 && new_action
->do_action
8290 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8292 /* Narrow an instruction and we are done. */
8293 new_action
->do_action
= FALSE
;
8294 new_action
->removed_bytes
+= 1;
8295 bad_alignment
= FALSE
;
8298 if (new_action
->do_action
)
8299 removed_bytes
+= new_action
->removed_bytes
;
8303 action
->removed_bytes
+= 3;
8304 action
->action
= ta_remove_longcall
;
8305 action
->do_action
= TRUE
;
8308 removed_bytes
= old_removed_bytes
;
8309 if (action
->do_action
)
8310 removed_bytes
+= action
->removed_bytes
;
8315 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8317 proposed_action
*action
= &ebb_table
->actions
[i
];
8318 if (action
->do_action
)
8319 removed_bytes
+= action
->removed_bytes
;
8322 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8323 && ebb
->ends_unreachable
)
8325 proposed_action
*action
;
8329 BFD_ASSERT (ebb_table
->action_count
!= 0);
8330 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8331 BFD_ASSERT (action
->action
== ta_fill
);
8332 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8334 extra_space
= xtensa_compute_fill_extra_space (ebb
->ends_unreachable
);
8335 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8336 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8338 action
->removed_bytes
= extra_space
- br
;
8344 /* The xlate_map is a sorted array of address mappings designed to
8345 answer the offset_with_removed_text() query with a binary search instead
8346 of a linear search through the section's action_list. */
8348 typedef struct xlate_map_entry xlate_map_entry_t
;
8349 typedef struct xlate_map xlate_map_t
;
8351 struct xlate_map_entry
8353 bfd_vma orig_address
;
8354 bfd_vma new_address
;
8360 unsigned entry_count
;
8361 xlate_map_entry_t
*entry
;
8366 xlate_compare (const void *a_v
, const void *b_v
)
8368 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8369 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8370 if (a
->orig_address
< b
->orig_address
)
8372 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8379 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8380 text_action_list
*action_list
,
8384 xlate_map_entry_t
*e
;
8385 struct xlate_map_entry se
;
8388 return offset_with_removed_text (action_list
, offset
);
8390 if (map
->entry_count
== 0)
8393 se
.orig_address
= offset
;
8394 r
= bsearch (&se
, map
->entry
, map
->entry_count
,
8395 sizeof (xlate_map_entry_t
), &xlate_compare
);
8396 e
= (xlate_map_entry_t
*) r
;
8398 /* There could be a jump past the end of the section,
8399 allow it using the last xlate map entry to translate its address. */
8402 e
= map
->entry
+ map
->entry_count
- 1;
8403 if (xlate_compare (&se
, e
) <= 0)
8406 BFD_ASSERT (e
!= NULL
);
8409 return e
->new_address
- e
->orig_address
+ offset
;
8412 typedef struct xlate_map_context_struct xlate_map_context
;
8413 struct xlate_map_context_struct
8416 xlate_map_entry_t
*current_entry
;
8421 xlate_map_fn (splay_tree_node node
, void *p
)
8423 text_action
*r
= (text_action
*)node
->value
;
8424 xlate_map_context
*ctx
= p
;
8425 unsigned orig_size
= 0;
8430 case ta_remove_insn
:
8431 case ta_convert_longcall
:
8432 case ta_remove_literal
:
8433 case ta_add_literal
:
8435 case ta_remove_longcall
:
8438 case ta_narrow_insn
:
8447 ctx
->current_entry
->size
=
8448 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8449 if (ctx
->current_entry
->size
!= 0)
8451 ctx
->current_entry
++;
8452 ctx
->map
->entry_count
++;
8454 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8455 ctx
->removed
+= r
->removed_bytes
;
8456 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8457 ctx
->current_entry
->size
= 0;
8461 /* Build a binary searchable offset translation map from a section's
8464 static xlate_map_t
*
8465 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8467 text_action_list
*action_list
= &relax_info
->action_list
;
8468 unsigned num_actions
= 0;
8469 xlate_map_context ctx
;
8471 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8473 if (ctx
.map
== NULL
)
8476 num_actions
= action_list_count (action_list
);
8477 ctx
.map
->entry
= (xlate_map_entry_t
*)
8478 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8479 if (ctx
.map
->entry
== NULL
)
8484 ctx
.map
->entry_count
= 0;
8487 ctx
.current_entry
= &ctx
.map
->entry
[0];
8489 ctx
.current_entry
->orig_address
= 0;
8490 ctx
.current_entry
->new_address
= 0;
8491 ctx
.current_entry
->size
= 0;
8493 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8495 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8496 - ctx
.current_entry
->orig_address
);
8497 if (ctx
.current_entry
->size
!= 0)
8498 ctx
.map
->entry_count
++;
8504 /* Free an offset translation map. */
8507 free_xlate_map (xlate_map_t
*map
)
8517 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8518 relocations in a section will fit if a proposed set of actions
8522 check_section_ebb_pcrels_fit (bfd
*abfd
,
8525 Elf_Internal_Rela
*internal_relocs
,
8526 reloc_range_list
*relevant_relocs
,
8527 const ebb_constraint
*constraint
,
8528 const xtensa_opcode
*reloc_opcodes
)
8531 unsigned n
= sec
->reloc_count
;
8532 Elf_Internal_Rela
*irel
;
8533 xlate_map_t
*xmap
= NULL
;
8534 bfd_boolean ok
= TRUE
;
8535 xtensa_relax_info
*relax_info
;
8536 reloc_range_list_entry
*entry
= NULL
;
8538 relax_info
= get_xtensa_relax_info (sec
);
8540 if (relax_info
&& sec
->reloc_count
> 100)
8542 xmap
= build_xlate_map (sec
, relax_info
);
8543 /* NULL indicates out of memory, but the slow version
8544 can still be used. */
8547 if (relevant_relocs
&& constraint
->action_count
)
8549 if (!relevant_relocs
->ok
)
8556 bfd_vma min_offset
, max_offset
;
8557 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8559 for (i
= 1; i
< constraint
->action_count
; ++i
)
8561 proposed_action
*action
= &constraint
->actions
[i
];
8562 bfd_vma offset
= action
->offset
;
8564 if (offset
< min_offset
)
8565 min_offset
= offset
;
8566 if (offset
> max_offset
)
8567 max_offset
= offset
;
8569 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8571 n
= relevant_relocs
->n_list
;
8572 entry
= &relevant_relocs
->list_root
;
8577 relevant_relocs
= NULL
;
8580 for (i
= 0; i
< n
; i
++)
8583 bfd_vma orig_self_offset
, orig_target_offset
;
8584 bfd_vma self_offset
, target_offset
;
8586 reloc_howto_type
*howto
;
8587 int self_removed_bytes
, target_removed_bytes
;
8589 if (relevant_relocs
)
8591 entry
= entry
->next
;
8596 irel
= internal_relocs
+ i
;
8598 r_type
= ELF32_R_TYPE (irel
->r_info
);
8600 howto
= &elf_howto_table
[r_type
];
8601 /* We maintain the required invariant: PC-relative relocations
8602 that fit before linking must fit after linking. Thus we only
8603 need to deal with relocations to the same section that are
8605 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8606 || r_type
== R_XTENSA_32_PCREL
8607 || !howto
->pc_relative
)
8610 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8611 bfd_get_section_limit (abfd
, sec
));
8613 if (r_reloc_get_section (&r_rel
) != sec
)
8616 orig_self_offset
= irel
->r_offset
;
8617 orig_target_offset
= r_rel
.target_offset
;
8619 self_offset
= orig_self_offset
;
8620 target_offset
= orig_target_offset
;
8625 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8628 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8629 orig_target_offset
);
8632 self_removed_bytes
= 0;
8633 target_removed_bytes
= 0;
8635 for (j
= 0; j
< constraint
->action_count
; ++j
)
8637 proposed_action
*action
= &constraint
->actions
[j
];
8638 bfd_vma offset
= action
->offset
;
8639 int removed_bytes
= action
->removed_bytes
;
8640 if (offset
< orig_self_offset
8641 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8642 && action
->removed_bytes
< 0))
8643 self_removed_bytes
+= removed_bytes
;
8644 if (offset
< orig_target_offset
8645 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8646 && action
->removed_bytes
< 0))
8647 target_removed_bytes
+= removed_bytes
;
8649 self_offset
-= self_removed_bytes
;
8650 target_offset
-= target_removed_bytes
;
8652 /* Try to encode it. Get the operand and check. */
8653 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8655 /* None of the current alternate relocs are PC-relative,
8656 and only PC-relative relocs matter here. */
8660 xtensa_opcode opcode
;
8663 if (relevant_relocs
)
8665 opcode
= entry
->opcode
;
8666 opnum
= entry
->opnum
;
8671 opcode
= reloc_opcodes
[relevant_relocs
?
8672 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8674 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8675 if (opcode
== XTENSA_UNDEFINED
)
8681 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8682 if (opnum
== XTENSA_UNDEFINED
)
8689 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8697 free_xlate_map (xmap
);
8704 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8709 for (i
= 0; i
< constraint
->action_count
; i
++)
8711 const proposed_action
*action
= &constraint
->actions
[i
];
8712 if (action
->do_action
)
8713 removed
+= action
->removed_bytes
;
8723 text_action_add_proposed (text_action_list
*l
,
8724 const ebb_constraint
*ebb_table
,
8729 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8731 proposed_action
*action
= &ebb_table
->actions
[i
];
8733 if (!action
->do_action
)
8735 switch (action
->action
)
8737 case ta_remove_insn
:
8738 case ta_remove_longcall
:
8739 case ta_convert_longcall
:
8740 case ta_narrow_insn
:
8743 case ta_remove_literal
:
8744 text_action_add (l
, action
->action
, sec
, action
->offset
,
8745 action
->removed_bytes
);
8758 xtensa_compute_fill_extra_space (property_table_entry
*entry
)
8760 int fill_extra_space
;
8765 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8768 fill_extra_space
= entry
->size
;
8769 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8771 /* Fill bytes for alignment:
8772 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8773 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8774 int nsm
= (1 << pow
) - 1;
8775 bfd_vma addr
= entry
->address
+ entry
->size
;
8776 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8777 fill_extra_space
+= align_fill
;
8779 return fill_extra_space
;
8783 /* First relaxation pass. */
8785 /* If the section contains relaxable literals, check each literal to
8786 see if it has the same value as another literal that has already
8787 been seen, either in the current section or a previous one. If so,
8788 add an entry to the per-section list of removed literals. The
8789 actual changes are deferred until the next pass. */
8792 compute_removed_literals (bfd
*abfd
,
8794 struct bfd_link_info
*link_info
,
8795 value_map_hash_table
*values
)
8797 xtensa_relax_info
*relax_info
;
8799 Elf_Internal_Rela
*internal_relocs
;
8800 source_reloc
*src_relocs
, *rel
;
8801 bfd_boolean ok
= TRUE
;
8802 property_table_entry
*prop_table
= NULL
;
8805 bfd_boolean last_loc_is_prev
= FALSE
;
8806 bfd_vma last_target_offset
= 0;
8807 section_cache_t target_sec_cache
;
8808 bfd_size_type sec_size
;
8810 init_section_cache (&target_sec_cache
);
8812 /* Do nothing if it is not a relaxable literal section. */
8813 relax_info
= get_xtensa_relax_info (sec
);
8814 BFD_ASSERT (relax_info
);
8815 if (!relax_info
->is_relaxable_literal_section
)
8818 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8819 link_info
->keep_memory
);
8821 sec_size
= bfd_get_section_limit (abfd
, sec
);
8822 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8823 if (contents
== NULL
&& sec_size
!= 0)
8829 /* Sort the source_relocs by target offset. */
8830 src_relocs
= relax_info
->src_relocs
;
8831 qsort (src_relocs
, relax_info
->src_count
,
8832 sizeof (source_reloc
), source_reloc_compare
);
8833 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8834 internal_reloc_compare
);
8836 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8837 XTENSA_PROP_SEC_NAME
, FALSE
);
8845 for (i
= 0; i
< relax_info
->src_count
; i
++)
8847 Elf_Internal_Rela
*irel
= NULL
;
8849 rel
= &src_relocs
[i
];
8850 if (get_l32r_opcode () != rel
->opcode
)
8852 irel
= get_irel_at_offset (sec
, internal_relocs
,
8853 rel
->r_rel
.target_offset
);
8855 /* If the relocation on this is not a simple R_XTENSA_32 or
8856 R_XTENSA_PLT then do not consider it. This may happen when
8857 the difference of two symbols is used in a literal. */
8858 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8859 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8862 /* If the target_offset for this relocation is the same as the
8863 previous relocation, then we've already considered whether the
8864 literal can be coalesced. Skip to the next one.... */
8865 if (i
!= 0 && prev_i
!= -1
8866 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8870 if (last_loc_is_prev
&&
8871 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8872 last_loc_is_prev
= FALSE
;
8874 /* Check if the relocation was from an L32R that is being removed
8875 because a CALLX was converted to a direct CALL, and check if
8876 there are no other relocations to the literal. */
8877 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8878 sec
, prop_table
, ptblsize
))
8880 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8881 irel
, rel
, prop_table
, ptblsize
))
8886 last_target_offset
= rel
->r_rel
.target_offset
;
8890 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8892 &last_loc_is_prev
, irel
,
8893 relax_info
->src_count
- i
, rel
,
8894 prop_table
, ptblsize
,
8895 &target_sec_cache
, rel
->is_abs_literal
))
8900 last_target_offset
= rel
->r_rel
.target_offset
;
8904 print_removed_literals (stderr
, &relax_info
->removed_list
);
8905 print_action_list (stderr
, &relax_info
->action_list
);
8910 free_section_cache (&target_sec_cache
);
8912 release_contents (sec
, contents
);
8913 release_internal_relocs (sec
, internal_relocs
);
8918 static Elf_Internal_Rela
*
8919 get_irel_at_offset (asection
*sec
,
8920 Elf_Internal_Rela
*internal_relocs
,
8924 Elf_Internal_Rela
*irel
;
8926 Elf_Internal_Rela key
;
8928 if (!internal_relocs
)
8931 key
.r_offset
= offset
;
8932 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8933 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8937 /* bsearch does not guarantee which will be returned if there are
8938 multiple matches. We need the first that is not an alignment. */
8939 i
= irel
- internal_relocs
;
8942 if (internal_relocs
[i
-1].r_offset
!= offset
)
8946 for ( ; i
< sec
->reloc_count
; i
++)
8948 irel
= &internal_relocs
[i
];
8949 r_type
= ELF32_R_TYPE (irel
->r_info
);
8950 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8959 is_removable_literal (const source_reloc
*rel
,
8961 const source_reloc
*src_relocs
,
8964 property_table_entry
*prop_table
,
8967 const source_reloc
*curr_rel
;
8968 property_table_entry
*entry
;
8973 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8974 sec
->vma
+ rel
->r_rel
.target_offset
);
8975 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8978 for (++i
; i
< src_count
; ++i
)
8980 curr_rel
= &src_relocs
[i
];
8981 /* If all others have the same target offset.... */
8982 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8985 if (!curr_rel
->is_null
8986 && !xtensa_is_property_section (curr_rel
->source_sec
)
8987 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8995 remove_dead_literal (bfd
*abfd
,
8997 struct bfd_link_info
*link_info
,
8998 Elf_Internal_Rela
*internal_relocs
,
8999 Elf_Internal_Rela
*irel
,
9001 property_table_entry
*prop_table
,
9004 property_table_entry
*entry
;
9005 xtensa_relax_info
*relax_info
;
9007 relax_info
= get_xtensa_relax_info (sec
);
9011 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9012 sec
->vma
+ rel
->r_rel
.target_offset
);
9014 /* Mark the unused literal so that it will be removed. */
9015 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
9017 text_action_add (&relax_info
->action_list
,
9018 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9020 /* If the section is 4-byte aligned, do not add fill. */
9021 if (sec
->alignment_power
> 2)
9023 int fill_extra_space
;
9024 bfd_vma entry_sec_offset
;
9026 property_table_entry
*the_add_entry
;
9030 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9032 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9034 /* If the literal range is at the end of the section,
9036 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9038 fill_extra_space
= xtensa_compute_fill_extra_space (the_add_entry
);
9040 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9041 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9042 -4, fill_extra_space
);
9044 adjust_fill_action (fa
, removed_diff
);
9046 text_action_add (&relax_info
->action_list
,
9047 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9050 /* Zero out the relocation on this literal location. */
9053 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9054 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9056 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9057 pin_internal_relocs (sec
, internal_relocs
);
9060 /* Do not modify "last_loc_is_prev". */
9066 identify_literal_placement (bfd
*abfd
,
9069 struct bfd_link_info
*link_info
,
9070 value_map_hash_table
*values
,
9071 bfd_boolean
*last_loc_is_prev_p
,
9072 Elf_Internal_Rela
*irel
,
9073 int remaining_src_rels
,
9075 property_table_entry
*prop_table
,
9077 section_cache_t
*target_sec_cache
,
9078 bfd_boolean is_abs_literal
)
9082 xtensa_relax_info
*relax_info
;
9083 bfd_boolean literal_placed
= FALSE
;
9085 unsigned long value
;
9086 bfd_boolean final_static_link
;
9087 bfd_size_type sec_size
;
9089 relax_info
= get_xtensa_relax_info (sec
);
9093 sec_size
= bfd_get_section_limit (abfd
, sec
);
9096 (!bfd_link_relocatable (link_info
)
9097 && !elf_hash_table (link_info
)->dynamic_sections_created
);
9099 /* The placement algorithm first checks to see if the literal is
9100 already in the value map. If so and the value map is reachable
9101 from all uses, then the literal is moved to that location. If
9102 not, then we identify the last location where a fresh literal was
9103 placed. If the literal can be safely moved there, then we do so.
9104 If not, then we assume that the literal is not to move and leave
9105 the literal where it is, marking it as the last literal
9108 /* Find the literal value. */
9110 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9113 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
9114 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
9116 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
9118 /* Check if we've seen another literal with the same value that
9119 is in the same output section. */
9120 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
9123 && (r_reloc_get_section (&val_map
->loc
)->output_section
9124 == sec
->output_section
)
9125 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
9126 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
9128 /* No change to last_loc_is_prev. */
9129 literal_placed
= TRUE
;
9132 /* For relocatable links, do not try to move literals. To do it
9133 correctly might increase the number of relocations in an input
9134 section making the default relocatable linking fail. */
9135 if (!bfd_link_relocatable (link_info
) && !literal_placed
9136 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
9138 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
9139 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
9141 /* Increment the virtual offset. */
9142 r_reloc try_loc
= values
->last_loc
;
9143 try_loc
.virtual_offset
+= 4;
9145 /* There is a last loc that was in the same output section. */
9146 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
9147 && move_shared_literal (sec
, link_info
, rel
,
9148 prop_table
, ptblsize
,
9149 &try_loc
, &val
, target_sec_cache
))
9151 values
->last_loc
.virtual_offset
+= 4;
9152 literal_placed
= TRUE
;
9154 val_map
= add_value_map (values
, &val
, &try_loc
,
9157 val_map
->loc
= try_loc
;
9162 if (!literal_placed
)
9164 /* Nothing worked, leave the literal alone but update the last loc. */
9165 values
->has_last_loc
= TRUE
;
9166 values
->last_loc
= rel
->r_rel
;
9168 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
9170 val_map
->loc
= rel
->r_rel
;
9171 *last_loc_is_prev_p
= TRUE
;
9178 /* Check if the original relocations (presumably on L32R instructions)
9179 identified by reloc[0..N] can be changed to reference the literal
9180 identified by r_rel. If r_rel is out of range for any of the
9181 original relocations, then we don't want to coalesce the original
9182 literal with the one at r_rel. We only check reloc[0..N], where the
9183 offsets are all the same as for reloc[0] (i.e., they're all
9184 referencing the same literal) and where N is also bounded by the
9185 number of remaining entries in the "reloc" array. The "reloc" array
9186 is sorted by target offset so we know all the entries for the same
9187 literal will be contiguous. */
9190 relocations_reach (source_reloc
*reloc
,
9191 int remaining_relocs
,
9192 const r_reloc
*r_rel
)
9194 bfd_vma from_offset
, source_address
, dest_address
;
9198 if (!r_reloc_is_defined (r_rel
))
9201 sec
= r_reloc_get_section (r_rel
);
9202 from_offset
= reloc
[0].r_rel
.target_offset
;
9204 for (i
= 0; i
< remaining_relocs
; i
++)
9206 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9209 /* Ignore relocations that have been removed. */
9210 if (reloc
[i
].is_null
)
9213 /* The original and new output section for these must be the same
9214 in order to coalesce. */
9215 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9216 != sec
->output_section
)
9219 /* Absolute literals in the same output section can always be
9221 if (reloc
[i
].is_abs_literal
)
9224 /* A literal with no PC-relative relocations can be moved anywhere. */
9225 if (reloc
[i
].opnd
!= -1)
9227 /* Otherwise, check to see that it fits. */
9228 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9229 + reloc
[i
].source_sec
->output_offset
9230 + reloc
[i
].r_rel
.rela
.r_offset
);
9231 dest_address
= (sec
->output_section
->vma
9232 + sec
->output_offset
9233 + r_rel
->target_offset
);
9235 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9236 source_address
, dest_address
))
9245 /* Move a literal to another literal location because it is
9246 the same as the other literal value. */
9249 coalesce_shared_literal (asection
*sec
,
9251 property_table_entry
*prop_table
,
9255 property_table_entry
*entry
;
9257 property_table_entry
*the_add_entry
;
9259 xtensa_relax_info
*relax_info
;
9261 relax_info
= get_xtensa_relax_info (sec
);
9265 entry
= elf_xtensa_find_property_entry
9266 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9267 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9270 /* Mark that the literal will be coalesced. */
9271 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9273 text_action_add (&relax_info
->action_list
,
9274 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9276 /* If the section is 4-byte aligned, do not add fill. */
9277 if (sec
->alignment_power
> 2)
9279 int fill_extra_space
;
9280 bfd_vma entry_sec_offset
;
9283 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9285 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9287 /* If the literal range is at the end of the section,
9289 fill_extra_space
= 0;
9290 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9292 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9293 fill_extra_space
= the_add_entry
->size
;
9295 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9296 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9297 -4, fill_extra_space
);
9299 adjust_fill_action (fa
, removed_diff
);
9301 text_action_add (&relax_info
->action_list
,
9302 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9309 /* Move a literal to another location. This may actually increase the
9310 total amount of space used because of alignments so we need to do
9311 this carefully. Also, it may make a branch go out of range. */
9314 move_shared_literal (asection
*sec
,
9315 struct bfd_link_info
*link_info
,
9317 property_table_entry
*prop_table
,
9319 const r_reloc
*target_loc
,
9320 const literal_value
*lit_value
,
9321 section_cache_t
*target_sec_cache
)
9323 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9324 text_action
*fa
, *target_fa
;
9326 xtensa_relax_info
*relax_info
, *target_relax_info
;
9327 asection
*target_sec
;
9329 ebb_constraint ebb_table
;
9330 bfd_boolean relocs_fit
;
9332 /* If this routine always returns FALSE, the literals that cannot be
9333 coalesced will not be moved. */
9334 if (elf32xtensa_no_literal_movement
)
9337 relax_info
= get_xtensa_relax_info (sec
);
9341 target_sec
= r_reloc_get_section (target_loc
);
9342 target_relax_info
= get_xtensa_relax_info (target_sec
);
9344 /* Literals to undefined sections may not be moved because they
9345 must report an error. */
9346 if (bfd_is_und_section (target_sec
))
9349 src_entry
= elf_xtensa_find_property_entry
9350 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9352 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9355 target_entry
= elf_xtensa_find_property_entry
9356 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9357 target_sec
->vma
+ target_loc
->target_offset
);
9362 /* Make sure that we have not broken any branches. */
9365 init_ebb_constraint (&ebb_table
);
9366 ebb
= &ebb_table
.ebb
;
9367 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9368 target_sec_cache
->content_length
,
9369 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9370 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9372 /* Propose to add 4 bytes + worst-case alignment size increase to
9374 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9375 ta_fill
, target_loc
->target_offset
,
9376 -4 - (1 << target_sec
->alignment_power
), TRUE
);
9378 /* Check all of the PC-relative relocations to make sure they still fit. */
9379 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9380 target_sec_cache
->contents
,
9381 target_sec_cache
->relocs
, NULL
,
9387 text_action_add_literal (&target_relax_info
->action_list
,
9388 ta_add_literal
, target_loc
, lit_value
, -4);
9390 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9392 /* May need to add or remove some fill to maintain alignment. */
9393 int fill_extra_space
;
9394 bfd_vma entry_sec_offset
;
9397 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9399 /* If the literal range is at the end of the section,
9401 fill_extra_space
= 0;
9403 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9404 target_sec_cache
->pte_count
,
9406 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9407 fill_extra_space
= the_add_entry
->size
;
9409 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9410 target_sec
, entry_sec_offset
);
9411 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9412 entry_sec_offset
, 4,
9415 adjust_fill_action (target_fa
, removed_diff
);
9417 text_action_add (&target_relax_info
->action_list
,
9418 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9421 /* Mark that the literal will be moved to the new location. */
9422 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9424 /* Remove the literal. */
9425 text_action_add (&relax_info
->action_list
,
9426 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9428 /* If the section is 4-byte aligned, do not add fill. */
9429 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9431 int fill_extra_space
;
9432 bfd_vma entry_sec_offset
;
9435 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9437 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9439 /* If the literal range is at the end of the section,
9441 fill_extra_space
= 0;
9442 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9444 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9445 fill_extra_space
= the_add_entry
->size
;
9447 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9448 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9449 -4, fill_extra_space
);
9451 adjust_fill_action (fa
, removed_diff
);
9453 text_action_add (&relax_info
->action_list
,
9454 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9461 /* Second relaxation pass. */
9464 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9466 bfd_size_type
*final_size
= p
;
9467 text_action
*action
= (text_action
*)node
->value
;
9469 *final_size
-= action
->removed_bytes
;
9473 /* Modify all of the relocations to point to the right spot, and if this
9474 is a relaxable section, delete the unwanted literals and fix the
9478 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9480 Elf_Internal_Rela
*internal_relocs
;
9481 xtensa_relax_info
*relax_info
;
9483 bfd_boolean ok
= TRUE
;
9485 bfd_boolean rv
= FALSE
;
9486 bfd_boolean virtual_action
;
9487 bfd_size_type sec_size
;
9489 sec_size
= bfd_get_section_limit (abfd
, sec
);
9490 relax_info
= get_xtensa_relax_info (sec
);
9491 BFD_ASSERT (relax_info
);
9493 /* First translate any of the fixes that have been added already. */
9494 translate_section_fixes (sec
);
9496 /* Handle property sections (e.g., literal tables) specially. */
9497 if (xtensa_is_property_section (sec
))
9499 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9500 return relax_property_section (abfd
, sec
, link_info
);
9503 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9504 link_info
->keep_memory
);
9505 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9508 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9509 if (contents
== NULL
&& sec_size
!= 0)
9515 if (internal_relocs
)
9517 for (i
= 0; i
< sec
->reloc_count
; i
++)
9519 Elf_Internal_Rela
*irel
;
9520 xtensa_relax_info
*target_relax_info
;
9521 bfd_vma source_offset
, old_source_offset
;
9524 asection
*target_sec
;
9526 /* Locally change the source address.
9527 Translate the target to the new target address.
9528 If it points to this section and has been removed,
9532 irel
= &internal_relocs
[i
];
9533 source_offset
= irel
->r_offset
;
9534 old_source_offset
= source_offset
;
9536 r_type
= ELF32_R_TYPE (irel
->r_info
);
9537 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9538 bfd_get_section_limit (abfd
, sec
));
9540 /* If this section could have changed then we may need to
9541 change the relocation's offset. */
9543 if (relax_info
->is_relaxable_literal_section
9544 || relax_info
->is_relaxable_asm_section
)
9546 pin_internal_relocs (sec
, internal_relocs
);
9548 if (r_type
!= R_XTENSA_NONE
9549 && find_removed_literal (&relax_info
->removed_list
,
9552 /* Remove this relocation. */
9553 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9554 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9555 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9556 irel
->r_offset
= offset_with_removed_text_map
9557 (&relax_info
->action_list
, irel
->r_offset
);
9561 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9563 text_action
*action
=
9564 find_insn_action (&relax_info
->action_list
,
9566 if (action
&& (action
->action
== ta_convert_longcall
9567 || action
->action
== ta_remove_longcall
))
9569 bfd_reloc_status_type retval
;
9570 char *error_message
= NULL
;
9572 retval
= contract_asm_expansion (contents
, sec_size
,
9573 irel
, &error_message
);
9574 if (retval
!= bfd_reloc_ok
)
9576 (*link_info
->callbacks
->reloc_dangerous
)
9577 (link_info
, error_message
, abfd
, sec
,
9581 /* Update the action so that the code that moves
9582 the contents will do the right thing. */
9583 /* ta_remove_longcall and ta_remove_insn actions are
9584 grouped together in the tree as well as
9585 ta_convert_longcall and ta_none, so that changes below
9586 can be done w/o removing and reinserting action into
9589 if (action
->action
== ta_remove_longcall
)
9590 action
->action
= ta_remove_insn
;
9592 action
->action
= ta_none
;
9593 /* Refresh the info in the r_rel. */
9594 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9595 r_type
= ELF32_R_TYPE (irel
->r_info
);
9599 source_offset
= offset_with_removed_text_map
9600 (&relax_info
->action_list
, irel
->r_offset
);
9601 irel
->r_offset
= source_offset
;
9604 /* If the target section could have changed then
9605 we may need to change the relocation's target offset. */
9607 target_sec
= r_reloc_get_section (&r_rel
);
9609 /* For a reference to a discarded section from a DWARF section,
9610 i.e., where action_discarded is PRETEND, the symbol will
9611 eventually be modified to refer to the kept section (at least if
9612 the kept and discarded sections are the same size). Anticipate
9613 that here and adjust things accordingly. */
9614 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9615 && elf_xtensa_action_discarded (sec
) == PRETEND
9616 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9617 && target_sec
!= NULL
9618 && discarded_section (target_sec
))
9620 /* It would be natural to call _bfd_elf_check_kept_section
9621 here, but it's not exported from elflink.c. It's also a
9622 fairly expensive check. Adjusting the relocations to the
9623 discarded section is fairly harmless; it will only adjust
9624 some addends and difference values. If it turns out that
9625 _bfd_elf_check_kept_section fails later, it won't matter,
9626 so just compare the section names to find the right group
9628 asection
*kept
= target_sec
->kept_section
;
9631 if ((kept
->flags
& SEC_GROUP
) != 0)
9633 asection
*first
= elf_next_in_group (kept
);
9634 asection
*s
= first
;
9639 if (strcmp (s
->name
, target_sec
->name
) == 0)
9644 s
= elf_next_in_group (s
);
9651 && ((target_sec
->rawsize
!= 0
9652 ? target_sec
->rawsize
: target_sec
->size
)
9653 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9657 target_relax_info
= get_xtensa_relax_info (target_sec
);
9658 if (target_relax_info
9659 && (target_relax_info
->is_relaxable_literal_section
9660 || target_relax_info
->is_relaxable_asm_section
))
9663 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9665 if (r_type
== R_XTENSA_DIFF8
9666 || r_type
== R_XTENSA_DIFF16
9667 || r_type
== R_XTENSA_DIFF32
9668 || r_type
== R_XTENSA_PDIFF8
9669 || r_type
== R_XTENSA_PDIFF16
9670 || r_type
== R_XTENSA_PDIFF32
9671 || r_type
== R_XTENSA_NDIFF8
9672 || r_type
== R_XTENSA_NDIFF16
9673 || r_type
== R_XTENSA_NDIFF32
)
9675 bfd_signed_vma diff_value
= 0;
9676 bfd_vma new_end_offset
, diff_mask
= 0;
9678 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9680 (*link_info
->callbacks
->reloc_dangerous
)
9681 (link_info
, _("invalid relocation address"),
9682 abfd
, sec
, old_source_offset
);
9688 case R_XTENSA_DIFF8
:
9691 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9693 case R_XTENSA_DIFF16
:
9696 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9698 case R_XTENSA_DIFF32
:
9699 diff_mask
= 0x7fffffff;
9701 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9703 case R_XTENSA_PDIFF8
:
9704 case R_XTENSA_NDIFF8
:
9707 bfd_get_8 (abfd
, &contents
[old_source_offset
]);
9709 case R_XTENSA_PDIFF16
:
9710 case R_XTENSA_NDIFF16
:
9713 bfd_get_16 (abfd
, &contents
[old_source_offset
]);
9715 case R_XTENSA_PDIFF32
:
9716 case R_XTENSA_NDIFF32
:
9717 diff_mask
= 0xffffffff;
9719 bfd_get_32 (abfd
, &contents
[old_source_offset
]);
9723 if (r_type
>= R_XTENSA_NDIFF8
9724 && r_type
<= R_XTENSA_NDIFF32
9726 diff_value
|= ~diff_mask
;
9728 new_end_offset
= offset_with_removed_text_map
9729 (&target_relax_info
->action_list
,
9730 r_rel
.target_offset
+ diff_value
);
9731 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9735 case R_XTENSA_DIFF8
:
9736 bfd_put_signed_8 (abfd
, diff_value
,
9737 &contents
[old_source_offset
]);
9739 case R_XTENSA_DIFF16
:
9740 bfd_put_signed_16 (abfd
, diff_value
,
9741 &contents
[old_source_offset
]);
9743 case R_XTENSA_DIFF32
:
9744 bfd_put_signed_32 (abfd
, diff_value
,
9745 &contents
[old_source_offset
]);
9747 case R_XTENSA_PDIFF8
:
9748 case R_XTENSA_NDIFF8
:
9749 bfd_put_8 (abfd
, diff_value
,
9750 &contents
[old_source_offset
]);
9752 case R_XTENSA_PDIFF16
:
9753 case R_XTENSA_NDIFF16
:
9754 bfd_put_16 (abfd
, diff_value
,
9755 &contents
[old_source_offset
]);
9757 case R_XTENSA_PDIFF32
:
9758 case R_XTENSA_NDIFF32
:
9759 bfd_put_32 (abfd
, diff_value
,
9760 &contents
[old_source_offset
]);
9764 /* Check for overflow. Sign bits must be all zeroes or
9765 all ones. When sign bits are all ones diff_value
9767 if (((diff_value
& ~diff_mask
) != 0
9768 && (diff_value
& ~diff_mask
) != ~diff_mask
)
9769 || (diff_value
&& (bfd_vma
) diff_value
== ~diff_mask
))
9771 (*link_info
->callbacks
->reloc_dangerous
)
9772 (link_info
, _("overflow after relaxation"),
9773 abfd
, sec
, old_source_offset
);
9777 pin_contents (sec
, contents
);
9780 /* If the relocation still references a section in the same
9781 input file, modify the relocation directly instead of
9782 adding a "fix" record. */
9783 if (target_sec
->owner
== abfd
)
9785 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9786 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9787 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9788 pin_internal_relocs (sec
, internal_relocs
);
9792 bfd_vma addend_displacement
;
9795 addend_displacement
=
9796 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9797 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9799 addend_displacement
, TRUE
);
9806 if ((relax_info
->is_relaxable_literal_section
9807 || relax_info
->is_relaxable_asm_section
)
9808 && action_list_count (&relax_info
->action_list
))
9810 /* Walk through the planned actions and build up a table
9811 of move, copy and fill records. Use the move, copy and
9812 fill records to perform the actions once. */
9814 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9815 bfd_byte
*scratch
= NULL
;
9816 bfd_byte
*dup_contents
= NULL
;
9817 bfd_size_type orig_size
= sec
->size
;
9818 bfd_vma orig_dot
= 0;
9819 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9820 orig dot in physical memory. */
9821 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9822 bfd_vma dup_dot
= 0;
9824 text_action
*action
;
9826 final_size
= sec
->size
;
9828 splay_tree_foreach (relax_info
->action_list
.tree
,
9829 action_remove_bytes_fn
, &final_size
);
9830 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9831 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9833 /* The dot is the current fill location. */
9835 print_action_list (stderr
, &relax_info
->action_list
);
9838 for (action
= action_first (&relax_info
->action_list
); action
;
9839 action
= action_next (&relax_info
->action_list
, action
))
9841 virtual_action
= FALSE
;
9842 if (action
->offset
> orig_dot
)
9844 orig_dot
+= orig_dot_copied
;
9845 orig_dot_copied
= 0;
9847 /* Out of the virtual world. */
9850 if (action
->offset
> orig_dot
)
9852 copy_size
= action
->offset
- orig_dot
;
9853 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9854 orig_dot
+= copy_size
;
9855 dup_dot
+= copy_size
;
9856 BFD_ASSERT (action
->offset
== orig_dot
);
9858 else if (action
->offset
< orig_dot
)
9860 if (action
->action
== ta_fill
9861 && action
->offset
- action
->removed_bytes
== orig_dot
)
9863 /* This is OK because the fill only effects the dup_dot. */
9865 else if (action
->action
== ta_add_literal
)
9867 /* TBD. Might need to handle this. */
9870 if (action
->offset
== orig_dot
)
9872 if (action
->virtual_offset
> orig_dot_vo
)
9874 if (orig_dot_vo
== 0)
9876 /* Need to copy virtual_offset bytes. Probably four. */
9877 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9878 memmove (&dup_contents
[dup_dot
],
9879 &contents
[orig_dot
], copy_size
);
9880 orig_dot_copied
= copy_size
;
9881 dup_dot
+= copy_size
;
9883 virtual_action
= TRUE
;
9886 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9888 switch (action
->action
)
9890 case ta_remove_literal
:
9891 case ta_remove_insn
:
9892 BFD_ASSERT (action
->removed_bytes
>= 0);
9893 orig_dot
+= action
->removed_bytes
;
9896 case ta_narrow_insn
:
9899 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9900 BFD_ASSERT (action
->removed_bytes
== 1);
9901 rv
= narrow_instruction (scratch
, final_size
, 0);
9903 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9904 orig_dot
+= orig_insn_size
;
9905 dup_dot
+= copy_size
;
9909 if (action
->removed_bytes
>= 0)
9910 orig_dot
+= action
->removed_bytes
;
9913 /* Already zeroed in dup_contents. Just bump the
9915 dup_dot
+= (-action
->removed_bytes
);
9920 BFD_ASSERT (action
->removed_bytes
== 0);
9923 case ta_convert_longcall
:
9924 case ta_remove_longcall
:
9925 /* These will be removed or converted before we get here. */
9932 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9933 BFD_ASSERT (action
->removed_bytes
== -1);
9934 rv
= widen_instruction (scratch
, final_size
, 0);
9936 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9937 orig_dot
+= orig_insn_size
;
9938 dup_dot
+= copy_size
;
9941 case ta_add_literal
:
9944 BFD_ASSERT (action
->removed_bytes
== -4);
9945 /* TBD -- place the literal value here and insert
9947 memset (&dup_contents
[dup_dot
], 0, 4);
9948 pin_internal_relocs (sec
, internal_relocs
);
9949 pin_contents (sec
, contents
);
9951 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9952 relax_info
, &internal_relocs
, &action
->value
))
9956 orig_dot_vo
+= copy_size
;
9958 orig_dot
+= orig_insn_size
;
9959 dup_dot
+= copy_size
;
9963 /* Not implemented yet. */
9968 BFD_ASSERT (dup_dot
<= final_size
);
9969 BFD_ASSERT (orig_dot
<= orig_size
);
9972 orig_dot
+= orig_dot_copied
;
9973 orig_dot_copied
= 0;
9975 if (orig_dot
!= orig_size
)
9977 copy_size
= orig_size
- orig_dot
;
9978 BFD_ASSERT (orig_size
> orig_dot
);
9979 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9980 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9981 orig_dot
+= copy_size
;
9982 dup_dot
+= copy_size
;
9984 BFD_ASSERT (orig_size
== orig_dot
);
9985 BFD_ASSERT (final_size
== dup_dot
);
9987 /* Move the dup_contents back. */
9988 if (final_size
> orig_size
)
9990 /* Contents need to be reallocated. Swap the dup_contents into
9992 sec
->contents
= dup_contents
;
9994 contents
= dup_contents
;
9995 pin_contents (sec
, contents
);
9999 BFD_ASSERT (final_size
<= orig_size
);
10000 memset (contents
, 0, orig_size
);
10001 memcpy (contents
, dup_contents
, final_size
);
10002 free (dup_contents
);
10005 pin_contents (sec
, contents
);
10007 if (sec
->rawsize
== 0)
10008 sec
->rawsize
= sec
->size
;
10009 sec
->size
= final_size
;
10013 release_internal_relocs (sec
, internal_relocs
);
10014 release_contents (sec
, contents
);
10020 translate_section_fixes (asection
*sec
)
10022 xtensa_relax_info
*relax_info
;
10025 relax_info
= get_xtensa_relax_info (sec
);
10029 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
10030 if (!translate_reloc_bfd_fix (r
))
10037 /* Translate a fix given the mapping in the relax info for the target
10038 section. If it has already been translated, no work is required. */
10041 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
10043 reloc_bfd_fix new_fix
;
10045 xtensa_relax_info
*relax_info
;
10046 removed_literal
*removed
;
10047 bfd_vma new_offset
, target_offset
;
10049 if (fix
->translated
)
10052 sec
= fix
->target_sec
;
10053 target_offset
= fix
->target_offset
;
10055 relax_info
= get_xtensa_relax_info (sec
);
10058 fix
->translated
= TRUE
;
10064 /* The fix does not need to be translated if the section cannot change. */
10065 if (!relax_info
->is_relaxable_literal_section
10066 && !relax_info
->is_relaxable_asm_section
)
10068 fix
->translated
= TRUE
;
10072 /* If the literal has been moved and this relocation was on an
10073 opcode, then the relocation should move to the new literal
10074 location. Otherwise, the relocation should move within the
10078 if (is_operand_relocation (fix
->src_type
))
10080 /* Check if the original relocation is against a literal being
10082 removed
= find_removed_literal (&relax_info
->removed_list
,
10090 /* The fact that there is still a relocation to this literal indicates
10091 that the literal is being coalesced, not simply removed. */
10092 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10094 /* This was moved to some other address (possibly another section). */
10095 new_sec
= r_reloc_get_section (&removed
->to
);
10096 if (new_sec
!= sec
)
10099 relax_info
= get_xtensa_relax_info (sec
);
10101 (!relax_info
->is_relaxable_literal_section
10102 && !relax_info
->is_relaxable_asm_section
))
10104 target_offset
= removed
->to
.target_offset
;
10105 new_fix
.target_sec
= new_sec
;
10106 new_fix
.target_offset
= target_offset
;
10107 new_fix
.translated
= TRUE
;
10112 target_offset
= removed
->to
.target_offset
;
10113 new_fix
.target_sec
= new_sec
;
10116 /* The target address may have been moved within its section. */
10117 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
10120 new_fix
.target_offset
= new_offset
;
10121 new_fix
.target_offset
= new_offset
;
10122 new_fix
.translated
= TRUE
;
10128 /* Fix up a relocation to take account of removed literals. */
10131 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
10133 xtensa_relax_info
*relax_info
;
10134 removed_literal
*removed
;
10135 bfd_vma target_offset
, base_offset
;
10137 *new_rel
= *orig_rel
;
10139 if (!r_reloc_is_defined (orig_rel
))
10142 relax_info
= get_xtensa_relax_info (sec
);
10143 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
10144 || relax_info
->is_relaxable_asm_section
));
10146 target_offset
= orig_rel
->target_offset
;
10149 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
10151 /* Check if the original relocation is against a literal being
10153 removed
= find_removed_literal (&relax_info
->removed_list
,
10156 if (removed
&& removed
->to
.abfd
)
10160 /* The fact that there is still a relocation to this literal indicates
10161 that the literal is being coalesced, not simply removed. */
10162 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10164 /* This was moved to some other address
10165 (possibly in another section). */
10166 *new_rel
= removed
->to
;
10167 new_sec
= r_reloc_get_section (new_rel
);
10168 if (new_sec
!= sec
)
10171 relax_info
= get_xtensa_relax_info (sec
);
10173 || (!relax_info
->is_relaxable_literal_section
10174 && !relax_info
->is_relaxable_asm_section
))
10177 target_offset
= new_rel
->target_offset
;
10180 /* Find the base offset of the reloc symbol, excluding any addend from the
10181 reloc or from the section contents (for a partial_inplace reloc). Then
10182 find the adjusted values of the offsets due to relaxation. The base
10183 offset is needed to determine the change to the reloc's addend; the reloc
10184 addend should not be adjusted due to relaxations located before the base
10187 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
10188 if (base_offset
<= target_offset
)
10190 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
10191 base_offset
, FALSE
);
10192 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10193 target_offset
, FALSE
) -
10196 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
10197 new_rel
->rela
.r_addend
-= addend_removed
;
10201 /* Handle a negative addend. The base offset comes first. */
10202 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
10203 target_offset
, FALSE
);
10204 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10205 base_offset
, FALSE
) -
10208 new_rel
->target_offset
= target_offset
- tgt_removed
;
10209 new_rel
->rela
.r_addend
+= addend_removed
;
10216 /* For dynamic links, there may be a dynamic relocation for each
10217 literal. The number of dynamic relocations must be computed in
10218 size_dynamic_sections, which occurs before relaxation. When a
10219 literal is removed, this function checks if there is a corresponding
10220 dynamic relocation and shrinks the size of the appropriate dynamic
10221 relocation section accordingly. At this point, the contents of the
10222 dynamic relocation sections have not yet been filled in, so there's
10223 nothing else that needs to be done. */
10226 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
10228 asection
*input_section
,
10229 Elf_Internal_Rela
*rel
)
10231 struct elf_xtensa_link_hash_table
*htab
;
10232 Elf_Internal_Shdr
*symtab_hdr
;
10233 struct elf_link_hash_entry
**sym_hashes
;
10234 unsigned long r_symndx
;
10236 struct elf_link_hash_entry
*h
;
10237 bfd_boolean dynamic_symbol
;
10239 htab
= elf_xtensa_hash_table (info
);
10243 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10244 sym_hashes
= elf_sym_hashes (abfd
);
10246 r_type
= ELF32_R_TYPE (rel
->r_info
);
10247 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10249 if (r_symndx
< symtab_hdr
->sh_info
)
10252 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10254 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10256 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10257 && (input_section
->flags
& SEC_ALLOC
) != 0
10259 || (bfd_link_pic (info
)
10260 && (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
))))
10263 bfd_boolean is_plt
= FALSE
;
10265 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10267 srel
= htab
->elf
.srelplt
;
10271 srel
= htab
->elf
.srelgot
;
10273 /* Reduce size of the .rela.* section by one reloc. */
10274 BFD_ASSERT (srel
!= NULL
);
10275 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10276 srel
->size
-= sizeof (Elf32_External_Rela
);
10280 asection
*splt
, *sgotplt
, *srelgot
;
10281 int reloc_index
, chunk
;
10283 /* Find the PLT reloc index of the entry being removed. This
10284 is computed from the size of ".rela.plt". It is needed to
10285 figure out which PLT chunk to resize. Usually "last index
10286 = size - 1" since the index starts at zero, but in this
10287 context, the size has just been decremented so there's no
10288 need to subtract one. */
10289 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10291 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10292 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10293 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10294 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10296 /* Check if an entire PLT chunk has just been eliminated. */
10297 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10299 /* The two magic GOT entries for that chunk can go away. */
10300 srelgot
= htab
->elf
.srelgot
;
10301 BFD_ASSERT (srelgot
!= NULL
);
10302 srelgot
->reloc_count
-= 2;
10303 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10304 sgotplt
->size
-= 8;
10306 /* There should be only one entry left (and it will be
10308 BFD_ASSERT (sgotplt
->size
== 4);
10309 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10312 BFD_ASSERT (sgotplt
->size
>= 4);
10313 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10315 sgotplt
->size
-= 4;
10316 splt
->size
-= PLT_ENTRY_SIZE
;
10322 /* Take an r_rel and move it to another section. This usually
10323 requires extending the interal_relocation array and pinning it. If
10324 the original r_rel is from the same BFD, we can complete this here.
10325 Otherwise, we add a fix record to let the final link fix the
10326 appropriate address. Contents and internal relocations for the
10327 section must be pinned after calling this routine. */
10330 move_literal (bfd
*abfd
,
10331 struct bfd_link_info
*link_info
,
10334 bfd_byte
*contents
,
10335 xtensa_relax_info
*relax_info
,
10336 Elf_Internal_Rela
**internal_relocs_p
,
10337 const literal_value
*lit
)
10339 Elf_Internal_Rela
*new_relocs
= NULL
;
10340 size_t new_relocs_count
= 0;
10341 Elf_Internal_Rela this_rela
;
10342 const r_reloc
*r_rel
;
10344 r_rel
= &lit
->r_rel
;
10345 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10347 if (r_reloc_is_const (r_rel
))
10348 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10353 reloc_bfd_fix
*fix
;
10354 unsigned insert_at
;
10356 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10358 /* This is the difficult case. We have to create a fix up. */
10359 this_rela
.r_offset
= offset
;
10360 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10361 this_rela
.r_addend
=
10362 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10363 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10365 /* Currently, we cannot move relocations during a relocatable link. */
10366 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10367 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10368 r_reloc_get_section (r_rel
),
10369 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10371 /* We also need to mark that relocations are needed here. */
10372 sec
->flags
|= SEC_RELOC
;
10374 translate_reloc_bfd_fix (fix
);
10375 /* This fix has not yet been translated. */
10376 add_fix (sec
, fix
);
10378 /* Add the relocation. If we have already allocated our own
10379 space for the relocations and we have room for more, then use
10380 it. Otherwise, allocate new space and move the literals. */
10381 insert_at
= sec
->reloc_count
;
10382 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10384 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10391 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10392 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10394 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10395 || sec
->reloc_count
== relax_info
->relocs_count
);
10397 if (relax_info
->allocated_relocs_count
== 0)
10398 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10400 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10402 new_relocs
= (Elf_Internal_Rela
*)
10403 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10407 /* We could handle this more quickly by finding the split point. */
10408 if (insert_at
!= 0)
10409 memcpy (new_relocs
, *internal_relocs_p
,
10410 insert_at
* sizeof (Elf_Internal_Rela
));
10412 new_relocs
[insert_at
] = this_rela
;
10414 if (insert_at
!= sec
->reloc_count
)
10415 memcpy (new_relocs
+ insert_at
+ 1,
10416 (*internal_relocs_p
) + insert_at
,
10417 (sec
->reloc_count
- insert_at
)
10418 * sizeof (Elf_Internal_Rela
));
10420 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10422 /* The first time we re-allocate, we can only free the
10423 old relocs if they were allocated with bfd_malloc.
10424 This is not true when keep_memory is in effect. */
10425 if (!link_info
->keep_memory
)
10426 free (*internal_relocs_p
);
10429 free (*internal_relocs_p
);
10430 relax_info
->allocated_relocs
= new_relocs
;
10431 relax_info
->allocated_relocs_count
= new_relocs_count
;
10432 elf_section_data (sec
)->relocs
= new_relocs
;
10433 sec
->reloc_count
++;
10434 relax_info
->relocs_count
= sec
->reloc_count
;
10435 *internal_relocs_p
= new_relocs
;
10439 if (insert_at
!= sec
->reloc_count
)
10442 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10443 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10445 (*internal_relocs_p
)[insert_at
] = this_rela
;
10446 sec
->reloc_count
++;
10447 if (relax_info
->allocated_relocs
)
10448 relax_info
->relocs_count
= sec
->reloc_count
;
10455 /* This is similar to relax_section except that when a target is moved,
10456 we shift addresses up. We also need to modify the size. This
10457 algorithm does NOT allow for relocations into the middle of the
10458 property sections. */
10461 relax_property_section (bfd
*abfd
,
10463 struct bfd_link_info
*link_info
)
10465 Elf_Internal_Rela
*internal_relocs
;
10466 bfd_byte
*contents
;
10468 bfd_boolean ok
= TRUE
;
10469 bfd_boolean is_full_prop_section
;
10470 size_t last_zfill_target_offset
= 0;
10471 asection
*last_zfill_target_sec
= NULL
;
10472 bfd_size_type sec_size
;
10473 bfd_size_type entry_size
;
10475 sec_size
= bfd_get_section_limit (abfd
, sec
);
10476 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10477 link_info
->keep_memory
);
10478 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10479 if (contents
== NULL
&& sec_size
!= 0)
10485 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10486 if (is_full_prop_section
)
10491 if (internal_relocs
)
10493 for (i
= 0; i
< sec
->reloc_count
; i
++)
10495 Elf_Internal_Rela
*irel
;
10496 xtensa_relax_info
*target_relax_info
;
10498 asection
*target_sec
;
10500 bfd_byte
*size_p
, *flags_p
;
10502 /* Locally change the source address.
10503 Translate the target to the new target address.
10504 If it points to this section and has been removed, MOVE IT.
10505 Also, don't forget to modify the associated SIZE at
10508 irel
= &internal_relocs
[i
];
10509 r_type
= ELF32_R_TYPE (irel
->r_info
);
10510 if (r_type
== R_XTENSA_NONE
)
10513 /* Find the literal value. */
10514 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10515 size_p
= &contents
[irel
->r_offset
+ 4];
10517 if (is_full_prop_section
)
10518 flags_p
= &contents
[irel
->r_offset
+ 8];
10519 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10521 target_sec
= r_reloc_get_section (&val
.r_rel
);
10522 target_relax_info
= get_xtensa_relax_info (target_sec
);
10524 if (target_relax_info
10525 && (target_relax_info
->is_relaxable_literal_section
10526 || target_relax_info
->is_relaxable_asm_section
))
10528 /* Translate the relocation's destination. */
10529 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10530 bfd_vma new_offset
;
10531 long old_size
, new_size
;
10532 int removed_by_old_offset
=
10533 removed_by_actions_map (&target_relax_info
->action_list
,
10534 old_offset
, FALSE
);
10535 new_offset
= old_offset
- removed_by_old_offset
;
10537 /* Assert that we are not out of bounds. */
10538 old_size
= bfd_get_32 (abfd
, size_p
);
10539 new_size
= old_size
;
10543 /* Only the first zero-sized unreachable entry is
10544 allowed to expand. In this case the new offset
10545 should be the offset before the fill and the new
10546 size is the expansion size. For other zero-sized
10547 entries the resulting size should be zero with an
10548 offset before or after the fill address depending
10549 on whether the expanding unreachable entry
10551 if (last_zfill_target_sec
== 0
10552 || last_zfill_target_sec
!= target_sec
10553 || last_zfill_target_offset
!= old_offset
)
10555 bfd_vma new_end_offset
= new_offset
;
10557 /* Recompute the new_offset, but this time don't
10558 include any fill inserted by relaxation. */
10559 removed_by_old_offset
=
10560 removed_by_actions_map (&target_relax_info
->action_list
,
10562 new_offset
= old_offset
- removed_by_old_offset
;
10564 /* If it is not unreachable and we have not yet
10565 seen an unreachable at this address, place it
10566 before the fill address. */
10567 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10568 & XTENSA_PROP_UNREACHABLE
) != 0)
10570 new_size
= new_end_offset
- new_offset
;
10572 last_zfill_target_sec
= target_sec
;
10573 last_zfill_target_offset
= old_offset
;
10579 int removed_by_old_offset_size
=
10580 removed_by_actions_map (&target_relax_info
->action_list
,
10581 old_offset
+ old_size
, TRUE
);
10582 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10585 if (new_size
!= old_size
)
10587 bfd_put_32 (abfd
, new_size
, size_p
);
10588 pin_contents (sec
, contents
);
10591 if (new_offset
!= old_offset
)
10593 bfd_vma diff
= new_offset
- old_offset
;
10594 irel
->r_addend
+= diff
;
10595 pin_internal_relocs (sec
, internal_relocs
);
10601 /* Combine adjacent property table entries. This is also done in
10602 finish_dynamic_sections() but at that point it's too late to
10603 reclaim the space in the output section, so we do this twice. */
10605 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10606 || xtensa_is_littable_section (sec
)))
10608 Elf_Internal_Rela
*last_irel
= NULL
;
10609 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10610 int removed_bytes
= 0;
10612 flagword predef_flags
;
10614 predef_flags
= xtensa_get_property_predef_flags (sec
);
10616 /* Walk over memory and relocations at the same time.
10617 This REQUIRES that the internal_relocs be sorted by offset. */
10618 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10619 internal_reloc_compare
);
10621 pin_internal_relocs (sec
, internal_relocs
);
10622 pin_contents (sec
, contents
);
10624 next_rel
= internal_relocs
;
10625 rel_end
= internal_relocs
+ sec
->reloc_count
;
10627 BFD_ASSERT (sec
->size
% entry_size
== 0);
10629 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10631 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10632 bfd_vma bytes_to_remove
, size
, actual_offset
;
10633 bfd_boolean remove_this_rel
;
10636 /* Find the first relocation for the entry at the current offset.
10637 Adjust the offsets of any extra relocations for the previous
10642 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10644 if ((irel
->r_offset
== offset
10645 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10646 || irel
->r_offset
> offset
)
10651 irel
->r_offset
-= removed_bytes
;
10655 /* Find the next relocation (if there are any left). */
10659 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10661 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10669 /* Check if there are relocations on the current entry. There
10670 should usually be a relocation on the offset field. If there
10671 are relocations on the size or flags, then we can't optimize
10672 this entry. Also, find the next relocation to examine on the
10676 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10678 next_rel
= offset_rel
;
10679 /* There are no relocations on the current entry, but we
10680 might still be able to remove it if the size is zero. */
10683 else if (offset_rel
->r_offset
> offset
10685 && extra_rel
->r_offset
< offset
+ entry_size
))
10687 /* There is a relocation on the size or flags, so we can't
10688 do anything with this entry. Continue with the next. */
10689 next_rel
= offset_rel
;
10694 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10695 offset_rel
->r_offset
-= removed_bytes
;
10696 next_rel
= offset_rel
+ 1;
10702 remove_this_rel
= FALSE
;
10703 bytes_to_remove
= 0;
10704 actual_offset
= offset
- removed_bytes
;
10705 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10707 if (is_full_prop_section
)
10708 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10710 flags
= predef_flags
;
10713 && (flags
& XTENSA_PROP_ALIGN
) == 0
10714 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10716 /* Always remove entries with zero size and no alignment. */
10717 bytes_to_remove
= entry_size
;
10719 remove_this_rel
= TRUE
;
10721 else if (offset_rel
10722 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10726 flagword old_flags
;
10728 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10729 bfd_vma old_address
=
10730 (last_irel
->r_addend
10731 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10732 bfd_vma new_address
=
10733 (offset_rel
->r_addend
10734 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10735 if (is_full_prop_section
)
10736 old_flags
= bfd_get_32
10737 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10739 old_flags
= predef_flags
;
10741 if ((ELF32_R_SYM (offset_rel
->r_info
)
10742 == ELF32_R_SYM (last_irel
->r_info
))
10743 && old_address
+ old_size
== new_address
10744 && old_flags
== flags
10745 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10746 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10748 /* Fix the old size. */
10749 bfd_put_32 (abfd
, old_size
+ size
,
10750 &contents
[last_irel
->r_offset
+ 4]);
10751 bytes_to_remove
= entry_size
;
10752 remove_this_rel
= TRUE
;
10755 last_irel
= offset_rel
;
10758 last_irel
= offset_rel
;
10761 if (remove_this_rel
)
10763 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10764 offset_rel
->r_offset
= 0;
10767 if (bytes_to_remove
!= 0)
10769 removed_bytes
+= bytes_to_remove
;
10770 if (offset
+ bytes_to_remove
< sec
->size
)
10771 memmove (&contents
[actual_offset
],
10772 &contents
[actual_offset
+ bytes_to_remove
],
10773 sec
->size
- offset
- bytes_to_remove
);
10779 /* Fix up any extra relocations on the last entry. */
10780 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10781 irel
->r_offset
-= removed_bytes
;
10783 /* Clear the removed bytes. */
10784 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10786 if (sec
->rawsize
== 0)
10787 sec
->rawsize
= sec
->size
;
10788 sec
->size
-= removed_bytes
;
10790 if (xtensa_is_littable_section (sec
))
10792 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10794 sgotloc
->size
-= removed_bytes
;
10800 release_internal_relocs (sec
, internal_relocs
);
10801 release_contents (sec
, contents
);
10806 /* Third relaxation pass. */
10808 /* Change symbol values to account for removed literals. */
10811 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10813 xtensa_relax_info
*relax_info
;
10814 unsigned int sec_shndx
;
10815 Elf_Internal_Shdr
*symtab_hdr
;
10816 Elf_Internal_Sym
*isymbuf
;
10817 unsigned i
, num_syms
, num_locals
;
10819 relax_info
= get_xtensa_relax_info (sec
);
10820 BFD_ASSERT (relax_info
);
10822 if (!relax_info
->is_relaxable_literal_section
10823 && !relax_info
->is_relaxable_asm_section
)
10826 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10828 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10829 isymbuf
= retrieve_local_syms (abfd
);
10831 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10832 num_locals
= symtab_hdr
->sh_info
;
10834 /* Adjust the local symbols defined in this section. */
10835 for (i
= 0; i
< num_locals
; i
++)
10837 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10839 if (isym
->st_shndx
== sec_shndx
)
10841 bfd_vma orig_addr
= isym
->st_value
;
10842 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10845 isym
->st_value
-= removed
;
10846 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10848 removed_by_actions_map (&relax_info
->action_list
,
10849 orig_addr
+ isym
->st_size
, FALSE
) -
10854 /* Now adjust the global symbols defined in this section. */
10855 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10857 struct elf_link_hash_entry
*sym_hash
;
10859 sym_hash
= elf_sym_hashes (abfd
)[i
];
10861 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10862 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10864 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10865 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10866 && sym_hash
->root
.u
.def
.section
== sec
)
10868 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10869 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10872 sym_hash
->root
.u
.def
.value
-= removed
;
10874 if (sym_hash
->type
== STT_FUNC
)
10876 removed_by_actions_map (&relax_info
->action_list
,
10877 orig_addr
+ sym_hash
->size
, FALSE
) -
10886 /* "Fix" handling functions, called while performing relocations. */
10889 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10891 asection
*input_section
,
10892 bfd_byte
*contents
)
10895 asection
*sec
, *old_sec
;
10896 bfd_vma old_offset
;
10897 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10898 reloc_bfd_fix
*fix
;
10900 if (r_type
== R_XTENSA_NONE
)
10903 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10907 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10908 bfd_get_section_limit (input_bfd
, input_section
));
10909 old_sec
= r_reloc_get_section (&r_rel
);
10910 old_offset
= r_rel
.target_offset
;
10912 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10914 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10917 /* xgettext:c-format */
10918 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10919 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10920 elf_howto_table
[r_type
].name
);
10923 /* Leave it be. Resolution will happen in a later stage. */
10927 sec
= fix
->target_sec
;
10928 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10929 - (old_sec
->output_offset
+ old_offset
));
10936 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10938 asection
*input_section
,
10939 bfd_byte
*contents
,
10940 bfd_vma
*relocationp
)
10943 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10944 reloc_bfd_fix
*fix
;
10945 bfd_vma fixup_diff
;
10947 if (r_type
== R_XTENSA_NONE
)
10950 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10954 sec
= fix
->target_sec
;
10956 fixup_diff
= rel
->r_addend
;
10957 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10959 bfd_vma inplace_val
;
10960 BFD_ASSERT (fix
->src_offset
10961 < bfd_get_section_limit (input_bfd
, input_section
));
10962 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10963 fixup_diff
+= inplace_val
;
10966 *relocationp
= (sec
->output_section
->vma
10967 + sec
->output_offset
10968 + fix
->target_offset
- fixup_diff
);
10972 /* Miscellaneous utility functions.... */
10975 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10981 return elf_hash_table (info
)->splt
;
10983 dynobj
= elf_hash_table (info
)->dynobj
;
10984 sprintf (plt_name
, ".plt.%u", chunk
);
10985 return bfd_get_linker_section (dynobj
, plt_name
);
10990 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10996 return elf_hash_table (info
)->sgotplt
;
10998 dynobj
= elf_hash_table (info
)->dynobj
;
10999 sprintf (got_name
, ".got.plt.%u", chunk
);
11000 return bfd_get_linker_section (dynobj
, got_name
);
11004 /* Get the input section for a given symbol index.
11006 . a section symbol, return the section;
11007 . a common symbol, return the common section;
11008 . an undefined symbol, return the undefined section;
11009 . an indirect symbol, follow the links;
11010 . an absolute value, return the absolute section. */
11013 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
11015 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11016 asection
*target_sec
= NULL
;
11017 if (r_symndx
< symtab_hdr
->sh_info
)
11019 Elf_Internal_Sym
*isymbuf
;
11020 unsigned int section_index
;
11022 isymbuf
= retrieve_local_syms (abfd
);
11023 section_index
= isymbuf
[r_symndx
].st_shndx
;
11025 if (section_index
== SHN_UNDEF
)
11026 target_sec
= bfd_und_section_ptr
;
11027 else if (section_index
== SHN_ABS
)
11028 target_sec
= bfd_abs_section_ptr
;
11029 else if (section_index
== SHN_COMMON
)
11030 target_sec
= bfd_com_section_ptr
;
11032 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
11036 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11037 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
11039 while (h
->root
.type
== bfd_link_hash_indirect
11040 || h
->root
.type
== bfd_link_hash_warning
)
11041 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11043 switch (h
->root
.type
)
11045 case bfd_link_hash_defined
:
11046 case bfd_link_hash_defweak
:
11047 target_sec
= h
->root
.u
.def
.section
;
11049 case bfd_link_hash_common
:
11050 target_sec
= bfd_com_section_ptr
;
11052 case bfd_link_hash_undefined
:
11053 case bfd_link_hash_undefweak
:
11054 target_sec
= bfd_und_section_ptr
;
11056 default: /* New indirect warning. */
11057 target_sec
= bfd_und_section_ptr
;
11065 static struct elf_link_hash_entry
*
11066 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
11068 unsigned long indx
;
11069 struct elf_link_hash_entry
*h
;
11070 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11072 if (r_symndx
< symtab_hdr
->sh_info
)
11075 indx
= r_symndx
- symtab_hdr
->sh_info
;
11076 h
= elf_sym_hashes (abfd
)[indx
];
11077 while (h
->root
.type
== bfd_link_hash_indirect
11078 || h
->root
.type
== bfd_link_hash_warning
)
11079 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11084 /* Get the section-relative offset for a symbol number. */
11087 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
11089 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11090 bfd_vma offset
= 0;
11092 if (r_symndx
< symtab_hdr
->sh_info
)
11094 Elf_Internal_Sym
*isymbuf
;
11095 isymbuf
= retrieve_local_syms (abfd
);
11096 offset
= isymbuf
[r_symndx
].st_value
;
11100 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11101 struct elf_link_hash_entry
*h
=
11102 elf_sym_hashes (abfd
)[indx
];
11104 while (h
->root
.type
== bfd_link_hash_indirect
11105 || h
->root
.type
== bfd_link_hash_warning
)
11106 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11107 if (h
->root
.type
== bfd_link_hash_defined
11108 || h
->root
.type
== bfd_link_hash_defweak
)
11109 offset
= h
->root
.u
.def
.value
;
11116 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
11118 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
11119 struct elf_link_hash_entry
*h
;
11121 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
11122 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
11129 pcrel_reloc_fits (xtensa_opcode opc
,
11131 bfd_vma self_address
,
11132 bfd_vma dest_address
)
11134 xtensa_isa isa
= xtensa_default_isa
;
11135 uint32 valp
= dest_address
;
11136 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
11137 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
11144 xtensa_is_property_section (asection
*sec
)
11146 if (xtensa_is_insntable_section (sec
)
11147 || xtensa_is_littable_section (sec
)
11148 || xtensa_is_proptable_section (sec
))
11156 xtensa_is_insntable_section (asection
*sec
)
11158 if (CONST_STRNEQ (sec
->name
, XTENSA_INSN_SEC_NAME
)
11159 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.x."))
11167 xtensa_is_littable_section (asection
*sec
)
11169 if (CONST_STRNEQ (sec
->name
, XTENSA_LIT_SEC_NAME
)
11170 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.p."))
11178 xtensa_is_proptable_section (asection
*sec
)
11180 if (CONST_STRNEQ (sec
->name
, XTENSA_PROP_SEC_NAME
)
11181 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.prop."))
11189 internal_reloc_compare (const void *ap
, const void *bp
)
11191 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11192 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11194 if (a
->r_offset
!= b
->r_offset
)
11195 return (a
->r_offset
- b
->r_offset
);
11197 /* We don't need to sort on these criteria for correctness,
11198 but enforcing a more strict ordering prevents unstable qsort
11199 from behaving differently with different implementations.
11200 Without the code below we get correct but different results
11201 on Solaris 2.7 and 2.8. We would like to always produce the
11202 same results no matter the host. */
11204 if (a
->r_info
!= b
->r_info
)
11205 return (a
->r_info
- b
->r_info
);
11207 return (a
->r_addend
- b
->r_addend
);
11212 internal_reloc_matches (const void *ap
, const void *bp
)
11214 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11215 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11217 /* Check if one entry overlaps with the other; this shouldn't happen
11218 except when searching for a match. */
11219 return (a
->r_offset
- b
->r_offset
);
11223 /* Predicate function used to look up a section in a particular group. */
11226 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
11228 const char *gname
= inf
;
11229 const char *group_name
= elf_group_name (sec
);
11231 return (group_name
== gname
11232 || (group_name
!= NULL
11234 && strcmp (group_name
, gname
) == 0));
11239 xtensa_add_names (const char *base
, const char *suffix
)
11243 size_t base_len
= strlen (base
);
11244 size_t suffix_len
= strlen (suffix
);
11245 char *str
= bfd_malloc (base_len
+ suffix_len
+ 1);
11247 memcpy (str
, base
, base_len
);
11248 memcpy (str
+ base_len
, suffix
, suffix_len
+ 1);
11253 return strdup (base
);
11257 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11260 xtensa_property_section_name (asection
*sec
, const char *base_name
,
11261 bfd_boolean separate_sections
)
11263 const char *suffix
, *group_name
;
11264 char *prop_sec_name
;
11266 group_name
= elf_group_name (sec
);
11269 suffix
= strrchr (sec
->name
, '.');
11270 if (suffix
== sec
->name
)
11272 prop_sec_name
= xtensa_add_names (base_name
, suffix
);
11274 else if (strncmp (sec
->name
, ".gnu.linkonce.", linkonce_len
) == 0)
11276 char *linkonce_kind
= 0;
11278 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11279 linkonce_kind
= "x.";
11280 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11281 linkonce_kind
= "p.";
11282 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11283 linkonce_kind
= "prop.";
11287 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11288 + strlen (linkonce_kind
) + 1);
11289 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11290 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11292 suffix
= sec
->name
+ linkonce_len
;
11293 /* For backward compatibility, replace "t." instead of inserting
11294 the new linkonce_kind (but not for "prop" sections). */
11295 if (CONST_STRNEQ (suffix
, "t.") && linkonce_kind
[1] == '.')
11297 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11301 prop_sec_name
= xtensa_add_names (base_name
,
11302 separate_sections
? sec
->name
: NULL
);
11305 return prop_sec_name
;
11310 xtensa_get_separate_property_section (asection
*sec
, const char *base_name
,
11311 bfd_boolean separate_section
)
11313 char *prop_sec_name
;
11314 asection
*prop_sec
;
11316 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11318 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11319 match_section_group
,
11320 (void *) elf_group_name (sec
));
11321 free (prop_sec_name
);
11326 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11328 asection
*prop_sec
;
11330 /* Try individual property section first. */
11331 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, TRUE
);
11333 /* Refer to a common property section if individual is not present. */
11335 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, FALSE
);
11342 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11344 char *prop_sec_name
;
11345 asection
*prop_sec
;
11347 /* Check if the section already exists. */
11348 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11349 elf32xtensa_separate_props
);
11350 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11351 match_section_group
,
11352 (void *) elf_group_name (sec
));
11353 /* If not, create it. */
11356 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11357 flags
|= (bfd_section_flags (sec
)
11358 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11360 prop_sec
= bfd_make_section_anyway_with_flags
11361 (sec
->owner
, strdup (prop_sec_name
), flags
);
11365 elf_group_name (prop_sec
) = elf_group_name (sec
);
11368 free (prop_sec_name
);
11374 xtensa_get_property_predef_flags (asection
*sec
)
11376 if (xtensa_is_insntable_section (sec
))
11377 return (XTENSA_PROP_INSN
11378 | XTENSA_PROP_NO_TRANSFORM
11379 | XTENSA_PROP_INSN_NO_REORDER
);
11381 if (xtensa_is_littable_section (sec
))
11382 return (XTENSA_PROP_LITERAL
11383 | XTENSA_PROP_NO_TRANSFORM
11384 | XTENSA_PROP_INSN_NO_REORDER
);
11390 /* Other functions called directly by the linker. */
11393 xtensa_callback_required_dependence (bfd
*abfd
,
11395 struct bfd_link_info
*link_info
,
11396 deps_callback_t callback
,
11399 Elf_Internal_Rela
*internal_relocs
;
11400 bfd_byte
*contents
;
11402 bfd_boolean ok
= TRUE
;
11403 bfd_size_type sec_size
;
11405 sec_size
= bfd_get_section_limit (abfd
, sec
);
11407 /* ".plt*" sections have no explicit relocations but they contain L32R
11408 instructions that reference the corresponding ".got.plt*" sections. */
11409 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11410 && CONST_STRNEQ (sec
->name
, ".plt"))
11414 /* Find the corresponding ".got.plt*" section. */
11415 if (sec
->name
[4] == '\0')
11416 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11422 BFD_ASSERT (sec
->name
[4] == '.');
11423 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11425 sprintf (got_name
, ".got.plt.%u", chunk
);
11426 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11428 BFD_ASSERT (sgotplt
);
11430 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11431 section referencing a literal at the very beginning of
11432 ".got.plt". This is very close to the real dependence, anyway. */
11433 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11436 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11437 when building uclibc, which runs "ld -b binary /dev/null". */
11438 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11441 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11442 link_info
->keep_memory
);
11443 if (internal_relocs
== NULL
11444 || sec
->reloc_count
== 0)
11447 /* Cache the contents for the duration of this scan. */
11448 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11449 if (contents
== NULL
&& sec_size
!= 0)
11455 if (!xtensa_default_isa
)
11456 xtensa_default_isa
= xtensa_isa_init (0, 0);
11458 for (i
= 0; i
< sec
->reloc_count
; i
++)
11460 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11461 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11464 asection
*target_sec
;
11465 bfd_vma target_offset
;
11467 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11470 /* L32Rs must be local to the input file. */
11471 if (r_reloc_is_defined (&l32r_rel
))
11473 target_sec
= r_reloc_get_section (&l32r_rel
);
11474 target_offset
= l32r_rel
.target_offset
;
11476 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11482 release_internal_relocs (sec
, internal_relocs
);
11483 release_contents (sec
, contents
);
11487 /* The default literal sections should always be marked as "code" (i.e.,
11488 SHF_EXECINSTR). This is particularly important for the Linux kernel
11489 module loader so that the literals are not placed after the text. */
11490 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11492 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11493 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11494 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11495 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11496 { NULL
, 0, 0, 0, 0 }
11499 #define ELF_TARGET_ID XTENSA_ELF_DATA
11501 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11502 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11503 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11504 #define TARGET_BIG_NAME "elf32-xtensa-be"
11505 #define ELF_ARCH bfd_arch_xtensa
11507 #define ELF_MACHINE_CODE EM_XTENSA
11508 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11510 #define ELF_MAXPAGESIZE 0x1000
11511 #endif /* ELF_ARCH */
11513 #define elf_backend_can_gc_sections 1
11514 #define elf_backend_can_refcount 1
11515 #define elf_backend_plt_readonly 1
11516 #define elf_backend_got_header_size 4
11517 #define elf_backend_want_dynbss 0
11518 #define elf_backend_want_got_plt 1
11519 #define elf_backend_dtrel_excludes_plt 1
11521 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11523 #define bfd_elf32_mkobject elf_xtensa_mkobject
11525 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11526 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11527 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11528 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11529 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11530 #define bfd_elf32_bfd_reloc_name_lookup \
11531 elf_xtensa_reloc_name_lookup
11532 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11533 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11535 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11536 #define elf_backend_check_relocs elf_xtensa_check_relocs
11537 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11538 #define elf_backend_discard_info elf_xtensa_discard_info
11539 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11540 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11541 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11542 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11543 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11544 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11545 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11546 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11547 #define elf_backend_object_p elf_xtensa_object_p
11548 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11549 #define elf_backend_relocate_section elf_xtensa_relocate_section
11550 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11551 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11552 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11553 #define elf_backend_special_sections elf_xtensa_special_sections
11554 #define elf_backend_action_discarded elf_xtensa_action_discarded
11555 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11557 #include "elf32-target.h"