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 ((is_elf_hash_table ((p)->hash) \
709 && elf_hash_table_id (elf_hash_table (p)) == XTENSA_ELF_DATA) \
710 ? (struct elf_xtensa_link_hash_table *) (p)->hash : NULL)
712 /* Create an entry in an Xtensa ELF linker hash table. */
714 static struct bfd_hash_entry
*
715 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
716 struct bfd_hash_table
*table
,
719 /* Allocate the structure if it has not already been allocated by a
723 entry
= bfd_hash_allocate (table
,
724 sizeof (struct elf_xtensa_link_hash_entry
));
729 /* Call the allocation method of the superclass. */
730 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
733 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (entry
);
734 eh
->tlsfunc_refcount
= 0;
735 eh
->tls_type
= GOT_UNKNOWN
;
741 /* Create an Xtensa ELF linker hash table. */
743 static struct bfd_link_hash_table
*
744 elf_xtensa_link_hash_table_create (bfd
*abfd
)
746 struct elf_link_hash_entry
*tlsbase
;
747 struct elf_xtensa_link_hash_table
*ret
;
748 size_t amt
= sizeof (struct elf_xtensa_link_hash_table
);
750 ret
= bfd_zmalloc (amt
);
754 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
755 elf_xtensa_link_hash_newfunc
,
756 sizeof (struct elf_xtensa_link_hash_entry
),
763 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
765 tlsbase
= elf_link_hash_lookup (&ret
->elf
, "_TLS_MODULE_BASE_",
767 tlsbase
->root
.type
= bfd_link_hash_new
;
768 tlsbase
->root
.u
.undef
.abfd
= NULL
;
769 tlsbase
->non_elf
= 0;
770 ret
->elf
.dt_pltgot_required
= TRUE
;
771 ret
->tlsbase
= elf_xtensa_hash_entry (tlsbase
);
772 ret
->tlsbase
->tls_type
= GOT_UNKNOWN
;
774 return &ret
->elf
.root
;
777 /* Copy the extra info we tack onto an elf_link_hash_entry. */
780 elf_xtensa_copy_indirect_symbol (struct bfd_link_info
*info
,
781 struct elf_link_hash_entry
*dir
,
782 struct elf_link_hash_entry
*ind
)
784 struct elf_xtensa_link_hash_entry
*edir
, *eind
;
786 edir
= elf_xtensa_hash_entry (dir
);
787 eind
= elf_xtensa_hash_entry (ind
);
789 if (ind
->root
.type
== bfd_link_hash_indirect
)
791 edir
->tlsfunc_refcount
+= eind
->tlsfunc_refcount
;
792 eind
->tlsfunc_refcount
= 0;
794 if (dir
->got
.refcount
<= 0)
796 edir
->tls_type
= eind
->tls_type
;
797 eind
->tls_type
= GOT_UNKNOWN
;
801 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
804 static inline bfd_boolean
805 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
806 struct bfd_link_info
*info
)
808 /* Check if we should do dynamic things to this symbol. The
809 "ignore_protected" argument need not be set, because Xtensa code
810 does not require special handling of STV_PROTECTED to make function
811 pointer comparisons work properly. The PLT addresses are never
812 used for function pointers. */
814 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
819 property_table_compare (const void *ap
, const void *bp
)
821 const property_table_entry
*a
= (const property_table_entry
*) ap
;
822 const property_table_entry
*b
= (const property_table_entry
*) bp
;
824 if (a
->address
== b
->address
)
826 if (a
->size
!= b
->size
)
827 return (a
->size
- b
->size
);
829 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
830 return ((b
->flags
& XTENSA_PROP_ALIGN
)
831 - (a
->flags
& XTENSA_PROP_ALIGN
));
833 if ((a
->flags
& XTENSA_PROP_ALIGN
)
834 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
835 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
836 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
837 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
839 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
840 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
841 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
842 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
844 return (a
->flags
- b
->flags
);
847 return (a
->address
- b
->address
);
852 property_table_matches (const void *ap
, const void *bp
)
854 const property_table_entry
*a
= (const property_table_entry
*) ap
;
855 const property_table_entry
*b
= (const property_table_entry
*) bp
;
857 /* Check if one entry overlaps with the other. */
858 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
859 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
862 return (a
->address
- b
->address
);
866 /* Get the literal table or property table entries for the given
867 section. Sets TABLE_P and returns the number of entries. On
868 error, returns a negative value. */
871 xtensa_read_table_entries (bfd
*abfd
,
873 property_table_entry
**table_p
,
874 const char *sec_name
,
875 bfd_boolean output_addr
)
877 asection
*table_section
;
878 bfd_size_type table_size
= 0;
879 bfd_byte
*table_data
;
880 property_table_entry
*blocks
;
881 int blk
, block_count
;
882 bfd_size_type num_records
;
883 Elf_Internal_Rela
*internal_relocs
, *irel
, *rel_end
;
884 bfd_vma section_addr
, off
;
885 flagword predef_flags
;
886 bfd_size_type table_entry_size
, section_limit
;
889 || !(section
->flags
& SEC_ALLOC
)
890 || (section
->flags
& SEC_DEBUGGING
))
896 table_section
= xtensa_get_property_section (section
, sec_name
);
898 table_size
= table_section
->size
;
906 predef_flags
= xtensa_get_property_predef_flags (table_section
);
907 table_entry_size
= 12;
909 table_entry_size
-= 4;
911 num_records
= table_size
/ table_entry_size
;
912 table_data
= retrieve_contents (abfd
, table_section
, TRUE
);
913 blocks
= (property_table_entry
*)
914 bfd_malloc (num_records
* sizeof (property_table_entry
));
918 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
920 section_addr
= section
->vma
;
922 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, TRUE
);
923 if (internal_relocs
&& !table_section
->reloc_done
)
925 qsort (internal_relocs
, table_section
->reloc_count
,
926 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
927 irel
= internal_relocs
;
932 section_limit
= bfd_get_section_limit (abfd
, section
);
933 rel_end
= internal_relocs
+ table_section
->reloc_count
;
935 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
937 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
939 /* Skip any relocations before the current offset. This should help
940 avoid confusion caused by unexpected relocations for the preceding
943 (irel
->r_offset
< off
944 || (irel
->r_offset
== off
945 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
952 if (irel
&& irel
->r_offset
== off
)
955 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
956 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
958 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
961 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
962 BFD_ASSERT (sym_off
== 0);
963 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
967 if (address
< section_addr
968 || address
>= section_addr
+ section_limit
)
972 blocks
[block_count
].address
= address
;
973 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
975 blocks
[block_count
].flags
= predef_flags
;
977 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
981 release_contents (table_section
, table_data
);
982 release_internal_relocs (table_section
, internal_relocs
);
986 /* Now sort them into address order for easy reference. */
987 qsort (blocks
, block_count
, sizeof (property_table_entry
),
988 property_table_compare
);
990 /* Check that the table contents are valid. Problems may occur,
991 for example, if an unrelocated object file is stripped. */
992 for (blk
= 1; blk
< block_count
; blk
++)
994 /* The only circumstance where two entries may legitimately
995 have the same address is when one of them is a zero-size
996 placeholder to mark a place where fill can be inserted.
997 The zero-size entry should come first. */
998 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
999 blocks
[blk
- 1].size
!= 0)
1001 /* xgettext:c-format */
1002 _bfd_error_handler (_("%pB(%pA): invalid property table"),
1004 bfd_set_error (bfd_error_bad_value
);
1016 static property_table_entry
*
1017 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
1018 int property_table_size
,
1021 property_table_entry entry
;
1022 property_table_entry
*rv
;
1024 if (property_table_size
== 0)
1027 entry
.address
= addr
;
1031 rv
= bsearch (&entry
, property_table
, property_table_size
,
1032 sizeof (property_table_entry
), property_table_matches
);
1038 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
1042 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
1049 /* Look through the relocs for a section during the first phase, and
1050 calculate needed space in the dynamic reloc sections. */
1053 elf_xtensa_check_relocs (bfd
*abfd
,
1054 struct bfd_link_info
*info
,
1056 const Elf_Internal_Rela
*relocs
)
1058 struct elf_xtensa_link_hash_table
*htab
;
1059 Elf_Internal_Shdr
*symtab_hdr
;
1060 struct elf_link_hash_entry
**sym_hashes
;
1061 const Elf_Internal_Rela
*rel
;
1062 const Elf_Internal_Rela
*rel_end
;
1064 if (bfd_link_relocatable (info
))
1067 BFD_ASSERT (is_xtensa_elf (abfd
));
1069 htab
= elf_xtensa_hash_table (info
);
1073 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1074 sym_hashes
= elf_sym_hashes (abfd
);
1076 rel_end
= relocs
+ sec
->reloc_count
;
1077 for (rel
= relocs
; rel
< rel_end
; rel
++)
1079 unsigned int r_type
;
1081 struct elf_link_hash_entry
*h
= NULL
;
1082 struct elf_xtensa_link_hash_entry
*eh
;
1083 int tls_type
, old_tls_type
;
1084 bfd_boolean is_got
= FALSE
;
1085 bfd_boolean is_plt
= FALSE
;
1086 bfd_boolean is_tlsfunc
= FALSE
;
1088 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1089 r_type
= ELF32_R_TYPE (rel
->r_info
);
1091 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1093 /* xgettext:c-format */
1094 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1099 if (r_symndx
>= symtab_hdr
->sh_info
)
1101 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1102 while (h
->root
.type
== bfd_link_hash_indirect
1103 || h
->root
.type
== bfd_link_hash_warning
)
1104 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1106 eh
= elf_xtensa_hash_entry (h
);
1110 case R_XTENSA_TLSDESC_FN
:
1111 if (bfd_link_pic (info
))
1113 tls_type
= GOT_TLS_GD
;
1118 tls_type
= GOT_TLS_IE
;
1121 case R_XTENSA_TLSDESC_ARG
:
1122 if (bfd_link_pic (info
))
1124 tls_type
= GOT_TLS_GD
;
1129 tls_type
= GOT_TLS_IE
;
1130 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1135 case R_XTENSA_TLS_DTPOFF
:
1136 if (bfd_link_pic (info
))
1137 tls_type
= GOT_TLS_GD
;
1139 tls_type
= GOT_TLS_IE
;
1142 case R_XTENSA_TLS_TPOFF
:
1143 tls_type
= GOT_TLS_IE
;
1144 if (bfd_link_pic (info
))
1145 info
->flags
|= DF_STATIC_TLS
;
1146 if (bfd_link_pic (info
) || h
)
1151 tls_type
= GOT_NORMAL
;
1156 tls_type
= GOT_NORMAL
;
1160 case R_XTENSA_GNU_VTINHERIT
:
1161 /* This relocation describes the C++ object vtable hierarchy.
1162 Reconstruct it for later use during GC. */
1163 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1167 case R_XTENSA_GNU_VTENTRY
:
1168 /* This relocation describes which C++ vtable entries are actually
1169 used. Record for later use during GC. */
1170 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1175 /* Nothing to do for any other relocations. */
1183 if (h
->plt
.refcount
<= 0)
1186 h
->plt
.refcount
= 1;
1189 h
->plt
.refcount
+= 1;
1191 /* Keep track of the total PLT relocation count even if we
1192 don't yet know whether the dynamic sections will be
1194 htab
->plt_reloc_count
+= 1;
1196 if (elf_hash_table (info
)->dynamic_sections_created
)
1198 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1204 if (h
->got
.refcount
<= 0)
1205 h
->got
.refcount
= 1;
1207 h
->got
.refcount
+= 1;
1211 eh
->tlsfunc_refcount
+= 1;
1213 old_tls_type
= eh
->tls_type
;
1217 /* Allocate storage the first time. */
1218 if (elf_local_got_refcounts (abfd
) == NULL
)
1220 bfd_size_type size
= symtab_hdr
->sh_info
;
1223 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1226 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1228 mem
= bfd_zalloc (abfd
, size
);
1231 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1233 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1236 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1237 = (bfd_signed_vma
*) mem
;
1240 /* This is a global offset table entry for a local symbol. */
1241 if (is_got
|| is_plt
)
1242 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1245 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1247 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1250 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1251 tls_type
|= old_tls_type
;
1252 /* If a TLS symbol is accessed using IE at least once,
1253 there is no point to use a dynamic model for it. */
1254 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1255 && ((old_tls_type
& GOT_TLS_GD
) == 0
1256 || (tls_type
& GOT_TLS_IE
) == 0))
1258 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1259 tls_type
= old_tls_type
;
1260 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1261 tls_type
|= old_tls_type
;
1265 /* xgettext:c-format */
1266 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1268 h
? h
->root
.root
.string
: "<local>");
1273 if (old_tls_type
!= tls_type
)
1276 eh
->tls_type
= tls_type
;
1278 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1287 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1288 struct elf_link_hash_entry
*h
)
1290 if (bfd_link_pic (info
))
1292 if (h
->plt
.refcount
> 0)
1294 /* For shared objects, there's no need for PLT entries for local
1295 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1296 if (h
->got
.refcount
< 0)
1297 h
->got
.refcount
= 0;
1298 h
->got
.refcount
+= h
->plt
.refcount
;
1299 h
->plt
.refcount
= 0;
1304 /* Don't need any dynamic relocations at all. */
1305 h
->plt
.refcount
= 0;
1306 h
->got
.refcount
= 0;
1312 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1313 struct elf_link_hash_entry
*h
,
1314 bfd_boolean force_local
)
1316 /* For a shared link, move the plt refcount to the got refcount to leave
1317 space for RELATIVE relocs. */
1318 elf_xtensa_make_sym_local (info
, h
);
1320 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1324 /* Return the section that should be marked against GC for a given
1328 elf_xtensa_gc_mark_hook (asection
*sec
,
1329 struct bfd_link_info
*info
,
1330 Elf_Internal_Rela
*rel
,
1331 struct elf_link_hash_entry
*h
,
1332 Elf_Internal_Sym
*sym
)
1334 /* Property sections are marked "KEEP" in the linker scripts, but they
1335 should not cause other sections to be marked. (This approach relies
1336 on elf_xtensa_discard_info to remove property table entries that
1337 describe discarded sections. Alternatively, it might be more
1338 efficient to avoid using "KEEP" in the linker scripts and instead use
1339 the gc_mark_extra_sections hook to mark only the property sections
1340 that describe marked sections. That alternative does not work well
1341 with the current property table sections, which do not correspond
1342 one-to-one with the sections they describe, but that should be fixed
1344 if (xtensa_is_property_section (sec
))
1348 switch (ELF32_R_TYPE (rel
->r_info
))
1350 case R_XTENSA_GNU_VTINHERIT
:
1351 case R_XTENSA_GNU_VTENTRY
:
1355 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1359 /* Create all the dynamic sections. */
1362 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1364 struct elf_xtensa_link_hash_table
*htab
;
1365 flagword flags
, noalloc_flags
;
1367 htab
= elf_xtensa_hash_table (info
);
1371 /* First do all the standard stuff. */
1372 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1375 /* Create any extra PLT sections in case check_relocs has already
1376 been called on all the non-dynamic input files. */
1377 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1380 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1381 | SEC_LINKER_CREATED
| SEC_READONLY
);
1382 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1384 /* Mark the ".got.plt" section READONLY. */
1385 if (htab
->elf
.sgotplt
== NULL
1386 || !bfd_set_section_flags (htab
->elf
.sgotplt
, flags
))
1389 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1390 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1392 if (htab
->sgotloc
== NULL
1393 || !bfd_set_section_alignment (htab
->sgotloc
, 2))
1396 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1397 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1399 if (htab
->spltlittbl
== NULL
1400 || !bfd_set_section_alignment (htab
->spltlittbl
, 2))
1408 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1410 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1413 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1414 ".got.plt" sections. */
1415 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1421 /* Stop when we find a section has already been created. */
1422 if (elf_xtensa_get_plt_section (info
, chunk
))
1425 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1426 | SEC_LINKER_CREATED
| SEC_READONLY
);
1428 sname
= (char *) bfd_malloc (10);
1429 sprintf (sname
, ".plt.%u", chunk
);
1430 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1432 || !bfd_set_section_alignment (s
, 2))
1435 sname
= (char *) bfd_malloc (14);
1436 sprintf (sname
, ".got.plt.%u", chunk
);
1437 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1439 || !bfd_set_section_alignment (s
, 2))
1447 /* Adjust a symbol defined by a dynamic object and referenced by a
1448 regular object. The current definition is in some section of the
1449 dynamic object, but we're not including those sections. We have to
1450 change the definition to something the rest of the link can
1454 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1455 struct elf_link_hash_entry
*h
)
1457 /* If this is a weak symbol, and there is a real definition, the
1458 processor independent code will have arranged for us to see the
1459 real definition first, and we can just use the same value. */
1460 if (h
->is_weakalias
)
1462 struct elf_link_hash_entry
*def
= weakdef (h
);
1463 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1464 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1465 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1469 /* This is a reference to a symbol defined by a dynamic object. The
1470 reference must go through the GOT, so there's no need for COPY relocs,
1478 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1480 struct bfd_link_info
*info
;
1481 struct elf_xtensa_link_hash_table
*htab
;
1482 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1484 if (h
->root
.type
== bfd_link_hash_indirect
)
1487 info
= (struct bfd_link_info
*) arg
;
1488 htab
= elf_xtensa_hash_table (info
);
1492 /* If we saw any use of an IE model for this symbol, we can then optimize
1493 away GOT entries for any TLSDESC_FN relocs. */
1494 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1496 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1497 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1500 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1501 elf_xtensa_make_sym_local (info
, h
);
1503 if (! elf_xtensa_dynamic_symbol_p (h
, info
)
1504 && h
->root
.type
== bfd_link_hash_undefweak
)
1507 if (h
->plt
.refcount
> 0)
1508 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1510 if (h
->got
.refcount
> 0)
1511 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1518 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1520 struct elf_xtensa_link_hash_table
*htab
;
1523 htab
= elf_xtensa_hash_table (info
);
1527 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1529 bfd_signed_vma
*local_got_refcounts
;
1530 bfd_size_type j
, cnt
;
1531 Elf_Internal_Shdr
*symtab_hdr
;
1533 local_got_refcounts
= elf_local_got_refcounts (i
);
1534 if (!local_got_refcounts
)
1537 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1538 cnt
= symtab_hdr
->sh_info
;
1540 for (j
= 0; j
< cnt
; ++j
)
1542 /* If we saw any use of an IE model for this symbol, we can
1543 then optimize away GOT entries for any TLSDESC_FN relocs. */
1544 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1546 bfd_signed_vma
*tlsfunc_refcount
1547 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1548 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1549 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1552 if (local_got_refcounts
[j
] > 0)
1553 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1554 * sizeof (Elf32_External_Rela
));
1560 /* Set the sizes of the dynamic sections. */
1563 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1564 struct bfd_link_info
*info
)
1566 struct elf_xtensa_link_hash_table
*htab
;
1568 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1569 bfd_boolean relplt
, relgot
;
1570 int plt_entries
, plt_chunks
, chunk
;
1575 htab
= elf_xtensa_hash_table (info
);
1579 dynobj
= elf_hash_table (info
)->dynobj
;
1582 srelgot
= htab
->elf
.srelgot
;
1583 srelplt
= htab
->elf
.srelplt
;
1585 if (elf_hash_table (info
)->dynamic_sections_created
)
1587 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1588 && htab
->elf
.srelplt
!= NULL
1589 && htab
->elf
.sgot
!= NULL
1590 && htab
->spltlittbl
!= NULL
1591 && htab
->sgotloc
!= NULL
);
1593 /* Set the contents of the .interp section to the interpreter. */
1594 if (bfd_link_executable (info
) && !info
->nointerp
)
1596 s
= bfd_get_linker_section (dynobj
, ".interp");
1599 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1600 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1603 /* Allocate room for one word in ".got". */
1604 htab
->elf
.sgot
->size
= 4;
1606 /* Allocate space in ".rela.got" for literals that reference global
1607 symbols and space in ".rela.plt" for literals that have PLT
1609 elf_link_hash_traverse (elf_hash_table (info
),
1610 elf_xtensa_allocate_dynrelocs
,
1613 /* If we are generating a shared object, we also need space in
1614 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1615 reference local symbols. */
1616 if (bfd_link_pic (info
))
1617 elf_xtensa_allocate_local_got_size (info
);
1619 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1620 each PLT entry, we need the PLT code plus a 4-byte literal.
1621 For each chunk of ".plt", we also need two more 4-byte
1622 literals, two corresponding entries in ".rela.got", and an
1623 8-byte entry in ".xt.lit.plt". */
1624 spltlittbl
= htab
->spltlittbl
;
1625 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1627 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1629 /* Iterate over all the PLT chunks, including any extra sections
1630 created earlier because the initial count of PLT relocations
1631 was an overestimate. */
1633 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1638 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1639 BFD_ASSERT (sgotplt
!= NULL
);
1641 if (chunk
< plt_chunks
- 1)
1642 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1643 else if (chunk
== plt_chunks
- 1)
1644 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1648 if (chunk_entries
!= 0)
1650 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1651 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1652 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1653 spltlittbl
->size
+= 8;
1662 /* Allocate space in ".got.loc" to match the total size of all the
1664 sgotloc
= htab
->sgotloc
;
1665 sgotloc
->size
= spltlittbl
->size
;
1666 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1668 if (abfd
->flags
& DYNAMIC
)
1670 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1672 if (! discarded_section (s
)
1673 && xtensa_is_littable_section (s
)
1675 sgotloc
->size
+= s
->size
;
1680 /* Allocate memory for dynamic sections. */
1683 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1687 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1690 /* It's OK to base decisions on the section name, because none
1691 of the dynobj section names depend upon the input files. */
1692 name
= bfd_section_name (s
);
1694 if (CONST_STRNEQ (name
, ".rela"))
1698 if (strcmp (name
, ".rela.plt") == 0)
1700 else if (strcmp (name
, ".rela.got") == 0)
1703 /* We use the reloc_count field as a counter if we need
1704 to copy relocs into the output file. */
1708 else if (! CONST_STRNEQ (name
, ".plt.")
1709 && ! CONST_STRNEQ (name
, ".got.plt.")
1710 && strcmp (name
, ".got") != 0
1711 && strcmp (name
, ".plt") != 0
1712 && strcmp (name
, ".got.plt") != 0
1713 && strcmp (name
, ".xt.lit.plt") != 0
1714 && strcmp (name
, ".got.loc") != 0)
1716 /* It's not one of our sections, so don't allocate space. */
1722 /* If we don't need this section, strip it from the output
1723 file. We must create the ".plt*" and ".got.plt*"
1724 sections in create_dynamic_sections and/or check_relocs
1725 based on a conservative estimate of the PLT relocation
1726 count, because the sections must be created before the
1727 linker maps input sections to output sections. The
1728 linker does that before size_dynamic_sections, where we
1729 compute the exact size of the PLT, so there may be more
1730 of these sections than are actually needed. */
1731 s
->flags
|= SEC_EXCLUDE
;
1733 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1735 /* Allocate memory for the section contents. */
1736 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1737 if (s
->contents
== NULL
)
1742 if (elf_hash_table (info
)->dynamic_sections_created
)
1744 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1745 known until finish_dynamic_sections, but we need to get the relocs
1746 in place before they are sorted. */
1747 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1749 Elf_Internal_Rela irela
;
1753 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1756 loc
= (srelgot
->contents
1757 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1758 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1759 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1760 loc
+ sizeof (Elf32_External_Rela
));
1761 srelgot
->reloc_count
+= 2;
1764 /* Add some entries to the .dynamic section. We fill in the
1765 values later, in elf_xtensa_finish_dynamic_sections, but we
1766 must add the entries now so that we get the correct size for
1767 the .dynamic section. The DT_DEBUG entry is filled in by the
1768 dynamic linker and used by the debugger. */
1769 #define add_dynamic_entry(TAG, VAL) \
1770 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1772 if (!_bfd_elf_add_dynamic_tags (output_bfd
, info
,
1776 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1777 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1780 #undef add_dynamic_entry
1786 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1787 struct bfd_link_info
*info
)
1789 struct elf_xtensa_link_hash_table
*htab
;
1792 htab
= elf_xtensa_hash_table (info
);
1796 tls_sec
= htab
->elf
.tls_sec
;
1798 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1800 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1801 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1802 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1804 tlsbase
->type
= STT_TLS
;
1805 if (!(_bfd_generic_link_add_one_symbol
1806 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1807 tls_sec
, 0, NULL
, FALSE
,
1808 bed
->collect
, &bh
)))
1810 tlsbase
->def_regular
= 1;
1811 tlsbase
->other
= STV_HIDDEN
;
1812 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1819 /* Return the base VMA address which should be subtracted from real addresses
1820 when resolving @dtpoff relocation.
1821 This is PT_TLS segment p_vaddr. */
1824 dtpoff_base (struct bfd_link_info
*info
)
1826 /* If tls_sec is NULL, we should have signalled an error already. */
1827 if (elf_hash_table (info
)->tls_sec
== NULL
)
1829 return elf_hash_table (info
)->tls_sec
->vma
;
1832 /* Return the relocation value for @tpoff relocation
1833 if STT_TLS virtual address is ADDRESS. */
1836 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1838 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1841 /* If tls_sec is NULL, we should have signalled an error already. */
1842 if (htab
->tls_sec
== NULL
)
1844 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1845 return address
- htab
->tls_sec
->vma
+ base
;
1848 /* Perform the specified relocation. The instruction at (contents + address)
1849 is modified to set one operand to represent the value in "relocation". The
1850 operand position is determined by the relocation type recorded in the
1853 #define CALL_SEGMENT_BITS (30)
1854 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1856 static bfd_reloc_status_type
1857 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1859 asection
*input_section
,
1863 bfd_boolean is_weak_undef
,
1864 char **error_message
)
1867 xtensa_opcode opcode
;
1868 xtensa_isa isa
= xtensa_default_isa
;
1869 static xtensa_insnbuf ibuff
= NULL
;
1870 static xtensa_insnbuf sbuff
= NULL
;
1871 bfd_vma self_address
;
1872 bfd_size_type input_size
;
1878 ibuff
= xtensa_insnbuf_alloc (isa
);
1879 sbuff
= xtensa_insnbuf_alloc (isa
);
1882 input_size
= bfd_get_section_limit (abfd
, input_section
);
1884 /* Calculate the PC address for this instruction. */
1885 self_address
= (input_section
->output_section
->vma
1886 + input_section
->output_offset
1889 switch (howto
->type
)
1892 case R_XTENSA_DIFF8
:
1893 case R_XTENSA_DIFF16
:
1894 case R_XTENSA_DIFF32
:
1895 case R_XTENSA_PDIFF8
:
1896 case R_XTENSA_PDIFF16
:
1897 case R_XTENSA_PDIFF32
:
1898 case R_XTENSA_NDIFF8
:
1899 case R_XTENSA_NDIFF16
:
1900 case R_XTENSA_NDIFF32
:
1901 case R_XTENSA_TLS_FUNC
:
1902 case R_XTENSA_TLS_ARG
:
1903 case R_XTENSA_TLS_CALL
:
1904 return bfd_reloc_ok
;
1906 case R_XTENSA_ASM_EXPAND
:
1909 /* Check for windowed CALL across a 1GB boundary. */
1910 opcode
= get_expanded_call_opcode (contents
+ address
,
1911 input_size
- address
, 0);
1912 if (is_windowed_call_opcode (opcode
))
1914 if ((self_address
>> CALL_SEGMENT_BITS
)
1915 != (relocation
>> CALL_SEGMENT_BITS
))
1917 *error_message
= "windowed longcall crosses 1GB boundary; "
1919 return bfd_reloc_dangerous
;
1923 return bfd_reloc_ok
;
1925 case R_XTENSA_ASM_SIMPLIFY
:
1927 /* Convert the L32R/CALLX to CALL. */
1928 bfd_reloc_status_type retval
=
1929 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1931 if (retval
!= bfd_reloc_ok
)
1932 return bfd_reloc_dangerous
;
1934 /* The CALL needs to be relocated. Continue below for that part. */
1937 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1944 x
= bfd_get_32 (abfd
, contents
+ address
);
1946 bfd_put_32 (abfd
, x
, contents
+ address
);
1948 return bfd_reloc_ok
;
1950 case R_XTENSA_32_PCREL
:
1951 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1952 return bfd_reloc_ok
;
1955 case R_XTENSA_TLSDESC_FN
:
1956 case R_XTENSA_TLSDESC_ARG
:
1957 case R_XTENSA_TLS_DTPOFF
:
1958 case R_XTENSA_TLS_TPOFF
:
1959 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1960 return bfd_reloc_ok
;
1963 /* Only instruction slot-specific relocations handled below.... */
1964 slot
= get_relocation_slot (howto
->type
);
1965 if (slot
== XTENSA_UNDEFINED
)
1967 *error_message
= "unexpected relocation";
1968 return bfd_reloc_dangerous
;
1971 /* Read the instruction into a buffer and decode the opcode. */
1972 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1973 input_size
- address
);
1974 fmt
= xtensa_format_decode (isa
, ibuff
);
1975 if (fmt
== XTENSA_UNDEFINED
)
1977 *error_message
= "cannot decode instruction format";
1978 return bfd_reloc_dangerous
;
1981 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1983 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1984 if (opcode
== XTENSA_UNDEFINED
)
1986 *error_message
= "cannot decode instruction opcode";
1987 return bfd_reloc_dangerous
;
1990 /* Check for opcode-specific "alternate" relocations. */
1991 if (is_alt_relocation (howto
->type
))
1993 if (opcode
== get_l32r_opcode ())
1995 /* Handle the special-case of non-PC-relative L32R instructions. */
1996 bfd
*output_bfd
= input_section
->output_section
->owner
;
1997 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
2000 *error_message
= "relocation references missing .lit4 section";
2001 return bfd_reloc_dangerous
;
2003 self_address
= ((lit4_sec
->vma
& ~0xfff)
2004 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2005 newval
= relocation
;
2008 else if (opcode
== get_const16_opcode ())
2010 /* ALT used for high 16 bits.
2011 Ignore 32-bit overflow. */
2012 newval
= (relocation
>> 16) & 0xffff;
2017 /* No other "alternate" relocations currently defined. */
2018 *error_message
= "unexpected relocation";
2019 return bfd_reloc_dangerous
;
2022 else /* Not an "alternate" relocation.... */
2024 if (opcode
== get_const16_opcode ())
2026 newval
= relocation
& 0xffff;
2031 /* ...normal PC-relative relocation.... */
2033 /* Determine which operand is being relocated. */
2034 opnd
= get_relocation_opnd (opcode
, howto
->type
);
2035 if (opnd
== XTENSA_UNDEFINED
)
2037 *error_message
= "unexpected relocation";
2038 return bfd_reloc_dangerous
;
2041 if (!howto
->pc_relative
)
2043 *error_message
= "expected PC-relative relocation";
2044 return bfd_reloc_dangerous
;
2047 newval
= relocation
;
2051 /* Apply the relocation. */
2052 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
2053 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
2054 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2057 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2060 msg
= "cannot encode";
2061 if (is_direct_call_opcode (opcode
))
2063 if ((relocation
& 0x3) != 0)
2064 msg
= "misaligned call target";
2066 msg
= "call target out of range";
2068 else if (opcode
== get_l32r_opcode ())
2070 if ((relocation
& 0x3) != 0)
2071 msg
= "misaligned literal target";
2072 else if (is_alt_relocation (howto
->type
))
2073 msg
= "literal target out of range (too many literals)";
2074 else if (self_address
> relocation
)
2075 msg
= "literal target out of range (try using text-section-literals)";
2077 msg
= "literal placed after use";
2080 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2081 return bfd_reloc_dangerous
;
2084 /* Check for calls across 1GB boundaries. */
2085 if (is_direct_call_opcode (opcode
)
2086 && is_windowed_call_opcode (opcode
))
2088 if ((self_address
>> CALL_SEGMENT_BITS
)
2089 != (relocation
>> CALL_SEGMENT_BITS
))
2092 "windowed call crosses 1GB boundary; return may fail";
2093 return bfd_reloc_dangerous
;
2097 /* Write the modified instruction back out of the buffer. */
2098 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2099 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2100 input_size
- address
);
2101 return bfd_reloc_ok
;
2106 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2108 /* To reduce the size of the memory leak,
2109 we only use a single message buffer. */
2110 static bfd_size_type alloc_size
= 0;
2111 static char *message
= NULL
;
2112 bfd_size_type orig_len
, len
= 0;
2113 bfd_boolean is_append
;
2116 va_start (ap
, arglen
);
2118 is_append
= (origmsg
== message
);
2120 orig_len
= strlen (origmsg
);
2121 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2122 if (len
> alloc_size
)
2124 message
= (char *) bfd_realloc_or_free (message
, len
);
2127 if (message
!= NULL
)
2130 memcpy (message
, origmsg
, orig_len
);
2131 vsprintf (message
+ orig_len
, fmt
, ap
);
2138 /* This function is registered as the "special_function" in the
2139 Xtensa howto for handling simplify operations.
2140 bfd_perform_relocation / bfd_install_relocation use it to
2141 perform (install) the specified relocation. Since this replaces the code
2142 in bfd_perform_relocation, it is basically an Xtensa-specific,
2143 stripped-down version of bfd_perform_relocation. */
2145 static bfd_reloc_status_type
2146 bfd_elf_xtensa_reloc (bfd
*abfd
,
2147 arelent
*reloc_entry
,
2150 asection
*input_section
,
2152 char **error_message
)
2155 bfd_reloc_status_type flag
;
2156 bfd_size_type octets
= (reloc_entry
->address
2157 * OCTETS_PER_BYTE (abfd
, input_section
));
2158 bfd_vma output_base
= 0;
2159 reloc_howto_type
*howto
= reloc_entry
->howto
;
2160 asection
*reloc_target_output_section
;
2161 bfd_boolean is_weak_undef
;
2163 if (!xtensa_default_isa
)
2164 xtensa_default_isa
= xtensa_isa_init (0, 0);
2166 /* ELF relocs are against symbols. If we are producing relocatable
2167 output, and the reloc is against an external symbol, the resulting
2168 reloc will also be against the same symbol. In such a case, we
2169 don't want to change anything about the way the reloc is handled,
2170 since it will all be done at final link time. This test is similar
2171 to what bfd_elf_generic_reloc does except that it lets relocs with
2172 howto->partial_inplace go through even if the addend is non-zero.
2173 (The real problem is that partial_inplace is set for XTENSA_32
2174 relocs to begin with, but that's a long story and there's little we
2175 can do about it now....) */
2177 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2179 reloc_entry
->address
+= input_section
->output_offset
;
2180 return bfd_reloc_ok
;
2183 /* Is the address of the relocation really within the section? */
2184 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2185 return bfd_reloc_outofrange
;
2187 /* Work out which section the relocation is targeted at and the
2188 initial relocation command value. */
2190 /* Get symbol value. (Common symbols are special.) */
2191 if (bfd_is_com_section (symbol
->section
))
2194 relocation
= symbol
->value
;
2196 reloc_target_output_section
= symbol
->section
->output_section
;
2198 /* Convert input-section-relative symbol value to absolute. */
2199 if ((output_bfd
&& !howto
->partial_inplace
)
2200 || reloc_target_output_section
== NULL
)
2203 output_base
= reloc_target_output_section
->vma
;
2205 relocation
+= output_base
+ symbol
->section
->output_offset
;
2207 /* Add in supplied addend. */
2208 relocation
+= reloc_entry
->addend
;
2210 /* Here the variable relocation holds the final address of the
2211 symbol we are relocating against, plus any addend. */
2214 if (!howto
->partial_inplace
)
2216 /* This is a partial relocation, and we want to apply the relocation
2217 to the reloc entry rather than the raw data. Everything except
2218 relocations against section symbols has already been handled
2221 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2222 reloc_entry
->addend
= relocation
;
2223 reloc_entry
->address
+= input_section
->output_offset
;
2224 return bfd_reloc_ok
;
2228 reloc_entry
->address
+= input_section
->output_offset
;
2229 reloc_entry
->addend
= 0;
2233 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2234 && (symbol
->flags
& BSF_WEAK
) != 0);
2235 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2236 (bfd_byte
*) data
, (bfd_vma
) octets
,
2237 is_weak_undef
, error_message
);
2239 if (flag
== bfd_reloc_dangerous
)
2241 /* Add the symbol name to the error message. */
2242 if (! *error_message
)
2243 *error_message
= "";
2244 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2245 strlen (symbol
->name
) + 17,
2247 (unsigned long) reloc_entry
->addend
);
2253 int xtensa_abi_choice (void)
2255 if (elf32xtensa_abi
== XTHAL_ABI_UNDEFINED
)
2258 return elf32xtensa_abi
;
2261 /* Set up an entry in the procedure linkage table. */
2264 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2266 unsigned reloc_index
)
2268 asection
*splt
, *sgotplt
;
2269 bfd_vma plt_base
, got_base
;
2270 bfd_vma code_offset
, lit_offset
, abi_offset
;
2272 int abi
= xtensa_abi_choice ();
2274 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2275 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2276 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2277 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2279 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2280 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2282 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2283 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2285 /* Fill in the literal entry. This is the offset of the dynamic
2286 relocation entry. */
2287 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2288 sgotplt
->contents
+ lit_offset
);
2290 /* Fill in the entry in the procedure linkage table. */
2291 memcpy (splt
->contents
+ code_offset
,
2292 (bfd_big_endian (output_bfd
)
2293 ? elf_xtensa_be_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]
2294 : elf_xtensa_le_plt_entry
[abi
!= XTHAL_ABI_WINDOWED
]),
2296 abi_offset
= abi
== XTHAL_ABI_WINDOWED
? 3 : 0;
2297 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2298 plt_base
+ code_offset
+ abi_offset
),
2299 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2300 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2301 plt_base
+ code_offset
+ abi_offset
+ 3),
2302 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2303 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2304 plt_base
+ code_offset
+ abi_offset
+ 6),
2305 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2307 return plt_base
+ code_offset
;
2311 static bfd_boolean
get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2314 replace_tls_insn (Elf_Internal_Rela
*rel
,
2316 asection
*input_section
,
2318 bfd_boolean is_ld_model
,
2319 char **error_message
)
2321 static xtensa_insnbuf ibuff
= NULL
;
2322 static xtensa_insnbuf sbuff
= NULL
;
2323 xtensa_isa isa
= xtensa_default_isa
;
2325 xtensa_opcode old_op
, new_op
;
2326 bfd_size_type input_size
;
2328 unsigned dest_reg
, src_reg
;
2332 ibuff
= xtensa_insnbuf_alloc (isa
);
2333 sbuff
= xtensa_insnbuf_alloc (isa
);
2336 input_size
= bfd_get_section_limit (abfd
, input_section
);
2338 /* Read the instruction into a buffer and decode the opcode. */
2339 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2340 input_size
- rel
->r_offset
);
2341 fmt
= xtensa_format_decode (isa
, ibuff
);
2342 if (fmt
== XTENSA_UNDEFINED
)
2344 *error_message
= "cannot decode instruction format";
2348 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2349 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2351 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2352 if (old_op
== XTENSA_UNDEFINED
)
2354 *error_message
= "cannot decode instruction opcode";
2358 r_type
= ELF32_R_TYPE (rel
->r_info
);
2361 case R_XTENSA_TLS_FUNC
:
2362 case R_XTENSA_TLS_ARG
:
2363 if (old_op
!= get_l32r_opcode ()
2364 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2365 sbuff
, &dest_reg
) != 0)
2367 *error_message
= "cannot extract L32R destination for TLS access";
2372 case R_XTENSA_TLS_CALL
:
2373 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2374 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2375 sbuff
, &src_reg
) != 0)
2377 *error_message
= "cannot extract CALLXn operands for TLS access";
2390 case R_XTENSA_TLS_FUNC
:
2391 case R_XTENSA_TLS_ARG
:
2392 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2393 versions of Xtensa). */
2394 new_op
= xtensa_opcode_lookup (isa
, "nop");
2395 if (new_op
== XTENSA_UNDEFINED
)
2397 new_op
= xtensa_opcode_lookup (isa
, "or");
2398 if (new_op
== XTENSA_UNDEFINED
2399 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2400 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2402 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2404 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2407 *error_message
= "cannot encode OR for TLS access";
2413 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2415 *error_message
= "cannot encode NOP for TLS access";
2421 case R_XTENSA_TLS_CALL
:
2422 /* Read THREADPTR into the CALLX's return value register. */
2423 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2424 if (new_op
== XTENSA_UNDEFINED
2425 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2426 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2427 sbuff
, dest_reg
+ 2) != 0)
2429 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2439 case R_XTENSA_TLS_FUNC
:
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
) != 0)
2446 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2451 case R_XTENSA_TLS_ARG
:
2452 /* Nothing to do. Keep the original L32R instruction. */
2455 case R_XTENSA_TLS_CALL
:
2456 /* Add the CALLX's src register (holding the THREADPTR value)
2457 to the first argument register (holding the offset) and put
2458 the result in the CALLX's return value register. */
2459 new_op
= xtensa_opcode_lookup (isa
, "add");
2460 if (new_op
== XTENSA_UNDEFINED
2461 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2462 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2463 sbuff
, dest_reg
+ 2) != 0
2464 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2465 sbuff
, dest_reg
+ 2) != 0
2466 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2467 sbuff
, src_reg
) != 0)
2469 *error_message
= "cannot encode ADD for TLS access";
2476 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2477 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2478 input_size
- rel
->r_offset
);
2484 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2485 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2486 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2487 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2488 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2489 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2490 || (R_TYPE) == R_XTENSA_TLS_ARG \
2491 || (R_TYPE) == R_XTENSA_TLS_CALL)
2493 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2494 both relocatable and final links. */
2497 elf_xtensa_relocate_section (bfd
*output_bfd
,
2498 struct bfd_link_info
*info
,
2500 asection
*input_section
,
2502 Elf_Internal_Rela
*relocs
,
2503 Elf_Internal_Sym
*local_syms
,
2504 asection
**local_sections
)
2506 struct elf_xtensa_link_hash_table
*htab
;
2507 Elf_Internal_Shdr
*symtab_hdr
;
2508 Elf_Internal_Rela
*rel
;
2509 Elf_Internal_Rela
*relend
;
2510 struct elf_link_hash_entry
**sym_hashes
;
2511 property_table_entry
*lit_table
= 0;
2513 char *local_got_tls_types
;
2514 char *error_message
= NULL
;
2515 bfd_size_type input_size
;
2518 if (!xtensa_default_isa
)
2519 xtensa_default_isa
= xtensa_isa_init (0, 0);
2521 if (!is_xtensa_elf (input_bfd
))
2523 bfd_set_error (bfd_error_wrong_format
);
2527 htab
= elf_xtensa_hash_table (info
);
2531 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2532 sym_hashes
= elf_sym_hashes (input_bfd
);
2533 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2535 if (elf_hash_table (info
)->dynamic_sections_created
)
2537 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2538 &lit_table
, XTENSA_LIT_SEC_NAME
,
2544 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2547 relend
= relocs
+ input_section
->reloc_count
;
2548 for (; rel
< relend
; rel
++)
2551 reloc_howto_type
*howto
;
2552 unsigned long r_symndx
;
2553 struct elf_link_hash_entry
*h
;
2554 Elf_Internal_Sym
*sym
;
2559 bfd_reloc_status_type r
;
2560 bfd_boolean is_weak_undef
;
2561 bfd_boolean unresolved_reloc
;
2563 bfd_boolean dynamic_symbol
;
2565 r_type
= ELF32_R_TYPE (rel
->r_info
);
2566 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2567 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2570 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2572 bfd_set_error (bfd_error_bad_value
);
2575 howto
= &elf_howto_table
[r_type
];
2577 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2582 is_weak_undef
= FALSE
;
2583 unresolved_reloc
= FALSE
;
2586 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2588 /* Because R_XTENSA_32 was made partial_inplace to fix some
2589 problems with DWARF info in partial links, there may be
2590 an addend stored in the contents. Take it out of there
2591 and move it back into the addend field of the reloc. */
2592 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2593 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2596 if (r_symndx
< symtab_hdr
->sh_info
)
2598 sym
= local_syms
+ r_symndx
;
2599 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2600 sec
= local_sections
[r_symndx
];
2601 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2605 bfd_boolean ignored
;
2607 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2608 r_symndx
, symtab_hdr
, sym_hashes
,
2610 unresolved_reloc
, warned
, ignored
);
2613 && !unresolved_reloc
2614 && h
->root
.type
== bfd_link_hash_undefweak
)
2615 is_weak_undef
= TRUE
;
2620 if (sec
!= NULL
&& discarded_section (sec
))
2621 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2622 rel
, 1, relend
, howto
, 0, contents
);
2624 if (bfd_link_relocatable (info
))
2627 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2629 /* This is a relocatable link.
2630 1) If the reloc is against a section symbol, adjust
2631 according to the output section.
2632 2) If there is a new target for this relocation,
2633 the new target will be in the same output section.
2634 We adjust the relocation by the output section
2637 if (relaxing_section
)
2639 /* Check if this references a section in another input file. */
2640 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2645 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2646 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2648 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2650 error_message
= NULL
;
2651 /* Convert ASM_SIMPLIFY into the simpler relocation
2652 so that they never escape a relaxing link. */
2653 r
= contract_asm_expansion (contents
, input_size
, rel
,
2655 if (r
!= bfd_reloc_ok
)
2656 (*info
->callbacks
->reloc_dangerous
)
2657 (info
, error_message
,
2658 input_bfd
, input_section
, rel
->r_offset
);
2660 r_type
= ELF32_R_TYPE (rel
->r_info
);
2663 /* This is a relocatable link, so we don't have to change
2664 anything unless the reloc is against a section symbol,
2665 in which case we have to adjust according to where the
2666 section symbol winds up in the output section. */
2667 if (r_symndx
< symtab_hdr
->sh_info
)
2669 sym
= local_syms
+ r_symndx
;
2670 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2672 sec
= local_sections
[r_symndx
];
2673 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2677 /* If there is an addend with a partial_inplace howto,
2678 then move the addend to the contents. This is a hack
2679 to work around problems with DWARF in relocatable links
2680 with some previous version of BFD. Now we can't easily get
2681 rid of the hack without breaking backward compatibility.... */
2683 howto
= &elf_howto_table
[r_type
];
2684 if (howto
->partial_inplace
&& rel
->r_addend
)
2686 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2687 rel
->r_addend
, contents
,
2688 rel
->r_offset
, FALSE
,
2694 /* Put the correct bits in the target instruction, even
2695 though the relocation will still be present in the output
2696 file. This makes disassembly clearer, as well as
2697 allowing loadable kernel modules to work without needing
2698 relocations on anything other than calls and l32r's. */
2700 /* If it is not in the same section, there is nothing we can do. */
2701 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2702 sym_sec
->output_section
== input_section
->output_section
)
2704 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2705 dest_addr
, contents
,
2706 rel
->r_offset
, FALSE
,
2710 if (r
!= bfd_reloc_ok
)
2711 (*info
->callbacks
->reloc_dangerous
)
2712 (info
, error_message
,
2713 input_bfd
, input_section
, rel
->r_offset
);
2715 /* Done with work for relocatable link; continue with next reloc. */
2719 /* This is a final link. */
2721 if (relaxing_section
)
2723 /* Check if this references a section in another input file. */
2724 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2728 /* Sanity check the address. */
2729 if (rel
->r_offset
>= input_size
2730 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2733 /* xgettext:c-format */
2734 (_("%pB(%pA+%#" PRIx64
"): "
2735 "relocation offset out of range (size=%#" PRIx64
")"),
2736 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2737 (uint64_t) input_size
);
2738 bfd_set_error (bfd_error_bad_value
);
2743 name
= h
->root
.root
.string
;
2746 name
= (bfd_elf_string_from_elf_section
2747 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2748 if (name
== NULL
|| *name
== '\0')
2749 name
= bfd_section_name (sec
);
2752 if (r_symndx
!= STN_UNDEF
2753 && r_type
!= R_XTENSA_NONE
2755 || h
->root
.type
== bfd_link_hash_defined
2756 || h
->root
.type
== bfd_link_hash_defweak
)
2757 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2760 ((sym_type
== STT_TLS
2761 /* xgettext:c-format */
2762 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2763 /* xgettext:c-format */
2764 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2767 (uint64_t) rel
->r_offset
,
2772 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2774 tls_type
= GOT_UNKNOWN
;
2776 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2777 else if (local_got_tls_types
)
2778 tls_type
= local_got_tls_types
[r_symndx
];
2784 if (elf_hash_table (info
)->dynamic_sections_created
2785 && (input_section
->flags
& SEC_ALLOC
) != 0
2786 && (dynamic_symbol
|| bfd_link_pic (info
)))
2788 Elf_Internal_Rela outrel
;
2792 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2793 srel
= htab
->elf
.srelplt
;
2795 srel
= htab
->elf
.srelgot
;
2797 BFD_ASSERT (srel
!= NULL
);
2800 _bfd_elf_section_offset (output_bfd
, info
,
2801 input_section
, rel
->r_offset
);
2803 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2804 memset (&outrel
, 0, sizeof outrel
);
2807 outrel
.r_offset
+= (input_section
->output_section
->vma
2808 + input_section
->output_offset
);
2810 /* Complain if the relocation is in a read-only section
2811 and not in a literal pool. */
2812 if ((input_section
->flags
& SEC_READONLY
) != 0
2813 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2817 _("dynamic relocation in read-only section");
2818 (*info
->callbacks
->reloc_dangerous
)
2819 (info
, error_message
,
2820 input_bfd
, input_section
, rel
->r_offset
);
2825 outrel
.r_addend
= rel
->r_addend
;
2828 if (r_type
== R_XTENSA_32
)
2831 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2834 else /* r_type == R_XTENSA_PLT */
2837 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2839 /* Create the PLT entry and set the initial
2840 contents of the literal entry to the address of
2843 elf_xtensa_create_plt_entry (info
, output_bfd
,
2846 unresolved_reloc
= FALSE
;
2848 else if (!is_weak_undef
)
2850 /* Generate a RELATIVE relocation. */
2851 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2852 outrel
.r_addend
= 0;
2860 loc
= (srel
->contents
2861 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2862 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2863 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2866 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2868 /* This should only happen for non-PIC code, which is not
2869 supposed to be used on systems with dynamic linking.
2870 Just ignore these relocations. */
2875 case R_XTENSA_TLS_TPOFF
:
2876 /* Switch to LE model for local symbols in an executable. */
2877 if (! bfd_link_pic (info
) && ! dynamic_symbol
)
2879 relocation
= tpoff (info
, relocation
);
2884 case R_XTENSA_TLSDESC_FN
:
2885 case R_XTENSA_TLSDESC_ARG
:
2887 if (r_type
== R_XTENSA_TLSDESC_FN
)
2889 if (! bfd_link_pic (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2890 r_type
= R_XTENSA_NONE
;
2892 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2894 if (bfd_link_pic (info
))
2896 if ((tls_type
& GOT_TLS_IE
) != 0)
2897 r_type
= R_XTENSA_TLS_TPOFF
;
2901 r_type
= R_XTENSA_TLS_TPOFF
;
2902 if (! dynamic_symbol
)
2904 relocation
= tpoff (info
, relocation
);
2910 if (r_type
== R_XTENSA_NONE
)
2911 /* Nothing to do here; skip to the next reloc. */
2914 if (! elf_hash_table (info
)->dynamic_sections_created
)
2917 _("TLS relocation invalid without dynamic sections");
2918 (*info
->callbacks
->reloc_dangerous
)
2919 (info
, error_message
,
2920 input_bfd
, input_section
, rel
->r_offset
);
2924 Elf_Internal_Rela outrel
;
2926 asection
*srel
= htab
->elf
.srelgot
;
2929 outrel
.r_offset
= (input_section
->output_section
->vma
2930 + input_section
->output_offset
2933 /* Complain if the relocation is in a read-only section
2934 and not in a literal pool. */
2935 if ((input_section
->flags
& SEC_READONLY
) != 0
2936 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2940 _("dynamic relocation in read-only section");
2941 (*info
->callbacks
->reloc_dangerous
)
2942 (info
, error_message
,
2943 input_bfd
, input_section
, rel
->r_offset
);
2946 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2948 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2950 outrel
.r_addend
= 0;
2953 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2955 unresolved_reloc
= FALSE
;
2958 loc
= (srel
->contents
2959 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2960 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2961 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2967 case R_XTENSA_TLS_DTPOFF
:
2968 if (! bfd_link_pic (info
))
2969 /* Switch from LD model to LE model. */
2970 relocation
= tpoff (info
, relocation
);
2972 relocation
-= dtpoff_base (info
);
2975 case R_XTENSA_TLS_FUNC
:
2976 case R_XTENSA_TLS_ARG
:
2977 case R_XTENSA_TLS_CALL
:
2978 /* Check if optimizing to IE or LE model. */
2979 if ((tls_type
& GOT_TLS_IE
) != 0)
2981 bfd_boolean is_ld_model
=
2982 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
2983 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
2984 is_ld_model
, &error_message
))
2985 (*info
->callbacks
->reloc_dangerous
)
2986 (info
, error_message
,
2987 input_bfd
, input_section
, rel
->r_offset
);
2989 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
2991 /* Skip subsequent relocations on the same instruction. */
2992 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
2999 if (elf_hash_table (info
)->dynamic_sections_created
3000 && dynamic_symbol
&& (is_operand_relocation (r_type
)
3001 || r_type
== R_XTENSA_32_PCREL
))
3004 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3005 strlen (name
) + 2, name
);
3006 (*info
->callbacks
->reloc_dangerous
)
3007 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3013 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3014 because such sections are not SEC_ALLOC and thus ld.so will
3015 not process them. */
3016 if (unresolved_reloc
3017 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3019 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3020 rel
->r_offset
) != (bfd_vma
) -1)
3023 /* xgettext:c-format */
3024 (_("%pB(%pA+%#" PRIx64
"): "
3025 "unresolvable %s relocation against symbol `%s'"),
3028 (uint64_t) rel
->r_offset
,
3034 /* TLS optimizations may have changed r_type; update "howto". */
3035 howto
= &elf_howto_table
[r_type
];
3037 /* There's no point in calling bfd_perform_relocation here.
3038 Just go directly to our "special function". */
3039 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
3040 relocation
+ rel
->r_addend
,
3041 contents
, rel
->r_offset
, is_weak_undef
,
3044 if (r
!= bfd_reloc_ok
&& !warned
)
3046 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
3047 BFD_ASSERT (error_message
!= NULL
);
3049 if (rel
->r_addend
== 0)
3050 error_message
= vsprint_msg (error_message
, ": %s",
3051 strlen (name
) + 2, name
);
3053 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
3055 name
, (int) rel
->r_addend
);
3057 (*info
->callbacks
->reloc_dangerous
)
3058 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3063 input_section
->reloc_done
= TRUE
;
3069 /* Finish up dynamic symbol handling. There's not much to do here since
3070 the PLT and GOT entries are all set up by relocate_section. */
3073 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3074 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3075 struct elf_link_hash_entry
*h
,
3076 Elf_Internal_Sym
*sym
)
3078 if (h
->needs_plt
&& !h
->def_regular
)
3080 /* Mark the symbol as undefined, rather than as defined in
3081 the .plt section. Leave the value alone. */
3082 sym
->st_shndx
= SHN_UNDEF
;
3083 /* If the symbol is weak, we do need to clear the value.
3084 Otherwise, the PLT entry would provide a definition for
3085 the symbol even if the symbol wasn't defined anywhere,
3086 and so the symbol would never be NULL. */
3087 if (!h
->ref_regular_nonweak
)
3091 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3092 if (h
== elf_hash_table (info
)->hdynamic
3093 || h
== elf_hash_table (info
)->hgot
)
3094 sym
->st_shndx
= SHN_ABS
;
3100 /* Combine adjacent literal table entries in the output. Adjacent
3101 entries within each input section may have been removed during
3102 relaxation, but we repeat the process here, even though it's too late
3103 to shrink the output section, because it's important to minimize the
3104 number of literal table entries to reduce the start-up work for the
3105 runtime linker. Returns the number of remaining table entries or -1
3109 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3114 property_table_entry
*table
;
3115 bfd_size_type section_size
, sgotloc_size
;
3119 section_size
= sxtlit
->size
;
3120 BFD_ASSERT (section_size
% 8 == 0);
3121 num
= section_size
/ 8;
3123 sgotloc_size
= sgotloc
->size
;
3124 if (sgotloc_size
!= section_size
)
3127 (_("internal inconsistency in size of .got.loc section"));
3131 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3135 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3136 propagates to the output section, where it doesn't really apply and
3137 where it breaks the following call to bfd_malloc_and_get_section. */
3138 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3140 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3147 /* There should never be any relocations left at this point, so this
3148 is quite a bit easier than what is done during relaxation. */
3150 /* Copy the raw contents into a property table array and sort it. */
3152 for (n
= 0; n
< num
; n
++)
3154 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3155 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3158 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3160 for (n
= 0; n
< num
; n
++)
3162 bfd_boolean remove_entry
= FALSE
;
3164 if (table
[n
].size
== 0)
3165 remove_entry
= TRUE
;
3167 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3169 table
[n
-1].size
+= table
[n
].size
;
3170 remove_entry
= TRUE
;
3175 for (m
= n
; m
< num
- 1; m
++)
3177 table
[m
].address
= table
[m
+1].address
;
3178 table
[m
].size
= table
[m
+1].size
;
3186 /* Copy the data back to the raw contents. */
3188 for (n
= 0; n
< num
; n
++)
3190 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3191 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3195 /* Clear the removed bytes. */
3196 if ((bfd_size_type
) (num
* 8) < section_size
)
3197 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3199 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3203 /* Copy the contents to ".got.loc". */
3204 memcpy (sgotloc
->contents
, contents
, section_size
);
3212 /* Finish up the dynamic sections. */
3215 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3216 struct bfd_link_info
*info
)
3218 struct elf_xtensa_link_hash_table
*htab
;
3220 asection
*sdyn
, *srelplt
, *srelgot
, *sgot
, *sxtlit
, *sgotloc
;
3221 Elf32_External_Dyn
*dyncon
, *dynconend
;
3222 int num_xtlit_entries
= 0;
3224 if (! elf_hash_table (info
)->dynamic_sections_created
)
3227 htab
= elf_xtensa_hash_table (info
);
3231 dynobj
= elf_hash_table (info
)->dynobj
;
3232 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3233 BFD_ASSERT (sdyn
!= NULL
);
3235 /* Set the first entry in the global offset table to the address of
3236 the dynamic section. */
3237 sgot
= htab
->elf
.sgot
;
3240 BFD_ASSERT (sgot
->size
== 4);
3242 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3244 bfd_put_32 (output_bfd
,
3245 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3249 srelplt
= htab
->elf
.srelplt
;
3250 srelgot
= htab
->elf
.srelgot
;
3251 if (srelplt
&& srelplt
->size
!= 0)
3253 asection
*sgotplt
, *spltlittbl
;
3254 int chunk
, plt_chunks
, plt_entries
;
3255 Elf_Internal_Rela irela
;
3257 unsigned rtld_reloc
;
3259 spltlittbl
= htab
->spltlittbl
;
3260 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3262 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3263 of them follow immediately after.... */
3264 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3266 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3267 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3268 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3271 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3273 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3275 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3277 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3279 int chunk_entries
= 0;
3281 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3282 BFD_ASSERT (sgotplt
!= NULL
);
3284 /* Emit special RTLD relocations for the first two entries in
3285 each chunk of the .got.plt section. */
3287 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3288 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3289 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3290 irela
.r_offset
= (sgotplt
->output_section
->vma
3291 + sgotplt
->output_offset
);
3292 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3293 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3295 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3297 /* Next literal immediately follows the first. */
3298 loc
+= sizeof (Elf32_External_Rela
);
3299 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3300 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3301 irela
.r_offset
= (sgotplt
->output_section
->vma
3302 + sgotplt
->output_offset
+ 4);
3303 /* Tell rtld to set value to object's link map. */
3305 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3307 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3309 /* Fill in the literal table. */
3310 if (chunk
< plt_chunks
- 1)
3311 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3313 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3315 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3316 bfd_put_32 (output_bfd
,
3317 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3318 spltlittbl
->contents
+ (chunk
* 8) + 0);
3319 bfd_put_32 (output_bfd
,
3320 8 + (chunk_entries
* 4),
3321 spltlittbl
->contents
+ (chunk
* 8) + 4);
3324 /* The .xt.lit.plt section has just been modified. This must
3325 happen before the code below which combines adjacent literal
3326 table entries, and the .xt.lit.plt contents have to be forced to
3328 if (! bfd_set_section_contents (output_bfd
,
3329 spltlittbl
->output_section
,
3330 spltlittbl
->contents
,
3331 spltlittbl
->output_offset
,
3334 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3335 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3338 /* All the dynamic relocations have been emitted at this point.
3339 Make sure the relocation sections are the correct size. */
3340 if ((srelgot
&& srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3341 * srelgot
->reloc_count
))
3342 || (srelplt
&& srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3343 * srelplt
->reloc_count
)))
3346 /* Combine adjacent literal table entries. */
3347 BFD_ASSERT (! bfd_link_relocatable (info
));
3348 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3349 sgotloc
= htab
->sgotloc
;
3350 BFD_ASSERT (sgotloc
);
3354 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3355 if (num_xtlit_entries
< 0)
3359 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3360 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3361 for (; dyncon
< dynconend
; dyncon
++)
3363 Elf_Internal_Dyn dyn
;
3365 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3372 case DT_XTENSA_GOT_LOC_SZ
:
3373 dyn
.d_un
.d_val
= num_xtlit_entries
;
3376 case DT_XTENSA_GOT_LOC_OFF
:
3377 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3378 + htab
->sgotloc
->output_offset
);
3382 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3383 + htab
->elf
.sgot
->output_offset
);
3387 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3388 + htab
->elf
.srelplt
->output_offset
);
3392 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3396 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3403 /* Functions for dealing with the e_flags field. */
3405 /* Merge backend specific data from an object file to the output
3406 object file when linking. */
3409 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3411 bfd
*obfd
= info
->output_bfd
;
3412 unsigned out_mach
, in_mach
;
3413 flagword out_flag
, in_flag
;
3415 /* Check if we have the same endianness. */
3416 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3419 /* Don't even pretend to support mixed-format linking. */
3420 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3421 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3424 out_flag
= elf_elfheader (obfd
)->e_flags
;
3425 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3427 out_mach
= out_flag
& EF_XTENSA_MACH
;
3428 in_mach
= in_flag
& EF_XTENSA_MACH
;
3429 if (out_mach
!= in_mach
)
3432 /* xgettext:c-format */
3433 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3434 ibfd
, out_mach
, in_mach
);
3435 bfd_set_error (bfd_error_wrong_format
);
3439 if (! elf_flags_init (obfd
))
3441 elf_flags_init (obfd
) = TRUE
;
3442 elf_elfheader (obfd
)->e_flags
= in_flag
;
3444 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3445 && bfd_get_arch_info (obfd
)->the_default
)
3446 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3447 bfd_get_mach (ibfd
));
3452 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3453 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3455 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3456 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3463 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3465 BFD_ASSERT (!elf_flags_init (abfd
)
3466 || elf_elfheader (abfd
)->e_flags
== flags
);
3468 elf_elfheader (abfd
)->e_flags
|= flags
;
3469 elf_flags_init (abfd
) = TRUE
;
3476 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3478 FILE *f
= (FILE *) farg
;
3479 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3481 fprintf (f
, "\nXtensa header:\n");
3482 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3483 fprintf (f
, "\nMachine = Base\n");
3485 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3487 fprintf (f
, "Insn tables = %s\n",
3488 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3490 fprintf (f
, "Literal tables = %s\n",
3491 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3493 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3497 /* Set the right machine number for an Xtensa ELF file. */
3500 elf_xtensa_object_p (bfd
*abfd
)
3503 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3508 mach
= bfd_mach_xtensa
;
3514 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3519 /* The final processing done just before writing out an Xtensa ELF object
3520 file. This gets the Xtensa architecture right based on the machine
3524 elf_xtensa_final_write_processing (bfd
*abfd
)
3527 unsigned long val
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3529 switch (mach
= bfd_get_mach (abfd
))
3531 case bfd_mach_xtensa
:
3532 val
= E_XTENSA_MACH
;
3538 elf_elfheader (abfd
)->e_flags
&= ~EF_XTENSA_MACH
;
3539 elf_elfheader (abfd
)->e_flags
|= val
;
3540 return _bfd_elf_final_write_processing (abfd
);
3544 static enum elf_reloc_type_class
3545 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3546 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3547 const Elf_Internal_Rela
*rela
)
3549 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3551 case R_XTENSA_RELATIVE
:
3552 return reloc_class_relative
;
3553 case R_XTENSA_JMP_SLOT
:
3554 return reloc_class_plt
;
3556 return reloc_class_normal
;
3562 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3563 struct elf_reloc_cookie
*cookie
,
3564 struct bfd_link_info
*info
,
3568 bfd_vma offset
, actual_offset
;
3569 bfd_size_type removed_bytes
= 0;
3570 bfd_size_type entry_size
;
3572 if (sec
->output_section
3573 && bfd_is_abs_section (sec
->output_section
))
3576 if (xtensa_is_proptable_section (sec
))
3581 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3584 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3588 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3591 release_contents (sec
, contents
);
3595 /* Sort the relocations. They should already be in order when
3596 relaxation is enabled, but it might not be. */
3597 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3598 internal_reloc_compare
);
3600 cookie
->rel
= cookie
->rels
;
3601 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3603 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3605 actual_offset
= offset
- removed_bytes
;
3607 /* The ...symbol_deleted_p function will skip over relocs but it
3608 won't adjust their offsets, so do that here. */
3609 while (cookie
->rel
< cookie
->relend
3610 && cookie
->rel
->r_offset
< offset
)
3612 cookie
->rel
->r_offset
-= removed_bytes
;
3616 while (cookie
->rel
< cookie
->relend
3617 && cookie
->rel
->r_offset
== offset
)
3619 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3621 /* Remove the table entry. (If the reloc type is NONE, then
3622 the entry has already been merged with another and deleted
3623 during relaxation.) */
3624 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3626 /* Shift the contents up. */
3627 if (offset
+ entry_size
< sec
->size
)
3628 memmove (&contents
[actual_offset
],
3629 &contents
[actual_offset
+ entry_size
],
3630 sec
->size
- offset
- entry_size
);
3631 removed_bytes
+= entry_size
;
3634 /* Remove this relocation. */
3635 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3638 /* Adjust the relocation offset for previous removals. This
3639 should not be done before calling ...symbol_deleted_p
3640 because it might mess up the offset comparisons there.
3641 Make sure the offset doesn't underflow in the case where
3642 the first entry is removed. */
3643 if (cookie
->rel
->r_offset
>= removed_bytes
)
3644 cookie
->rel
->r_offset
-= removed_bytes
;
3646 cookie
->rel
->r_offset
= 0;
3652 if (removed_bytes
!= 0)
3654 /* Adjust any remaining relocs (shouldn't be any). */
3655 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3657 if (cookie
->rel
->r_offset
>= removed_bytes
)
3658 cookie
->rel
->r_offset
-= removed_bytes
;
3660 cookie
->rel
->r_offset
= 0;
3663 /* Clear the removed bytes. */
3664 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3666 pin_contents (sec
, contents
);
3667 pin_internal_relocs (sec
, cookie
->rels
);
3670 if (sec
->rawsize
== 0)
3671 sec
->rawsize
= sec
->size
;
3672 sec
->size
-= removed_bytes
;
3674 if (xtensa_is_littable_section (sec
))
3676 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3678 sgotloc
->size
-= removed_bytes
;
3683 release_contents (sec
, contents
);
3684 release_internal_relocs (sec
, cookie
->rels
);
3687 return (removed_bytes
!= 0);
3692 elf_xtensa_discard_info (bfd
*abfd
,
3693 struct elf_reloc_cookie
*cookie
,
3694 struct bfd_link_info
*info
)
3697 bfd_boolean changed
= FALSE
;
3699 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3701 if (xtensa_is_property_section (sec
))
3703 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3713 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3715 return xtensa_is_property_section (sec
);
3720 elf_xtensa_action_discarded (asection
*sec
)
3722 if (strcmp (".xt_except_table", sec
->name
) == 0)
3725 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3728 return _bfd_elf_default_action_discarded (sec
);
3732 /* Support for core dump NOTE sections. */
3735 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3740 /* The size for Xtensa is variable, so don't try to recognize the format
3741 based on the size. Just assume this is GNU/Linux. */
3744 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3747 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3751 size
= note
->descsz
- offset
- 4;
3753 /* Make a ".reg/999" section. */
3754 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3755 size
, note
->descpos
+ offset
);
3760 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3762 switch (note
->descsz
)
3767 case 128: /* GNU/Linux elf_prpsinfo */
3768 elf_tdata (abfd
)->core
->program
3769 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3770 elf_tdata (abfd
)->core
->command
3771 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3774 /* Note that for some reason, a spurious space is tacked
3775 onto the end of the args in some (at least one anyway)
3776 implementations, so strip it off if it exists. */
3779 char *command
= elf_tdata (abfd
)->core
->command
;
3780 int n
= strlen (command
);
3782 if (0 < n
&& command
[n
- 1] == ' ')
3783 command
[n
- 1] = '\0';
3790 /* Generic Xtensa configurability stuff. */
3792 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3793 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3794 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3795 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3796 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3797 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3798 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3799 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3802 init_call_opcodes (void)
3804 if (callx0_op
== XTENSA_UNDEFINED
)
3806 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3807 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3808 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3809 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3810 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3811 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3812 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3813 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3819 is_indirect_call_opcode (xtensa_opcode opcode
)
3821 init_call_opcodes ();
3822 return (opcode
== callx0_op
3823 || opcode
== callx4_op
3824 || opcode
== callx8_op
3825 || opcode
== callx12_op
);
3830 is_direct_call_opcode (xtensa_opcode opcode
)
3832 init_call_opcodes ();
3833 return (opcode
== call0_op
3834 || opcode
== call4_op
3835 || opcode
== call8_op
3836 || opcode
== call12_op
);
3841 is_windowed_call_opcode (xtensa_opcode opcode
)
3843 init_call_opcodes ();
3844 return (opcode
== call4_op
3845 || opcode
== call8_op
3846 || opcode
== call12_op
3847 || opcode
== callx4_op
3848 || opcode
== callx8_op
3849 || opcode
== callx12_op
);
3854 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3856 unsigned dst
= (unsigned) -1;
3858 init_call_opcodes ();
3859 if (opcode
== callx0_op
)
3861 else if (opcode
== callx4_op
)
3863 else if (opcode
== callx8_op
)
3865 else if (opcode
== callx12_op
)
3868 if (dst
== (unsigned) -1)
3876 static xtensa_opcode
3877 get_const16_opcode (void)
3879 static bfd_boolean done_lookup
= FALSE
;
3880 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3883 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3886 return const16_opcode
;
3890 static xtensa_opcode
3891 get_l32r_opcode (void)
3893 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3894 static bfd_boolean done_lookup
= FALSE
;
3898 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3906 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3910 offset
= addr
- ((pc
+3) & -4);
3911 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3912 offset
= (signed int) offset
>> 2;
3913 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3918 static xtensa_opcode
3919 get_rsr_lend_opcode (void)
3921 static xtensa_opcode rsr_lend_opcode
= XTENSA_UNDEFINED
;
3922 static bfd_boolean done_lookup
= FALSE
;
3925 rsr_lend_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "rsr.lend");
3928 return rsr_lend_opcode
;
3931 static xtensa_opcode
3932 get_wsr_lbeg_opcode (void)
3934 static xtensa_opcode wsr_lbeg_opcode
= XTENSA_UNDEFINED
;
3935 static bfd_boolean done_lookup
= FALSE
;
3938 wsr_lbeg_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "wsr.lbeg");
3941 return wsr_lbeg_opcode
;
3946 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3948 xtensa_isa isa
= xtensa_default_isa
;
3949 int last_immed
, last_opnd
, opi
;
3951 if (opcode
== XTENSA_UNDEFINED
)
3952 return XTENSA_UNDEFINED
;
3954 /* Find the last visible PC-relative immediate operand for the opcode.
3955 If there are no PC-relative immediates, then choose the last visible
3956 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3957 last_immed
= XTENSA_UNDEFINED
;
3958 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3959 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3961 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3963 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3968 if (last_immed
== XTENSA_UNDEFINED
3969 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3973 return XTENSA_UNDEFINED
;
3975 /* If the operand number was specified in an old-style relocation,
3976 check for consistency with the operand computed above. */
3977 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3979 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3980 if (reloc_opnd
!= last_immed
)
3981 return XTENSA_UNDEFINED
;
3989 get_relocation_slot (int r_type
)
3999 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4000 return r_type
- R_XTENSA_SLOT0_OP
;
4001 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4002 return r_type
- R_XTENSA_SLOT0_ALT
;
4006 return XTENSA_UNDEFINED
;
4010 /* Get the opcode for a relocation. */
4012 static xtensa_opcode
4013 get_relocation_opcode (bfd
*abfd
,
4016 Elf_Internal_Rela
*irel
)
4018 static xtensa_insnbuf ibuff
= NULL
;
4019 static xtensa_insnbuf sbuff
= NULL
;
4020 xtensa_isa isa
= xtensa_default_isa
;
4024 if (contents
== NULL
)
4025 return XTENSA_UNDEFINED
;
4027 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
4028 return XTENSA_UNDEFINED
;
4032 ibuff
= xtensa_insnbuf_alloc (isa
);
4033 sbuff
= xtensa_insnbuf_alloc (isa
);
4036 /* Decode the instruction. */
4037 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
4038 sec
->size
- irel
->r_offset
);
4039 fmt
= xtensa_format_decode (isa
, ibuff
);
4040 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
4041 if (slot
== XTENSA_UNDEFINED
)
4042 return XTENSA_UNDEFINED
;
4043 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
4044 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
4049 is_l32r_relocation (bfd
*abfd
,
4052 Elf_Internal_Rela
*irel
)
4054 xtensa_opcode opcode
;
4055 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
4057 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
4058 return (opcode
== get_l32r_opcode ());
4062 static bfd_size_type
4063 get_asm_simplify_size (bfd_byte
*contents
,
4064 bfd_size_type content_len
,
4065 bfd_size_type offset
)
4067 bfd_size_type insnlen
, size
= 0;
4069 /* Decode the size of the next two instructions. */
4070 insnlen
= insn_decode_len (contents
, content_len
, offset
);
4076 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
4086 is_alt_relocation (int r_type
)
4088 return (r_type
>= R_XTENSA_SLOT0_ALT
4089 && r_type
<= R_XTENSA_SLOT14_ALT
);
4094 is_operand_relocation (int r_type
)
4104 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4106 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4115 #define MIN_INSN_LENGTH 2
4117 /* Return 0 if it fails to decode. */
4120 insn_decode_len (bfd_byte
*contents
,
4121 bfd_size_type content_len
,
4122 bfd_size_type offset
)
4125 xtensa_isa isa
= xtensa_default_isa
;
4127 static xtensa_insnbuf ibuff
= NULL
;
4129 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4133 ibuff
= xtensa_insnbuf_alloc (isa
);
4134 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4135 content_len
- offset
);
4136 fmt
= xtensa_format_decode (isa
, ibuff
);
4137 if (fmt
== XTENSA_UNDEFINED
)
4139 insn_len
= xtensa_format_length (isa
, fmt
);
4140 if (insn_len
== XTENSA_UNDEFINED
)
4146 insn_num_slots (bfd_byte
*contents
,
4147 bfd_size_type content_len
,
4148 bfd_size_type offset
)
4150 xtensa_isa isa
= xtensa_default_isa
;
4152 static xtensa_insnbuf ibuff
= NULL
;
4154 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4155 return XTENSA_UNDEFINED
;
4158 ibuff
= xtensa_insnbuf_alloc (isa
);
4159 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4160 content_len
- offset
);
4161 fmt
= xtensa_format_decode (isa
, ibuff
);
4162 if (fmt
== XTENSA_UNDEFINED
)
4163 return XTENSA_UNDEFINED
;
4164 return xtensa_format_num_slots (isa
, fmt
);
4168 /* Decode the opcode for a single slot instruction.
4169 Return 0 if it fails to decode or the instruction is multi-slot. */
4172 insn_decode_opcode (bfd_byte
*contents
,
4173 bfd_size_type content_len
,
4174 bfd_size_type offset
,
4177 xtensa_isa isa
= xtensa_default_isa
;
4179 static xtensa_insnbuf insnbuf
= NULL
;
4180 static xtensa_insnbuf slotbuf
= NULL
;
4182 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4183 return XTENSA_UNDEFINED
;
4185 if (insnbuf
== NULL
)
4187 insnbuf
= xtensa_insnbuf_alloc (isa
);
4188 slotbuf
= xtensa_insnbuf_alloc (isa
);
4191 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4192 content_len
- offset
);
4193 fmt
= xtensa_format_decode (isa
, insnbuf
);
4194 if (fmt
== XTENSA_UNDEFINED
)
4195 return XTENSA_UNDEFINED
;
4197 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4198 return XTENSA_UNDEFINED
;
4200 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4201 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4205 /* The offset is the offset in the contents.
4206 The address is the address of that offset. */
4209 check_branch_target_aligned (bfd_byte
*contents
,
4210 bfd_size_type content_length
,
4214 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4217 return check_branch_target_aligned_address (address
, insn_len
);
4222 check_loop_aligned (bfd_byte
*contents
,
4223 bfd_size_type content_length
,
4227 bfd_size_type loop_len
, insn_len
;
4228 xtensa_opcode opcode
;
4230 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4231 if (opcode
== XTENSA_UNDEFINED
4232 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4238 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4239 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4240 if (loop_len
== 0 || insn_len
== 0)
4246 /* If this is relaxed loop, analyze first instruction of the actual loop
4247 body. It must be at offset 27 from the loop instruction address. */
4249 && insn_num_slots (contents
, content_length
, offset
+ loop_len
) == 1
4250 && insn_decode_opcode (contents
, content_length
,
4251 offset
+ loop_len
, 0) == get_rsr_lend_opcode()
4252 && insn_decode_len (contents
, content_length
, offset
+ loop_len
+ 3) == 3
4253 && insn_num_slots (contents
, content_length
, offset
+ loop_len
+ 3) == 1
4254 && insn_decode_opcode (contents
, content_length
,
4255 offset
+ loop_len
+ 3, 0) == get_wsr_lbeg_opcode())
4258 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4260 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4265 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4268 return (addr
% 8 == 0);
4269 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4273 /* Instruction widening and narrowing. */
4275 /* When FLIX is available we need to access certain instructions only
4276 when they are 16-bit or 24-bit instructions. This table caches
4277 information about such instructions by walking through all the
4278 opcodes and finding the smallest single-slot format into which each
4281 static xtensa_format
*op_single_fmt_table
= NULL
;
4285 init_op_single_format_table (void)
4287 xtensa_isa isa
= xtensa_default_isa
;
4288 xtensa_insnbuf ibuf
;
4289 xtensa_opcode opcode
;
4293 if (op_single_fmt_table
)
4296 ibuf
= xtensa_insnbuf_alloc (isa
);
4297 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4299 op_single_fmt_table
= (xtensa_format
*)
4300 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4301 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4303 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4304 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4306 if (xtensa_format_num_slots (isa
, fmt
) == 1
4307 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4309 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4310 int fmt_length
= xtensa_format_length (isa
, fmt
);
4311 if (old_fmt
== XTENSA_UNDEFINED
4312 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4313 op_single_fmt_table
[opcode
] = fmt
;
4317 xtensa_insnbuf_free (isa
, ibuf
);
4321 static xtensa_format
4322 get_single_format (xtensa_opcode opcode
)
4324 init_op_single_format_table ();
4325 return op_single_fmt_table
[opcode
];
4329 /* For the set of narrowable instructions we do NOT include the
4330 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4331 involved during linker relaxation that may require these to
4332 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4333 requires special case code to ensure it only works when op1 == op2. */
4341 struct string_pair narrowable
[] =
4344 { "addi", "addi.n" },
4345 { "addmi", "addi.n" },
4346 { "l32i", "l32i.n" },
4347 { "movi", "movi.n" },
4349 { "retw", "retw.n" },
4350 { "s32i", "s32i.n" },
4351 { "or", "mov.n" } /* special case only when op1 == op2 */
4354 struct string_pair widenable
[] =
4357 { "addi", "addi.n" },
4358 { "addmi", "addi.n" },
4359 { "beqz", "beqz.n" },
4360 { "bnez", "bnez.n" },
4361 { "l32i", "l32i.n" },
4362 { "movi", "movi.n" },
4364 { "retw", "retw.n" },
4365 { "s32i", "s32i.n" },
4366 { "or", "mov.n" } /* special case only when op1 == op2 */
4370 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4371 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4372 return the instruction buffer holding the narrow instruction. Otherwise,
4373 return 0. The set of valid narrowing are specified by a string table
4374 but require some special case operand checks in some cases. */
4376 static xtensa_insnbuf
4377 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4379 xtensa_opcode opcode
)
4381 xtensa_isa isa
= xtensa_default_isa
;
4382 xtensa_format o_fmt
;
4385 static xtensa_insnbuf o_insnbuf
= NULL
;
4386 static xtensa_insnbuf o_slotbuf
= NULL
;
4388 if (o_insnbuf
== NULL
)
4390 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4391 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4394 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4396 bfd_boolean is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4398 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4400 uint32 value
, newval
;
4401 int i
, operand_count
, o_operand_count
;
4402 xtensa_opcode o_opcode
;
4404 /* Address does not matter in this case. We might need to
4405 fix it to handle branches/jumps. */
4406 bfd_vma self_address
= 0;
4408 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4409 if (o_opcode
== XTENSA_UNDEFINED
)
4411 o_fmt
= get_single_format (o_opcode
);
4412 if (o_fmt
== XTENSA_UNDEFINED
)
4415 if (xtensa_format_length (isa
, fmt
) != 3
4416 || xtensa_format_length (isa
, o_fmt
) != 2)
4419 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4420 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4421 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4423 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4428 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4433 uint32 rawval0
, rawval1
, rawval2
;
4435 if (o_operand_count
+ 1 != operand_count
4436 || xtensa_operand_get_field (isa
, opcode
, 0,
4437 fmt
, 0, slotbuf
, &rawval0
) != 0
4438 || xtensa_operand_get_field (isa
, opcode
, 1,
4439 fmt
, 0, slotbuf
, &rawval1
) != 0
4440 || xtensa_operand_get_field (isa
, opcode
, 2,
4441 fmt
, 0, slotbuf
, &rawval2
) != 0
4442 || rawval1
!= rawval2
4443 || rawval0
== rawval1
/* it is a nop */)
4447 for (i
= 0; i
< o_operand_count
; ++i
)
4449 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4451 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4454 /* PC-relative branches need adjustment, but
4455 the PC-rel operand will always have a relocation. */
4457 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4459 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4460 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4465 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4475 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4476 the action in-place directly into the contents and return TRUE. Otherwise,
4477 the return value is FALSE and the contents are not modified. */
4480 narrow_instruction (bfd_byte
*contents
,
4481 bfd_size_type content_length
,
4482 bfd_size_type offset
)
4484 xtensa_opcode opcode
;
4485 bfd_size_type insn_len
;
4486 xtensa_isa isa
= xtensa_default_isa
;
4488 xtensa_insnbuf o_insnbuf
;
4490 static xtensa_insnbuf insnbuf
= NULL
;
4491 static xtensa_insnbuf slotbuf
= NULL
;
4493 if (insnbuf
== NULL
)
4495 insnbuf
= xtensa_insnbuf_alloc (isa
);
4496 slotbuf
= xtensa_insnbuf_alloc (isa
);
4499 BFD_ASSERT (offset
< content_length
);
4501 if (content_length
< 2)
4504 /* We will hand-code a few of these for a little while.
4505 These have all been specified in the assembler aleady. */
4506 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4507 content_length
- offset
);
4508 fmt
= xtensa_format_decode (isa
, insnbuf
);
4509 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4512 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4515 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4516 if (opcode
== XTENSA_UNDEFINED
)
4518 insn_len
= xtensa_format_length (isa
, fmt
);
4519 if (insn_len
> content_length
)
4522 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4525 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4526 content_length
- offset
);
4534 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4535 "density" instruction to a standard 3-byte instruction. If it is valid,
4536 return the instruction buffer holding the wide instruction. Otherwise,
4537 return 0. The set of valid widenings are specified by a string table
4538 but require some special case operand checks in some cases. */
4540 static xtensa_insnbuf
4541 can_widen_instruction (xtensa_insnbuf slotbuf
,
4543 xtensa_opcode opcode
)
4545 xtensa_isa isa
= xtensa_default_isa
;
4546 xtensa_format o_fmt
;
4549 static xtensa_insnbuf o_insnbuf
= NULL
;
4550 static xtensa_insnbuf o_slotbuf
= NULL
;
4552 if (o_insnbuf
== NULL
)
4554 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4555 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4558 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4560 bfd_boolean is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4561 bfd_boolean is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4562 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4564 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4566 uint32 value
, newval
;
4567 int i
, operand_count
, o_operand_count
, check_operand_count
;
4568 xtensa_opcode o_opcode
;
4570 /* Address does not matter in this case. We might need to fix it
4571 to handle branches/jumps. */
4572 bfd_vma self_address
= 0;
4574 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4575 if (o_opcode
== XTENSA_UNDEFINED
)
4577 o_fmt
= get_single_format (o_opcode
);
4578 if (o_fmt
== XTENSA_UNDEFINED
)
4581 if (xtensa_format_length (isa
, fmt
) != 2
4582 || xtensa_format_length (isa
, o_fmt
) != 3)
4585 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4586 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4587 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4588 check_operand_count
= o_operand_count
;
4590 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4595 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4600 uint32 rawval0
, rawval1
;
4602 if (o_operand_count
!= operand_count
+ 1
4603 || xtensa_operand_get_field (isa
, opcode
, 0,
4604 fmt
, 0, slotbuf
, &rawval0
) != 0
4605 || xtensa_operand_get_field (isa
, opcode
, 1,
4606 fmt
, 0, slotbuf
, &rawval1
) != 0
4607 || rawval0
== rawval1
/* it is a nop */)
4611 check_operand_count
--;
4613 for (i
= 0; i
< check_operand_count
; i
++)
4616 if (is_or
&& i
== o_operand_count
- 1)
4618 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4620 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4623 /* PC-relative branches need adjustment, but
4624 the PC-rel operand will always have a relocation. */
4626 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4628 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4629 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4634 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4644 /* Attempt to widen an instruction. If the widening is valid, perform
4645 the action in-place directly into the contents and return TRUE. Otherwise,
4646 the return value is FALSE and the contents are not modified. */
4649 widen_instruction (bfd_byte
*contents
,
4650 bfd_size_type content_length
,
4651 bfd_size_type offset
)
4653 xtensa_opcode opcode
;
4654 bfd_size_type insn_len
;
4655 xtensa_isa isa
= xtensa_default_isa
;
4657 xtensa_insnbuf o_insnbuf
;
4659 static xtensa_insnbuf insnbuf
= NULL
;
4660 static xtensa_insnbuf slotbuf
= NULL
;
4662 if (insnbuf
== NULL
)
4664 insnbuf
= xtensa_insnbuf_alloc (isa
);
4665 slotbuf
= xtensa_insnbuf_alloc (isa
);
4668 BFD_ASSERT (offset
< content_length
);
4670 if (content_length
< 2)
4673 /* We will hand-code a few of these for a little while.
4674 These have all been specified in the assembler aleady. */
4675 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4676 content_length
- offset
);
4677 fmt
= xtensa_format_decode (isa
, insnbuf
);
4678 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4681 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4684 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4685 if (opcode
== XTENSA_UNDEFINED
)
4687 insn_len
= xtensa_format_length (isa
, fmt
);
4688 if (insn_len
> content_length
)
4691 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4694 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4695 content_length
- offset
);
4702 /* Code for transforming CALLs at link-time. */
4704 static bfd_reloc_status_type
4705 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4707 bfd_vma content_length
,
4708 char **error_message
)
4710 static xtensa_insnbuf insnbuf
= NULL
;
4711 static xtensa_insnbuf slotbuf
= NULL
;
4712 xtensa_format core_format
= XTENSA_UNDEFINED
;
4713 xtensa_opcode opcode
;
4714 xtensa_opcode direct_call_opcode
;
4715 xtensa_isa isa
= xtensa_default_isa
;
4716 bfd_byte
*chbuf
= contents
+ address
;
4719 if (insnbuf
== NULL
)
4721 insnbuf
= xtensa_insnbuf_alloc (isa
);
4722 slotbuf
= xtensa_insnbuf_alloc (isa
);
4725 if (content_length
< address
)
4727 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4728 return bfd_reloc_other
;
4731 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4732 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4733 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4735 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4736 return bfd_reloc_other
;
4739 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4740 core_format
= xtensa_format_lookup (isa
, "x24");
4741 opcode
= xtensa_opcode_lookup (isa
, "or");
4742 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4743 for (opn
= 0; opn
< 3; opn
++)
4746 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4747 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4750 xtensa_format_encode (isa
, core_format
, insnbuf
);
4751 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4752 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4754 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4755 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4756 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4758 xtensa_format_encode (isa
, core_format
, insnbuf
);
4759 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4760 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4761 content_length
- address
- 3);
4763 return bfd_reloc_ok
;
4767 static bfd_reloc_status_type
4768 contract_asm_expansion (bfd_byte
*contents
,
4769 bfd_vma content_length
,
4770 Elf_Internal_Rela
*irel
,
4771 char **error_message
)
4773 bfd_reloc_status_type retval
=
4774 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4777 if (retval
!= bfd_reloc_ok
)
4778 return bfd_reloc_dangerous
;
4780 /* Update the irel->r_offset field so that the right immediate and
4781 the right instruction are modified during the relocation. */
4782 irel
->r_offset
+= 3;
4783 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4784 return bfd_reloc_ok
;
4788 static xtensa_opcode
4789 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4791 init_call_opcodes ();
4793 if (opcode
== callx0_op
) return call0_op
;
4794 if (opcode
== callx4_op
) return call4_op
;
4795 if (opcode
== callx8_op
) return call8_op
;
4796 if (opcode
== callx12_op
) return call12_op
;
4798 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4799 return XTENSA_UNDEFINED
;
4803 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4804 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4805 If not, return XTENSA_UNDEFINED. */
4807 #define L32R_TARGET_REG_OPERAND 0
4808 #define CONST16_TARGET_REG_OPERAND 0
4809 #define CALLN_SOURCE_OPERAND 0
4811 static xtensa_opcode
4812 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bfd_boolean
*p_uses_l32r
)
4814 static xtensa_insnbuf insnbuf
= NULL
;
4815 static xtensa_insnbuf slotbuf
= NULL
;
4817 xtensa_opcode opcode
;
4818 xtensa_isa isa
= xtensa_default_isa
;
4819 uint32 regno
, const16_regno
, call_regno
;
4822 if (insnbuf
== NULL
)
4824 insnbuf
= xtensa_insnbuf_alloc (isa
);
4825 slotbuf
= xtensa_insnbuf_alloc (isa
);
4828 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4829 fmt
= xtensa_format_decode (isa
, insnbuf
);
4830 if (fmt
== XTENSA_UNDEFINED
4831 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4832 return XTENSA_UNDEFINED
;
4834 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4835 if (opcode
== XTENSA_UNDEFINED
)
4836 return XTENSA_UNDEFINED
;
4838 if (opcode
== get_l32r_opcode ())
4841 *p_uses_l32r
= TRUE
;
4842 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4843 fmt
, 0, slotbuf
, ®no
)
4844 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4846 return XTENSA_UNDEFINED
;
4848 else if (opcode
== get_const16_opcode ())
4851 *p_uses_l32r
= FALSE
;
4852 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4853 fmt
, 0, slotbuf
, ®no
)
4854 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4856 return XTENSA_UNDEFINED
;
4858 /* Check that the next instruction is also CONST16. */
4859 offset
+= xtensa_format_length (isa
, fmt
);
4860 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4861 fmt
= xtensa_format_decode (isa
, insnbuf
);
4862 if (fmt
== XTENSA_UNDEFINED
4863 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4864 return XTENSA_UNDEFINED
;
4865 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4866 if (opcode
!= get_const16_opcode ())
4867 return XTENSA_UNDEFINED
;
4869 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4870 fmt
, 0, slotbuf
, &const16_regno
)
4871 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4873 || const16_regno
!= regno
)
4874 return XTENSA_UNDEFINED
;
4877 return XTENSA_UNDEFINED
;
4879 /* Next instruction should be an CALLXn with operand 0 == regno. */
4880 offset
+= xtensa_format_length (isa
, fmt
);
4881 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4882 fmt
= xtensa_format_decode (isa
, insnbuf
);
4883 if (fmt
== XTENSA_UNDEFINED
4884 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4885 return XTENSA_UNDEFINED
;
4886 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4887 if (opcode
== XTENSA_UNDEFINED
4888 || !is_indirect_call_opcode (opcode
))
4889 return XTENSA_UNDEFINED
;
4891 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4892 fmt
, 0, slotbuf
, &call_regno
)
4893 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4895 return XTENSA_UNDEFINED
;
4897 if (call_regno
!= regno
)
4898 return XTENSA_UNDEFINED
;
4904 /* Data structures used during relaxation. */
4906 /* r_reloc: relocation values. */
4908 /* Through the relaxation process, we need to keep track of the values
4909 that will result from evaluating relocations. The standard ELF
4910 relocation structure is not sufficient for this purpose because we're
4911 operating on multiple input files at once, so we need to know which
4912 input file a relocation refers to. The r_reloc structure thus
4913 records both the input file (bfd) and ELF relocation.
4915 For efficiency, an r_reloc also contains a "target_offset" field to
4916 cache the target-section-relative offset value that is represented by
4919 The r_reloc also contains a virtual offset that allows multiple
4920 inserted literals to be placed at the same "address" with
4921 different offsets. */
4923 typedef struct r_reloc_struct r_reloc
;
4925 struct r_reloc_struct
4928 Elf_Internal_Rela rela
;
4929 bfd_vma target_offset
;
4930 bfd_vma virtual_offset
;
4934 /* The r_reloc structure is included by value in literal_value, but not
4935 every literal_value has an associated relocation -- some are simple
4936 constants. In such cases, we set all the fields in the r_reloc
4937 struct to zero. The r_reloc_is_const function should be used to
4938 detect this case. */
4941 r_reloc_is_const (const r_reloc
*r_rel
)
4943 return (r_rel
->abfd
== NULL
);
4948 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4950 bfd_vma target_offset
;
4951 unsigned long r_symndx
;
4953 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4954 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4955 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4956 return (target_offset
+ r_rel
->rela
.r_addend
);
4960 static struct elf_link_hash_entry
*
4961 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4963 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4964 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4969 r_reloc_get_section (const r_reloc
*r_rel
)
4971 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4972 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4977 r_reloc_is_defined (const r_reloc
*r_rel
)
4983 sec
= r_reloc_get_section (r_rel
);
4984 if (sec
== bfd_abs_section_ptr
4985 || sec
== bfd_com_section_ptr
4986 || sec
== bfd_und_section_ptr
)
4993 r_reloc_init (r_reloc
*r_rel
,
4995 Elf_Internal_Rela
*irel
,
4997 bfd_size_type content_length
)
5000 reloc_howto_type
*howto
;
5004 r_rel
->rela
= *irel
;
5006 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
5007 r_rel
->virtual_offset
= 0;
5008 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
5009 howto
= &elf_howto_table
[r_type
];
5010 if (howto
->partial_inplace
)
5012 bfd_vma inplace_val
;
5013 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
5015 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
5016 r_rel
->target_offset
+= inplace_val
;
5020 memset (r_rel
, 0, sizeof (r_reloc
));
5027 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
5029 if (r_reloc_is_defined (r_rel
))
5031 asection
*sec
= r_reloc_get_section (r_rel
);
5032 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
5034 else if (r_reloc_get_hash_entry (r_rel
))
5035 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
5037 fprintf (fp
, " ?? + ");
5039 fprintf_vma (fp
, r_rel
->target_offset
);
5040 if (r_rel
->virtual_offset
)
5042 fprintf (fp
, " + ");
5043 fprintf_vma (fp
, r_rel
->virtual_offset
);
5052 /* source_reloc: relocations that reference literals. */
5054 /* To determine whether literals can be coalesced, we need to first
5055 record all the relocations that reference the literals. The
5056 source_reloc structure below is used for this purpose. The
5057 source_reloc entries are kept in a per-literal-section array, sorted
5058 by offset within the literal section (i.e., target offset).
5060 The source_sec and r_rel.rela.r_offset fields identify the source of
5061 the relocation. The r_rel field records the relocation value, i.e.,
5062 the offset of the literal being referenced. The opnd field is needed
5063 to determine the range of the immediate field to which the relocation
5064 applies, so we can determine whether another literal with the same
5065 value is within range. The is_null field is true when the relocation
5066 is being removed (e.g., when an L32R is being removed due to a CALLX
5067 that is converted to a direct CALL). */
5069 typedef struct source_reloc_struct source_reloc
;
5071 struct source_reloc_struct
5073 asection
*source_sec
;
5075 xtensa_opcode opcode
;
5077 bfd_boolean is_null
;
5078 bfd_boolean is_abs_literal
;
5083 init_source_reloc (source_reloc
*reloc
,
5084 asection
*source_sec
,
5085 const r_reloc
*r_rel
,
5086 xtensa_opcode opcode
,
5088 bfd_boolean is_abs_literal
)
5090 reloc
->source_sec
= source_sec
;
5091 reloc
->r_rel
= *r_rel
;
5092 reloc
->opcode
= opcode
;
5094 reloc
->is_null
= FALSE
;
5095 reloc
->is_abs_literal
= is_abs_literal
;
5099 /* Find the source_reloc for a particular source offset and relocation
5100 type. Note that the array is sorted by _target_ offset, so this is
5101 just a linear search. */
5103 static source_reloc
*
5104 find_source_reloc (source_reloc
*src_relocs
,
5107 Elf_Internal_Rela
*irel
)
5111 for (i
= 0; i
< src_count
; i
++)
5113 if (src_relocs
[i
].source_sec
== sec
5114 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
5115 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
5116 == ELF32_R_TYPE (irel
->r_info
)))
5117 return &src_relocs
[i
];
5125 source_reloc_compare (const void *ap
, const void *bp
)
5127 const source_reloc
*a
= (const source_reloc
*) ap
;
5128 const source_reloc
*b
= (const source_reloc
*) bp
;
5130 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
5131 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5133 /* We don't need to sort on these criteria for correctness,
5134 but enforcing a more strict ordering prevents unstable qsort
5135 from behaving differently with different implementations.
5136 Without the code below we get correct but different results
5137 on Solaris 2.7 and 2.8. We would like to always produce the
5138 same results no matter the host. */
5140 if ((!a
->is_null
) - (!b
->is_null
))
5141 return ((!a
->is_null
) - (!b
->is_null
));
5142 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5146 /* Literal values and value hash tables. */
5148 /* Literals with the same value can be coalesced. The literal_value
5149 structure records the value of a literal: the "r_rel" field holds the
5150 information from the relocation on the literal (if there is one) and
5151 the "value" field holds the contents of the literal word itself.
5153 The value_map structure records a literal value along with the
5154 location of a literal holding that value. The value_map hash table
5155 is indexed by the literal value, so that we can quickly check if a
5156 particular literal value has been seen before and is thus a candidate
5159 typedef struct literal_value_struct literal_value
;
5160 typedef struct value_map_struct value_map
;
5161 typedef struct value_map_hash_table_struct value_map_hash_table
;
5163 struct literal_value_struct
5166 unsigned long value
;
5167 bfd_boolean is_abs_literal
;
5170 struct value_map_struct
5172 literal_value val
; /* The literal value. */
5173 r_reloc loc
; /* Location of the literal. */
5177 struct value_map_hash_table_struct
5179 unsigned bucket_count
;
5180 value_map
**buckets
;
5182 bfd_boolean has_last_loc
;
5188 init_literal_value (literal_value
*lit
,
5189 const r_reloc
*r_rel
,
5190 unsigned long value
,
5191 bfd_boolean is_abs_literal
)
5193 lit
->r_rel
= *r_rel
;
5195 lit
->is_abs_literal
= is_abs_literal
;
5200 literal_value_equal (const literal_value
*src1
,
5201 const literal_value
*src2
,
5202 bfd_boolean final_static_link
)
5204 struct elf_link_hash_entry
*h1
, *h2
;
5206 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5209 if (r_reloc_is_const (&src1
->r_rel
))
5210 return (src1
->value
== src2
->value
);
5212 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5213 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5216 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5219 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5222 if (src1
->value
!= src2
->value
)
5225 /* Now check for the same section (if defined) or the same elf_hash
5226 (if undefined or weak). */
5227 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5228 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5229 if (r_reloc_is_defined (&src1
->r_rel
)
5230 && (final_static_link
5231 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5232 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5234 if (r_reloc_get_section (&src1
->r_rel
)
5235 != r_reloc_get_section (&src2
->r_rel
))
5240 /* Require that the hash entries (i.e., symbols) be identical. */
5241 if (h1
!= h2
|| h1
== 0)
5245 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5252 /* Must be power of 2. */
5253 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5255 static value_map_hash_table
*
5256 value_map_hash_table_init (void)
5258 value_map_hash_table
*values
;
5260 values
= (value_map_hash_table
*)
5261 bfd_zmalloc (sizeof (value_map_hash_table
));
5262 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5264 values
->buckets
= (value_map
**)
5265 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5266 if (values
->buckets
== NULL
)
5271 values
->has_last_loc
= FALSE
;
5278 value_map_hash_table_delete (value_map_hash_table
*table
)
5280 free (table
->buckets
);
5286 hash_bfd_vma (bfd_vma val
)
5288 return (val
>> 2) + (val
>> 10);
5293 literal_value_hash (const literal_value
*src
)
5297 hash_val
= hash_bfd_vma (src
->value
);
5298 if (!r_reloc_is_const (&src
->r_rel
))
5302 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5303 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5304 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5306 /* Now check for the same section and the same elf_hash. */
5307 if (r_reloc_is_defined (&src
->r_rel
))
5308 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5310 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5311 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5317 /* Check if the specified literal_value has been seen before. */
5320 value_map_get_cached_value (value_map_hash_table
*map
,
5321 const literal_value
*val
,
5322 bfd_boolean final_static_link
)
5328 idx
= literal_value_hash (val
);
5329 idx
= idx
& (map
->bucket_count
- 1);
5330 bucket
= map
->buckets
[idx
];
5331 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5333 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5340 /* Record a new literal value. It is illegal to call this if VALUE
5341 already has an entry here. */
5344 add_value_map (value_map_hash_table
*map
,
5345 const literal_value
*val
,
5347 bfd_boolean final_static_link
)
5349 value_map
**bucket_p
;
5352 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5355 bfd_set_error (bfd_error_no_memory
);
5359 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5363 idx
= literal_value_hash (val
);
5364 idx
= idx
& (map
->bucket_count
- 1);
5365 bucket_p
= &map
->buckets
[idx
];
5367 val_e
->next
= *bucket_p
;
5370 /* FIXME: Consider resizing the hash table if we get too many entries. */
5376 /* Lists of text actions (ta_) for narrowing, widening, longcall
5377 conversion, space fill, code & literal removal, etc. */
5379 /* The following text actions are generated:
5381 "ta_remove_insn" remove an instruction or instructions
5382 "ta_remove_longcall" convert longcall to call
5383 "ta_convert_longcall" convert longcall to nop/call
5384 "ta_narrow_insn" narrow a wide instruction
5385 "ta_widen" widen a narrow instruction
5386 "ta_fill" add fill or remove fill
5387 removed < 0 is a fill; branches to the fill address will be
5388 changed to address + fill size (e.g., address - removed)
5389 removed >= 0 branches to the fill address will stay unchanged
5390 "ta_remove_literal" remove a literal; this action is
5391 indicated when a literal is removed
5393 "ta_add_literal" insert a new literal; this action is
5394 indicated when a literal has been moved.
5395 It may use a virtual_offset because
5396 multiple literals can be placed at the
5399 For each of these text actions, we also record the number of bytes
5400 removed by performing the text action. In the case of a "ta_widen"
5401 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5403 typedef struct text_action_struct text_action
;
5404 typedef struct text_action_list_struct text_action_list
;
5405 typedef enum text_action_enum_t text_action_t
;
5407 enum text_action_enum_t
5410 ta_remove_insn
, /* removed = -size */
5411 ta_remove_longcall
, /* removed = -size */
5412 ta_convert_longcall
, /* removed = 0 */
5413 ta_narrow_insn
, /* removed = -1 */
5414 ta_widen_insn
, /* removed = +1 */
5415 ta_fill
, /* removed = +size */
5421 /* Structure for a text action record. */
5422 struct text_action_struct
5424 text_action_t action
;
5425 asection
*sec
; /* Optional */
5427 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5429 literal_value value
; /* Only valid when adding literals. */
5432 struct removal_by_action_entry_struct
5437 int eq_removed_before_fill
;
5439 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5441 struct removal_by_action_map_struct
5444 removal_by_action_entry
*entry
;
5446 typedef struct removal_by_action_map_struct removal_by_action_map
;
5449 /* List of all of the actions taken on a text section. */
5450 struct text_action_list_struct
5454 removal_by_action_map map
;
5458 static text_action
*
5459 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5463 /* It is not necessary to fill at the end of a section. */
5464 if (sec
->size
== offset
)
5470 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5472 return (text_action
*)node
->value
;
5478 compute_removed_action_diff (const text_action
*ta
,
5482 int removable_space
)
5485 int current_removed
= 0;
5488 current_removed
= ta
->removed_bytes
;
5490 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5491 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5493 /* It is not necessary to fill at the end of a section. Clean this up. */
5494 if (sec
->size
== offset
)
5495 new_removed
= removable_space
- 0;
5499 int added
= -removed
- current_removed
;
5500 /* Ignore multiples of the section alignment. */
5501 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5502 new_removed
= (-added
);
5504 /* Modify for removable. */
5505 space
= removable_space
- new_removed
;
5506 new_removed
= (removable_space
5507 - (((1 << sec
->alignment_power
) - 1) & space
));
5509 return (new_removed
- current_removed
);
5514 adjust_fill_action (text_action
*ta
, int fill_diff
)
5516 ta
->removed_bytes
+= fill_diff
;
5521 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5523 text_action
*pa
= (text_action
*)a
;
5524 text_action
*pb
= (text_action
*)b
;
5525 static const int action_priority
[] =
5529 [ta_convert_longcall
] = 2,
5530 [ta_narrow_insn
] = 3,
5531 [ta_remove_insn
] = 4,
5532 [ta_remove_longcall
] = 5,
5533 [ta_remove_literal
] = 6,
5534 [ta_widen_insn
] = 7,
5535 [ta_add_literal
] = 8,
5538 if (pa
->offset
== pb
->offset
)
5540 if (pa
->action
== pb
->action
)
5542 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5545 return pa
->offset
< pb
->offset
? -1 : 1;
5548 static text_action
*
5549 action_first (text_action_list
*action_list
)
5551 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5552 return node
? (text_action
*)node
->value
: NULL
;
5555 static text_action
*
5556 action_next (text_action_list
*action_list
, text_action
*action
)
5558 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5559 (splay_tree_key
)action
);
5560 return node
? (text_action
*)node
->value
: NULL
;
5563 /* Add a modification action to the text. For the case of adding or
5564 removing space, modify any current fill and assume that
5565 "unreachable_space" bytes can be freely contracted. Note that a
5566 negative removed value is a fill. */
5569 text_action_add (text_action_list
*l
,
5570 text_action_t action
,
5578 /* It is not necessary to fill at the end of a section. */
5579 if (action
== ta_fill
&& sec
->size
== offset
)
5582 /* It is not necessary to fill 0 bytes. */
5583 if (action
== ta_fill
&& removed
== 0)
5589 if (action
== ta_fill
)
5591 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5595 ta
= (text_action
*)node
->value
;
5596 ta
->removed_bytes
+= removed
;
5601 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5603 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5604 ta
->action
= action
;
5606 ta
->offset
= offset
;
5607 ta
->removed_bytes
= removed
;
5608 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5614 text_action_add_literal (text_action_list
*l
,
5615 text_action_t action
,
5617 const literal_value
*value
,
5621 asection
*sec
= r_reloc_get_section (loc
);
5622 bfd_vma offset
= loc
->target_offset
;
5623 bfd_vma virtual_offset
= loc
->virtual_offset
;
5625 BFD_ASSERT (action
== ta_add_literal
);
5627 /* Create a new record and fill it up. */
5628 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5629 ta
->action
= action
;
5631 ta
->offset
= offset
;
5632 ta
->virtual_offset
= virtual_offset
;
5634 ta
->removed_bytes
= removed
;
5636 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5637 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5642 /* Find the total offset adjustment for the relaxations specified by
5643 text_actions, beginning from a particular starting action. This is
5644 typically used from offset_with_removed_text to search an entire list of
5645 actions, but it may also be called directly when adjusting adjacent offsets
5646 so that each search may begin where the previous one left off. */
5649 removed_by_actions (text_action_list
*action_list
,
5650 text_action
**p_start_action
,
5652 bfd_boolean before_fill
)
5657 r
= *p_start_action
;
5660 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5662 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5667 if (r
->offset
> offset
)
5670 if (r
->offset
== offset
5671 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5674 removed
+= r
->removed_bytes
;
5676 r
= action_next (action_list
, r
);
5679 *p_start_action
= r
;
5685 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5687 text_action
*r
= action_first (action_list
);
5689 return offset
- removed_by_actions (action_list
, &r
, offset
, FALSE
);
5694 action_list_count (text_action_list
*action_list
)
5696 return action_list
->count
;
5699 typedef struct map_action_fn_context_struct map_action_fn_context
;
5700 struct map_action_fn_context_struct
5703 removal_by_action_map map
;
5704 bfd_boolean eq_complete
;
5708 map_action_fn (splay_tree_node node
, void *p
)
5710 map_action_fn_context
*ctx
= p
;
5711 text_action
*r
= (text_action
*)node
->value
;
5712 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5714 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5720 ++ctx
->map
.n_entries
;
5721 ctx
->eq_complete
= FALSE
;
5722 ientry
->offset
= r
->offset
;
5723 ientry
->eq_removed_before_fill
= ctx
->removed
;
5726 if (!ctx
->eq_complete
)
5728 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5730 ientry
->eq_removed
= ctx
->removed
;
5731 ctx
->eq_complete
= TRUE
;
5734 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5737 ctx
->removed
+= r
->removed_bytes
;
5738 ientry
->removed
= ctx
->removed
;
5743 map_removal_by_action (text_action_list
*action_list
)
5745 map_action_fn_context ctx
;
5748 ctx
.map
.n_entries
= 0;
5749 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5750 sizeof (removal_by_action_entry
));
5751 ctx
.eq_complete
= FALSE
;
5753 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5754 action_list
->map
= ctx
.map
;
5758 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5759 bfd_boolean before_fill
)
5763 if (!action_list
->map
.entry
)
5764 map_removal_by_action (action_list
);
5766 if (!action_list
->map
.n_entries
)
5770 b
= action_list
->map
.n_entries
;
5774 unsigned c
= (a
+ b
) / 2;
5776 if (action_list
->map
.entry
[c
].offset
<= offset
)
5782 if (action_list
->map
.entry
[a
].offset
< offset
)
5784 return action_list
->map
.entry
[a
].removed
;
5786 else if (action_list
->map
.entry
[a
].offset
== offset
)
5788 return before_fill
?
5789 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5790 action_list
->map
.entry
[a
].eq_removed
;
5799 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5801 int removed
= removed_by_actions_map (action_list
, offset
, FALSE
);
5802 return offset
- removed
;
5806 /* The find_insn_action routine will only find non-fill actions. */
5808 static text_action
*
5809 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5811 static const text_action_t action
[] =
5813 ta_convert_longcall
,
5823 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5825 splay_tree_node node
;
5827 a
.action
= action
[i
];
5828 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5830 return (text_action
*)node
->value
;
5839 print_action (FILE *fp
, text_action
*r
)
5841 const char *t
= "unknown";
5844 case ta_remove_insn
:
5845 t
= "remove_insn"; break;
5846 case ta_remove_longcall
:
5847 t
= "remove_longcall"; break;
5848 case ta_convert_longcall
:
5849 t
= "convert_longcall"; break;
5850 case ta_narrow_insn
:
5851 t
= "narrow_insn"; break;
5853 t
= "widen_insn"; break;
5858 case ta_remove_literal
:
5859 t
= "remove_literal"; break;
5860 case ta_add_literal
:
5861 t
= "add_literal"; break;
5864 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5865 r
->sec
->owner
->filename
,
5866 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5870 print_action_list_fn (splay_tree_node node
, void *p
)
5872 text_action
*r
= (text_action
*)node
->value
;
5874 print_action (p
, r
);
5879 print_action_list (FILE *fp
, text_action_list
*action_list
)
5881 fprintf (fp
, "Text Action\n");
5882 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5888 /* Lists of literals being coalesced or removed. */
5890 /* In the usual case, the literal identified by "from" is being
5891 coalesced with another literal identified by "to". If the literal is
5892 unused and is being removed altogether, "to.abfd" will be NULL.
5893 The removed_literal entries are kept on a per-section list, sorted
5894 by the "from" offset field. */
5896 typedef struct removed_literal_struct removed_literal
;
5897 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5898 typedef struct removed_literal_list_struct removed_literal_list
;
5900 struct removed_literal_struct
5904 removed_literal
*next
;
5907 struct removed_literal_map_entry_struct
5910 removed_literal
*literal
;
5913 struct removed_literal_list_struct
5915 removed_literal
*head
;
5916 removed_literal
*tail
;
5919 removed_literal_map_entry
*map
;
5923 /* Record that the literal at "from" is being removed. If "to" is not
5924 NULL, the "from" literal is being coalesced with the "to" literal. */
5927 add_removed_literal (removed_literal_list
*removed_list
,
5928 const r_reloc
*from
,
5931 removed_literal
*r
, *new_r
, *next_r
;
5933 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5935 new_r
->from
= *from
;
5939 new_r
->to
.abfd
= NULL
;
5942 r
= removed_list
->head
;
5945 removed_list
->head
= new_r
;
5946 removed_list
->tail
= new_r
;
5948 /* Special check for common case of append. */
5949 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5951 removed_list
->tail
->next
= new_r
;
5952 removed_list
->tail
= new_r
;
5956 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5962 new_r
->next
= next_r
;
5964 removed_list
->tail
= new_r
;
5969 map_removed_literal (removed_literal_list
*removed_list
)
5973 removed_literal_map_entry
*map
= NULL
;
5974 removed_literal
*r
= removed_list
->head
;
5976 for (i
= 0; r
; ++i
, r
= r
->next
)
5980 n_map
= (n_map
* 2) + 2;
5981 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5983 map
[i
].addr
= r
->from
.target_offset
;
5986 removed_list
->map
= map
;
5987 removed_list
->n_map
= i
;
5991 removed_literal_compare (const void *a
, const void *b
)
5993 const bfd_vma
*key
= a
;
5994 const removed_literal_map_entry
*memb
= b
;
5996 if (*key
== memb
->addr
)
5999 return *key
< memb
->addr
? -1 : 1;
6002 /* Check if the list of removed literals contains an entry for the
6003 given address. Return the entry if found. */
6005 static removed_literal
*
6006 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
6008 removed_literal_map_entry
*p
;
6009 removed_literal
*r
= NULL
;
6011 if (removed_list
->map
== NULL
)
6012 map_removed_literal (removed_list
);
6014 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
6015 sizeof (*removed_list
->map
), removed_literal_compare
);
6018 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
6029 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
6032 r
= removed_list
->head
;
6034 fprintf (fp
, "Removed Literals\n");
6035 for (; r
!= NULL
; r
= r
->next
)
6037 print_r_reloc (fp
, &r
->from
);
6038 fprintf (fp
, " => ");
6039 if (r
->to
.abfd
== NULL
)
6040 fprintf (fp
, "REMOVED");
6042 print_r_reloc (fp
, &r
->to
);
6050 /* Per-section data for relaxation. */
6052 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
6054 struct xtensa_relax_info_struct
6056 bfd_boolean is_relaxable_literal_section
;
6057 bfd_boolean is_relaxable_asm_section
;
6058 int visited
; /* Number of times visited. */
6060 source_reloc
*src_relocs
; /* Array[src_count]. */
6062 int src_next
; /* Next src_relocs entry to assign. */
6064 removed_literal_list removed_list
;
6065 text_action_list action_list
;
6067 reloc_bfd_fix
*fix_list
;
6068 reloc_bfd_fix
*fix_array
;
6069 unsigned fix_array_count
;
6071 /* Support for expanding the reloc array that is stored
6072 in the section structure. If the relocations have been
6073 reallocated, the newly allocated relocations will be referenced
6074 here along with the actual size allocated. The relocation
6075 count will always be found in the section structure. */
6076 Elf_Internal_Rela
*allocated_relocs
;
6077 unsigned relocs_count
;
6078 unsigned allocated_relocs_count
;
6081 struct elf_xtensa_section_data
6083 struct bfd_elf_section_data elf
;
6084 xtensa_relax_info relax_info
;
6089 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
6091 if (!sec
->used_by_bfd
)
6093 struct elf_xtensa_section_data
*sdata
;
6094 size_t amt
= sizeof (*sdata
);
6096 sdata
= bfd_zalloc (abfd
, amt
);
6099 sec
->used_by_bfd
= sdata
;
6102 return _bfd_elf_new_section_hook (abfd
, sec
);
6106 static xtensa_relax_info
*
6107 get_xtensa_relax_info (asection
*sec
)
6109 struct elf_xtensa_section_data
*section_data
;
6111 /* No info available if no section or if it is an output section. */
6112 if (!sec
|| sec
== sec
->output_section
)
6115 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
6116 return §ion_data
->relax_info
;
6121 init_xtensa_relax_info (asection
*sec
)
6123 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6125 relax_info
->is_relaxable_literal_section
= FALSE
;
6126 relax_info
->is_relaxable_asm_section
= FALSE
;
6127 relax_info
->visited
= 0;
6129 relax_info
->src_relocs
= NULL
;
6130 relax_info
->src_count
= 0;
6131 relax_info
->src_next
= 0;
6133 relax_info
->removed_list
.head
= NULL
;
6134 relax_info
->removed_list
.tail
= NULL
;
6136 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6138 relax_info
->action_list
.map
.n_entries
= 0;
6139 relax_info
->action_list
.map
.entry
= NULL
;
6141 relax_info
->fix_list
= NULL
;
6142 relax_info
->fix_array
= NULL
;
6143 relax_info
->fix_array_count
= 0;
6145 relax_info
->allocated_relocs
= NULL
;
6146 relax_info
->relocs_count
= 0;
6147 relax_info
->allocated_relocs_count
= 0;
6151 /* Coalescing literals may require a relocation to refer to a section in
6152 a different input file, but the standard relocation information
6153 cannot express that. Instead, the reloc_bfd_fix structures are used
6154 to "fix" the relocations that refer to sections in other input files.
6155 These structures are kept on per-section lists. The "src_type" field
6156 records the relocation type in case there are multiple relocations on
6157 the same location. FIXME: This is ugly; an alternative might be to
6158 add new symbols with the "owner" field to some other input file. */
6160 struct reloc_bfd_fix_struct
6164 unsigned src_type
; /* Relocation type. */
6166 asection
*target_sec
;
6167 bfd_vma target_offset
;
6168 bfd_boolean translated
;
6170 reloc_bfd_fix
*next
;
6174 static reloc_bfd_fix
*
6175 reloc_bfd_fix_init (asection
*src_sec
,
6178 asection
*target_sec
,
6179 bfd_vma target_offset
,
6180 bfd_boolean translated
)
6184 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6185 fix
->src_sec
= src_sec
;
6186 fix
->src_offset
= src_offset
;
6187 fix
->src_type
= src_type
;
6188 fix
->target_sec
= target_sec
;
6189 fix
->target_offset
= target_offset
;
6190 fix
->translated
= translated
;
6197 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6199 xtensa_relax_info
*relax_info
;
6201 relax_info
= get_xtensa_relax_info (src_sec
);
6202 fix
->next
= relax_info
->fix_list
;
6203 relax_info
->fix_list
= fix
;
6208 fix_compare (const void *ap
, const void *bp
)
6210 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6211 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6213 if (a
->src_offset
!= b
->src_offset
)
6214 return (a
->src_offset
- b
->src_offset
);
6215 return (a
->src_type
- b
->src_type
);
6220 cache_fix_array (asection
*sec
)
6222 unsigned i
, count
= 0;
6224 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6226 if (relax_info
== NULL
)
6228 if (relax_info
->fix_list
== NULL
)
6231 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6234 relax_info
->fix_array
=
6235 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6236 relax_info
->fix_array_count
= count
;
6238 r
= relax_info
->fix_list
;
6239 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6241 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6242 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6245 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6246 sizeof (reloc_bfd_fix
), fix_compare
);
6250 static reloc_bfd_fix
*
6251 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6253 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6257 if (relax_info
== NULL
)
6259 if (relax_info
->fix_list
== NULL
)
6262 if (relax_info
->fix_array
== NULL
)
6263 cache_fix_array (sec
);
6265 key
.src_offset
= offset
;
6266 key
.src_type
= type
;
6267 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6268 sizeof (reloc_bfd_fix
), fix_compare
);
6273 /* Section caching. */
6275 typedef struct section_cache_struct section_cache_t
;
6277 struct section_cache_struct
6281 bfd_byte
*contents
; /* Cache of the section contents. */
6282 bfd_size_type content_length
;
6284 property_table_entry
*ptbl
; /* Cache of the section property table. */
6287 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6288 unsigned reloc_count
;
6293 init_section_cache (section_cache_t
*sec_cache
)
6295 memset (sec_cache
, 0, sizeof (*sec_cache
));
6300 free_section_cache (section_cache_t
*sec_cache
)
6304 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6305 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6306 free (sec_cache
->ptbl
);
6312 section_cache_section (section_cache_t
*sec_cache
,
6314 struct bfd_link_info
*link_info
)
6317 property_table_entry
*prop_table
= NULL
;
6319 bfd_byte
*contents
= NULL
;
6320 Elf_Internal_Rela
*internal_relocs
= NULL
;
6321 bfd_size_type sec_size
;
6325 if (sec
== sec_cache
->sec
)
6329 sec_size
= bfd_get_section_limit (abfd
, sec
);
6331 /* Get the contents. */
6332 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6333 if (contents
== NULL
&& sec_size
!= 0)
6336 /* Get the relocations. */
6337 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6338 link_info
->keep_memory
);
6340 /* Get the entry table. */
6341 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6342 XTENSA_PROP_SEC_NAME
, FALSE
);
6346 /* Fill in the new section cache. */
6347 free_section_cache (sec_cache
);
6348 init_section_cache (sec_cache
);
6350 sec_cache
->sec
= sec
;
6351 sec_cache
->contents
= contents
;
6352 sec_cache
->content_length
= sec_size
;
6353 sec_cache
->relocs
= internal_relocs
;
6354 sec_cache
->reloc_count
= sec
->reloc_count
;
6355 sec_cache
->pte_count
= ptblsize
;
6356 sec_cache
->ptbl
= prop_table
;
6361 release_contents (sec
, contents
);
6362 release_internal_relocs (sec
, internal_relocs
);
6368 /* Extended basic blocks. */
6370 /* An ebb_struct represents an Extended Basic Block. Within this
6371 range, we guarantee that all instructions are decodable, the
6372 property table entries are contiguous, and no property table
6373 specifies a segment that cannot have instructions moved. This
6374 structure contains caches of the contents, property table and
6375 relocations for the specified section for easy use. The range is
6376 specified by ranges of indices for the byte offset, property table
6377 offsets and relocation offsets. These must be consistent. */
6379 typedef struct ebb_struct ebb_t
;
6385 bfd_byte
*contents
; /* Cache of the section contents. */
6386 bfd_size_type content_length
;
6388 property_table_entry
*ptbl
; /* Cache of the section property table. */
6391 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6392 unsigned reloc_count
;
6394 bfd_vma start_offset
; /* Offset in section. */
6395 unsigned start_ptbl_idx
; /* Offset in the property table. */
6396 unsigned start_reloc_idx
; /* Offset in the relocations. */
6399 unsigned end_ptbl_idx
;
6400 unsigned end_reloc_idx
;
6402 bfd_boolean ends_section
; /* Is this the last ebb in a section? */
6404 /* The unreachable property table at the end of this set of blocks;
6405 NULL if the end is not an unreachable block. */
6406 property_table_entry
*ends_unreachable
;
6410 enum ebb_target_enum
6413 EBB_DESIRE_TGT_ALIGN
,
6414 EBB_REQUIRE_TGT_ALIGN
,
6415 EBB_REQUIRE_LOOP_ALIGN
,
6420 /* proposed_action_struct is similar to the text_action_struct except
6421 that is represents a potential transformation, not one that will
6422 occur. We build a list of these for an extended basic block
6423 and use them to compute the actual actions desired. We must be
6424 careful that the entire set of actual actions we perform do not
6425 break any relocations that would fit if the actions were not
6428 typedef struct proposed_action_struct proposed_action
;
6430 struct proposed_action_struct
6432 enum ebb_target_enum align_type
; /* for the target alignment */
6433 bfd_vma alignment_pow
;
6434 text_action_t action
;
6437 bfd_boolean do_action
; /* If false, then we will not perform the action. */
6441 /* The ebb_constraint_struct keeps a set of proposed actions for an
6442 extended basic block. */
6444 typedef struct ebb_constraint_struct ebb_constraint
;
6446 struct ebb_constraint_struct
6449 bfd_boolean start_movable
;
6451 /* Bytes of extra space at the beginning if movable. */
6452 int start_extra_space
;
6454 enum ebb_target_enum start_align
;
6456 bfd_boolean end_movable
;
6458 /* Bytes of extra space at the end if movable. */
6459 int end_extra_space
;
6461 unsigned action_count
;
6462 unsigned action_allocated
;
6464 /* Array of proposed actions. */
6465 proposed_action
*actions
;
6467 /* Action alignments -- one for each proposed action. */
6468 enum ebb_target_enum
*action_aligns
;
6473 init_ebb_constraint (ebb_constraint
*c
)
6475 memset (c
, 0, sizeof (ebb_constraint
));
6480 free_ebb_constraint (ebb_constraint
*c
)
6487 init_ebb (ebb_t
*ebb
,
6490 bfd_size_type content_length
,
6491 property_table_entry
*prop_table
,
6493 Elf_Internal_Rela
*internal_relocs
,
6494 unsigned reloc_count
)
6496 memset (ebb
, 0, sizeof (ebb_t
));
6498 ebb
->contents
= contents
;
6499 ebb
->content_length
= content_length
;
6500 ebb
->ptbl
= prop_table
;
6501 ebb
->pte_count
= ptblsize
;
6502 ebb
->relocs
= internal_relocs
;
6503 ebb
->reloc_count
= reloc_count
;
6504 ebb
->start_offset
= 0;
6505 ebb
->end_offset
= ebb
->content_length
- 1;
6506 ebb
->start_ptbl_idx
= 0;
6507 ebb
->end_ptbl_idx
= ptblsize
;
6508 ebb
->start_reloc_idx
= 0;
6509 ebb
->end_reloc_idx
= reloc_count
;
6513 /* Extend the ebb to all decodable contiguous sections. The algorithm
6514 for building a basic block around an instruction is to push it
6515 forward until we hit the end of a section, an unreachable block or
6516 a block that cannot be transformed. Then we push it backwards
6517 searching for similar conditions. */
6519 static bfd_boolean
extend_ebb_bounds_forward (ebb_t
*);
6520 static bfd_boolean
extend_ebb_bounds_backward (ebb_t
*);
6521 static bfd_size_type insn_block_decodable_len
6522 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6525 extend_ebb_bounds (ebb_t
*ebb
)
6527 if (!extend_ebb_bounds_forward (ebb
))
6529 if (!extend_ebb_bounds_backward (ebb
))
6536 extend_ebb_bounds_forward (ebb_t
*ebb
)
6538 property_table_entry
*the_entry
, *new_entry
;
6540 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6542 /* Stop when (1) we cannot decode an instruction, (2) we are at
6543 the end of the property tables, (3) we hit a non-contiguous property
6544 table entry, (4) we hit a NO_TRANSFORM region. */
6549 bfd_size_type insn_block_len
;
6551 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6553 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6555 entry_end
- ebb
->end_offset
);
6556 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6559 /* xgettext:c-format */
6560 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6561 "possible configuration mismatch"),
6562 ebb
->sec
->owner
, ebb
->sec
,
6563 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6566 ebb
->end_offset
+= insn_block_len
;
6568 if (ebb
->end_offset
== ebb
->sec
->size
)
6569 ebb
->ends_section
= TRUE
;
6571 /* Update the reloc counter. */
6572 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6573 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6576 ebb
->end_reloc_idx
++;
6579 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6582 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6583 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6584 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6585 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6588 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6591 the_entry
= new_entry
;
6592 ebb
->end_ptbl_idx
++;
6595 /* Quick check for an unreachable or end of file just at the end. */
6596 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6598 if (ebb
->end_offset
== ebb
->content_length
)
6599 ebb
->ends_section
= TRUE
;
6603 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6604 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6605 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6606 ebb
->ends_unreachable
= new_entry
;
6609 /* Any other ending requires exact alignment. */
6615 extend_ebb_bounds_backward (ebb_t
*ebb
)
6617 property_table_entry
*the_entry
, *new_entry
;
6619 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6621 /* Stop when (1) we cannot decode the instructions in the current entry.
6622 (2) we are at the beginning of the property tables, (3) we hit a
6623 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6627 bfd_vma block_begin
;
6628 bfd_size_type insn_block_len
;
6630 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6632 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6634 ebb
->start_offset
- block_begin
);
6635 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6638 /* xgettext:c-format */
6639 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6640 "possible configuration mismatch"),
6641 ebb
->sec
->owner
, ebb
->sec
,
6642 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6645 ebb
->start_offset
-= insn_block_len
;
6647 /* Update the reloc counter. */
6648 while (ebb
->start_reloc_idx
> 0
6649 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6650 >= ebb
->start_offset
))
6652 ebb
->start_reloc_idx
--;
6655 if (ebb
->start_ptbl_idx
== 0)
6658 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6659 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6660 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6661 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6663 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6666 the_entry
= new_entry
;
6667 ebb
->start_ptbl_idx
--;
6673 static bfd_size_type
6674 insn_block_decodable_len (bfd_byte
*contents
,
6675 bfd_size_type content_len
,
6676 bfd_vma block_offset
,
6677 bfd_size_type block_len
)
6679 bfd_vma offset
= block_offset
;
6681 while (offset
< block_offset
+ block_len
)
6683 bfd_size_type insn_len
= 0;
6685 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6687 return (offset
- block_offset
);
6690 return (offset
- block_offset
);
6695 ebb_propose_action (ebb_constraint
*c
,
6696 enum ebb_target_enum align_type
,
6697 bfd_vma alignment_pow
,
6698 text_action_t action
,
6701 bfd_boolean do_action
)
6703 proposed_action
*act
;
6705 if (c
->action_allocated
<= c
->action_count
)
6707 unsigned new_allocated
, i
;
6708 proposed_action
*new_actions
;
6710 new_allocated
= (c
->action_count
+ 2) * 2;
6711 new_actions
= (proposed_action
*)
6712 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6714 for (i
= 0; i
< c
->action_count
; i
++)
6715 new_actions
[i
] = c
->actions
[i
];
6717 c
->actions
= new_actions
;
6718 c
->action_allocated
= new_allocated
;
6721 act
= &c
->actions
[c
->action_count
];
6722 act
->align_type
= align_type
;
6723 act
->alignment_pow
= alignment_pow
;
6724 act
->action
= action
;
6725 act
->offset
= offset
;
6726 act
->removed_bytes
= removed_bytes
;
6727 act
->do_action
= do_action
;
6733 /* Access to internal relocations, section contents and symbols. */
6735 /* During relaxation, we need to modify relocations, section contents,
6736 and symbol definitions, and we need to keep the original values from
6737 being reloaded from the input files, i.e., we need to "pin" the
6738 modified values in memory. We also want to continue to observe the
6739 setting of the "keep-memory" flag. The following functions wrap the
6740 standard BFD functions to take care of this for us. */
6742 static Elf_Internal_Rela
*
6743 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6745 Elf_Internal_Rela
*internal_relocs
;
6747 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6750 internal_relocs
= elf_section_data (sec
)->relocs
;
6751 if (internal_relocs
== NULL
)
6752 internal_relocs
= (_bfd_elf_link_read_relocs
6753 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6754 return internal_relocs
;
6759 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6761 elf_section_data (sec
)->relocs
= internal_relocs
;
6766 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6768 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
6769 free (internal_relocs
);
6774 retrieve_contents (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6777 bfd_size_type sec_size
;
6779 sec_size
= bfd_get_section_limit (abfd
, sec
);
6780 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6782 if (contents
== NULL
&& sec_size
!= 0)
6784 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6790 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6797 pin_contents (asection
*sec
, bfd_byte
*contents
)
6799 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6804 release_contents (asection
*sec
, bfd_byte
*contents
)
6806 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6811 static Elf_Internal_Sym
*
6812 retrieve_local_syms (bfd
*input_bfd
)
6814 Elf_Internal_Shdr
*symtab_hdr
;
6815 Elf_Internal_Sym
*isymbuf
;
6818 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6819 locsymcount
= symtab_hdr
->sh_info
;
6821 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6822 if (isymbuf
== NULL
&& locsymcount
!= 0)
6823 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6826 /* Save the symbols for this input file so they won't be read again. */
6827 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6828 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6834 /* Code for link-time relaxation. */
6836 /* Initialization for relaxation: */
6837 static bfd_boolean
analyze_relocations (struct bfd_link_info
*);
6838 static bfd_boolean find_relaxable_sections
6839 (bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*);
6840 static bfd_boolean collect_source_relocs
6841 (bfd
*, asection
*, struct bfd_link_info
*);
6842 static bfd_boolean is_resolvable_asm_expansion
6843 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6845 static Elf_Internal_Rela
*find_associated_l32r_irel
6846 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6847 static bfd_boolean compute_text_actions
6848 (bfd
*, asection
*, struct bfd_link_info
*);
6849 static bfd_boolean
compute_ebb_proposed_actions (ebb_constraint
*);
6850 static bfd_boolean
compute_ebb_actions (ebb_constraint
*);
6851 typedef struct reloc_range_list_struct reloc_range_list
;
6852 static bfd_boolean check_section_ebb_pcrels_fit
6853 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6854 reloc_range_list
*, const ebb_constraint
*,
6855 const xtensa_opcode
*);
6856 static bfd_boolean
check_section_ebb_reduces (const ebb_constraint
*);
6857 static void text_action_add_proposed
6858 (text_action_list
*, const ebb_constraint
*, asection
*);
6861 static bfd_boolean compute_removed_literals
6862 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6863 static Elf_Internal_Rela
*get_irel_at_offset
6864 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6865 static bfd_boolean is_removable_literal
6866 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6867 property_table_entry
*, int);
6868 static bfd_boolean remove_dead_literal
6869 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6870 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6871 static bfd_boolean identify_literal_placement
6872 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6873 value_map_hash_table
*, bfd_boolean
*, Elf_Internal_Rela
*, int,
6874 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6876 static bfd_boolean
relocations_reach (source_reloc
*, int, const r_reloc
*);
6877 static bfd_boolean coalesce_shared_literal
6878 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6879 static bfd_boolean move_shared_literal
6880 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6881 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6884 static bfd_boolean
relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6885 static bfd_boolean
translate_section_fixes (asection
*);
6886 static bfd_boolean
translate_reloc_bfd_fix (reloc_bfd_fix
*);
6887 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6888 static void shrink_dynamic_reloc_sections
6889 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6890 static bfd_boolean move_literal
6891 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6892 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6893 static bfd_boolean relax_property_section
6894 (bfd
*, asection
*, struct bfd_link_info
*);
6897 static bfd_boolean
relax_section_symbols (bfd
*, asection
*);
6901 elf_xtensa_relax_section (bfd
*abfd
,
6903 struct bfd_link_info
*link_info
,
6906 static value_map_hash_table
*values
= NULL
;
6907 static bfd_boolean relocations_analyzed
= FALSE
;
6908 xtensa_relax_info
*relax_info
;
6910 if (!relocations_analyzed
)
6912 /* Do some overall initialization for relaxation. */
6913 values
= value_map_hash_table_init ();
6916 relaxing_section
= TRUE
;
6917 if (!analyze_relocations (link_info
))
6919 relocations_analyzed
= TRUE
;
6923 /* Don't mess with linker-created sections. */
6924 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6927 relax_info
= get_xtensa_relax_info (sec
);
6928 BFD_ASSERT (relax_info
!= NULL
);
6930 switch (relax_info
->visited
)
6933 /* Note: It would be nice to fold this pass into
6934 analyze_relocations, but it is important for this step that the
6935 sections be examined in link order. */
6936 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6943 value_map_hash_table_delete (values
);
6945 if (!relax_section (abfd
, sec
, link_info
))
6951 if (!relax_section_symbols (abfd
, sec
))
6956 relax_info
->visited
++;
6961 /* Initialization for relaxation. */
6963 /* This function is called once at the start of relaxation. It scans
6964 all the input sections and marks the ones that are relaxable (i.e.,
6965 literal sections with L32R relocations against them), and then
6966 collects source_reloc information for all the relocations against
6967 those relaxable sections. During this process, it also detects
6968 longcalls, i.e., calls relaxed by the assembler into indirect
6969 calls, that can be optimized back into direct calls. Within each
6970 extended basic block (ebb) containing an optimized longcall, it
6971 computes a set of "text actions" that can be performed to remove
6972 the L32R associated with the longcall while optionally preserving
6973 branch target alignments. */
6976 analyze_relocations (struct bfd_link_info
*link_info
)
6980 bfd_boolean is_relaxable
= FALSE
;
6982 /* Initialize the per-section relaxation info. */
6983 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6984 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6986 init_xtensa_relax_info (sec
);
6989 /* Mark relaxable sections (and count relocations against each one). */
6990 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6991 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6993 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
6997 /* Bail out if there are no relaxable sections. */
7001 /* Allocate space for source_relocs. */
7002 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7003 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7005 xtensa_relax_info
*relax_info
;
7007 relax_info
= get_xtensa_relax_info (sec
);
7008 if (relax_info
->is_relaxable_literal_section
7009 || relax_info
->is_relaxable_asm_section
)
7011 relax_info
->src_relocs
= (source_reloc
*)
7012 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
7015 relax_info
->src_count
= 0;
7018 /* Collect info on relocations against each relaxable section. */
7019 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7020 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7022 if (!collect_source_relocs (abfd
, sec
, link_info
))
7026 /* Compute the text actions. */
7027 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7028 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7030 if (!compute_text_actions (abfd
, sec
, link_info
))
7038 /* Find all the sections that might be relaxed. The motivation for
7039 this pass is that collect_source_relocs() needs to record _all_ the
7040 relocations that target each relaxable section. That is expensive
7041 and unnecessary unless the target section is actually going to be
7042 relaxed. This pass identifies all such sections by checking if
7043 they have L32Rs pointing to them. In the process, the total number
7044 of relocations targeting each section is also counted so that we
7045 know how much space to allocate for source_relocs against each
7046 relaxable literal section. */
7049 find_relaxable_sections (bfd
*abfd
,
7051 struct bfd_link_info
*link_info
,
7052 bfd_boolean
*is_relaxable_p
)
7054 Elf_Internal_Rela
*internal_relocs
;
7056 bfd_boolean ok
= TRUE
;
7058 xtensa_relax_info
*source_relax_info
;
7059 bfd_boolean is_l32r_reloc
;
7061 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7062 link_info
->keep_memory
);
7063 if (internal_relocs
== NULL
)
7066 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7067 if (contents
== NULL
&& sec
->size
!= 0)
7073 source_relax_info
= get_xtensa_relax_info (sec
);
7074 for (i
= 0; i
< sec
->reloc_count
; i
++)
7076 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7078 asection
*target_sec
;
7079 xtensa_relax_info
*target_relax_info
;
7081 /* If this section has not already been marked as "relaxable", and
7082 if it contains any ASM_EXPAND relocations (marking expanded
7083 longcalls) that can be optimized into direct calls, then mark
7084 the section as "relaxable". */
7085 if (source_relax_info
7086 && !source_relax_info
->is_relaxable_asm_section
7087 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
7089 bfd_boolean is_reachable
= FALSE
;
7090 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
7091 link_info
, &is_reachable
)
7094 source_relax_info
->is_relaxable_asm_section
= TRUE
;
7095 *is_relaxable_p
= TRUE
;
7099 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7100 bfd_get_section_limit (abfd
, sec
));
7102 target_sec
= r_reloc_get_section (&r_rel
);
7103 target_relax_info
= get_xtensa_relax_info (target_sec
);
7104 if (!target_relax_info
)
7107 /* Count PC-relative operand relocations against the target section.
7108 Note: The conditions tested here must match the conditions under
7109 which init_source_reloc is called in collect_source_relocs(). */
7110 is_l32r_reloc
= FALSE
;
7111 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7113 xtensa_opcode opcode
=
7114 get_relocation_opcode (abfd
, sec
, contents
, irel
);
7115 if (opcode
!= XTENSA_UNDEFINED
)
7117 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
7118 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
7120 target_relax_info
->src_count
++;
7124 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7126 /* Mark the target section as relaxable. */
7127 target_relax_info
->is_relaxable_literal_section
= TRUE
;
7128 *is_relaxable_p
= TRUE
;
7133 release_contents (sec
, contents
);
7134 release_internal_relocs (sec
, internal_relocs
);
7139 /* Record _all_ the relocations that point to relaxable sections, and
7140 get rid of ASM_EXPAND relocs by either converting them to
7141 ASM_SIMPLIFY or by removing them. */
7144 collect_source_relocs (bfd
*abfd
,
7146 struct bfd_link_info
*link_info
)
7148 Elf_Internal_Rela
*internal_relocs
;
7150 bfd_boolean ok
= TRUE
;
7152 bfd_size_type sec_size
;
7154 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7155 link_info
->keep_memory
);
7156 if (internal_relocs
== NULL
)
7159 sec_size
= bfd_get_section_limit (abfd
, sec
);
7160 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7161 if (contents
== NULL
&& sec_size
!= 0)
7167 /* Record relocations against relaxable literal sections. */
7168 for (i
= 0; i
< sec
->reloc_count
; i
++)
7170 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7172 asection
*target_sec
;
7173 xtensa_relax_info
*target_relax_info
;
7175 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7177 target_sec
= r_reloc_get_section (&r_rel
);
7178 target_relax_info
= get_xtensa_relax_info (target_sec
);
7180 if (target_relax_info
7181 && (target_relax_info
->is_relaxable_literal_section
7182 || target_relax_info
->is_relaxable_asm_section
))
7184 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7186 bfd_boolean is_abs_literal
= FALSE
;
7188 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7190 /* None of the current alternate relocs are PC-relative,
7191 and only PC-relative relocs matter here. However, we
7192 still need to record the opcode for literal
7194 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7195 if (opcode
== get_l32r_opcode ())
7197 is_abs_literal
= TRUE
;
7201 opcode
= XTENSA_UNDEFINED
;
7203 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7205 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7206 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7209 if (opcode
!= XTENSA_UNDEFINED
)
7211 int src_next
= target_relax_info
->src_next
++;
7212 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7214 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7220 /* Now get rid of ASM_EXPAND relocations. At this point, the
7221 src_relocs array for the target literal section may still be
7222 incomplete, but it must at least contain the entries for the L32R
7223 relocations associated with ASM_EXPANDs because they were just
7224 added in the preceding loop over the relocations. */
7226 for (i
= 0; i
< sec
->reloc_count
; i
++)
7228 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7229 bfd_boolean is_reachable
;
7231 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7237 Elf_Internal_Rela
*l32r_irel
;
7239 asection
*target_sec
;
7240 xtensa_relax_info
*target_relax_info
;
7242 /* Mark the source_reloc for the L32R so that it will be
7243 removed in compute_removed_literals(), along with the
7244 associated literal. */
7245 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7246 irel
, internal_relocs
);
7247 if (l32r_irel
== NULL
)
7250 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7252 target_sec
= r_reloc_get_section (&r_rel
);
7253 target_relax_info
= get_xtensa_relax_info (target_sec
);
7255 if (target_relax_info
7256 && (target_relax_info
->is_relaxable_literal_section
7257 || target_relax_info
->is_relaxable_asm_section
))
7259 source_reloc
*s_reloc
;
7261 /* Search the source_relocs for the entry corresponding to
7262 the l32r_irel. Note: The src_relocs array is not yet
7263 sorted, but it wouldn't matter anyway because we're
7264 searching by source offset instead of target offset. */
7265 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7266 target_relax_info
->src_next
,
7268 BFD_ASSERT (s_reloc
);
7269 s_reloc
->is_null
= TRUE
;
7272 /* Convert this reloc to ASM_SIMPLIFY. */
7273 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7274 R_XTENSA_ASM_SIMPLIFY
);
7275 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7277 pin_internal_relocs (sec
, internal_relocs
);
7281 /* It is resolvable but doesn't reach. We resolve now
7282 by eliminating the relocation -- the call will remain
7283 expanded into L32R/CALLX. */
7284 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7285 pin_internal_relocs (sec
, internal_relocs
);
7290 release_contents (sec
, contents
);
7291 release_internal_relocs (sec
, internal_relocs
);
7296 /* Return TRUE if the asm expansion can be resolved. Generally it can
7297 be resolved on a final link or when a partial link locates it in the
7298 same section as the target. Set "is_reachable" flag if the target of
7299 the call is within the range of a direct call, given the current VMA
7300 for this section and the target section. */
7303 is_resolvable_asm_expansion (bfd
*abfd
,
7306 Elf_Internal_Rela
*irel
,
7307 struct bfd_link_info
*link_info
,
7308 bfd_boolean
*is_reachable_p
)
7310 asection
*target_sec
;
7314 unsigned int first_align
;
7315 unsigned int adjust
;
7316 bfd_vma target_offset
;
7318 xtensa_opcode opcode
, direct_call_opcode
;
7319 bfd_vma self_address
;
7320 bfd_vma dest_address
;
7321 bfd_boolean uses_l32r
;
7322 bfd_size_type sec_size
;
7324 *is_reachable_p
= FALSE
;
7326 if (contents
== NULL
)
7329 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7332 sec_size
= bfd_get_section_limit (abfd
, sec
);
7333 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7334 sec_size
- irel
->r_offset
, &uses_l32r
);
7335 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7339 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7340 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7343 /* Check and see that the target resolves. */
7344 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7345 if (!r_reloc_is_defined (&r_rel
))
7348 target_sec
= r_reloc_get_section (&r_rel
);
7349 target_offset
= r_rel
.target_offset
;
7351 /* If the target is in a shared library, then it doesn't reach. This
7352 isn't supposed to come up because the compiler should never generate
7353 non-PIC calls on systems that use shared libraries, but the linker
7354 shouldn't crash regardless. */
7355 if (!target_sec
->output_section
)
7358 /* For relocatable sections, we can only simplify when the output
7359 section of the target is the same as the output section of the
7361 if (bfd_link_relocatable (link_info
)
7362 && (target_sec
->output_section
!= sec
->output_section
7363 || is_reloc_sym_weak (abfd
, irel
)))
7366 if (target_sec
->output_section
!= sec
->output_section
)
7368 /* If the two sections are sufficiently far away that relaxation
7369 might take the call out of range, we can't simplify. For
7370 example, a positive displacement call into another memory
7371 could get moved to a lower address due to literal removal,
7372 but the destination won't move, and so the displacment might
7375 If the displacement is negative, assume the destination could
7376 move as far back as the start of the output section. The
7377 self_address will be at least as far into the output section
7378 as it is prior to relaxation.
7380 If the displacement is postive, assume the destination will be in
7381 it's pre-relaxed location (because relaxation only makes sections
7382 smaller). The self_address could go all the way to the beginning
7383 of the output section. */
7385 dest_address
= target_sec
->output_section
->vma
;
7386 self_address
= sec
->output_section
->vma
;
7388 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7389 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7391 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7392 /* Call targets should be four-byte aligned. */
7393 dest_address
= (dest_address
+ 3) & ~3;
7398 self_address
= (sec
->output_section
->vma
7399 + sec
->output_offset
+ irel
->r_offset
+ 3);
7400 dest_address
= (target_sec
->output_section
->vma
7401 + target_sec
->output_offset
+ target_offset
);
7404 /* Adjust addresses with alignments for the worst case to see if call insn
7405 can fit. Don't relax l32r + callx to call if the target can be out of
7406 range due to alignment.
7407 Caller and target addresses are highest and lowest address.
7408 Search all sections between caller and target, looking for max alignment.
7409 The adjustment is max alignment bytes. If the alignment at the lowest
7410 address is less than the adjustment, apply the adjustment to highest
7413 /* Start from lowest address.
7414 Lowest address aligmnet is from input section.
7415 Initial alignment (adjust) is from input section. */
7416 if (dest_address
> self_address
)
7418 s
= sec
->output_section
;
7419 last_vma
= dest_address
;
7420 first_align
= sec
->alignment_power
;
7421 adjust
= target_sec
->alignment_power
;
7425 s
= target_sec
->output_section
;
7426 last_vma
= self_address
;
7427 first_align
= target_sec
->alignment_power
;
7428 adjust
= sec
->alignment_power
;
7433 /* Find the largest alignment in output section list. */
7434 for (; s
&& s
->vma
>= first_vma
&& s
->vma
<= last_vma
; s
= s
->next
)
7436 if (s
->alignment_power
> adjust
)
7437 adjust
= s
->alignment_power
;
7440 if (adjust
> first_align
)
7442 /* Alignment may enlarge the range, adjust highest address. */
7443 adjust
= 1 << adjust
;
7444 if (dest_address
> self_address
)
7446 dest_address
+= adjust
;
7450 self_address
+= adjust
;
7454 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7455 self_address
, dest_address
);
7457 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7458 (dest_address
>> CALL_SEGMENT_BITS
))
7465 static Elf_Internal_Rela
*
7466 find_associated_l32r_irel (bfd
*abfd
,
7469 Elf_Internal_Rela
*other_irel
,
7470 Elf_Internal_Rela
*internal_relocs
)
7474 for (i
= 0; i
< sec
->reloc_count
; i
++)
7476 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7478 if (irel
== other_irel
)
7480 if (irel
->r_offset
!= other_irel
->r_offset
)
7482 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7490 static xtensa_opcode
*
7491 build_reloc_opcodes (bfd
*abfd
,
7494 Elf_Internal_Rela
*internal_relocs
)
7497 xtensa_opcode
*reloc_opcodes
=
7498 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7499 for (i
= 0; i
< sec
->reloc_count
; i
++)
7501 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7502 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7504 return reloc_opcodes
;
7507 struct reloc_range_struct
7510 bfd_boolean add
; /* TRUE if start of a range, FALSE otherwise. */
7511 /* Original irel index in the array of relocations for a section. */
7512 unsigned irel_index
;
7514 typedef struct reloc_range_struct reloc_range
;
7516 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7517 struct reloc_range_list_entry_struct
7519 reloc_range_list_entry
*next
;
7520 reloc_range_list_entry
*prev
;
7521 Elf_Internal_Rela
*irel
;
7522 xtensa_opcode opcode
;
7526 struct reloc_range_list_struct
7528 /* The rest of the structure is only meaningful when ok is TRUE. */
7531 unsigned n_range
; /* Number of range markers. */
7532 reloc_range
*range
; /* Sorted range markers. */
7534 unsigned first
; /* Index of a first range element in the list. */
7535 unsigned last
; /* One past index of a last range element in the list. */
7537 unsigned n_list
; /* Number of list elements. */
7538 reloc_range_list_entry
*reloc
; /* */
7539 reloc_range_list_entry list_root
;
7543 reloc_range_compare (const void *a
, const void *b
)
7545 const reloc_range
*ra
= a
;
7546 const reloc_range
*rb
= b
;
7548 if (ra
->addr
!= rb
->addr
)
7549 return ra
->addr
< rb
->addr
? -1 : 1;
7550 if (ra
->add
!= rb
->add
)
7551 return ra
->add
? -1 : 1;
7556 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7558 Elf_Internal_Rela
*internal_relocs
,
7559 xtensa_opcode
*reloc_opcodes
,
7560 reloc_range_list
*list
)
7565 reloc_range
*ranges
= NULL
;
7566 reloc_range_list_entry
*reloc
=
7567 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7569 memset (list
, 0, sizeof (*list
));
7572 for (i
= 0; i
< sec
->reloc_count
; i
++)
7574 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7575 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7576 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7579 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7580 || r_type
== R_XTENSA_32_PCREL
7581 || !howto
->pc_relative
)
7584 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7585 bfd_get_section_limit (abfd
, sec
));
7587 if (r_reloc_get_section (&r_rel
) != sec
)
7592 max_n
= (max_n
+ 2) * 2;
7593 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7596 ranges
[n
].addr
= irel
->r_offset
;
7597 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7599 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7600 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7602 ranges
[n
].irel_index
= i
;
7603 ranges
[n
+ 1].irel_index
= i
;
7607 reloc
[i
].irel
= irel
;
7609 /* Every relocation won't possibly be checked in the optimized version of
7610 check_section_ebb_pcrels_fit, so this needs to be done here. */
7611 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7613 /* None of the current alternate relocs are PC-relative,
7614 and only PC-relative relocs matter here. */
7618 xtensa_opcode opcode
;
7622 opcode
= reloc_opcodes
[i
];
7624 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7626 if (opcode
== XTENSA_UNDEFINED
)
7632 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7633 if (opnum
== XTENSA_UNDEFINED
)
7639 /* Record relocation opcode and opnum as we've calculated them
7640 anyway and they won't change. */
7641 reloc
[i
].opcode
= opcode
;
7642 reloc
[i
].opnum
= opnum
;
7648 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7649 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7652 list
->range
= ranges
;
7653 list
->reloc
= reloc
;
7654 list
->list_root
.prev
= &list
->list_root
;
7655 list
->list_root
.next
= &list
->list_root
;
7664 static void reloc_range_list_append (reloc_range_list
*list
,
7665 unsigned irel_index
)
7667 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7669 entry
->prev
= list
->list_root
.prev
;
7670 entry
->next
= &list
->list_root
;
7671 entry
->prev
->next
= entry
;
7672 entry
->next
->prev
= entry
;
7676 static void reloc_range_list_remove (reloc_range_list
*list
,
7677 unsigned irel_index
)
7679 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7681 entry
->next
->prev
= entry
->prev
;
7682 entry
->prev
->next
= entry
->next
;
7686 /* Update relocation list object so that it lists all relocations that cross
7687 [first; last] range. Range bounds should not decrease with successive
7689 static void reloc_range_list_update_range (reloc_range_list
*list
,
7690 bfd_vma first
, bfd_vma last
)
7692 /* This should not happen: EBBs are iterated from lower addresses to higher.
7693 But even if that happens there's no need to break: just flush current list
7694 and start from scratch. */
7695 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7696 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7701 list
->list_root
.next
= &list
->list_root
;
7702 list
->list_root
.prev
= &list
->list_root
;
7703 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7706 for (; list
->last
< list
->n_range
&&
7707 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7708 if (list
->range
[list
->last
].add
)
7709 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7711 for (; list
->first
< list
->n_range
&&
7712 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7713 if (!list
->range
[list
->first
].add
)
7714 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7717 static void free_reloc_range_list (reloc_range_list
*list
)
7723 /* The compute_text_actions function will build a list of potential
7724 transformation actions for code in the extended basic block of each
7725 longcall that is optimized to a direct call. From this list we
7726 generate a set of actions to actually perform that optimizes for
7727 space and, if not using size_opt, maintains branch target
7730 These actions to be performed are placed on a per-section list.
7731 The actual changes are performed by relax_section() in the second
7735 compute_text_actions (bfd
*abfd
,
7737 struct bfd_link_info
*link_info
)
7739 xtensa_opcode
*reloc_opcodes
= NULL
;
7740 xtensa_relax_info
*relax_info
;
7742 Elf_Internal_Rela
*internal_relocs
;
7743 bfd_boolean ok
= TRUE
;
7745 property_table_entry
*prop_table
= 0;
7747 bfd_size_type sec_size
;
7748 reloc_range_list relevant_relocs
;
7750 relax_info
= get_xtensa_relax_info (sec
);
7751 BFD_ASSERT (relax_info
);
7752 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7754 /* Do nothing if the section contains no optimized longcalls. */
7755 if (!relax_info
->is_relaxable_asm_section
)
7758 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7759 link_info
->keep_memory
);
7761 if (internal_relocs
)
7762 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7763 internal_reloc_compare
);
7765 sec_size
= bfd_get_section_limit (abfd
, sec
);
7766 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7767 if (contents
== NULL
&& sec_size
!= 0)
7773 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7774 XTENSA_PROP_SEC_NAME
, FALSE
);
7781 /* Precompute the opcode for each relocation. */
7782 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7784 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7787 for (i
= 0; i
< sec
->reloc_count
; i
++)
7789 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7791 property_table_entry
*the_entry
;
7794 ebb_constraint ebb_table
;
7795 bfd_size_type simplify_size
;
7797 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7799 r_offset
= irel
->r_offset
;
7801 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7802 if (simplify_size
== 0)
7805 /* xgettext:c-format */
7806 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7807 "XTENSA_ASM_SIMPLIFY relocation; "
7808 "possible configuration mismatch"),
7809 sec
->owner
, sec
, (uint64_t) r_offset
);
7813 /* If the instruction table is not around, then don't do this
7815 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7816 sec
->vma
+ irel
->r_offset
);
7817 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7819 text_action_add (&relax_info
->action_list
,
7820 ta_convert_longcall
, sec
, r_offset
,
7825 /* If the next longcall happens to be at the same address as an
7826 unreachable section of size 0, then skip forward. */
7827 ptbl_idx
= the_entry
- prop_table
;
7828 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7829 && the_entry
->size
== 0
7830 && ptbl_idx
+ 1 < ptblsize
7831 && (prop_table
[ptbl_idx
+ 1].address
7832 == prop_table
[ptbl_idx
].address
))
7838 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7839 /* NO_REORDER is OK */
7842 init_ebb_constraint (&ebb_table
);
7843 ebb
= &ebb_table
.ebb
;
7844 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7845 internal_relocs
, sec
->reloc_count
);
7846 ebb
->start_offset
= r_offset
+ simplify_size
;
7847 ebb
->end_offset
= r_offset
+ simplify_size
;
7848 ebb
->start_ptbl_idx
= ptbl_idx
;
7849 ebb
->end_ptbl_idx
= ptbl_idx
;
7850 ebb
->start_reloc_idx
= i
;
7851 ebb
->end_reloc_idx
= i
;
7853 if (!extend_ebb_bounds (ebb
)
7854 || !compute_ebb_proposed_actions (&ebb_table
)
7855 || !compute_ebb_actions (&ebb_table
)
7856 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7859 &ebb_table
, reloc_opcodes
)
7860 || !check_section_ebb_reduces (&ebb_table
))
7862 /* If anything goes wrong or we get unlucky and something does
7863 not fit, with our plan because of expansion between
7864 critical branches, just convert to a NOP. */
7866 text_action_add (&relax_info
->action_list
,
7867 ta_convert_longcall
, sec
, r_offset
, 0);
7868 i
= ebb_table
.ebb
.end_reloc_idx
;
7869 free_ebb_constraint (&ebb_table
);
7873 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7875 /* Update the index so we do not go looking at the relocations
7876 we have already processed. */
7877 i
= ebb_table
.ebb
.end_reloc_idx
;
7878 free_ebb_constraint (&ebb_table
);
7881 free_reloc_range_list (&relevant_relocs
);
7884 if (action_list_count (&relax_info
->action_list
))
7885 print_action_list (stderr
, &relax_info
->action_list
);
7889 release_contents (sec
, contents
);
7890 release_internal_relocs (sec
, internal_relocs
);
7892 free (reloc_opcodes
);
7898 /* Do not widen an instruction if it is preceeded by a
7899 loop opcode. It might cause misalignment. */
7902 prev_instr_is_a_loop (bfd_byte
*contents
,
7903 bfd_size_type content_length
,
7904 bfd_size_type offset
)
7906 xtensa_opcode prev_opcode
;
7910 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7911 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7915 /* Find all of the possible actions for an extended basic block. */
7918 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7920 const ebb_t
*ebb
= &ebb_table
->ebb
;
7921 unsigned rel_idx
= ebb
->start_reloc_idx
;
7922 property_table_entry
*entry
, *start_entry
, *end_entry
;
7924 xtensa_isa isa
= xtensa_default_isa
;
7926 static xtensa_insnbuf insnbuf
= NULL
;
7927 static xtensa_insnbuf slotbuf
= NULL
;
7929 if (insnbuf
== NULL
)
7931 insnbuf
= xtensa_insnbuf_alloc (isa
);
7932 slotbuf
= xtensa_insnbuf_alloc (isa
);
7935 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7936 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7938 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7940 bfd_vma start_offset
, end_offset
;
7941 bfd_size_type insn_len
;
7943 start_offset
= entry
->address
- ebb
->sec
->vma
;
7944 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7946 if (entry
== start_entry
)
7947 start_offset
= ebb
->start_offset
;
7948 if (entry
== end_entry
)
7949 end_offset
= ebb
->end_offset
;
7950 offset
= start_offset
;
7952 if (offset
== entry
->address
- ebb
->sec
->vma
7953 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7955 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7956 BFD_ASSERT (offset
!= end_offset
);
7957 if (offset
== end_offset
)
7960 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7965 if (check_branch_target_aligned_address (offset
, insn_len
))
7966 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7968 ebb_propose_action (ebb_table
, align_type
, 0,
7969 ta_none
, offset
, 0, TRUE
);
7972 while (offset
!= end_offset
)
7974 Elf_Internal_Rela
*irel
;
7975 xtensa_opcode opcode
;
7977 while (rel_idx
< ebb
->end_reloc_idx
7978 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7979 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7980 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
7981 != R_XTENSA_ASM_SIMPLIFY
))))
7984 /* Check for longcall. */
7985 irel
= &ebb
->relocs
[rel_idx
];
7986 if (irel
->r_offset
== offset
7987 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
7989 bfd_size_type simplify_size
;
7991 simplify_size
= get_asm_simplify_size (ebb
->contents
,
7992 ebb
->content_length
,
7994 if (simplify_size
== 0)
7997 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7998 ta_convert_longcall
, offset
, 0, TRUE
);
8000 offset
+= simplify_size
;
8004 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
8006 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
8007 ebb
->content_length
- offset
);
8008 fmt
= xtensa_format_decode (isa
, insnbuf
);
8009 if (fmt
== XTENSA_UNDEFINED
)
8011 insn_len
= xtensa_format_length (isa
, fmt
);
8012 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
8015 if (xtensa_format_num_slots (isa
, fmt
) != 1)
8021 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
8022 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
8023 if (opcode
== XTENSA_UNDEFINED
)
8026 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
8027 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8028 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
8030 /* Add an instruction narrow action. */
8031 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8032 ta_narrow_insn
, offset
, 0, FALSE
);
8034 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
8035 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
8036 && ! prev_instr_is_a_loop (ebb
->contents
,
8037 ebb
->content_length
, offset
))
8039 /* Add an instruction widen action. */
8040 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8041 ta_widen_insn
, offset
, 0, FALSE
);
8043 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
8045 /* Check for branch targets. */
8046 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
8047 ta_none
, offset
, 0, TRUE
);
8054 if (ebb
->ends_unreachable
)
8056 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8057 ta_fill
, ebb
->end_offset
, 0, TRUE
);
8064 /* xgettext:c-format */
8065 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
8066 "possible configuration mismatch"),
8067 ebb
->sec
->owner
, ebb
->sec
, (uint64_t) offset
);
8072 /* After all of the information has collected about the
8073 transformations possible in an EBB, compute the appropriate actions
8074 here in compute_ebb_actions. We still must check later to make
8075 sure that the actions do not break any relocations. The algorithm
8076 used here is pretty greedy. Basically, it removes as many no-ops
8077 as possible so that the end of the EBB has the same alignment
8078 characteristics as the original. First, it uses narrowing, then
8079 fill space at the end of the EBB, and finally widenings. If that
8080 does not work, it tries again with one fewer no-op removed. The
8081 optimization will only be performed if all of the branch targets
8082 that were aligned before transformation are also aligned after the
8085 When the size_opt flag is set, ignore the branch target alignments,
8086 narrow all wide instructions, and remove all no-ops unless the end
8087 of the EBB prevents it. */
8090 compute_ebb_actions (ebb_constraint
*ebb_table
)
8094 int removed_bytes
= 0;
8095 ebb_t
*ebb
= &ebb_table
->ebb
;
8096 unsigned seg_idx_start
= 0;
8097 unsigned seg_idx_end
= 0;
8099 /* We perform this like the assembler relaxation algorithm: Start by
8100 assuming all instructions are narrow and all no-ops removed; then
8103 /* For each segment of this that has a solid constraint, check to
8104 see if there are any combinations that will keep the constraint.
8106 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
8108 bfd_boolean requires_text_end_align
= FALSE
;
8109 unsigned longcall_count
= 0;
8110 unsigned longcall_convert_count
= 0;
8111 unsigned narrowable_count
= 0;
8112 unsigned narrowable_convert_count
= 0;
8113 unsigned widenable_count
= 0;
8114 unsigned widenable_convert_count
= 0;
8116 proposed_action
*action
= NULL
;
8117 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
8119 seg_idx_start
= seg_idx_end
;
8121 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
8123 action
= &ebb_table
->actions
[i
];
8124 if (action
->action
== ta_convert_longcall
)
8126 if (action
->action
== ta_narrow_insn
)
8128 if (action
->action
== ta_widen_insn
)
8130 if (action
->action
== ta_fill
)
8132 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8134 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
8135 && !elf32xtensa_size_opt
)
8140 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
8141 requires_text_end_align
= TRUE
;
8143 if (elf32xtensa_size_opt
&& !requires_text_end_align
8144 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
8145 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
8147 longcall_convert_count
= longcall_count
;
8148 narrowable_convert_count
= narrowable_count
;
8149 widenable_convert_count
= 0;
8153 /* There is a constraint. Convert the max number of longcalls. */
8154 narrowable_convert_count
= 0;
8155 longcall_convert_count
= 0;
8156 widenable_convert_count
= 0;
8158 for (j
= 0; j
< longcall_count
; j
++)
8160 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
8161 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
8162 unsigned desire_widen
= removed
;
8163 if (desire_narrow
<= narrowable_count
)
8165 narrowable_convert_count
= desire_narrow
;
8166 narrowable_convert_count
+=
8167 (align
* ((narrowable_count
- narrowable_convert_count
)
8169 longcall_convert_count
= (longcall_count
- j
);
8170 widenable_convert_count
= 0;
8173 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
8175 narrowable_convert_count
= 0;
8176 longcall_convert_count
= longcall_count
- j
;
8177 widenable_convert_count
= desire_widen
;
8183 /* Now the number of conversions are saved. Do them. */
8184 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
8186 action
= &ebb_table
->actions
[i
];
8187 switch (action
->action
)
8189 case ta_convert_longcall
:
8190 if (longcall_convert_count
!= 0)
8192 action
->action
= ta_remove_longcall
;
8193 action
->do_action
= TRUE
;
8194 action
->removed_bytes
+= 3;
8195 longcall_convert_count
--;
8198 case ta_narrow_insn
:
8199 if (narrowable_convert_count
!= 0)
8201 action
->do_action
= TRUE
;
8202 action
->removed_bytes
+= 1;
8203 narrowable_convert_count
--;
8207 if (widenable_convert_count
!= 0)
8209 action
->do_action
= TRUE
;
8210 action
->removed_bytes
-= 1;
8211 widenable_convert_count
--;
8220 /* Now we move on to some local opts. Try to remove each of the
8221 remaining longcalls. */
8223 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8226 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8228 int old_removed_bytes
= removed_bytes
;
8229 proposed_action
*action
= &ebb_table
->actions
[i
];
8231 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8233 bfd_boolean bad_alignment
= FALSE
;
8235 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8237 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8238 bfd_vma offset
= new_action
->offset
;
8239 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8241 if (!check_branch_target_aligned
8242 (ebb_table
->ebb
.contents
,
8243 ebb_table
->ebb
.content_length
,
8244 offset
, offset
- removed_bytes
))
8246 bad_alignment
= TRUE
;
8250 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8252 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8253 ebb_table
->ebb
.content_length
,
8255 offset
- removed_bytes
))
8257 bad_alignment
= TRUE
;
8261 if (new_action
->action
== ta_narrow_insn
8262 && !new_action
->do_action
8263 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8265 /* Narrow an instruction and we are done. */
8266 new_action
->do_action
= TRUE
;
8267 new_action
->removed_bytes
+= 1;
8268 bad_alignment
= FALSE
;
8271 if (new_action
->action
== ta_widen_insn
8272 && new_action
->do_action
8273 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8275 /* Narrow an instruction and we are done. */
8276 new_action
->do_action
= FALSE
;
8277 new_action
->removed_bytes
+= 1;
8278 bad_alignment
= FALSE
;
8281 if (new_action
->do_action
)
8282 removed_bytes
+= new_action
->removed_bytes
;
8286 action
->removed_bytes
+= 3;
8287 action
->action
= ta_remove_longcall
;
8288 action
->do_action
= TRUE
;
8291 removed_bytes
= old_removed_bytes
;
8292 if (action
->do_action
)
8293 removed_bytes
+= action
->removed_bytes
;
8298 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8300 proposed_action
*action
= &ebb_table
->actions
[i
];
8301 if (action
->do_action
)
8302 removed_bytes
+= action
->removed_bytes
;
8305 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8306 && ebb
->ends_unreachable
)
8308 proposed_action
*action
;
8312 BFD_ASSERT (ebb_table
->action_count
!= 0);
8313 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8314 BFD_ASSERT (action
->action
== ta_fill
);
8315 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8317 extra_space
= xtensa_compute_fill_extra_space (ebb
->ends_unreachable
);
8318 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8319 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8321 action
->removed_bytes
= extra_space
- br
;
8327 /* The xlate_map is a sorted array of address mappings designed to
8328 answer the offset_with_removed_text() query with a binary search instead
8329 of a linear search through the section's action_list. */
8331 typedef struct xlate_map_entry xlate_map_entry_t
;
8332 typedef struct xlate_map xlate_map_t
;
8334 struct xlate_map_entry
8336 bfd_vma orig_address
;
8337 bfd_vma new_address
;
8343 unsigned entry_count
;
8344 xlate_map_entry_t
*entry
;
8349 xlate_compare (const void *a_v
, const void *b_v
)
8351 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8352 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8353 if (a
->orig_address
< b
->orig_address
)
8355 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8362 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8363 text_action_list
*action_list
,
8367 xlate_map_entry_t
*e
;
8368 struct xlate_map_entry se
;
8371 return offset_with_removed_text (action_list
, offset
);
8373 if (map
->entry_count
== 0)
8376 se
.orig_address
= offset
;
8377 r
= bsearch (&se
, map
->entry
, map
->entry_count
,
8378 sizeof (xlate_map_entry_t
), &xlate_compare
);
8379 e
= (xlate_map_entry_t
*) r
;
8381 /* There could be a jump past the end of the section,
8382 allow it using the last xlate map entry to translate its address. */
8385 e
= map
->entry
+ map
->entry_count
- 1;
8386 if (xlate_compare (&se
, e
) <= 0)
8389 BFD_ASSERT (e
!= NULL
);
8392 return e
->new_address
- e
->orig_address
+ offset
;
8395 typedef struct xlate_map_context_struct xlate_map_context
;
8396 struct xlate_map_context_struct
8399 xlate_map_entry_t
*current_entry
;
8404 xlate_map_fn (splay_tree_node node
, void *p
)
8406 text_action
*r
= (text_action
*)node
->value
;
8407 xlate_map_context
*ctx
= p
;
8408 unsigned orig_size
= 0;
8413 case ta_remove_insn
:
8414 case ta_convert_longcall
:
8415 case ta_remove_literal
:
8416 case ta_add_literal
:
8418 case ta_remove_longcall
:
8421 case ta_narrow_insn
:
8430 ctx
->current_entry
->size
=
8431 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8432 if (ctx
->current_entry
->size
!= 0)
8434 ctx
->current_entry
++;
8435 ctx
->map
->entry_count
++;
8437 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8438 ctx
->removed
+= r
->removed_bytes
;
8439 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8440 ctx
->current_entry
->size
= 0;
8444 /* Build a binary searchable offset translation map from a section's
8447 static xlate_map_t
*
8448 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8450 text_action_list
*action_list
= &relax_info
->action_list
;
8451 unsigned num_actions
= 0;
8452 xlate_map_context ctx
;
8454 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8456 if (ctx
.map
== NULL
)
8459 num_actions
= action_list_count (action_list
);
8460 ctx
.map
->entry
= (xlate_map_entry_t
*)
8461 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8462 if (ctx
.map
->entry
== NULL
)
8467 ctx
.map
->entry_count
= 0;
8470 ctx
.current_entry
= &ctx
.map
->entry
[0];
8472 ctx
.current_entry
->orig_address
= 0;
8473 ctx
.current_entry
->new_address
= 0;
8474 ctx
.current_entry
->size
= 0;
8476 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8478 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8479 - ctx
.current_entry
->orig_address
);
8480 if (ctx
.current_entry
->size
!= 0)
8481 ctx
.map
->entry_count
++;
8487 /* Free an offset translation map. */
8490 free_xlate_map (xlate_map_t
*map
)
8500 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8501 relocations in a section will fit if a proposed set of actions
8505 check_section_ebb_pcrels_fit (bfd
*abfd
,
8508 Elf_Internal_Rela
*internal_relocs
,
8509 reloc_range_list
*relevant_relocs
,
8510 const ebb_constraint
*constraint
,
8511 const xtensa_opcode
*reloc_opcodes
)
8514 unsigned n
= sec
->reloc_count
;
8515 Elf_Internal_Rela
*irel
;
8516 xlate_map_t
*xmap
= NULL
;
8517 bfd_boolean ok
= TRUE
;
8518 xtensa_relax_info
*relax_info
;
8519 reloc_range_list_entry
*entry
= NULL
;
8521 relax_info
= get_xtensa_relax_info (sec
);
8523 if (relax_info
&& sec
->reloc_count
> 100)
8525 xmap
= build_xlate_map (sec
, relax_info
);
8526 /* NULL indicates out of memory, but the slow version
8527 can still be used. */
8530 if (relevant_relocs
&& constraint
->action_count
)
8532 if (!relevant_relocs
->ok
)
8539 bfd_vma min_offset
, max_offset
;
8540 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8542 for (i
= 1; i
< constraint
->action_count
; ++i
)
8544 proposed_action
*action
= &constraint
->actions
[i
];
8545 bfd_vma offset
= action
->offset
;
8547 if (offset
< min_offset
)
8548 min_offset
= offset
;
8549 if (offset
> max_offset
)
8550 max_offset
= offset
;
8552 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8554 n
= relevant_relocs
->n_list
;
8555 entry
= &relevant_relocs
->list_root
;
8560 relevant_relocs
= NULL
;
8563 for (i
= 0; i
< n
; i
++)
8566 bfd_vma orig_self_offset
, orig_target_offset
;
8567 bfd_vma self_offset
, target_offset
;
8569 reloc_howto_type
*howto
;
8570 int self_removed_bytes
, target_removed_bytes
;
8572 if (relevant_relocs
)
8574 entry
= entry
->next
;
8579 irel
= internal_relocs
+ i
;
8581 r_type
= ELF32_R_TYPE (irel
->r_info
);
8583 howto
= &elf_howto_table
[r_type
];
8584 /* We maintain the required invariant: PC-relative relocations
8585 that fit before linking must fit after linking. Thus we only
8586 need to deal with relocations to the same section that are
8588 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8589 || r_type
== R_XTENSA_32_PCREL
8590 || !howto
->pc_relative
)
8593 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8594 bfd_get_section_limit (abfd
, sec
));
8596 if (r_reloc_get_section (&r_rel
) != sec
)
8599 orig_self_offset
= irel
->r_offset
;
8600 orig_target_offset
= r_rel
.target_offset
;
8602 self_offset
= orig_self_offset
;
8603 target_offset
= orig_target_offset
;
8608 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8611 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8612 orig_target_offset
);
8615 self_removed_bytes
= 0;
8616 target_removed_bytes
= 0;
8618 for (j
= 0; j
< constraint
->action_count
; ++j
)
8620 proposed_action
*action
= &constraint
->actions
[j
];
8621 bfd_vma offset
= action
->offset
;
8622 int removed_bytes
= action
->removed_bytes
;
8623 if (offset
< orig_self_offset
8624 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8625 && action
->removed_bytes
< 0))
8626 self_removed_bytes
+= removed_bytes
;
8627 if (offset
< orig_target_offset
8628 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8629 && action
->removed_bytes
< 0))
8630 target_removed_bytes
+= removed_bytes
;
8632 self_offset
-= self_removed_bytes
;
8633 target_offset
-= target_removed_bytes
;
8635 /* Try to encode it. Get the operand and check. */
8636 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8638 /* None of the current alternate relocs are PC-relative,
8639 and only PC-relative relocs matter here. */
8643 xtensa_opcode opcode
;
8646 if (relevant_relocs
)
8648 opcode
= entry
->opcode
;
8649 opnum
= entry
->opnum
;
8654 opcode
= reloc_opcodes
[relevant_relocs
?
8655 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8657 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8658 if (opcode
== XTENSA_UNDEFINED
)
8664 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8665 if (opnum
== XTENSA_UNDEFINED
)
8672 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8680 free_xlate_map (xmap
);
8687 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8692 for (i
= 0; i
< constraint
->action_count
; i
++)
8694 const proposed_action
*action
= &constraint
->actions
[i
];
8695 if (action
->do_action
)
8696 removed
+= action
->removed_bytes
;
8706 text_action_add_proposed (text_action_list
*l
,
8707 const ebb_constraint
*ebb_table
,
8712 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8714 proposed_action
*action
= &ebb_table
->actions
[i
];
8716 if (!action
->do_action
)
8718 switch (action
->action
)
8720 case ta_remove_insn
:
8721 case ta_remove_longcall
:
8722 case ta_convert_longcall
:
8723 case ta_narrow_insn
:
8726 case ta_remove_literal
:
8727 text_action_add (l
, action
->action
, sec
, action
->offset
,
8728 action
->removed_bytes
);
8741 xtensa_compute_fill_extra_space (property_table_entry
*entry
)
8743 int fill_extra_space
;
8748 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8751 fill_extra_space
= entry
->size
;
8752 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8754 /* Fill bytes for alignment:
8755 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8756 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8757 int nsm
= (1 << pow
) - 1;
8758 bfd_vma addr
= entry
->address
+ entry
->size
;
8759 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8760 fill_extra_space
+= align_fill
;
8762 return fill_extra_space
;
8766 /* First relaxation pass. */
8768 /* If the section contains relaxable literals, check each literal to
8769 see if it has the same value as another literal that has already
8770 been seen, either in the current section or a previous one. If so,
8771 add an entry to the per-section list of removed literals. The
8772 actual changes are deferred until the next pass. */
8775 compute_removed_literals (bfd
*abfd
,
8777 struct bfd_link_info
*link_info
,
8778 value_map_hash_table
*values
)
8780 xtensa_relax_info
*relax_info
;
8782 Elf_Internal_Rela
*internal_relocs
;
8783 source_reloc
*src_relocs
, *rel
;
8784 bfd_boolean ok
= TRUE
;
8785 property_table_entry
*prop_table
= NULL
;
8788 bfd_boolean last_loc_is_prev
= FALSE
;
8789 bfd_vma last_target_offset
= 0;
8790 section_cache_t target_sec_cache
;
8791 bfd_size_type sec_size
;
8793 init_section_cache (&target_sec_cache
);
8795 /* Do nothing if it is not a relaxable literal section. */
8796 relax_info
= get_xtensa_relax_info (sec
);
8797 BFD_ASSERT (relax_info
);
8798 if (!relax_info
->is_relaxable_literal_section
)
8801 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8802 link_info
->keep_memory
);
8804 sec_size
= bfd_get_section_limit (abfd
, sec
);
8805 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8806 if (contents
== NULL
&& sec_size
!= 0)
8812 /* Sort the source_relocs by target offset. */
8813 src_relocs
= relax_info
->src_relocs
;
8814 qsort (src_relocs
, relax_info
->src_count
,
8815 sizeof (source_reloc
), source_reloc_compare
);
8816 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8817 internal_reloc_compare
);
8819 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8820 XTENSA_PROP_SEC_NAME
, FALSE
);
8828 for (i
= 0; i
< relax_info
->src_count
; i
++)
8830 Elf_Internal_Rela
*irel
= NULL
;
8832 rel
= &src_relocs
[i
];
8833 if (get_l32r_opcode () != rel
->opcode
)
8835 irel
= get_irel_at_offset (sec
, internal_relocs
,
8836 rel
->r_rel
.target_offset
);
8838 /* If the relocation on this is not a simple R_XTENSA_32 or
8839 R_XTENSA_PLT then do not consider it. This may happen when
8840 the difference of two symbols is used in a literal. */
8841 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8842 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8845 /* If the target_offset for this relocation is the same as the
8846 previous relocation, then we've already considered whether the
8847 literal can be coalesced. Skip to the next one.... */
8848 if (i
!= 0 && prev_i
!= -1
8849 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8853 if (last_loc_is_prev
&&
8854 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8855 last_loc_is_prev
= FALSE
;
8857 /* Check if the relocation was from an L32R that is being removed
8858 because a CALLX was converted to a direct CALL, and check if
8859 there are no other relocations to the literal. */
8860 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8861 sec
, prop_table
, ptblsize
))
8863 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8864 irel
, rel
, prop_table
, ptblsize
))
8869 last_target_offset
= rel
->r_rel
.target_offset
;
8873 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8875 &last_loc_is_prev
, irel
,
8876 relax_info
->src_count
- i
, rel
,
8877 prop_table
, ptblsize
,
8878 &target_sec_cache
, rel
->is_abs_literal
))
8883 last_target_offset
= rel
->r_rel
.target_offset
;
8887 print_removed_literals (stderr
, &relax_info
->removed_list
);
8888 print_action_list (stderr
, &relax_info
->action_list
);
8893 free_section_cache (&target_sec_cache
);
8895 release_contents (sec
, contents
);
8896 release_internal_relocs (sec
, internal_relocs
);
8901 static Elf_Internal_Rela
*
8902 get_irel_at_offset (asection
*sec
,
8903 Elf_Internal_Rela
*internal_relocs
,
8907 Elf_Internal_Rela
*irel
;
8909 Elf_Internal_Rela key
;
8911 if (!internal_relocs
)
8914 key
.r_offset
= offset
;
8915 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8916 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8920 /* bsearch does not guarantee which will be returned if there are
8921 multiple matches. We need the first that is not an alignment. */
8922 i
= irel
- internal_relocs
;
8925 if (internal_relocs
[i
-1].r_offset
!= offset
)
8929 for ( ; i
< sec
->reloc_count
; i
++)
8931 irel
= &internal_relocs
[i
];
8932 r_type
= ELF32_R_TYPE (irel
->r_info
);
8933 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8942 is_removable_literal (const source_reloc
*rel
,
8944 const source_reloc
*src_relocs
,
8947 property_table_entry
*prop_table
,
8950 const source_reloc
*curr_rel
;
8951 property_table_entry
*entry
;
8956 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8957 sec
->vma
+ rel
->r_rel
.target_offset
);
8958 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8961 for (++i
; i
< src_count
; ++i
)
8963 curr_rel
= &src_relocs
[i
];
8964 /* If all others have the same target offset.... */
8965 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8968 if (!curr_rel
->is_null
8969 && !xtensa_is_property_section (curr_rel
->source_sec
)
8970 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8978 remove_dead_literal (bfd
*abfd
,
8980 struct bfd_link_info
*link_info
,
8981 Elf_Internal_Rela
*internal_relocs
,
8982 Elf_Internal_Rela
*irel
,
8984 property_table_entry
*prop_table
,
8987 property_table_entry
*entry
;
8988 xtensa_relax_info
*relax_info
;
8990 relax_info
= get_xtensa_relax_info (sec
);
8994 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8995 sec
->vma
+ rel
->r_rel
.target_offset
);
8997 /* Mark the unused literal so that it will be removed. */
8998 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
9000 text_action_add (&relax_info
->action_list
,
9001 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9003 /* If the section is 4-byte aligned, do not add fill. */
9004 if (sec
->alignment_power
> 2)
9006 int fill_extra_space
;
9007 bfd_vma entry_sec_offset
;
9009 property_table_entry
*the_add_entry
;
9013 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9015 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9017 /* If the literal range is at the end of the section,
9019 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9021 fill_extra_space
= xtensa_compute_fill_extra_space (the_add_entry
);
9023 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9024 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9025 -4, fill_extra_space
);
9027 adjust_fill_action (fa
, removed_diff
);
9029 text_action_add (&relax_info
->action_list
,
9030 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9033 /* Zero out the relocation on this literal location. */
9036 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9037 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9039 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9040 pin_internal_relocs (sec
, internal_relocs
);
9043 /* Do not modify "last_loc_is_prev". */
9049 identify_literal_placement (bfd
*abfd
,
9052 struct bfd_link_info
*link_info
,
9053 value_map_hash_table
*values
,
9054 bfd_boolean
*last_loc_is_prev_p
,
9055 Elf_Internal_Rela
*irel
,
9056 int remaining_src_rels
,
9058 property_table_entry
*prop_table
,
9060 section_cache_t
*target_sec_cache
,
9061 bfd_boolean is_abs_literal
)
9065 xtensa_relax_info
*relax_info
;
9066 bfd_boolean literal_placed
= FALSE
;
9068 unsigned long value
;
9069 bfd_boolean final_static_link
;
9070 bfd_size_type sec_size
;
9072 relax_info
= get_xtensa_relax_info (sec
);
9076 sec_size
= bfd_get_section_limit (abfd
, sec
);
9079 (!bfd_link_relocatable (link_info
)
9080 && !elf_hash_table (link_info
)->dynamic_sections_created
);
9082 /* The placement algorithm first checks to see if the literal is
9083 already in the value map. If so and the value map is reachable
9084 from all uses, then the literal is moved to that location. If
9085 not, then we identify the last location where a fresh literal was
9086 placed. If the literal can be safely moved there, then we do so.
9087 If not, then we assume that the literal is not to move and leave
9088 the literal where it is, marking it as the last literal
9091 /* Find the literal value. */
9093 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9096 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
9097 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
9099 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
9101 /* Check if we've seen another literal with the same value that
9102 is in the same output section. */
9103 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
9106 && (r_reloc_get_section (&val_map
->loc
)->output_section
9107 == sec
->output_section
)
9108 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
9109 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
9111 /* No change to last_loc_is_prev. */
9112 literal_placed
= TRUE
;
9115 /* For relocatable links, do not try to move literals. To do it
9116 correctly might increase the number of relocations in an input
9117 section making the default relocatable linking fail. */
9118 if (!bfd_link_relocatable (link_info
) && !literal_placed
9119 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
9121 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
9122 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
9124 /* Increment the virtual offset. */
9125 r_reloc try_loc
= values
->last_loc
;
9126 try_loc
.virtual_offset
+= 4;
9128 /* There is a last loc that was in the same output section. */
9129 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
9130 && move_shared_literal (sec
, link_info
, rel
,
9131 prop_table
, ptblsize
,
9132 &try_loc
, &val
, target_sec_cache
))
9134 values
->last_loc
.virtual_offset
+= 4;
9135 literal_placed
= TRUE
;
9137 val_map
= add_value_map (values
, &val
, &try_loc
,
9140 val_map
->loc
= try_loc
;
9145 if (!literal_placed
)
9147 /* Nothing worked, leave the literal alone but update the last loc. */
9148 values
->has_last_loc
= TRUE
;
9149 values
->last_loc
= rel
->r_rel
;
9151 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
9153 val_map
->loc
= rel
->r_rel
;
9154 *last_loc_is_prev_p
= TRUE
;
9161 /* Check if the original relocations (presumably on L32R instructions)
9162 identified by reloc[0..N] can be changed to reference the literal
9163 identified by r_rel. If r_rel is out of range for any of the
9164 original relocations, then we don't want to coalesce the original
9165 literal with the one at r_rel. We only check reloc[0..N], where the
9166 offsets are all the same as for reloc[0] (i.e., they're all
9167 referencing the same literal) and where N is also bounded by the
9168 number of remaining entries in the "reloc" array. The "reloc" array
9169 is sorted by target offset so we know all the entries for the same
9170 literal will be contiguous. */
9173 relocations_reach (source_reloc
*reloc
,
9174 int remaining_relocs
,
9175 const r_reloc
*r_rel
)
9177 bfd_vma from_offset
, source_address
, dest_address
;
9181 if (!r_reloc_is_defined (r_rel
))
9184 sec
= r_reloc_get_section (r_rel
);
9185 from_offset
= reloc
[0].r_rel
.target_offset
;
9187 for (i
= 0; i
< remaining_relocs
; i
++)
9189 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9192 /* Ignore relocations that have been removed. */
9193 if (reloc
[i
].is_null
)
9196 /* The original and new output section for these must be the same
9197 in order to coalesce. */
9198 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9199 != sec
->output_section
)
9202 /* Absolute literals in the same output section can always be
9204 if (reloc
[i
].is_abs_literal
)
9207 /* A literal with no PC-relative relocations can be moved anywhere. */
9208 if (reloc
[i
].opnd
!= -1)
9210 /* Otherwise, check to see that it fits. */
9211 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9212 + reloc
[i
].source_sec
->output_offset
9213 + reloc
[i
].r_rel
.rela
.r_offset
);
9214 dest_address
= (sec
->output_section
->vma
9215 + sec
->output_offset
9216 + r_rel
->target_offset
);
9218 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9219 source_address
, dest_address
))
9228 /* Move a literal to another literal location because it is
9229 the same as the other literal value. */
9232 coalesce_shared_literal (asection
*sec
,
9234 property_table_entry
*prop_table
,
9238 property_table_entry
*entry
;
9240 property_table_entry
*the_add_entry
;
9242 xtensa_relax_info
*relax_info
;
9244 relax_info
= get_xtensa_relax_info (sec
);
9248 entry
= elf_xtensa_find_property_entry
9249 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9250 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9253 /* Mark that the literal will be coalesced. */
9254 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9256 text_action_add (&relax_info
->action_list
,
9257 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9259 /* If the section is 4-byte aligned, do not add fill. */
9260 if (sec
->alignment_power
> 2)
9262 int fill_extra_space
;
9263 bfd_vma entry_sec_offset
;
9266 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9268 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9270 /* If the literal range is at the end of the section,
9272 fill_extra_space
= 0;
9273 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9275 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9276 fill_extra_space
= the_add_entry
->size
;
9278 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9279 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9280 -4, fill_extra_space
);
9282 adjust_fill_action (fa
, removed_diff
);
9284 text_action_add (&relax_info
->action_list
,
9285 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9292 /* Move a literal to another location. This may actually increase the
9293 total amount of space used because of alignments so we need to do
9294 this carefully. Also, it may make a branch go out of range. */
9297 move_shared_literal (asection
*sec
,
9298 struct bfd_link_info
*link_info
,
9300 property_table_entry
*prop_table
,
9302 const r_reloc
*target_loc
,
9303 const literal_value
*lit_value
,
9304 section_cache_t
*target_sec_cache
)
9306 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9307 text_action
*fa
, *target_fa
;
9309 xtensa_relax_info
*relax_info
, *target_relax_info
;
9310 asection
*target_sec
;
9312 ebb_constraint ebb_table
;
9313 bfd_boolean relocs_fit
;
9315 /* If this routine always returns FALSE, the literals that cannot be
9316 coalesced will not be moved. */
9317 if (elf32xtensa_no_literal_movement
)
9320 relax_info
= get_xtensa_relax_info (sec
);
9324 target_sec
= r_reloc_get_section (target_loc
);
9325 target_relax_info
= get_xtensa_relax_info (target_sec
);
9327 /* Literals to undefined sections may not be moved because they
9328 must report an error. */
9329 if (bfd_is_und_section (target_sec
))
9332 src_entry
= elf_xtensa_find_property_entry
9333 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9335 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9338 target_entry
= elf_xtensa_find_property_entry
9339 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9340 target_sec
->vma
+ target_loc
->target_offset
);
9345 /* Make sure that we have not broken any branches. */
9348 init_ebb_constraint (&ebb_table
);
9349 ebb
= &ebb_table
.ebb
;
9350 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9351 target_sec_cache
->content_length
,
9352 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9353 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9355 /* Propose to add 4 bytes + worst-case alignment size increase to
9357 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9358 ta_fill
, target_loc
->target_offset
,
9359 -4 - (1 << target_sec
->alignment_power
), TRUE
);
9361 /* Check all of the PC-relative relocations to make sure they still fit. */
9362 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9363 target_sec_cache
->contents
,
9364 target_sec_cache
->relocs
, NULL
,
9370 text_action_add_literal (&target_relax_info
->action_list
,
9371 ta_add_literal
, target_loc
, lit_value
, -4);
9373 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9375 /* May need to add or remove some fill to maintain alignment. */
9376 int fill_extra_space
;
9377 bfd_vma entry_sec_offset
;
9380 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9382 /* If the literal range is at the end of the section,
9384 fill_extra_space
= 0;
9386 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9387 target_sec_cache
->pte_count
,
9389 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9390 fill_extra_space
= the_add_entry
->size
;
9392 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9393 target_sec
, entry_sec_offset
);
9394 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9395 entry_sec_offset
, 4,
9398 adjust_fill_action (target_fa
, removed_diff
);
9400 text_action_add (&target_relax_info
->action_list
,
9401 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9404 /* Mark that the literal will be moved to the new location. */
9405 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9407 /* Remove the literal. */
9408 text_action_add (&relax_info
->action_list
,
9409 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9411 /* If the section is 4-byte aligned, do not add fill. */
9412 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9414 int fill_extra_space
;
9415 bfd_vma entry_sec_offset
;
9418 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9420 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9422 /* If the literal range is at the end of the section,
9424 fill_extra_space
= 0;
9425 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9427 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9428 fill_extra_space
= the_add_entry
->size
;
9430 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9431 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9432 -4, fill_extra_space
);
9434 adjust_fill_action (fa
, removed_diff
);
9436 text_action_add (&relax_info
->action_list
,
9437 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9444 /* Second relaxation pass. */
9447 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9449 bfd_size_type
*final_size
= p
;
9450 text_action
*action
= (text_action
*)node
->value
;
9452 *final_size
-= action
->removed_bytes
;
9456 /* Modify all of the relocations to point to the right spot, and if this
9457 is a relaxable section, delete the unwanted literals and fix the
9461 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9463 Elf_Internal_Rela
*internal_relocs
;
9464 xtensa_relax_info
*relax_info
;
9466 bfd_boolean ok
= TRUE
;
9468 bfd_boolean rv
= FALSE
;
9469 bfd_boolean virtual_action
;
9470 bfd_size_type sec_size
;
9472 sec_size
= bfd_get_section_limit (abfd
, sec
);
9473 relax_info
= get_xtensa_relax_info (sec
);
9474 BFD_ASSERT (relax_info
);
9476 /* First translate any of the fixes that have been added already. */
9477 translate_section_fixes (sec
);
9479 /* Handle property sections (e.g., literal tables) specially. */
9480 if (xtensa_is_property_section (sec
))
9482 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9483 return relax_property_section (abfd
, sec
, link_info
);
9486 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9487 link_info
->keep_memory
);
9488 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9491 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9492 if (contents
== NULL
&& sec_size
!= 0)
9498 if (internal_relocs
)
9500 for (i
= 0; i
< sec
->reloc_count
; i
++)
9502 Elf_Internal_Rela
*irel
;
9503 xtensa_relax_info
*target_relax_info
;
9504 bfd_vma source_offset
, old_source_offset
;
9507 asection
*target_sec
;
9509 /* Locally change the source address.
9510 Translate the target to the new target address.
9511 If it points to this section and has been removed,
9515 irel
= &internal_relocs
[i
];
9516 source_offset
= irel
->r_offset
;
9517 old_source_offset
= source_offset
;
9519 r_type
= ELF32_R_TYPE (irel
->r_info
);
9520 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9521 bfd_get_section_limit (abfd
, sec
));
9523 /* If this section could have changed then we may need to
9524 change the relocation's offset. */
9526 if (relax_info
->is_relaxable_literal_section
9527 || relax_info
->is_relaxable_asm_section
)
9529 pin_internal_relocs (sec
, internal_relocs
);
9531 if (r_type
!= R_XTENSA_NONE
9532 && find_removed_literal (&relax_info
->removed_list
,
9535 /* Remove this relocation. */
9536 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9537 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9538 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9539 irel
->r_offset
= offset_with_removed_text_map
9540 (&relax_info
->action_list
, irel
->r_offset
);
9544 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9546 text_action
*action
=
9547 find_insn_action (&relax_info
->action_list
,
9549 if (action
&& (action
->action
== ta_convert_longcall
9550 || action
->action
== ta_remove_longcall
))
9552 bfd_reloc_status_type retval
;
9553 char *error_message
= NULL
;
9555 retval
= contract_asm_expansion (contents
, sec_size
,
9556 irel
, &error_message
);
9557 if (retval
!= bfd_reloc_ok
)
9559 (*link_info
->callbacks
->reloc_dangerous
)
9560 (link_info
, error_message
, abfd
, sec
,
9564 /* Update the action so that the code that moves
9565 the contents will do the right thing. */
9566 /* ta_remove_longcall and ta_remove_insn actions are
9567 grouped together in the tree as well as
9568 ta_convert_longcall and ta_none, so that changes below
9569 can be done w/o removing and reinserting action into
9572 if (action
->action
== ta_remove_longcall
)
9573 action
->action
= ta_remove_insn
;
9575 action
->action
= ta_none
;
9576 /* Refresh the info in the r_rel. */
9577 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9578 r_type
= ELF32_R_TYPE (irel
->r_info
);
9582 source_offset
= offset_with_removed_text_map
9583 (&relax_info
->action_list
, irel
->r_offset
);
9584 irel
->r_offset
= source_offset
;
9587 /* If the target section could have changed then
9588 we may need to change the relocation's target offset. */
9590 target_sec
= r_reloc_get_section (&r_rel
);
9592 /* For a reference to a discarded section from a DWARF section,
9593 i.e., where action_discarded is PRETEND, the symbol will
9594 eventually be modified to refer to the kept section (at least if
9595 the kept and discarded sections are the same size). Anticipate
9596 that here and adjust things accordingly. */
9597 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9598 && elf_xtensa_action_discarded (sec
) == PRETEND
9599 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9600 && target_sec
!= NULL
9601 && discarded_section (target_sec
))
9603 /* It would be natural to call _bfd_elf_check_kept_section
9604 here, but it's not exported from elflink.c. It's also a
9605 fairly expensive check. Adjusting the relocations to the
9606 discarded section is fairly harmless; it will only adjust
9607 some addends and difference values. If it turns out that
9608 _bfd_elf_check_kept_section fails later, it won't matter,
9609 so just compare the section names to find the right group
9611 asection
*kept
= target_sec
->kept_section
;
9614 if ((kept
->flags
& SEC_GROUP
) != 0)
9616 asection
*first
= elf_next_in_group (kept
);
9617 asection
*s
= first
;
9622 if (strcmp (s
->name
, target_sec
->name
) == 0)
9627 s
= elf_next_in_group (s
);
9634 && ((target_sec
->rawsize
!= 0
9635 ? target_sec
->rawsize
: target_sec
->size
)
9636 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9640 target_relax_info
= get_xtensa_relax_info (target_sec
);
9641 if (target_relax_info
9642 && (target_relax_info
->is_relaxable_literal_section
9643 || target_relax_info
->is_relaxable_asm_section
))
9646 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9648 if (r_type
== R_XTENSA_DIFF8
9649 || r_type
== R_XTENSA_DIFF16
9650 || r_type
== R_XTENSA_DIFF32
9651 || r_type
== R_XTENSA_PDIFF8
9652 || r_type
== R_XTENSA_PDIFF16
9653 || r_type
== R_XTENSA_PDIFF32
9654 || r_type
== R_XTENSA_NDIFF8
9655 || r_type
== R_XTENSA_NDIFF16
9656 || r_type
== R_XTENSA_NDIFF32
)
9658 bfd_signed_vma diff_value
= 0;
9659 bfd_vma new_end_offset
, diff_mask
= 0;
9661 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9663 (*link_info
->callbacks
->reloc_dangerous
)
9664 (link_info
, _("invalid relocation address"),
9665 abfd
, sec
, old_source_offset
);
9671 case R_XTENSA_DIFF8
:
9674 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9676 case R_XTENSA_DIFF16
:
9679 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9681 case R_XTENSA_DIFF32
:
9682 diff_mask
= 0x7fffffff;
9684 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9686 case R_XTENSA_PDIFF8
:
9687 case R_XTENSA_NDIFF8
:
9690 bfd_get_8 (abfd
, &contents
[old_source_offset
]);
9692 case R_XTENSA_PDIFF16
:
9693 case R_XTENSA_NDIFF16
:
9696 bfd_get_16 (abfd
, &contents
[old_source_offset
]);
9698 case R_XTENSA_PDIFF32
:
9699 case R_XTENSA_NDIFF32
:
9700 diff_mask
= 0xffffffff;
9702 bfd_get_32 (abfd
, &contents
[old_source_offset
]);
9706 if (r_type
>= R_XTENSA_NDIFF8
9707 && r_type
<= R_XTENSA_NDIFF32
9709 diff_value
|= ~diff_mask
;
9711 new_end_offset
= offset_with_removed_text_map
9712 (&target_relax_info
->action_list
,
9713 r_rel
.target_offset
+ diff_value
);
9714 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9718 case R_XTENSA_DIFF8
:
9719 bfd_put_signed_8 (abfd
, diff_value
,
9720 &contents
[old_source_offset
]);
9722 case R_XTENSA_DIFF16
:
9723 bfd_put_signed_16 (abfd
, diff_value
,
9724 &contents
[old_source_offset
]);
9726 case R_XTENSA_DIFF32
:
9727 bfd_put_signed_32 (abfd
, diff_value
,
9728 &contents
[old_source_offset
]);
9730 case R_XTENSA_PDIFF8
:
9731 case R_XTENSA_NDIFF8
:
9732 bfd_put_8 (abfd
, diff_value
,
9733 &contents
[old_source_offset
]);
9735 case R_XTENSA_PDIFF16
:
9736 case R_XTENSA_NDIFF16
:
9737 bfd_put_16 (abfd
, diff_value
,
9738 &contents
[old_source_offset
]);
9740 case R_XTENSA_PDIFF32
:
9741 case R_XTENSA_NDIFF32
:
9742 bfd_put_32 (abfd
, diff_value
,
9743 &contents
[old_source_offset
]);
9747 /* Check for overflow. Sign bits must be all zeroes or
9748 all ones. When sign bits are all ones diff_value
9750 if (((diff_value
& ~diff_mask
) != 0
9751 && (diff_value
& ~diff_mask
) != ~diff_mask
)
9752 || (diff_value
&& (bfd_vma
) diff_value
== ~diff_mask
))
9754 (*link_info
->callbacks
->reloc_dangerous
)
9755 (link_info
, _("overflow after relaxation"),
9756 abfd
, sec
, old_source_offset
);
9760 pin_contents (sec
, contents
);
9763 /* If the relocation still references a section in the same
9764 input file, modify the relocation directly instead of
9765 adding a "fix" record. */
9766 if (target_sec
->owner
== abfd
)
9768 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9769 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9770 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9771 pin_internal_relocs (sec
, internal_relocs
);
9775 bfd_vma addend_displacement
;
9778 addend_displacement
=
9779 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9780 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9782 addend_displacement
, TRUE
);
9789 if ((relax_info
->is_relaxable_literal_section
9790 || relax_info
->is_relaxable_asm_section
)
9791 && action_list_count (&relax_info
->action_list
))
9793 /* Walk through the planned actions and build up a table
9794 of move, copy and fill records. Use the move, copy and
9795 fill records to perform the actions once. */
9797 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9798 bfd_byte
*scratch
= NULL
;
9799 bfd_byte
*dup_contents
= NULL
;
9800 bfd_size_type orig_size
= sec
->size
;
9801 bfd_vma orig_dot
= 0;
9802 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9803 orig dot in physical memory. */
9804 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9805 bfd_vma dup_dot
= 0;
9807 text_action
*action
;
9809 final_size
= sec
->size
;
9811 splay_tree_foreach (relax_info
->action_list
.tree
,
9812 action_remove_bytes_fn
, &final_size
);
9813 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9814 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9816 /* The dot is the current fill location. */
9818 print_action_list (stderr
, &relax_info
->action_list
);
9821 for (action
= action_first (&relax_info
->action_list
); action
;
9822 action
= action_next (&relax_info
->action_list
, action
))
9824 virtual_action
= FALSE
;
9825 if (action
->offset
> orig_dot
)
9827 orig_dot
+= orig_dot_copied
;
9828 orig_dot_copied
= 0;
9830 /* Out of the virtual world. */
9833 if (action
->offset
> orig_dot
)
9835 copy_size
= action
->offset
- orig_dot
;
9836 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9837 orig_dot
+= copy_size
;
9838 dup_dot
+= copy_size
;
9839 BFD_ASSERT (action
->offset
== orig_dot
);
9841 else if (action
->offset
< orig_dot
)
9843 if (action
->action
== ta_fill
9844 && action
->offset
- action
->removed_bytes
== orig_dot
)
9846 /* This is OK because the fill only effects the dup_dot. */
9848 else if (action
->action
== ta_add_literal
)
9850 /* TBD. Might need to handle this. */
9853 if (action
->offset
== orig_dot
)
9855 if (action
->virtual_offset
> orig_dot_vo
)
9857 if (orig_dot_vo
== 0)
9859 /* Need to copy virtual_offset bytes. Probably four. */
9860 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9861 memmove (&dup_contents
[dup_dot
],
9862 &contents
[orig_dot
], copy_size
);
9863 orig_dot_copied
= copy_size
;
9864 dup_dot
+= copy_size
;
9866 virtual_action
= TRUE
;
9869 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9871 switch (action
->action
)
9873 case ta_remove_literal
:
9874 case ta_remove_insn
:
9875 BFD_ASSERT (action
->removed_bytes
>= 0);
9876 orig_dot
+= action
->removed_bytes
;
9879 case ta_narrow_insn
:
9882 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9883 BFD_ASSERT (action
->removed_bytes
== 1);
9884 rv
= narrow_instruction (scratch
, final_size
, 0);
9886 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9887 orig_dot
+= orig_insn_size
;
9888 dup_dot
+= copy_size
;
9892 if (action
->removed_bytes
>= 0)
9893 orig_dot
+= action
->removed_bytes
;
9896 /* Already zeroed in dup_contents. Just bump the
9898 dup_dot
+= (-action
->removed_bytes
);
9903 BFD_ASSERT (action
->removed_bytes
== 0);
9906 case ta_convert_longcall
:
9907 case ta_remove_longcall
:
9908 /* These will be removed or converted before we get here. */
9915 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9916 BFD_ASSERT (action
->removed_bytes
== -1);
9917 rv
= widen_instruction (scratch
, final_size
, 0);
9919 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9920 orig_dot
+= orig_insn_size
;
9921 dup_dot
+= copy_size
;
9924 case ta_add_literal
:
9927 BFD_ASSERT (action
->removed_bytes
== -4);
9928 /* TBD -- place the literal value here and insert
9930 memset (&dup_contents
[dup_dot
], 0, 4);
9931 pin_internal_relocs (sec
, internal_relocs
);
9932 pin_contents (sec
, contents
);
9934 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9935 relax_info
, &internal_relocs
, &action
->value
))
9939 orig_dot_vo
+= copy_size
;
9941 orig_dot
+= orig_insn_size
;
9942 dup_dot
+= copy_size
;
9946 /* Not implemented yet. */
9951 BFD_ASSERT (dup_dot
<= final_size
);
9952 BFD_ASSERT (orig_dot
<= orig_size
);
9955 orig_dot
+= orig_dot_copied
;
9956 orig_dot_copied
= 0;
9958 if (orig_dot
!= orig_size
)
9960 copy_size
= orig_size
- orig_dot
;
9961 BFD_ASSERT (orig_size
> orig_dot
);
9962 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9963 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9964 orig_dot
+= copy_size
;
9965 dup_dot
+= copy_size
;
9967 BFD_ASSERT (orig_size
== orig_dot
);
9968 BFD_ASSERT (final_size
== dup_dot
);
9970 /* Move the dup_contents back. */
9971 if (final_size
> orig_size
)
9973 /* Contents need to be reallocated. Swap the dup_contents into
9975 sec
->contents
= dup_contents
;
9977 contents
= dup_contents
;
9978 pin_contents (sec
, contents
);
9982 BFD_ASSERT (final_size
<= orig_size
);
9983 memset (contents
, 0, orig_size
);
9984 memcpy (contents
, dup_contents
, final_size
);
9985 free (dup_contents
);
9988 pin_contents (sec
, contents
);
9990 if (sec
->rawsize
== 0)
9991 sec
->rawsize
= sec
->size
;
9992 sec
->size
= final_size
;
9996 release_internal_relocs (sec
, internal_relocs
);
9997 release_contents (sec
, contents
);
10003 translate_section_fixes (asection
*sec
)
10005 xtensa_relax_info
*relax_info
;
10008 relax_info
= get_xtensa_relax_info (sec
);
10012 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
10013 if (!translate_reloc_bfd_fix (r
))
10020 /* Translate a fix given the mapping in the relax info for the target
10021 section. If it has already been translated, no work is required. */
10024 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
10026 reloc_bfd_fix new_fix
;
10028 xtensa_relax_info
*relax_info
;
10029 removed_literal
*removed
;
10030 bfd_vma new_offset
, target_offset
;
10032 if (fix
->translated
)
10035 sec
= fix
->target_sec
;
10036 target_offset
= fix
->target_offset
;
10038 relax_info
= get_xtensa_relax_info (sec
);
10041 fix
->translated
= TRUE
;
10047 /* The fix does not need to be translated if the section cannot change. */
10048 if (!relax_info
->is_relaxable_literal_section
10049 && !relax_info
->is_relaxable_asm_section
)
10051 fix
->translated
= TRUE
;
10055 /* If the literal has been moved and this relocation was on an
10056 opcode, then the relocation should move to the new literal
10057 location. Otherwise, the relocation should move within the
10061 if (is_operand_relocation (fix
->src_type
))
10063 /* Check if the original relocation is against a literal being
10065 removed
= find_removed_literal (&relax_info
->removed_list
,
10073 /* The fact that there is still a relocation to this literal indicates
10074 that the literal is being coalesced, not simply removed. */
10075 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10077 /* This was moved to some other address (possibly another section). */
10078 new_sec
= r_reloc_get_section (&removed
->to
);
10079 if (new_sec
!= sec
)
10082 relax_info
= get_xtensa_relax_info (sec
);
10084 (!relax_info
->is_relaxable_literal_section
10085 && !relax_info
->is_relaxable_asm_section
))
10087 target_offset
= removed
->to
.target_offset
;
10088 new_fix
.target_sec
= new_sec
;
10089 new_fix
.target_offset
= target_offset
;
10090 new_fix
.translated
= TRUE
;
10095 target_offset
= removed
->to
.target_offset
;
10096 new_fix
.target_sec
= new_sec
;
10099 /* The target address may have been moved within its section. */
10100 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
10103 new_fix
.target_offset
= new_offset
;
10104 new_fix
.target_offset
= new_offset
;
10105 new_fix
.translated
= TRUE
;
10111 /* Fix up a relocation to take account of removed literals. */
10114 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
10116 xtensa_relax_info
*relax_info
;
10117 removed_literal
*removed
;
10118 bfd_vma target_offset
, base_offset
;
10120 *new_rel
= *orig_rel
;
10122 if (!r_reloc_is_defined (orig_rel
))
10125 relax_info
= get_xtensa_relax_info (sec
);
10126 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
10127 || relax_info
->is_relaxable_asm_section
));
10129 target_offset
= orig_rel
->target_offset
;
10132 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
10134 /* Check if the original relocation is against a literal being
10136 removed
= find_removed_literal (&relax_info
->removed_list
,
10139 if (removed
&& removed
->to
.abfd
)
10143 /* The fact that there is still a relocation to this literal indicates
10144 that the literal is being coalesced, not simply removed. */
10145 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10147 /* This was moved to some other address
10148 (possibly in another section). */
10149 *new_rel
= removed
->to
;
10150 new_sec
= r_reloc_get_section (new_rel
);
10151 if (new_sec
!= sec
)
10154 relax_info
= get_xtensa_relax_info (sec
);
10156 || (!relax_info
->is_relaxable_literal_section
10157 && !relax_info
->is_relaxable_asm_section
))
10160 target_offset
= new_rel
->target_offset
;
10163 /* Find the base offset of the reloc symbol, excluding any addend from the
10164 reloc or from the section contents (for a partial_inplace reloc). Then
10165 find the adjusted values of the offsets due to relaxation. The base
10166 offset is needed to determine the change to the reloc's addend; the reloc
10167 addend should not be adjusted due to relaxations located before the base
10170 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
10171 if (base_offset
<= target_offset
)
10173 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
10174 base_offset
, FALSE
);
10175 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10176 target_offset
, FALSE
) -
10179 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
10180 new_rel
->rela
.r_addend
-= addend_removed
;
10184 /* Handle a negative addend. The base offset comes first. */
10185 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
10186 target_offset
, FALSE
);
10187 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10188 base_offset
, FALSE
) -
10191 new_rel
->target_offset
= target_offset
- tgt_removed
;
10192 new_rel
->rela
.r_addend
+= addend_removed
;
10199 /* For dynamic links, there may be a dynamic relocation for each
10200 literal. The number of dynamic relocations must be computed in
10201 size_dynamic_sections, which occurs before relaxation. When a
10202 literal is removed, this function checks if there is a corresponding
10203 dynamic relocation and shrinks the size of the appropriate dynamic
10204 relocation section accordingly. At this point, the contents of the
10205 dynamic relocation sections have not yet been filled in, so there's
10206 nothing else that needs to be done. */
10209 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
10211 asection
*input_section
,
10212 Elf_Internal_Rela
*rel
)
10214 struct elf_xtensa_link_hash_table
*htab
;
10215 Elf_Internal_Shdr
*symtab_hdr
;
10216 struct elf_link_hash_entry
**sym_hashes
;
10217 unsigned long r_symndx
;
10219 struct elf_link_hash_entry
*h
;
10220 bfd_boolean dynamic_symbol
;
10222 htab
= elf_xtensa_hash_table (info
);
10226 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10227 sym_hashes
= elf_sym_hashes (abfd
);
10229 r_type
= ELF32_R_TYPE (rel
->r_info
);
10230 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10232 if (r_symndx
< symtab_hdr
->sh_info
)
10235 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10237 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10239 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10240 && (input_section
->flags
& SEC_ALLOC
) != 0
10242 || (bfd_link_pic (info
)
10243 && (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
))))
10246 bfd_boolean is_plt
= FALSE
;
10248 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10250 srel
= htab
->elf
.srelplt
;
10254 srel
= htab
->elf
.srelgot
;
10256 /* Reduce size of the .rela.* section by one reloc. */
10257 BFD_ASSERT (srel
!= NULL
);
10258 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10259 srel
->size
-= sizeof (Elf32_External_Rela
);
10263 asection
*splt
, *sgotplt
, *srelgot
;
10264 int reloc_index
, chunk
;
10266 /* Find the PLT reloc index of the entry being removed. This
10267 is computed from the size of ".rela.plt". It is needed to
10268 figure out which PLT chunk to resize. Usually "last index
10269 = size - 1" since the index starts at zero, but in this
10270 context, the size has just been decremented so there's no
10271 need to subtract one. */
10272 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10274 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10275 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10276 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10277 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10279 /* Check if an entire PLT chunk has just been eliminated. */
10280 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10282 /* The two magic GOT entries for that chunk can go away. */
10283 srelgot
= htab
->elf
.srelgot
;
10284 BFD_ASSERT (srelgot
!= NULL
);
10285 srelgot
->reloc_count
-= 2;
10286 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10287 sgotplt
->size
-= 8;
10289 /* There should be only one entry left (and it will be
10291 BFD_ASSERT (sgotplt
->size
== 4);
10292 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10295 BFD_ASSERT (sgotplt
->size
>= 4);
10296 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10298 sgotplt
->size
-= 4;
10299 splt
->size
-= PLT_ENTRY_SIZE
;
10305 /* Take an r_rel and move it to another section. This usually
10306 requires extending the interal_relocation array and pinning it. If
10307 the original r_rel is from the same BFD, we can complete this here.
10308 Otherwise, we add a fix record to let the final link fix the
10309 appropriate address. Contents and internal relocations for the
10310 section must be pinned after calling this routine. */
10313 move_literal (bfd
*abfd
,
10314 struct bfd_link_info
*link_info
,
10317 bfd_byte
*contents
,
10318 xtensa_relax_info
*relax_info
,
10319 Elf_Internal_Rela
**internal_relocs_p
,
10320 const literal_value
*lit
)
10322 Elf_Internal_Rela
*new_relocs
= NULL
;
10323 size_t new_relocs_count
= 0;
10324 Elf_Internal_Rela this_rela
;
10325 const r_reloc
*r_rel
;
10327 r_rel
= &lit
->r_rel
;
10328 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10330 if (r_reloc_is_const (r_rel
))
10331 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10336 reloc_bfd_fix
*fix
;
10337 unsigned insert_at
;
10339 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10341 /* This is the difficult case. We have to create a fix up. */
10342 this_rela
.r_offset
= offset
;
10343 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10344 this_rela
.r_addend
=
10345 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10346 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10348 /* Currently, we cannot move relocations during a relocatable link. */
10349 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10350 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10351 r_reloc_get_section (r_rel
),
10352 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10354 /* We also need to mark that relocations are needed here. */
10355 sec
->flags
|= SEC_RELOC
;
10357 translate_reloc_bfd_fix (fix
);
10358 /* This fix has not yet been translated. */
10359 add_fix (sec
, fix
);
10361 /* Add the relocation. If we have already allocated our own
10362 space for the relocations and we have room for more, then use
10363 it. Otherwise, allocate new space and move the literals. */
10364 insert_at
= sec
->reloc_count
;
10365 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10367 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10374 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10375 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10377 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10378 || sec
->reloc_count
== relax_info
->relocs_count
);
10380 if (relax_info
->allocated_relocs_count
== 0)
10381 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10383 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10385 new_relocs
= (Elf_Internal_Rela
*)
10386 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10390 /* We could handle this more quickly by finding the split point. */
10391 if (insert_at
!= 0)
10392 memcpy (new_relocs
, *internal_relocs_p
,
10393 insert_at
* sizeof (Elf_Internal_Rela
));
10395 new_relocs
[insert_at
] = this_rela
;
10397 if (insert_at
!= sec
->reloc_count
)
10398 memcpy (new_relocs
+ insert_at
+ 1,
10399 (*internal_relocs_p
) + insert_at
,
10400 (sec
->reloc_count
- insert_at
)
10401 * sizeof (Elf_Internal_Rela
));
10403 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10405 /* The first time we re-allocate, we can only free the
10406 old relocs if they were allocated with bfd_malloc.
10407 This is not true when keep_memory is in effect. */
10408 if (!link_info
->keep_memory
)
10409 free (*internal_relocs_p
);
10412 free (*internal_relocs_p
);
10413 relax_info
->allocated_relocs
= new_relocs
;
10414 relax_info
->allocated_relocs_count
= new_relocs_count
;
10415 elf_section_data (sec
)->relocs
= new_relocs
;
10416 sec
->reloc_count
++;
10417 relax_info
->relocs_count
= sec
->reloc_count
;
10418 *internal_relocs_p
= new_relocs
;
10422 if (insert_at
!= sec
->reloc_count
)
10425 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10426 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10428 (*internal_relocs_p
)[insert_at
] = this_rela
;
10429 sec
->reloc_count
++;
10430 if (relax_info
->allocated_relocs
)
10431 relax_info
->relocs_count
= sec
->reloc_count
;
10438 /* This is similar to relax_section except that when a target is moved,
10439 we shift addresses up. We also need to modify the size. This
10440 algorithm does NOT allow for relocations into the middle of the
10441 property sections. */
10444 relax_property_section (bfd
*abfd
,
10446 struct bfd_link_info
*link_info
)
10448 Elf_Internal_Rela
*internal_relocs
;
10449 bfd_byte
*contents
;
10451 bfd_boolean ok
= TRUE
;
10452 bfd_boolean is_full_prop_section
;
10453 size_t last_zfill_target_offset
= 0;
10454 asection
*last_zfill_target_sec
= NULL
;
10455 bfd_size_type sec_size
;
10456 bfd_size_type entry_size
;
10458 sec_size
= bfd_get_section_limit (abfd
, sec
);
10459 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10460 link_info
->keep_memory
);
10461 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10462 if (contents
== NULL
&& sec_size
!= 0)
10468 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10469 if (is_full_prop_section
)
10474 if (internal_relocs
)
10476 for (i
= 0; i
< sec
->reloc_count
; i
++)
10478 Elf_Internal_Rela
*irel
;
10479 xtensa_relax_info
*target_relax_info
;
10481 asection
*target_sec
;
10483 bfd_byte
*size_p
, *flags_p
;
10485 /* Locally change the source address.
10486 Translate the target to the new target address.
10487 If it points to this section and has been removed, MOVE IT.
10488 Also, don't forget to modify the associated SIZE at
10491 irel
= &internal_relocs
[i
];
10492 r_type
= ELF32_R_TYPE (irel
->r_info
);
10493 if (r_type
== R_XTENSA_NONE
)
10496 /* Find the literal value. */
10497 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10498 size_p
= &contents
[irel
->r_offset
+ 4];
10500 if (is_full_prop_section
)
10501 flags_p
= &contents
[irel
->r_offset
+ 8];
10502 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10504 target_sec
= r_reloc_get_section (&val
.r_rel
);
10505 target_relax_info
= get_xtensa_relax_info (target_sec
);
10507 if (target_relax_info
10508 && (target_relax_info
->is_relaxable_literal_section
10509 || target_relax_info
->is_relaxable_asm_section
))
10511 /* Translate the relocation's destination. */
10512 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10513 bfd_vma new_offset
;
10514 long old_size
, new_size
;
10515 int removed_by_old_offset
=
10516 removed_by_actions_map (&target_relax_info
->action_list
,
10517 old_offset
, FALSE
);
10518 new_offset
= old_offset
- removed_by_old_offset
;
10520 /* Assert that we are not out of bounds. */
10521 old_size
= bfd_get_32 (abfd
, size_p
);
10522 new_size
= old_size
;
10526 /* Only the first zero-sized unreachable entry is
10527 allowed to expand. In this case the new offset
10528 should be the offset before the fill and the new
10529 size is the expansion size. For other zero-sized
10530 entries the resulting size should be zero with an
10531 offset before or after the fill address depending
10532 on whether the expanding unreachable entry
10534 if (last_zfill_target_sec
== 0
10535 || last_zfill_target_sec
!= target_sec
10536 || last_zfill_target_offset
!= old_offset
)
10538 bfd_vma new_end_offset
= new_offset
;
10540 /* Recompute the new_offset, but this time don't
10541 include any fill inserted by relaxation. */
10542 removed_by_old_offset
=
10543 removed_by_actions_map (&target_relax_info
->action_list
,
10545 new_offset
= old_offset
- removed_by_old_offset
;
10547 /* If it is not unreachable and we have not yet
10548 seen an unreachable at this address, place it
10549 before the fill address. */
10550 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10551 & XTENSA_PROP_UNREACHABLE
) != 0)
10553 new_size
= new_end_offset
- new_offset
;
10555 last_zfill_target_sec
= target_sec
;
10556 last_zfill_target_offset
= old_offset
;
10562 int removed_by_old_offset_size
=
10563 removed_by_actions_map (&target_relax_info
->action_list
,
10564 old_offset
+ old_size
, TRUE
);
10565 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10568 if (new_size
!= old_size
)
10570 bfd_put_32 (abfd
, new_size
, size_p
);
10571 pin_contents (sec
, contents
);
10574 if (new_offset
!= old_offset
)
10576 bfd_vma diff
= new_offset
- old_offset
;
10577 irel
->r_addend
+= diff
;
10578 pin_internal_relocs (sec
, internal_relocs
);
10584 /* Combine adjacent property table entries. This is also done in
10585 finish_dynamic_sections() but at that point it's too late to
10586 reclaim the space in the output section, so we do this twice. */
10588 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10589 || xtensa_is_littable_section (sec
)))
10591 Elf_Internal_Rela
*last_irel
= NULL
;
10592 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10593 int removed_bytes
= 0;
10595 flagword predef_flags
;
10597 predef_flags
= xtensa_get_property_predef_flags (sec
);
10599 /* Walk over memory and relocations at the same time.
10600 This REQUIRES that the internal_relocs be sorted by offset. */
10601 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10602 internal_reloc_compare
);
10604 pin_internal_relocs (sec
, internal_relocs
);
10605 pin_contents (sec
, contents
);
10607 next_rel
= internal_relocs
;
10608 rel_end
= internal_relocs
+ sec
->reloc_count
;
10610 BFD_ASSERT (sec
->size
% entry_size
== 0);
10612 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10614 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10615 bfd_vma bytes_to_remove
, size
, actual_offset
;
10616 bfd_boolean remove_this_rel
;
10619 /* Find the first relocation for the entry at the current offset.
10620 Adjust the offsets of any extra relocations for the previous
10625 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10627 if ((irel
->r_offset
== offset
10628 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10629 || irel
->r_offset
> offset
)
10634 irel
->r_offset
-= removed_bytes
;
10638 /* Find the next relocation (if there are any left). */
10642 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10644 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10652 /* Check if there are relocations on the current entry. There
10653 should usually be a relocation on the offset field. If there
10654 are relocations on the size or flags, then we can't optimize
10655 this entry. Also, find the next relocation to examine on the
10659 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10661 next_rel
= offset_rel
;
10662 /* There are no relocations on the current entry, but we
10663 might still be able to remove it if the size is zero. */
10666 else if (offset_rel
->r_offset
> offset
10668 && extra_rel
->r_offset
< offset
+ entry_size
))
10670 /* There is a relocation on the size or flags, so we can't
10671 do anything with this entry. Continue with the next. */
10672 next_rel
= offset_rel
;
10677 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10678 offset_rel
->r_offset
-= removed_bytes
;
10679 next_rel
= offset_rel
+ 1;
10685 remove_this_rel
= FALSE
;
10686 bytes_to_remove
= 0;
10687 actual_offset
= offset
- removed_bytes
;
10688 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10690 if (is_full_prop_section
)
10691 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10693 flags
= predef_flags
;
10696 && (flags
& XTENSA_PROP_ALIGN
) == 0
10697 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10699 /* Always remove entries with zero size and no alignment. */
10700 bytes_to_remove
= entry_size
;
10702 remove_this_rel
= TRUE
;
10704 else if (offset_rel
10705 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10709 flagword old_flags
;
10711 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10712 bfd_vma old_address
=
10713 (last_irel
->r_addend
10714 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10715 bfd_vma new_address
=
10716 (offset_rel
->r_addend
10717 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10718 if (is_full_prop_section
)
10719 old_flags
= bfd_get_32
10720 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10722 old_flags
= predef_flags
;
10724 if ((ELF32_R_SYM (offset_rel
->r_info
)
10725 == ELF32_R_SYM (last_irel
->r_info
))
10726 && old_address
+ old_size
== new_address
10727 && old_flags
== flags
10728 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10729 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10731 /* Fix the old size. */
10732 bfd_put_32 (abfd
, old_size
+ size
,
10733 &contents
[last_irel
->r_offset
+ 4]);
10734 bytes_to_remove
= entry_size
;
10735 remove_this_rel
= TRUE
;
10738 last_irel
= offset_rel
;
10741 last_irel
= offset_rel
;
10744 if (remove_this_rel
)
10746 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10747 offset_rel
->r_offset
= 0;
10750 if (bytes_to_remove
!= 0)
10752 removed_bytes
+= bytes_to_remove
;
10753 if (offset
+ bytes_to_remove
< sec
->size
)
10754 memmove (&contents
[actual_offset
],
10755 &contents
[actual_offset
+ bytes_to_remove
],
10756 sec
->size
- offset
- bytes_to_remove
);
10762 /* Fix up any extra relocations on the last entry. */
10763 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10764 irel
->r_offset
-= removed_bytes
;
10766 /* Clear the removed bytes. */
10767 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10769 if (sec
->rawsize
== 0)
10770 sec
->rawsize
= sec
->size
;
10771 sec
->size
-= removed_bytes
;
10773 if (xtensa_is_littable_section (sec
))
10775 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10777 sgotloc
->size
-= removed_bytes
;
10783 release_internal_relocs (sec
, internal_relocs
);
10784 release_contents (sec
, contents
);
10789 /* Third relaxation pass. */
10791 /* Change symbol values to account for removed literals. */
10794 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10796 xtensa_relax_info
*relax_info
;
10797 unsigned int sec_shndx
;
10798 Elf_Internal_Shdr
*symtab_hdr
;
10799 Elf_Internal_Sym
*isymbuf
;
10800 unsigned i
, num_syms
, num_locals
;
10802 relax_info
= get_xtensa_relax_info (sec
);
10803 BFD_ASSERT (relax_info
);
10805 if (!relax_info
->is_relaxable_literal_section
10806 && !relax_info
->is_relaxable_asm_section
)
10809 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10811 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10812 isymbuf
= retrieve_local_syms (abfd
);
10814 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10815 num_locals
= symtab_hdr
->sh_info
;
10817 /* Adjust the local symbols defined in this section. */
10818 for (i
= 0; i
< num_locals
; i
++)
10820 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10822 if (isym
->st_shndx
== sec_shndx
)
10824 bfd_vma orig_addr
= isym
->st_value
;
10825 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10828 isym
->st_value
-= removed
;
10829 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10831 removed_by_actions_map (&relax_info
->action_list
,
10832 orig_addr
+ isym
->st_size
, FALSE
) -
10837 /* Now adjust the global symbols defined in this section. */
10838 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10840 struct elf_link_hash_entry
*sym_hash
;
10842 sym_hash
= elf_sym_hashes (abfd
)[i
];
10844 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10845 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10847 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10848 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10849 && sym_hash
->root
.u
.def
.section
== sec
)
10851 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10852 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10855 sym_hash
->root
.u
.def
.value
-= removed
;
10857 if (sym_hash
->type
== STT_FUNC
)
10859 removed_by_actions_map (&relax_info
->action_list
,
10860 orig_addr
+ sym_hash
->size
, FALSE
) -
10869 /* "Fix" handling functions, called while performing relocations. */
10872 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10874 asection
*input_section
,
10875 bfd_byte
*contents
)
10878 asection
*sec
, *old_sec
;
10879 bfd_vma old_offset
;
10880 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10881 reloc_bfd_fix
*fix
;
10883 if (r_type
== R_XTENSA_NONE
)
10886 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10890 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10891 bfd_get_section_limit (input_bfd
, input_section
));
10892 old_sec
= r_reloc_get_section (&r_rel
);
10893 old_offset
= r_rel
.target_offset
;
10895 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10897 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10900 /* xgettext:c-format */
10901 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10902 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10903 elf_howto_table
[r_type
].name
);
10906 /* Leave it be. Resolution will happen in a later stage. */
10910 sec
= fix
->target_sec
;
10911 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10912 - (old_sec
->output_offset
+ old_offset
));
10919 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10921 asection
*input_section
,
10922 bfd_byte
*contents
,
10923 bfd_vma
*relocationp
)
10926 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10927 reloc_bfd_fix
*fix
;
10928 bfd_vma fixup_diff
;
10930 if (r_type
== R_XTENSA_NONE
)
10933 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10937 sec
= fix
->target_sec
;
10939 fixup_diff
= rel
->r_addend
;
10940 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10942 bfd_vma inplace_val
;
10943 BFD_ASSERT (fix
->src_offset
10944 < bfd_get_section_limit (input_bfd
, input_section
));
10945 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10946 fixup_diff
+= inplace_val
;
10949 *relocationp
= (sec
->output_section
->vma
10950 + sec
->output_offset
10951 + fix
->target_offset
- fixup_diff
);
10955 /* Miscellaneous utility functions.... */
10958 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10964 return elf_hash_table (info
)->splt
;
10966 dynobj
= elf_hash_table (info
)->dynobj
;
10967 sprintf (plt_name
, ".plt.%u", chunk
);
10968 return bfd_get_linker_section (dynobj
, plt_name
);
10973 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10979 return elf_hash_table (info
)->sgotplt
;
10981 dynobj
= elf_hash_table (info
)->dynobj
;
10982 sprintf (got_name
, ".got.plt.%u", chunk
);
10983 return bfd_get_linker_section (dynobj
, got_name
);
10987 /* Get the input section for a given symbol index.
10989 . a section symbol, return the section;
10990 . a common symbol, return the common section;
10991 . an undefined symbol, return the undefined section;
10992 . an indirect symbol, follow the links;
10993 . an absolute value, return the absolute section. */
10996 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
10998 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10999 asection
*target_sec
= NULL
;
11000 if (r_symndx
< symtab_hdr
->sh_info
)
11002 Elf_Internal_Sym
*isymbuf
;
11003 unsigned int section_index
;
11005 isymbuf
= retrieve_local_syms (abfd
);
11006 section_index
= isymbuf
[r_symndx
].st_shndx
;
11008 if (section_index
== SHN_UNDEF
)
11009 target_sec
= bfd_und_section_ptr
;
11010 else if (section_index
== SHN_ABS
)
11011 target_sec
= bfd_abs_section_ptr
;
11012 else if (section_index
== SHN_COMMON
)
11013 target_sec
= bfd_com_section_ptr
;
11015 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
11019 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11020 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
11022 while (h
->root
.type
== bfd_link_hash_indirect
11023 || h
->root
.type
== bfd_link_hash_warning
)
11024 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11026 switch (h
->root
.type
)
11028 case bfd_link_hash_defined
:
11029 case bfd_link_hash_defweak
:
11030 target_sec
= h
->root
.u
.def
.section
;
11032 case bfd_link_hash_common
:
11033 target_sec
= bfd_com_section_ptr
;
11035 case bfd_link_hash_undefined
:
11036 case bfd_link_hash_undefweak
:
11037 target_sec
= bfd_und_section_ptr
;
11039 default: /* New indirect warning. */
11040 target_sec
= bfd_und_section_ptr
;
11048 static struct elf_link_hash_entry
*
11049 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
11051 unsigned long indx
;
11052 struct elf_link_hash_entry
*h
;
11053 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11055 if (r_symndx
< symtab_hdr
->sh_info
)
11058 indx
= r_symndx
- symtab_hdr
->sh_info
;
11059 h
= elf_sym_hashes (abfd
)[indx
];
11060 while (h
->root
.type
== bfd_link_hash_indirect
11061 || h
->root
.type
== bfd_link_hash_warning
)
11062 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11067 /* Get the section-relative offset for a symbol number. */
11070 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
11072 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11073 bfd_vma offset
= 0;
11075 if (r_symndx
< symtab_hdr
->sh_info
)
11077 Elf_Internal_Sym
*isymbuf
;
11078 isymbuf
= retrieve_local_syms (abfd
);
11079 offset
= isymbuf
[r_symndx
].st_value
;
11083 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11084 struct elf_link_hash_entry
*h
=
11085 elf_sym_hashes (abfd
)[indx
];
11087 while (h
->root
.type
== bfd_link_hash_indirect
11088 || h
->root
.type
== bfd_link_hash_warning
)
11089 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11090 if (h
->root
.type
== bfd_link_hash_defined
11091 || h
->root
.type
== bfd_link_hash_defweak
)
11092 offset
= h
->root
.u
.def
.value
;
11099 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
11101 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
11102 struct elf_link_hash_entry
*h
;
11104 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
11105 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
11112 pcrel_reloc_fits (xtensa_opcode opc
,
11114 bfd_vma self_address
,
11115 bfd_vma dest_address
)
11117 xtensa_isa isa
= xtensa_default_isa
;
11118 uint32 valp
= dest_address
;
11119 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
11120 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
11127 xtensa_is_property_section (asection
*sec
)
11129 if (xtensa_is_insntable_section (sec
)
11130 || xtensa_is_littable_section (sec
)
11131 || xtensa_is_proptable_section (sec
))
11139 xtensa_is_insntable_section (asection
*sec
)
11141 if (CONST_STRNEQ (sec
->name
, XTENSA_INSN_SEC_NAME
)
11142 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.x."))
11150 xtensa_is_littable_section (asection
*sec
)
11152 if (CONST_STRNEQ (sec
->name
, XTENSA_LIT_SEC_NAME
)
11153 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.p."))
11161 xtensa_is_proptable_section (asection
*sec
)
11163 if (CONST_STRNEQ (sec
->name
, XTENSA_PROP_SEC_NAME
)
11164 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.prop."))
11172 internal_reloc_compare (const void *ap
, const void *bp
)
11174 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11175 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11177 if (a
->r_offset
!= b
->r_offset
)
11178 return (a
->r_offset
- b
->r_offset
);
11180 /* We don't need to sort on these criteria for correctness,
11181 but enforcing a more strict ordering prevents unstable qsort
11182 from behaving differently with different implementations.
11183 Without the code below we get correct but different results
11184 on Solaris 2.7 and 2.8. We would like to always produce the
11185 same results no matter the host. */
11187 if (a
->r_info
!= b
->r_info
)
11188 return (a
->r_info
- b
->r_info
);
11190 return (a
->r_addend
- b
->r_addend
);
11195 internal_reloc_matches (const void *ap
, const void *bp
)
11197 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11198 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11200 /* Check if one entry overlaps with the other; this shouldn't happen
11201 except when searching for a match. */
11202 return (a
->r_offset
- b
->r_offset
);
11206 /* Predicate function used to look up a section in a particular group. */
11209 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
11211 const char *gname
= inf
;
11212 const char *group_name
= elf_group_name (sec
);
11214 return (group_name
== gname
11215 || (group_name
!= NULL
11217 && strcmp (group_name
, gname
) == 0));
11222 xtensa_add_names (const char *base
, const char *suffix
)
11226 size_t base_len
= strlen (base
);
11227 size_t suffix_len
= strlen (suffix
);
11228 char *str
= bfd_malloc (base_len
+ suffix_len
+ 1);
11230 memcpy (str
, base
, base_len
);
11231 memcpy (str
+ base_len
, suffix
, suffix_len
+ 1);
11236 return strdup (base
);
11240 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11243 xtensa_property_section_name (asection
*sec
, const char *base_name
,
11244 bfd_boolean separate_sections
)
11246 const char *suffix
, *group_name
;
11247 char *prop_sec_name
;
11249 group_name
= elf_group_name (sec
);
11252 suffix
= strrchr (sec
->name
, '.');
11253 if (suffix
== sec
->name
)
11255 prop_sec_name
= xtensa_add_names (base_name
, suffix
);
11257 else if (strncmp (sec
->name
, ".gnu.linkonce.", linkonce_len
) == 0)
11259 char *linkonce_kind
= 0;
11261 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11262 linkonce_kind
= "x.";
11263 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11264 linkonce_kind
= "p.";
11265 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11266 linkonce_kind
= "prop.";
11270 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11271 + strlen (linkonce_kind
) + 1);
11272 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11273 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11275 suffix
= sec
->name
+ linkonce_len
;
11276 /* For backward compatibility, replace "t." instead of inserting
11277 the new linkonce_kind (but not for "prop" sections). */
11278 if (CONST_STRNEQ (suffix
, "t.") && linkonce_kind
[1] == '.')
11280 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11284 prop_sec_name
= xtensa_add_names (base_name
,
11285 separate_sections
? sec
->name
: NULL
);
11288 return prop_sec_name
;
11293 xtensa_get_separate_property_section (asection
*sec
, const char *base_name
,
11294 bfd_boolean separate_section
)
11296 char *prop_sec_name
;
11297 asection
*prop_sec
;
11299 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11301 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11302 match_section_group
,
11303 (void *) elf_group_name (sec
));
11304 free (prop_sec_name
);
11309 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11311 asection
*prop_sec
;
11313 /* Try individual property section first. */
11314 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, TRUE
);
11316 /* Refer to a common property section if individual is not present. */
11318 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, FALSE
);
11325 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11327 char *prop_sec_name
;
11328 asection
*prop_sec
;
11330 /* Check if the section already exists. */
11331 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11332 elf32xtensa_separate_props
);
11333 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11334 match_section_group
,
11335 (void *) elf_group_name (sec
));
11336 /* If not, create it. */
11339 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11340 flags
|= (bfd_section_flags (sec
)
11341 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11343 prop_sec
= bfd_make_section_anyway_with_flags
11344 (sec
->owner
, strdup (prop_sec_name
), flags
);
11348 elf_group_name (prop_sec
) = elf_group_name (sec
);
11351 free (prop_sec_name
);
11357 xtensa_get_property_predef_flags (asection
*sec
)
11359 if (xtensa_is_insntable_section (sec
))
11360 return (XTENSA_PROP_INSN
11361 | XTENSA_PROP_NO_TRANSFORM
11362 | XTENSA_PROP_INSN_NO_REORDER
);
11364 if (xtensa_is_littable_section (sec
))
11365 return (XTENSA_PROP_LITERAL
11366 | XTENSA_PROP_NO_TRANSFORM
11367 | XTENSA_PROP_INSN_NO_REORDER
);
11373 /* Other functions called directly by the linker. */
11376 xtensa_callback_required_dependence (bfd
*abfd
,
11378 struct bfd_link_info
*link_info
,
11379 deps_callback_t callback
,
11382 Elf_Internal_Rela
*internal_relocs
;
11383 bfd_byte
*contents
;
11385 bfd_boolean ok
= TRUE
;
11386 bfd_size_type sec_size
;
11388 sec_size
= bfd_get_section_limit (abfd
, sec
);
11390 /* ".plt*" sections have no explicit relocations but they contain L32R
11391 instructions that reference the corresponding ".got.plt*" sections. */
11392 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11393 && CONST_STRNEQ (sec
->name
, ".plt"))
11397 /* Find the corresponding ".got.plt*" section. */
11398 if (sec
->name
[4] == '\0')
11399 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11405 BFD_ASSERT (sec
->name
[4] == '.');
11406 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11408 sprintf (got_name
, ".got.plt.%u", chunk
);
11409 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11411 BFD_ASSERT (sgotplt
);
11413 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11414 section referencing a literal at the very beginning of
11415 ".got.plt". This is very close to the real dependence, anyway. */
11416 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11419 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11420 when building uclibc, which runs "ld -b binary /dev/null". */
11421 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11424 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11425 link_info
->keep_memory
);
11426 if (internal_relocs
== NULL
11427 || sec
->reloc_count
== 0)
11430 /* Cache the contents for the duration of this scan. */
11431 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11432 if (contents
== NULL
&& sec_size
!= 0)
11438 if (!xtensa_default_isa
)
11439 xtensa_default_isa
= xtensa_isa_init (0, 0);
11441 for (i
= 0; i
< sec
->reloc_count
; i
++)
11443 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11444 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11447 asection
*target_sec
;
11448 bfd_vma target_offset
;
11450 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11453 /* L32Rs must be local to the input file. */
11454 if (r_reloc_is_defined (&l32r_rel
))
11456 target_sec
= r_reloc_get_section (&l32r_rel
);
11457 target_offset
= l32r_rel
.target_offset
;
11459 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11465 release_internal_relocs (sec
, internal_relocs
);
11466 release_contents (sec
, contents
);
11470 /* The default literal sections should always be marked as "code" (i.e.,
11471 SHF_EXECINSTR). This is particularly important for the Linux kernel
11472 module loader so that the literals are not placed after the text. */
11473 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11475 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11476 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11477 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11478 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11479 { NULL
, 0, 0, 0, 0 }
11482 #define ELF_TARGET_ID XTENSA_ELF_DATA
11484 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11485 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11486 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11487 #define TARGET_BIG_NAME "elf32-xtensa-be"
11488 #define ELF_ARCH bfd_arch_xtensa
11490 #define ELF_MACHINE_CODE EM_XTENSA
11491 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11493 #define ELF_MAXPAGESIZE 0x1000
11494 #endif /* ELF_ARCH */
11496 #define elf_backend_can_gc_sections 1
11497 #define elf_backend_can_refcount 1
11498 #define elf_backend_plt_readonly 1
11499 #define elf_backend_got_header_size 4
11500 #define elf_backend_want_dynbss 0
11501 #define elf_backend_want_got_plt 1
11502 #define elf_backend_dtrel_excludes_plt 1
11504 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11506 #define bfd_elf32_mkobject elf_xtensa_mkobject
11508 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11509 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11510 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11511 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11512 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11513 #define bfd_elf32_bfd_reloc_name_lookup \
11514 elf_xtensa_reloc_name_lookup
11515 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11516 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11518 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11519 #define elf_backend_check_relocs elf_xtensa_check_relocs
11520 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11521 #define elf_backend_discard_info elf_xtensa_discard_info
11522 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11523 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11524 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11525 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11526 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11527 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11528 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11529 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11530 #define elf_backend_object_p elf_xtensa_object_p
11531 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11532 #define elf_backend_relocate_section elf_xtensa_relocate_section
11533 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11534 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11535 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11536 #define elf_backend_special_sections elf_xtensa_special_sections
11537 #define elf_backend_action_discarded elf_xtensa_action_discarded
11538 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11540 #include "elf32-target.h"