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
40 /* Local helper functions. */
42 static bfd_boolean
add_extra_plt_sections (struct bfd_link_info
*, int);
43 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
44 static bfd_reloc_status_type bfd_elf_xtensa_reloc
45 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
46 static bfd_boolean do_fix_for_relocatable_link
47 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*);
48 static void do_fix_for_final_link
49 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*, bfd_vma
*);
51 /* Local functions to handle Xtensa configurability. */
53 static bfd_boolean
is_indirect_call_opcode (xtensa_opcode
);
54 static bfd_boolean
is_direct_call_opcode (xtensa_opcode
);
55 static bfd_boolean
is_windowed_call_opcode (xtensa_opcode
);
56 static xtensa_opcode
get_const16_opcode (void);
57 static xtensa_opcode
get_l32r_opcode (void);
58 static bfd_vma
l32r_offset (bfd_vma
, bfd_vma
);
59 static int get_relocation_opnd (xtensa_opcode
, int);
60 static int get_relocation_slot (int);
61 static xtensa_opcode get_relocation_opcode
62 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
63 static bfd_boolean is_l32r_relocation
64 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
65 static bfd_boolean
is_alt_relocation (int);
66 static bfd_boolean
is_operand_relocation (int);
67 static bfd_size_type insn_decode_len
68 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
69 static int insn_num_slots
70 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
71 static xtensa_opcode insn_decode_opcode
72 (bfd_byte
*, bfd_size_type
, bfd_size_type
, int);
73 static bfd_boolean check_branch_target_aligned
74 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
75 static bfd_boolean check_loop_aligned
76 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
77 static bfd_boolean
check_branch_target_aligned_address (bfd_vma
, int);
78 static bfd_size_type get_asm_simplify_size
79 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
81 /* Functions for link-time code simplifications. */
83 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
84 (bfd_byte
*, bfd_vma
, bfd_vma
, char **);
85 static bfd_reloc_status_type contract_asm_expansion
86 (bfd_byte
*, bfd_vma
, Elf_Internal_Rela
*, char **);
87 static xtensa_opcode
swap_callx_for_call_opcode (xtensa_opcode
);
88 static xtensa_opcode
get_expanded_call_opcode (bfd_byte
*, int, bfd_boolean
*);
90 /* Access to internal relocations, section contents and symbols. */
92 static Elf_Internal_Rela
*retrieve_internal_relocs
93 (bfd
*, asection
*, bfd_boolean
);
94 static void pin_internal_relocs (asection
*, Elf_Internal_Rela
*);
95 static void release_internal_relocs (asection
*, Elf_Internal_Rela
*);
96 static bfd_byte
*retrieve_contents (bfd
*, asection
*, bfd_boolean
);
97 static void pin_contents (asection
*, bfd_byte
*);
98 static void release_contents (asection
*, bfd_byte
*);
99 static Elf_Internal_Sym
*retrieve_local_syms (bfd
*);
101 /* Miscellaneous utility functions. */
103 static asection
*elf_xtensa_get_plt_section (struct bfd_link_info
*, int);
104 static asection
*elf_xtensa_get_gotplt_section (struct bfd_link_info
*, int);
105 static asection
*get_elf_r_symndx_section (bfd
*, unsigned long);
106 static struct elf_link_hash_entry
*get_elf_r_symndx_hash_entry
107 (bfd
*, unsigned long);
108 static bfd_vma
get_elf_r_symndx_offset (bfd
*, unsigned long);
109 static bfd_boolean
is_reloc_sym_weak (bfd
*, Elf_Internal_Rela
*);
110 static bfd_boolean
pcrel_reloc_fits (xtensa_opcode
, int, bfd_vma
, bfd_vma
);
111 static bfd_boolean
xtensa_is_property_section (asection
*);
112 static bfd_boolean
xtensa_is_insntable_section (asection
*);
113 static bfd_boolean
xtensa_is_littable_section (asection
*);
114 static bfd_boolean
xtensa_is_proptable_section (asection
*);
115 static int internal_reloc_compare (const void *, const void *);
116 static int internal_reloc_matches (const void *, const void *);
117 static asection
*xtensa_get_property_section (asection
*, const char *);
118 static flagword
xtensa_get_property_predef_flags (asection
*);
120 /* Other functions called directly by the linker. */
122 typedef void (*deps_callback_t
)
123 (asection
*, bfd_vma
, asection
*, bfd_vma
, void *);
124 extern bfd_boolean xtensa_callback_required_dependence
125 (bfd
*, asection
*, struct bfd_link_info
*, deps_callback_t
, void *);
128 /* Globally visible flag for choosing size optimization of NOP removal
129 instead of branch-target-aware minimization for NOP removal.
130 When nonzero, narrow all instructions and remove all NOPs possible
131 around longcall expansions. */
133 int elf32xtensa_size_opt
;
136 /* The "new_section_hook" is used to set up a per-section
137 "xtensa_relax_info" data structure with additional information used
138 during relaxation. */
140 typedef struct xtensa_relax_info_struct xtensa_relax_info
;
143 /* The GNU tools do not easily allow extending interfaces to pass around
144 the pointer to the Xtensa ISA information, so instead we add a global
145 variable here (in BFD) that can be used by any of the tools that need
148 xtensa_isa xtensa_default_isa
;
151 /* When this is true, relocations may have been modified to refer to
152 symbols from other input files. The per-section list of "fix"
153 records needs to be checked when resolving relocations. */
155 static bfd_boolean relaxing_section
= FALSE
;
157 /* When this is true, during final links, literals that cannot be
158 coalesced and their relocations may be moved to other sections. */
160 int elf32xtensa_no_literal_movement
= 1;
162 /* Place property records for a section into individual property section
163 with xt.prop. prefix. */
165 bfd_boolean elf32xtensa_separate_props
= FALSE
;
167 /* Rename one of the generic section flags to better document how it
169 /* Whether relocations have been processed. */
170 #define reloc_done sec_flg0
172 static reloc_howto_type elf_howto_table
[] =
174 HOWTO (R_XTENSA_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
175 bfd_elf_xtensa_reloc
, "R_XTENSA_NONE",
177 HOWTO (R_XTENSA_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
178 bfd_elf_xtensa_reloc
, "R_XTENSA_32",
179 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
181 /* Replace a 32-bit value with a value from the runtime linker (only
182 used by linker-generated stub functions). The r_addend value is
183 special: 1 means to substitute a pointer to the runtime linker's
184 dynamic resolver function; 2 means to substitute the link map for
185 the shared object. */
186 HOWTO (R_XTENSA_RTLD
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
187 NULL
, "R_XTENSA_RTLD", FALSE
, 0, 0, FALSE
),
189 HOWTO (R_XTENSA_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
190 bfd_elf_generic_reloc
, "R_XTENSA_GLOB_DAT",
191 FALSE
, 0, 0xffffffff, FALSE
),
192 HOWTO (R_XTENSA_JMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
193 bfd_elf_generic_reloc
, "R_XTENSA_JMP_SLOT",
194 FALSE
, 0, 0xffffffff, FALSE
),
195 HOWTO (R_XTENSA_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
196 bfd_elf_generic_reloc
, "R_XTENSA_RELATIVE",
197 FALSE
, 0, 0xffffffff, FALSE
),
198 HOWTO (R_XTENSA_PLT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
199 bfd_elf_xtensa_reloc
, "R_XTENSA_PLT",
200 FALSE
, 0, 0xffffffff, FALSE
),
204 /* Old relocations for backward compatibility. */
205 HOWTO (R_XTENSA_OP0
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
206 bfd_elf_xtensa_reloc
, "R_XTENSA_OP0", FALSE
, 0, 0, TRUE
),
207 HOWTO (R_XTENSA_OP1
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
208 bfd_elf_xtensa_reloc
, "R_XTENSA_OP1", FALSE
, 0, 0, TRUE
),
209 HOWTO (R_XTENSA_OP2
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
210 bfd_elf_xtensa_reloc
, "R_XTENSA_OP2", FALSE
, 0, 0, TRUE
),
212 /* Assembly auto-expansion. */
213 HOWTO (R_XTENSA_ASM_EXPAND
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
214 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_EXPAND", FALSE
, 0, 0, TRUE
),
215 /* Relax assembly auto-expansion. */
216 HOWTO (R_XTENSA_ASM_SIMPLIFY
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
217 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_SIMPLIFY", FALSE
, 0, 0, TRUE
),
221 HOWTO (R_XTENSA_32_PCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
222 bfd_elf_xtensa_reloc
, "R_XTENSA_32_PCREL",
223 FALSE
, 0, 0xffffffff, TRUE
),
225 /* GNU extension to record C++ vtable hierarchy. */
226 HOWTO (R_XTENSA_GNU_VTINHERIT
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
227 NULL
, "R_XTENSA_GNU_VTINHERIT",
229 /* GNU extension to record C++ vtable member usage. */
230 HOWTO (R_XTENSA_GNU_VTENTRY
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
231 _bfd_elf_rel_vtable_reloc_fn
, "R_XTENSA_GNU_VTENTRY",
234 /* Relocations for supporting difference of symbols. */
235 HOWTO (R_XTENSA_DIFF8
, 0, 0, 8, FALSE
, 0, complain_overflow_signed
,
236 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF8", FALSE
, 0, 0xff, FALSE
),
237 HOWTO (R_XTENSA_DIFF16
, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,
238 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF16", FALSE
, 0, 0xffff, FALSE
),
239 HOWTO (R_XTENSA_DIFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
240 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF32", FALSE
, 0, 0xffffffff, FALSE
),
242 /* General immediate operand relocations. */
243 HOWTO (R_XTENSA_SLOT0_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
244 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_OP", FALSE
, 0, 0, TRUE
),
245 HOWTO (R_XTENSA_SLOT1_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
246 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_OP", FALSE
, 0, 0, TRUE
),
247 HOWTO (R_XTENSA_SLOT2_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
248 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_OP", FALSE
, 0, 0, TRUE
),
249 HOWTO (R_XTENSA_SLOT3_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
250 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_OP", FALSE
, 0, 0, TRUE
),
251 HOWTO (R_XTENSA_SLOT4_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
252 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_OP", FALSE
, 0, 0, TRUE
),
253 HOWTO (R_XTENSA_SLOT5_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
254 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_OP", FALSE
, 0, 0, TRUE
),
255 HOWTO (R_XTENSA_SLOT6_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
256 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_OP", FALSE
, 0, 0, TRUE
),
257 HOWTO (R_XTENSA_SLOT7_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
258 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_OP", FALSE
, 0, 0, TRUE
),
259 HOWTO (R_XTENSA_SLOT8_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
260 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_OP", FALSE
, 0, 0, TRUE
),
261 HOWTO (R_XTENSA_SLOT9_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
262 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_OP", FALSE
, 0, 0, TRUE
),
263 HOWTO (R_XTENSA_SLOT10_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
264 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_OP", FALSE
, 0, 0, TRUE
),
265 HOWTO (R_XTENSA_SLOT11_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
266 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_OP", FALSE
, 0, 0, TRUE
),
267 HOWTO (R_XTENSA_SLOT12_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
268 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_OP", FALSE
, 0, 0, TRUE
),
269 HOWTO (R_XTENSA_SLOT13_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
270 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_OP", FALSE
, 0, 0, TRUE
),
271 HOWTO (R_XTENSA_SLOT14_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
272 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_OP", FALSE
, 0, 0, TRUE
),
274 /* "Alternate" relocations. The meaning of these is opcode-specific. */
275 HOWTO (R_XTENSA_SLOT0_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
276 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_ALT", FALSE
, 0, 0, TRUE
),
277 HOWTO (R_XTENSA_SLOT1_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
278 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_ALT", FALSE
, 0, 0, TRUE
),
279 HOWTO (R_XTENSA_SLOT2_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
280 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_ALT", FALSE
, 0, 0, TRUE
),
281 HOWTO (R_XTENSA_SLOT3_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
282 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_ALT", FALSE
, 0, 0, TRUE
),
283 HOWTO (R_XTENSA_SLOT4_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
284 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_ALT", FALSE
, 0, 0, TRUE
),
285 HOWTO (R_XTENSA_SLOT5_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
286 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_ALT", FALSE
, 0, 0, TRUE
),
287 HOWTO (R_XTENSA_SLOT6_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
288 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_ALT", FALSE
, 0, 0, TRUE
),
289 HOWTO (R_XTENSA_SLOT7_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
290 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_ALT", FALSE
, 0, 0, TRUE
),
291 HOWTO (R_XTENSA_SLOT8_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
292 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_ALT", FALSE
, 0, 0, TRUE
),
293 HOWTO (R_XTENSA_SLOT9_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
294 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_ALT", FALSE
, 0, 0, TRUE
),
295 HOWTO (R_XTENSA_SLOT10_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
296 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_ALT", FALSE
, 0, 0, TRUE
),
297 HOWTO (R_XTENSA_SLOT11_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
298 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_ALT", FALSE
, 0, 0, TRUE
),
299 HOWTO (R_XTENSA_SLOT12_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
300 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_ALT", FALSE
, 0, 0, TRUE
),
301 HOWTO (R_XTENSA_SLOT13_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
302 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_ALT", FALSE
, 0, 0, TRUE
),
303 HOWTO (R_XTENSA_SLOT14_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
304 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_ALT", FALSE
, 0, 0, TRUE
),
306 /* TLS relocations. */
307 HOWTO (R_XTENSA_TLSDESC_FN
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
308 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_FN",
309 FALSE
, 0, 0xffffffff, FALSE
),
310 HOWTO (R_XTENSA_TLSDESC_ARG
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
311 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_ARG",
312 FALSE
, 0, 0xffffffff, FALSE
),
313 HOWTO (R_XTENSA_TLS_DTPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
314 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_DTPOFF",
315 FALSE
, 0, 0xffffffff, FALSE
),
316 HOWTO (R_XTENSA_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
317 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_TPOFF",
318 FALSE
, 0, 0xffffffff, FALSE
),
319 HOWTO (R_XTENSA_TLS_FUNC
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
320 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_FUNC",
322 HOWTO (R_XTENSA_TLS_ARG
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
323 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_ARG",
325 HOWTO (R_XTENSA_TLS_CALL
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
326 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_CALL",
329 HOWTO (R_XTENSA_PDIFF8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
330 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF8", FALSE
, 0, 0xff, FALSE
),
331 HOWTO (R_XTENSA_PDIFF16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
332 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF16", FALSE
, 0, 0xffff, FALSE
),
333 HOWTO (R_XTENSA_PDIFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
334 bfd_elf_xtensa_reloc
, "R_XTENSA_PDIFF32", FALSE
, 0, 0xffffffff, FALSE
),
336 HOWTO (R_XTENSA_NDIFF8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
337 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF8", FALSE
, 0, 0xff, FALSE
),
338 HOWTO (R_XTENSA_NDIFF16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
339 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF16", FALSE
, 0, 0xffff, FALSE
),
340 HOWTO (R_XTENSA_NDIFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
341 bfd_elf_xtensa_reloc
, "R_XTENSA_NDIFF32", FALSE
, 0, 0xffffffff, FALSE
),
346 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
351 static reloc_howto_type
*
352 elf_xtensa_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
353 bfd_reloc_code_real_type code
)
358 TRACE ("BFD_RELOC_NONE");
359 return &elf_howto_table
[(unsigned) R_XTENSA_NONE
];
362 TRACE ("BFD_RELOC_32");
363 return &elf_howto_table
[(unsigned) R_XTENSA_32
];
365 case BFD_RELOC_32_PCREL
:
366 TRACE ("BFD_RELOC_32_PCREL");
367 return &elf_howto_table
[(unsigned) R_XTENSA_32_PCREL
];
369 case BFD_RELOC_XTENSA_DIFF8
:
370 TRACE ("BFD_RELOC_XTENSA_DIFF8");
371 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF8
];
373 case BFD_RELOC_XTENSA_DIFF16
:
374 TRACE ("BFD_RELOC_XTENSA_DIFF16");
375 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF16
];
377 case BFD_RELOC_XTENSA_DIFF32
:
378 TRACE ("BFD_RELOC_XTENSA_DIFF32");
379 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF32
];
381 case BFD_RELOC_XTENSA_PDIFF8
:
382 TRACE ("BFD_RELOC_XTENSA_PDIFF8");
383 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF8
];
385 case BFD_RELOC_XTENSA_PDIFF16
:
386 TRACE ("BFD_RELOC_XTENSA_PDIFF16");
387 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF16
];
389 case BFD_RELOC_XTENSA_PDIFF32
:
390 TRACE ("BFD_RELOC_XTENSA_PDIFF32");
391 return &elf_howto_table
[(unsigned) R_XTENSA_PDIFF32
];
393 case BFD_RELOC_XTENSA_NDIFF8
:
394 TRACE ("BFD_RELOC_XTENSA_NDIFF8");
395 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF8
];
397 case BFD_RELOC_XTENSA_NDIFF16
:
398 TRACE ("BFD_RELOC_XTENSA_NDIFF16");
399 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF16
];
401 case BFD_RELOC_XTENSA_NDIFF32
:
402 TRACE ("BFD_RELOC_XTENSA_NDIFF32");
403 return &elf_howto_table
[(unsigned) R_XTENSA_NDIFF32
];
405 case BFD_RELOC_XTENSA_RTLD
:
406 TRACE ("BFD_RELOC_XTENSA_RTLD");
407 return &elf_howto_table
[(unsigned) R_XTENSA_RTLD
];
409 case BFD_RELOC_XTENSA_GLOB_DAT
:
410 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
411 return &elf_howto_table
[(unsigned) R_XTENSA_GLOB_DAT
];
413 case BFD_RELOC_XTENSA_JMP_SLOT
:
414 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
415 return &elf_howto_table
[(unsigned) R_XTENSA_JMP_SLOT
];
417 case BFD_RELOC_XTENSA_RELATIVE
:
418 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
419 return &elf_howto_table
[(unsigned) R_XTENSA_RELATIVE
];
421 case BFD_RELOC_XTENSA_PLT
:
422 TRACE ("BFD_RELOC_XTENSA_PLT");
423 return &elf_howto_table
[(unsigned) R_XTENSA_PLT
];
425 case BFD_RELOC_XTENSA_OP0
:
426 TRACE ("BFD_RELOC_XTENSA_OP0");
427 return &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
429 case BFD_RELOC_XTENSA_OP1
:
430 TRACE ("BFD_RELOC_XTENSA_OP1");
431 return &elf_howto_table
[(unsigned) R_XTENSA_OP1
];
433 case BFD_RELOC_XTENSA_OP2
:
434 TRACE ("BFD_RELOC_XTENSA_OP2");
435 return &elf_howto_table
[(unsigned) R_XTENSA_OP2
];
437 case BFD_RELOC_XTENSA_ASM_EXPAND
:
438 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
439 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_EXPAND
];
441 case BFD_RELOC_XTENSA_ASM_SIMPLIFY
:
442 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
443 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_SIMPLIFY
];
445 case BFD_RELOC_VTABLE_INHERIT
:
446 TRACE ("BFD_RELOC_VTABLE_INHERIT");
447 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTINHERIT
];
449 case BFD_RELOC_VTABLE_ENTRY
:
450 TRACE ("BFD_RELOC_VTABLE_ENTRY");
451 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTENTRY
];
453 case BFD_RELOC_XTENSA_TLSDESC_FN
:
454 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
455 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_FN
];
457 case BFD_RELOC_XTENSA_TLSDESC_ARG
:
458 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
459 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_ARG
];
461 case BFD_RELOC_XTENSA_TLS_DTPOFF
:
462 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
463 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_DTPOFF
];
465 case BFD_RELOC_XTENSA_TLS_TPOFF
:
466 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
467 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_TPOFF
];
469 case BFD_RELOC_XTENSA_TLS_FUNC
:
470 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
471 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_FUNC
];
473 case BFD_RELOC_XTENSA_TLS_ARG
:
474 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
475 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_ARG
];
477 case BFD_RELOC_XTENSA_TLS_CALL
:
478 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
479 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_CALL
];
482 if (code
>= BFD_RELOC_XTENSA_SLOT0_OP
483 && code
<= BFD_RELOC_XTENSA_SLOT14_OP
)
485 unsigned n
= (R_XTENSA_SLOT0_OP
+
486 (code
- BFD_RELOC_XTENSA_SLOT0_OP
));
487 return &elf_howto_table
[n
];
490 if (code
>= BFD_RELOC_XTENSA_SLOT0_ALT
491 && code
<= BFD_RELOC_XTENSA_SLOT14_ALT
)
493 unsigned n
= (R_XTENSA_SLOT0_ALT
+
494 (code
- BFD_RELOC_XTENSA_SLOT0_ALT
));
495 return &elf_howto_table
[n
];
501 /* xgettext:c-format */
502 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
, (int) code
);
503 bfd_set_error (bfd_error_bad_value
);
508 static reloc_howto_type
*
509 elf_xtensa_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
514 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
515 if (elf_howto_table
[i
].name
!= NULL
516 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
517 return &elf_howto_table
[i
];
523 /* Given an ELF "rela" relocation, find the corresponding howto and record
524 it in the BFD internal arelent representation of the relocation. */
527 elf_xtensa_info_to_howto_rela (bfd
*abfd
,
529 Elf_Internal_Rela
*dst
)
531 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
533 if (r_type
>= (unsigned int) R_XTENSA_max
)
535 /* xgettext:c-format */
536 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
538 bfd_set_error (bfd_error_bad_value
);
541 cache_ptr
->howto
= &elf_howto_table
[r_type
];
546 /* Functions for the Xtensa ELF linker. */
548 /* The name of the dynamic interpreter. This is put in the .interp
551 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
553 /* The size in bytes of an entry in the procedure linkage table.
554 (This does _not_ include the space for the literals associated with
557 #define PLT_ENTRY_SIZE 16
559 /* For _really_ large PLTs, we may need to alternate between literals
560 and code to keep the literals within the 256K range of the L32R
561 instructions in the code. It's unlikely that anyone would ever need
562 such a big PLT, but an arbitrary limit on the PLT size would be bad.
563 Thus, we split the PLT into chunks. Since there's very little
564 overhead (2 extra literals) for each chunk, the chunk size is kept
565 small so that the code for handling multiple chunks get used and
566 tested regularly. With 254 entries, there are 1K of literals for
567 each chunk, and that seems like a nice round number. */
569 #define PLT_ENTRIES_PER_CHUNK 254
571 /* PLT entries are actually used as stub functions for lazy symbol
572 resolution. Once the symbol is resolved, the stub function is never
573 invoked. Note: the 32-byte frame size used here cannot be changed
574 without a corresponding change in the runtime linker. */
576 static const bfd_byte elf_xtensa_be_plt_entry
[][PLT_ENTRY_SIZE
] =
579 0x6c, 0x10, 0x04, /* entry sp, 32 */
580 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
581 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
582 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
583 0x0a, 0x80, 0x00, /* jx a8 */
587 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
588 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
589 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
590 0x0a, 0x80, 0x00, /* jx a8 */
595 static const bfd_byte elf_xtensa_le_plt_entry
[][PLT_ENTRY_SIZE
] =
598 0x36, 0x41, 0x00, /* entry sp, 32 */
599 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
600 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
601 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
602 0xa0, 0x08, 0x00, /* jx a8 */
606 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
607 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
608 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
609 0xa0, 0x08, 0x00, /* jx a8 */
614 /* The size of the thread control block. */
617 struct elf_xtensa_link_hash_entry
619 struct elf_link_hash_entry elf
;
621 bfd_signed_vma tlsfunc_refcount
;
623 #define GOT_UNKNOWN 0
625 #define GOT_TLS_GD 2 /* global or local dynamic */
626 #define GOT_TLS_IE 4 /* initial or local exec */
627 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
628 unsigned char tls_type
;
631 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
633 struct elf_xtensa_obj_tdata
635 struct elf_obj_tdata root
;
637 /* tls_type for each local got entry. */
638 char *local_got_tls_type
;
640 bfd_signed_vma
*local_tlsfunc_refcounts
;
643 #define elf_xtensa_tdata(abfd) \
644 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
646 #define elf_xtensa_local_got_tls_type(abfd) \
647 (elf_xtensa_tdata (abfd)->local_got_tls_type)
649 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
650 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
652 #define is_xtensa_elf(bfd) \
653 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
654 && elf_tdata (bfd) != NULL \
655 && elf_object_id (bfd) == XTENSA_ELF_DATA)
658 elf_xtensa_mkobject (bfd
*abfd
)
660 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_xtensa_obj_tdata
),
664 /* Xtensa ELF linker hash table. */
666 struct elf_xtensa_link_hash_table
668 struct elf_link_hash_table elf
;
670 /* Short-cuts to get to dynamic linker sections. */
672 asection
*spltlittbl
;
674 /* Total count of PLT relocations seen during check_relocs.
675 The actual PLT code must be split into multiple sections and all
676 the sections have to be created before size_dynamic_sections,
677 where we figure out the exact number of PLT entries that will be
678 needed. It is OK if this count is an overestimate, e.g., some
679 relocations may be removed by GC. */
682 struct elf_xtensa_link_hash_entry
*tlsbase
;
685 /* Get the Xtensa ELF linker hash table from a link_info structure. */
687 #define elf_xtensa_hash_table(p) \
688 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
689 == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
691 /* Create an entry in an Xtensa ELF linker hash table. */
693 static struct bfd_hash_entry
*
694 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
695 struct bfd_hash_table
*table
,
698 /* Allocate the structure if it has not already been allocated by a
702 entry
= bfd_hash_allocate (table
,
703 sizeof (struct elf_xtensa_link_hash_entry
));
708 /* Call the allocation method of the superclass. */
709 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
712 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (entry
);
713 eh
->tlsfunc_refcount
= 0;
714 eh
->tls_type
= GOT_UNKNOWN
;
720 /* Create an Xtensa ELF linker hash table. */
722 static struct bfd_link_hash_table
*
723 elf_xtensa_link_hash_table_create (bfd
*abfd
)
725 struct elf_link_hash_entry
*tlsbase
;
726 struct elf_xtensa_link_hash_table
*ret
;
727 size_t amt
= sizeof (struct elf_xtensa_link_hash_table
);
729 ret
= bfd_zmalloc (amt
);
733 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
734 elf_xtensa_link_hash_newfunc
,
735 sizeof (struct elf_xtensa_link_hash_entry
),
742 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
744 tlsbase
= elf_link_hash_lookup (&ret
->elf
, "_TLS_MODULE_BASE_",
746 tlsbase
->root
.type
= bfd_link_hash_new
;
747 tlsbase
->root
.u
.undef
.abfd
= NULL
;
748 tlsbase
->non_elf
= 0;
749 ret
->tlsbase
= elf_xtensa_hash_entry (tlsbase
);
750 ret
->tlsbase
->tls_type
= GOT_UNKNOWN
;
752 return &ret
->elf
.root
;
755 /* Copy the extra info we tack onto an elf_link_hash_entry. */
758 elf_xtensa_copy_indirect_symbol (struct bfd_link_info
*info
,
759 struct elf_link_hash_entry
*dir
,
760 struct elf_link_hash_entry
*ind
)
762 struct elf_xtensa_link_hash_entry
*edir
, *eind
;
764 edir
= elf_xtensa_hash_entry (dir
);
765 eind
= elf_xtensa_hash_entry (ind
);
767 if (ind
->root
.type
== bfd_link_hash_indirect
)
769 edir
->tlsfunc_refcount
+= eind
->tlsfunc_refcount
;
770 eind
->tlsfunc_refcount
= 0;
772 if (dir
->got
.refcount
<= 0)
774 edir
->tls_type
= eind
->tls_type
;
775 eind
->tls_type
= GOT_UNKNOWN
;
779 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
782 static inline bfd_boolean
783 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
784 struct bfd_link_info
*info
)
786 /* Check if we should do dynamic things to this symbol. The
787 "ignore_protected" argument need not be set, because Xtensa code
788 does not require special handling of STV_PROTECTED to make function
789 pointer comparisons work properly. The PLT addresses are never
790 used for function pointers. */
792 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
797 property_table_compare (const void *ap
, const void *bp
)
799 const property_table_entry
*a
= (const property_table_entry
*) ap
;
800 const property_table_entry
*b
= (const property_table_entry
*) bp
;
802 if (a
->address
== b
->address
)
804 if (a
->size
!= b
->size
)
805 return (a
->size
- b
->size
);
807 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
808 return ((b
->flags
& XTENSA_PROP_ALIGN
)
809 - (a
->flags
& XTENSA_PROP_ALIGN
));
811 if ((a
->flags
& XTENSA_PROP_ALIGN
)
812 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
813 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
814 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
815 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
817 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
818 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
819 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
820 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
822 return (a
->flags
- b
->flags
);
825 return (a
->address
- b
->address
);
830 property_table_matches (const void *ap
, const void *bp
)
832 const property_table_entry
*a
= (const property_table_entry
*) ap
;
833 const property_table_entry
*b
= (const property_table_entry
*) bp
;
835 /* Check if one entry overlaps with the other. */
836 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
837 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
840 return (a
->address
- b
->address
);
844 /* Get the literal table or property table entries for the given
845 section. Sets TABLE_P and returns the number of entries. On
846 error, returns a negative value. */
849 xtensa_read_table_entries (bfd
*abfd
,
851 property_table_entry
**table_p
,
852 const char *sec_name
,
853 bfd_boolean output_addr
)
855 asection
*table_section
;
856 bfd_size_type table_size
= 0;
857 bfd_byte
*table_data
;
858 property_table_entry
*blocks
;
859 int blk
, block_count
;
860 bfd_size_type num_records
;
861 Elf_Internal_Rela
*internal_relocs
, *irel
, *rel_end
;
862 bfd_vma section_addr
, off
;
863 flagword predef_flags
;
864 bfd_size_type table_entry_size
, section_limit
;
867 || !(section
->flags
& SEC_ALLOC
)
868 || (section
->flags
& SEC_DEBUGGING
))
874 table_section
= xtensa_get_property_section (section
, sec_name
);
876 table_size
= table_section
->size
;
884 predef_flags
= xtensa_get_property_predef_flags (table_section
);
885 table_entry_size
= 12;
887 table_entry_size
-= 4;
889 num_records
= table_size
/ table_entry_size
;
890 table_data
= retrieve_contents (abfd
, table_section
, TRUE
);
891 blocks
= (property_table_entry
*)
892 bfd_malloc (num_records
* sizeof (property_table_entry
));
896 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
898 section_addr
= section
->vma
;
900 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, TRUE
);
901 if (internal_relocs
&& !table_section
->reloc_done
)
903 qsort (internal_relocs
, table_section
->reloc_count
,
904 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
905 irel
= internal_relocs
;
910 section_limit
= bfd_get_section_limit (abfd
, section
);
911 rel_end
= internal_relocs
+ table_section
->reloc_count
;
913 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
915 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
917 /* Skip any relocations before the current offset. This should help
918 avoid confusion caused by unexpected relocations for the preceding
921 (irel
->r_offset
< off
922 || (irel
->r_offset
== off
923 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
930 if (irel
&& irel
->r_offset
== off
)
933 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
934 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
936 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
939 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
940 BFD_ASSERT (sym_off
== 0);
941 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
945 if (address
< section_addr
946 || address
>= section_addr
+ section_limit
)
950 blocks
[block_count
].address
= address
;
951 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
953 blocks
[block_count
].flags
= predef_flags
;
955 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
959 release_contents (table_section
, table_data
);
960 release_internal_relocs (table_section
, internal_relocs
);
964 /* Now sort them into address order for easy reference. */
965 qsort (blocks
, block_count
, sizeof (property_table_entry
),
966 property_table_compare
);
968 /* Check that the table contents are valid. Problems may occur,
969 for example, if an unrelocated object file is stripped. */
970 for (blk
= 1; blk
< block_count
; blk
++)
972 /* The only circumstance where two entries may legitimately
973 have the same address is when one of them is a zero-size
974 placeholder to mark a place where fill can be inserted.
975 The zero-size entry should come first. */
976 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
977 blocks
[blk
- 1].size
!= 0)
979 /* xgettext:c-format */
980 _bfd_error_handler (_("%pB(%pA): invalid property table"),
982 bfd_set_error (bfd_error_bad_value
);
994 static property_table_entry
*
995 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
996 int property_table_size
,
999 property_table_entry entry
;
1000 property_table_entry
*rv
;
1002 if (property_table_size
== 0)
1005 entry
.address
= addr
;
1009 rv
= bsearch (&entry
, property_table
, property_table_size
,
1010 sizeof (property_table_entry
), property_table_matches
);
1016 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
1020 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
1027 /* Look through the relocs for a section during the first phase, and
1028 calculate needed space in the dynamic reloc sections. */
1031 elf_xtensa_check_relocs (bfd
*abfd
,
1032 struct bfd_link_info
*info
,
1034 const Elf_Internal_Rela
*relocs
)
1036 struct elf_xtensa_link_hash_table
*htab
;
1037 Elf_Internal_Shdr
*symtab_hdr
;
1038 struct elf_link_hash_entry
**sym_hashes
;
1039 const Elf_Internal_Rela
*rel
;
1040 const Elf_Internal_Rela
*rel_end
;
1042 if (bfd_link_relocatable (info
) || (sec
->flags
& SEC_ALLOC
) == 0)
1045 BFD_ASSERT (is_xtensa_elf (abfd
));
1047 htab
= elf_xtensa_hash_table (info
);
1051 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1052 sym_hashes
= elf_sym_hashes (abfd
);
1054 rel_end
= relocs
+ sec
->reloc_count
;
1055 for (rel
= relocs
; rel
< rel_end
; rel
++)
1057 unsigned int r_type
;
1059 struct elf_link_hash_entry
*h
= NULL
;
1060 struct elf_xtensa_link_hash_entry
*eh
;
1061 int tls_type
, old_tls_type
;
1062 bfd_boolean is_got
= FALSE
;
1063 bfd_boolean is_plt
= FALSE
;
1064 bfd_boolean is_tlsfunc
= FALSE
;
1066 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1067 r_type
= ELF32_R_TYPE (rel
->r_info
);
1069 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1071 /* xgettext:c-format */
1072 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1077 if (r_symndx
>= symtab_hdr
->sh_info
)
1079 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1080 while (h
->root
.type
== bfd_link_hash_indirect
1081 || h
->root
.type
== bfd_link_hash_warning
)
1082 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1084 eh
= elf_xtensa_hash_entry (h
);
1088 case R_XTENSA_TLSDESC_FN
:
1089 if (bfd_link_pic (info
))
1091 tls_type
= GOT_TLS_GD
;
1096 tls_type
= GOT_TLS_IE
;
1099 case R_XTENSA_TLSDESC_ARG
:
1100 if (bfd_link_pic (info
))
1102 tls_type
= GOT_TLS_GD
;
1107 tls_type
= GOT_TLS_IE
;
1108 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1113 case R_XTENSA_TLS_DTPOFF
:
1114 if (bfd_link_pic (info
))
1115 tls_type
= GOT_TLS_GD
;
1117 tls_type
= GOT_TLS_IE
;
1120 case R_XTENSA_TLS_TPOFF
:
1121 tls_type
= GOT_TLS_IE
;
1122 if (bfd_link_pic (info
))
1123 info
->flags
|= DF_STATIC_TLS
;
1124 if (bfd_link_pic (info
) || h
)
1129 tls_type
= GOT_NORMAL
;
1134 tls_type
= GOT_NORMAL
;
1138 case R_XTENSA_GNU_VTINHERIT
:
1139 /* This relocation describes the C++ object vtable hierarchy.
1140 Reconstruct it for later use during GC. */
1141 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1145 case R_XTENSA_GNU_VTENTRY
:
1146 /* This relocation describes which C++ vtable entries are actually
1147 used. Record for later use during GC. */
1148 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1153 /* Nothing to do for any other relocations. */
1161 if (h
->plt
.refcount
<= 0)
1164 h
->plt
.refcount
= 1;
1167 h
->plt
.refcount
+= 1;
1169 /* Keep track of the total PLT relocation count even if we
1170 don't yet know whether the dynamic sections will be
1172 htab
->plt_reloc_count
+= 1;
1174 if (elf_hash_table (info
)->dynamic_sections_created
)
1176 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1182 if (h
->got
.refcount
<= 0)
1183 h
->got
.refcount
= 1;
1185 h
->got
.refcount
+= 1;
1189 eh
->tlsfunc_refcount
+= 1;
1191 old_tls_type
= eh
->tls_type
;
1195 /* Allocate storage the first time. */
1196 if (elf_local_got_refcounts (abfd
) == NULL
)
1198 bfd_size_type size
= symtab_hdr
->sh_info
;
1201 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1204 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1206 mem
= bfd_zalloc (abfd
, size
);
1209 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1211 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1214 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1215 = (bfd_signed_vma
*) mem
;
1218 /* This is a global offset table entry for a local symbol. */
1219 if (is_got
|| is_plt
)
1220 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1223 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1225 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1228 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1229 tls_type
|= old_tls_type
;
1230 /* If a TLS symbol is accessed using IE at least once,
1231 there is no point to use a dynamic model for it. */
1232 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1233 && ((old_tls_type
& GOT_TLS_GD
) == 0
1234 || (tls_type
& GOT_TLS_IE
) == 0))
1236 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1237 tls_type
= old_tls_type
;
1238 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1239 tls_type
|= old_tls_type
;
1243 /* xgettext:c-format */
1244 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1246 h
? h
->root
.root
.string
: "<local>");
1251 if (old_tls_type
!= tls_type
)
1254 eh
->tls_type
= tls_type
;
1256 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1265 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1266 struct elf_link_hash_entry
*h
)
1268 if (bfd_link_pic (info
))
1270 if (h
->plt
.refcount
> 0)
1272 /* For shared objects, there's no need for PLT entries for local
1273 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1274 if (h
->got
.refcount
< 0)
1275 h
->got
.refcount
= 0;
1276 h
->got
.refcount
+= h
->plt
.refcount
;
1277 h
->plt
.refcount
= 0;
1282 /* Don't need any dynamic relocations at all. */
1283 h
->plt
.refcount
= 0;
1284 h
->got
.refcount
= 0;
1290 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1291 struct elf_link_hash_entry
*h
,
1292 bfd_boolean force_local
)
1294 /* For a shared link, move the plt refcount to the got refcount to leave
1295 space for RELATIVE relocs. */
1296 elf_xtensa_make_sym_local (info
, h
);
1298 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1302 /* Return the section that should be marked against GC for a given
1306 elf_xtensa_gc_mark_hook (asection
*sec
,
1307 struct bfd_link_info
*info
,
1308 Elf_Internal_Rela
*rel
,
1309 struct elf_link_hash_entry
*h
,
1310 Elf_Internal_Sym
*sym
)
1312 /* Property sections are marked "KEEP" in the linker scripts, but they
1313 should not cause other sections to be marked. (This approach relies
1314 on elf_xtensa_discard_info to remove property table entries that
1315 describe discarded sections. Alternatively, it might be more
1316 efficient to avoid using "KEEP" in the linker scripts and instead use
1317 the gc_mark_extra_sections hook to mark only the property sections
1318 that describe marked sections. That alternative does not work well
1319 with the current property table sections, which do not correspond
1320 one-to-one with the sections they describe, but that should be fixed
1322 if (xtensa_is_property_section (sec
))
1326 switch (ELF32_R_TYPE (rel
->r_info
))
1328 case R_XTENSA_GNU_VTINHERIT
:
1329 case R_XTENSA_GNU_VTENTRY
:
1333 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1337 /* Create all the dynamic sections. */
1340 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1342 struct elf_xtensa_link_hash_table
*htab
;
1343 flagword flags
, noalloc_flags
;
1345 htab
= elf_xtensa_hash_table (info
);
1349 /* First do all the standard stuff. */
1350 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1353 /* Create any extra PLT sections in case check_relocs has already
1354 been called on all the non-dynamic input files. */
1355 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1358 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1359 | SEC_LINKER_CREATED
| SEC_READONLY
);
1360 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1362 /* Mark the ".got.plt" section READONLY. */
1363 if (htab
->elf
.sgotplt
== NULL
1364 || !bfd_set_section_flags (htab
->elf
.sgotplt
, flags
))
1367 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1368 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1370 if (htab
->sgotloc
== NULL
1371 || !bfd_set_section_alignment (htab
->sgotloc
, 2))
1374 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1375 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1377 if (htab
->spltlittbl
== NULL
1378 || !bfd_set_section_alignment (htab
->spltlittbl
, 2))
1386 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1388 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1391 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1392 ".got.plt" sections. */
1393 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1399 /* Stop when we find a section has already been created. */
1400 if (elf_xtensa_get_plt_section (info
, chunk
))
1403 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1404 | SEC_LINKER_CREATED
| SEC_READONLY
);
1406 sname
= (char *) bfd_malloc (10);
1407 sprintf (sname
, ".plt.%u", chunk
);
1408 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1410 || !bfd_set_section_alignment (s
, 2))
1413 sname
= (char *) bfd_malloc (14);
1414 sprintf (sname
, ".got.plt.%u", chunk
);
1415 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1417 || !bfd_set_section_alignment (s
, 2))
1425 /* Adjust a symbol defined by a dynamic object and referenced by a
1426 regular object. The current definition is in some section of the
1427 dynamic object, but we're not including those sections. We have to
1428 change the definition to something the rest of the link can
1432 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1433 struct elf_link_hash_entry
*h
)
1435 /* If this is a weak symbol, and there is a real definition, the
1436 processor independent code will have arranged for us to see the
1437 real definition first, and we can just use the same value. */
1438 if (h
->is_weakalias
)
1440 struct elf_link_hash_entry
*def
= weakdef (h
);
1441 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1442 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1443 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1447 /* This is a reference to a symbol defined by a dynamic object. The
1448 reference must go through the GOT, so there's no need for COPY relocs,
1456 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1458 struct bfd_link_info
*info
;
1459 struct elf_xtensa_link_hash_table
*htab
;
1460 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1462 if (h
->root
.type
== bfd_link_hash_indirect
)
1465 info
= (struct bfd_link_info
*) arg
;
1466 htab
= elf_xtensa_hash_table (info
);
1470 /* If we saw any use of an IE model for this symbol, we can then optimize
1471 away GOT entries for any TLSDESC_FN relocs. */
1472 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1474 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1475 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1478 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1479 elf_xtensa_make_sym_local (info
, h
);
1481 if (! elf_xtensa_dynamic_symbol_p (h
, info
)
1482 && h
->root
.type
== bfd_link_hash_undefweak
)
1485 if (h
->plt
.refcount
> 0)
1486 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1488 if (h
->got
.refcount
> 0)
1489 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1496 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1498 struct elf_xtensa_link_hash_table
*htab
;
1501 htab
= elf_xtensa_hash_table (info
);
1505 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1507 bfd_signed_vma
*local_got_refcounts
;
1508 bfd_size_type j
, cnt
;
1509 Elf_Internal_Shdr
*symtab_hdr
;
1511 local_got_refcounts
= elf_local_got_refcounts (i
);
1512 if (!local_got_refcounts
)
1515 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1516 cnt
= symtab_hdr
->sh_info
;
1518 for (j
= 0; j
< cnt
; ++j
)
1520 /* If we saw any use of an IE model for this symbol, we can
1521 then optimize away GOT entries for any TLSDESC_FN relocs. */
1522 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1524 bfd_signed_vma
*tlsfunc_refcount
1525 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1526 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1527 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1530 if (local_got_refcounts
[j
] > 0)
1531 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1532 * sizeof (Elf32_External_Rela
));
1538 /* Set the sizes of the dynamic sections. */
1541 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1542 struct bfd_link_info
*info
)
1544 struct elf_xtensa_link_hash_table
*htab
;
1546 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1547 bfd_boolean relplt
, relgot
;
1548 int plt_entries
, plt_chunks
, chunk
;
1553 htab
= elf_xtensa_hash_table (info
);
1557 dynobj
= elf_hash_table (info
)->dynobj
;
1560 srelgot
= htab
->elf
.srelgot
;
1561 srelplt
= htab
->elf
.srelplt
;
1563 if (elf_hash_table (info
)->dynamic_sections_created
)
1565 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1566 && htab
->elf
.srelplt
!= NULL
1567 && htab
->elf
.sgot
!= NULL
1568 && htab
->spltlittbl
!= NULL
1569 && htab
->sgotloc
!= NULL
);
1571 /* Set the contents of the .interp section to the interpreter. */
1572 if (bfd_link_executable (info
) && !info
->nointerp
)
1574 s
= bfd_get_linker_section (dynobj
, ".interp");
1577 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1578 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1581 /* Allocate room for one word in ".got". */
1582 htab
->elf
.sgot
->size
= 4;
1584 /* Allocate space in ".rela.got" for literals that reference global
1585 symbols and space in ".rela.plt" for literals that have PLT
1587 elf_link_hash_traverse (elf_hash_table (info
),
1588 elf_xtensa_allocate_dynrelocs
,
1591 /* If we are generating a shared object, we also need space in
1592 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1593 reference local symbols. */
1594 if (bfd_link_pic (info
))
1595 elf_xtensa_allocate_local_got_size (info
);
1597 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1598 each PLT entry, we need the PLT code plus a 4-byte literal.
1599 For each chunk of ".plt", we also need two more 4-byte
1600 literals, two corresponding entries in ".rela.got", and an
1601 8-byte entry in ".xt.lit.plt". */
1602 spltlittbl
= htab
->spltlittbl
;
1603 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1605 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1607 /* Iterate over all the PLT chunks, including any extra sections
1608 created earlier because the initial count of PLT relocations
1609 was an overestimate. */
1611 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1616 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1617 BFD_ASSERT (sgotplt
!= NULL
);
1619 if (chunk
< plt_chunks
- 1)
1620 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1621 else if (chunk
== plt_chunks
- 1)
1622 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1626 if (chunk_entries
!= 0)
1628 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1629 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1630 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1631 spltlittbl
->size
+= 8;
1640 /* Allocate space in ".got.loc" to match the total size of all the
1642 sgotloc
= htab
->sgotloc
;
1643 sgotloc
->size
= spltlittbl
->size
;
1644 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1646 if (abfd
->flags
& DYNAMIC
)
1648 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1650 if (! discarded_section (s
)
1651 && xtensa_is_littable_section (s
)
1653 sgotloc
->size
+= s
->size
;
1658 /* Allocate memory for dynamic sections. */
1661 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1665 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1668 /* It's OK to base decisions on the section name, because none
1669 of the dynobj section names depend upon the input files. */
1670 name
= bfd_section_name (s
);
1672 if (CONST_STRNEQ (name
, ".rela"))
1676 if (strcmp (name
, ".rela.plt") == 0)
1678 else if (strcmp (name
, ".rela.got") == 0)
1681 /* We use the reloc_count field as a counter if we need
1682 to copy relocs into the output file. */
1686 else if (! CONST_STRNEQ (name
, ".plt.")
1687 && ! CONST_STRNEQ (name
, ".got.plt.")
1688 && strcmp (name
, ".got") != 0
1689 && strcmp (name
, ".plt") != 0
1690 && strcmp (name
, ".got.plt") != 0
1691 && strcmp (name
, ".xt.lit.plt") != 0
1692 && strcmp (name
, ".got.loc") != 0)
1694 /* It's not one of our sections, so don't allocate space. */
1700 /* If we don't need this section, strip it from the output
1701 file. We must create the ".plt*" and ".got.plt*"
1702 sections in create_dynamic_sections and/or check_relocs
1703 based on a conservative estimate of the PLT relocation
1704 count, because the sections must be created before the
1705 linker maps input sections to output sections. The
1706 linker does that before size_dynamic_sections, where we
1707 compute the exact size of the PLT, so there may be more
1708 of these sections than are actually needed. */
1709 s
->flags
|= SEC_EXCLUDE
;
1711 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1713 /* Allocate memory for the section contents. */
1714 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1715 if (s
->contents
== NULL
)
1720 if (elf_hash_table (info
)->dynamic_sections_created
)
1722 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1723 known until finish_dynamic_sections, but we need to get the relocs
1724 in place before they are sorted. */
1725 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1727 Elf_Internal_Rela irela
;
1731 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1734 loc
= (srelgot
->contents
1735 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1736 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1737 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1738 loc
+ sizeof (Elf32_External_Rela
));
1739 srelgot
->reloc_count
+= 2;
1742 /* Add some entries to the .dynamic section. We fill in the
1743 values later, in elf_xtensa_finish_dynamic_sections, but we
1744 must add the entries now so that we get the correct size for
1745 the .dynamic section. The DT_DEBUG entry is filled in by the
1746 dynamic linker and used by the debugger. */
1747 #define add_dynamic_entry(TAG, VAL) \
1748 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1750 if (bfd_link_executable (info
))
1752 if (!add_dynamic_entry (DT_DEBUG
, 0))
1758 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1759 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1760 || !add_dynamic_entry (DT_JMPREL
, 0))
1766 if (!add_dynamic_entry (DT_RELA
, 0)
1767 || !add_dynamic_entry (DT_RELASZ
, 0)
1768 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1772 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1773 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1774 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1777 #undef add_dynamic_entry
1783 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1784 struct bfd_link_info
*info
)
1786 struct elf_xtensa_link_hash_table
*htab
;
1789 htab
= elf_xtensa_hash_table (info
);
1793 tls_sec
= htab
->elf
.tls_sec
;
1795 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1797 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1798 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1799 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1801 tlsbase
->type
= STT_TLS
;
1802 if (!(_bfd_generic_link_add_one_symbol
1803 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1804 tls_sec
, 0, NULL
, FALSE
,
1805 bed
->collect
, &bh
)))
1807 tlsbase
->def_regular
= 1;
1808 tlsbase
->other
= STV_HIDDEN
;
1809 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1816 /* Return the base VMA address which should be subtracted from real addresses
1817 when resolving @dtpoff relocation.
1818 This is PT_TLS segment p_vaddr. */
1821 dtpoff_base (struct bfd_link_info
*info
)
1823 /* If tls_sec is NULL, we should have signalled an error already. */
1824 if (elf_hash_table (info
)->tls_sec
== NULL
)
1826 return elf_hash_table (info
)->tls_sec
->vma
;
1829 /* Return the relocation value for @tpoff relocation
1830 if STT_TLS virtual address is ADDRESS. */
1833 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1835 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1838 /* If tls_sec is NULL, we should have signalled an error already. */
1839 if (htab
->tls_sec
== NULL
)
1841 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1842 return address
- htab
->tls_sec
->vma
+ base
;
1845 /* Perform the specified relocation. The instruction at (contents + address)
1846 is modified to set one operand to represent the value in "relocation". The
1847 operand position is determined by the relocation type recorded in the
1850 #define CALL_SEGMENT_BITS (30)
1851 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1853 static bfd_reloc_status_type
1854 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1856 asection
*input_section
,
1860 bfd_boolean is_weak_undef
,
1861 char **error_message
)
1864 xtensa_opcode opcode
;
1865 xtensa_isa isa
= xtensa_default_isa
;
1866 static xtensa_insnbuf ibuff
= NULL
;
1867 static xtensa_insnbuf sbuff
= NULL
;
1868 bfd_vma self_address
;
1869 bfd_size_type input_size
;
1875 ibuff
= xtensa_insnbuf_alloc (isa
);
1876 sbuff
= xtensa_insnbuf_alloc (isa
);
1879 input_size
= bfd_get_section_limit (abfd
, input_section
);
1881 /* Calculate the PC address for this instruction. */
1882 self_address
= (input_section
->output_section
->vma
1883 + input_section
->output_offset
1886 switch (howto
->type
)
1889 case R_XTENSA_DIFF8
:
1890 case R_XTENSA_DIFF16
:
1891 case R_XTENSA_DIFF32
:
1892 case R_XTENSA_PDIFF8
:
1893 case R_XTENSA_PDIFF16
:
1894 case R_XTENSA_PDIFF32
:
1895 case R_XTENSA_NDIFF8
:
1896 case R_XTENSA_NDIFF16
:
1897 case R_XTENSA_NDIFF32
:
1898 case R_XTENSA_TLS_FUNC
:
1899 case R_XTENSA_TLS_ARG
:
1900 case R_XTENSA_TLS_CALL
:
1901 return bfd_reloc_ok
;
1903 case R_XTENSA_ASM_EXPAND
:
1906 /* Check for windowed CALL across a 1GB boundary. */
1907 opcode
= get_expanded_call_opcode (contents
+ address
,
1908 input_size
- address
, 0);
1909 if (is_windowed_call_opcode (opcode
))
1911 if ((self_address
>> CALL_SEGMENT_BITS
)
1912 != (relocation
>> CALL_SEGMENT_BITS
))
1914 *error_message
= "windowed longcall crosses 1GB boundary; "
1916 return bfd_reloc_dangerous
;
1920 return bfd_reloc_ok
;
1922 case R_XTENSA_ASM_SIMPLIFY
:
1924 /* Convert the L32R/CALLX to CALL. */
1925 bfd_reloc_status_type retval
=
1926 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1928 if (retval
!= bfd_reloc_ok
)
1929 return bfd_reloc_dangerous
;
1931 /* The CALL needs to be relocated. Continue below for that part. */
1934 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1941 x
= bfd_get_32 (abfd
, contents
+ address
);
1943 bfd_put_32 (abfd
, x
, contents
+ address
);
1945 return bfd_reloc_ok
;
1947 case R_XTENSA_32_PCREL
:
1948 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1949 return bfd_reloc_ok
;
1952 case R_XTENSA_TLSDESC_FN
:
1953 case R_XTENSA_TLSDESC_ARG
:
1954 case R_XTENSA_TLS_DTPOFF
:
1955 case R_XTENSA_TLS_TPOFF
:
1956 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1957 return bfd_reloc_ok
;
1960 /* Only instruction slot-specific relocations handled below.... */
1961 slot
= get_relocation_slot (howto
->type
);
1962 if (slot
== XTENSA_UNDEFINED
)
1964 *error_message
= "unexpected relocation";
1965 return bfd_reloc_dangerous
;
1968 /* Read the instruction into a buffer and decode the opcode. */
1969 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1970 input_size
- address
);
1971 fmt
= xtensa_format_decode (isa
, ibuff
);
1972 if (fmt
== XTENSA_UNDEFINED
)
1974 *error_message
= "cannot decode instruction format";
1975 return bfd_reloc_dangerous
;
1978 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1980 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1981 if (opcode
== XTENSA_UNDEFINED
)
1983 *error_message
= "cannot decode instruction opcode";
1984 return bfd_reloc_dangerous
;
1987 /* Check for opcode-specific "alternate" relocations. */
1988 if (is_alt_relocation (howto
->type
))
1990 if (opcode
== get_l32r_opcode ())
1992 /* Handle the special-case of non-PC-relative L32R instructions. */
1993 bfd
*output_bfd
= input_section
->output_section
->owner
;
1994 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
1997 *error_message
= "relocation references missing .lit4 section";
1998 return bfd_reloc_dangerous
;
2000 self_address
= ((lit4_sec
->vma
& ~0xfff)
2001 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2002 newval
= relocation
;
2005 else if (opcode
== get_const16_opcode ())
2007 /* ALT used for high 16 bits.
2008 Ignore 32-bit overflow. */
2009 newval
= (relocation
>> 16) & 0xffff;
2014 /* No other "alternate" relocations currently defined. */
2015 *error_message
= "unexpected relocation";
2016 return bfd_reloc_dangerous
;
2019 else /* Not an "alternate" relocation.... */
2021 if (opcode
== get_const16_opcode ())
2023 newval
= relocation
& 0xffff;
2028 /* ...normal PC-relative relocation.... */
2030 /* Determine which operand is being relocated. */
2031 opnd
= get_relocation_opnd (opcode
, howto
->type
);
2032 if (opnd
== XTENSA_UNDEFINED
)
2034 *error_message
= "unexpected relocation";
2035 return bfd_reloc_dangerous
;
2038 if (!howto
->pc_relative
)
2040 *error_message
= "expected PC-relative relocation";
2041 return bfd_reloc_dangerous
;
2044 newval
= relocation
;
2048 /* Apply the relocation. */
2049 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
2050 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
2051 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2054 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2057 msg
= "cannot encode";
2058 if (is_direct_call_opcode (opcode
))
2060 if ((relocation
& 0x3) != 0)
2061 msg
= "misaligned call target";
2063 msg
= "call target out of range";
2065 else if (opcode
== get_l32r_opcode ())
2067 if ((relocation
& 0x3) != 0)
2068 msg
= "misaligned literal target";
2069 else if (is_alt_relocation (howto
->type
))
2070 msg
= "literal target out of range (too many literals)";
2071 else if (self_address
> relocation
)
2072 msg
= "literal target out of range (try using text-section-literals)";
2074 msg
= "literal placed after use";
2077 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2078 return bfd_reloc_dangerous
;
2081 /* Check for calls across 1GB boundaries. */
2082 if (is_direct_call_opcode (opcode
)
2083 && is_windowed_call_opcode (opcode
))
2085 if ((self_address
>> CALL_SEGMENT_BITS
)
2086 != (relocation
>> CALL_SEGMENT_BITS
))
2089 "windowed call crosses 1GB boundary; return may fail";
2090 return bfd_reloc_dangerous
;
2094 /* Write the modified instruction back out of the buffer. */
2095 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2096 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2097 input_size
- address
);
2098 return bfd_reloc_ok
;
2103 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2105 /* To reduce the size of the memory leak,
2106 we only use a single message buffer. */
2107 static bfd_size_type alloc_size
= 0;
2108 static char *message
= NULL
;
2109 bfd_size_type orig_len
, len
= 0;
2110 bfd_boolean is_append
;
2113 va_start (ap
, arglen
);
2115 is_append
= (origmsg
== message
);
2117 orig_len
= strlen (origmsg
);
2118 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2119 if (len
> alloc_size
)
2121 message
= (char *) bfd_realloc_or_free (message
, len
);
2124 if (message
!= NULL
)
2127 memcpy (message
, origmsg
, orig_len
);
2128 vsprintf (message
+ orig_len
, fmt
, ap
);
2135 /* This function is registered as the "special_function" in the
2136 Xtensa howto for handling simplify operations.
2137 bfd_perform_relocation / bfd_install_relocation use it to
2138 perform (install) the specified relocation. Since this replaces the code
2139 in bfd_perform_relocation, it is basically an Xtensa-specific,
2140 stripped-down version of bfd_perform_relocation. */
2142 static bfd_reloc_status_type
2143 bfd_elf_xtensa_reloc (bfd
*abfd
,
2144 arelent
*reloc_entry
,
2147 asection
*input_section
,
2149 char **error_message
)
2152 bfd_reloc_status_type flag
;
2153 bfd_size_type octets
= (reloc_entry
->address
2154 * OCTETS_PER_BYTE (abfd
, input_section
));
2155 bfd_vma output_base
= 0;
2156 reloc_howto_type
*howto
= reloc_entry
->howto
;
2157 asection
*reloc_target_output_section
;
2158 bfd_boolean is_weak_undef
;
2160 if (!xtensa_default_isa
)
2161 xtensa_default_isa
= xtensa_isa_init (0, 0);
2163 /* ELF relocs are against symbols. If we are producing relocatable
2164 output, and the reloc is against an external symbol, the resulting
2165 reloc will also be against the same symbol. In such a case, we
2166 don't want to change anything about the way the reloc is handled,
2167 since it will all be done at final link time. This test is similar
2168 to what bfd_elf_generic_reloc does except that it lets relocs with
2169 howto->partial_inplace go through even if the addend is non-zero.
2170 (The real problem is that partial_inplace is set for XTENSA_32
2171 relocs to begin with, but that's a long story and there's little we
2172 can do about it now....) */
2174 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2176 reloc_entry
->address
+= input_section
->output_offset
;
2177 return bfd_reloc_ok
;
2180 /* Is the address of the relocation really within the section? */
2181 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2182 return bfd_reloc_outofrange
;
2184 /* Work out which section the relocation is targeted at and the
2185 initial relocation command value. */
2187 /* Get symbol value. (Common symbols are special.) */
2188 if (bfd_is_com_section (symbol
->section
))
2191 relocation
= symbol
->value
;
2193 reloc_target_output_section
= symbol
->section
->output_section
;
2195 /* Convert input-section-relative symbol value to absolute. */
2196 if ((output_bfd
&& !howto
->partial_inplace
)
2197 || reloc_target_output_section
== NULL
)
2200 output_base
= reloc_target_output_section
->vma
;
2202 relocation
+= output_base
+ symbol
->section
->output_offset
;
2204 /* Add in supplied addend. */
2205 relocation
+= reloc_entry
->addend
;
2207 /* Here the variable relocation holds the final address of the
2208 symbol we are relocating against, plus any addend. */
2211 if (!howto
->partial_inplace
)
2213 /* This is a partial relocation, and we want to apply the relocation
2214 to the reloc entry rather than the raw data. Everything except
2215 relocations against section symbols has already been handled
2218 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2219 reloc_entry
->addend
= relocation
;
2220 reloc_entry
->address
+= input_section
->output_offset
;
2221 return bfd_reloc_ok
;
2225 reloc_entry
->address
+= input_section
->output_offset
;
2226 reloc_entry
->addend
= 0;
2230 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2231 && (symbol
->flags
& BSF_WEAK
) != 0);
2232 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2233 (bfd_byte
*) data
, (bfd_vma
) octets
,
2234 is_weak_undef
, error_message
);
2236 if (flag
== bfd_reloc_dangerous
)
2238 /* Add the symbol name to the error message. */
2239 if (! *error_message
)
2240 *error_message
= "";
2241 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2242 strlen (symbol
->name
) + 17,
2244 (unsigned long) reloc_entry
->addend
);
2251 /* Set up an entry in the procedure linkage table. */
2254 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2256 unsigned reloc_index
)
2258 asection
*splt
, *sgotplt
;
2259 bfd_vma plt_base
, got_base
;
2260 bfd_vma code_offset
, lit_offset
, abi_offset
;
2263 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2264 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2265 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2266 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2268 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2269 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2271 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2272 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2274 /* Fill in the literal entry. This is the offset of the dynamic
2275 relocation entry. */
2276 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2277 sgotplt
->contents
+ lit_offset
);
2279 /* Fill in the entry in the procedure linkage table. */
2280 memcpy (splt
->contents
+ code_offset
,
2281 (bfd_big_endian (output_bfd
)
2282 ? elf_xtensa_be_plt_entry
[XSHAL_ABI
!= XTHAL_ABI_WINDOWED
]
2283 : elf_xtensa_le_plt_entry
[XSHAL_ABI
!= XTHAL_ABI_WINDOWED
]),
2285 abi_offset
= XSHAL_ABI
== XTHAL_ABI_WINDOWED
? 3 : 0;
2286 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2287 plt_base
+ code_offset
+ abi_offset
),
2288 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2289 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2290 plt_base
+ code_offset
+ abi_offset
+ 3),
2291 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2292 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2293 plt_base
+ code_offset
+ abi_offset
+ 6),
2294 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2296 return plt_base
+ code_offset
;
2300 static bfd_boolean
get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2303 replace_tls_insn (Elf_Internal_Rela
*rel
,
2305 asection
*input_section
,
2307 bfd_boolean is_ld_model
,
2308 char **error_message
)
2310 static xtensa_insnbuf ibuff
= NULL
;
2311 static xtensa_insnbuf sbuff
= NULL
;
2312 xtensa_isa isa
= xtensa_default_isa
;
2314 xtensa_opcode old_op
, new_op
;
2315 bfd_size_type input_size
;
2317 unsigned dest_reg
, src_reg
;
2321 ibuff
= xtensa_insnbuf_alloc (isa
);
2322 sbuff
= xtensa_insnbuf_alloc (isa
);
2325 input_size
= bfd_get_section_limit (abfd
, input_section
);
2327 /* Read the instruction into a buffer and decode the opcode. */
2328 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2329 input_size
- rel
->r_offset
);
2330 fmt
= xtensa_format_decode (isa
, ibuff
);
2331 if (fmt
== XTENSA_UNDEFINED
)
2333 *error_message
= "cannot decode instruction format";
2337 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2338 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2340 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2341 if (old_op
== XTENSA_UNDEFINED
)
2343 *error_message
= "cannot decode instruction opcode";
2347 r_type
= ELF32_R_TYPE (rel
->r_info
);
2350 case R_XTENSA_TLS_FUNC
:
2351 case R_XTENSA_TLS_ARG
:
2352 if (old_op
!= get_l32r_opcode ()
2353 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2354 sbuff
, &dest_reg
) != 0)
2356 *error_message
= "cannot extract L32R destination for TLS access";
2361 case R_XTENSA_TLS_CALL
:
2362 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2363 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2364 sbuff
, &src_reg
) != 0)
2366 *error_message
= "cannot extract CALLXn operands for TLS access";
2379 case R_XTENSA_TLS_FUNC
:
2380 case R_XTENSA_TLS_ARG
:
2381 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2382 versions of Xtensa). */
2383 new_op
= xtensa_opcode_lookup (isa
, "nop");
2384 if (new_op
== XTENSA_UNDEFINED
)
2386 new_op
= xtensa_opcode_lookup (isa
, "or");
2387 if (new_op
== XTENSA_UNDEFINED
2388 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2389 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2391 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2393 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2396 *error_message
= "cannot encode OR for TLS access";
2402 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2404 *error_message
= "cannot encode NOP for TLS access";
2410 case R_XTENSA_TLS_CALL
:
2411 /* Read THREADPTR into the CALLX's return value register. */
2412 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2413 if (new_op
== XTENSA_UNDEFINED
2414 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2415 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2416 sbuff
, dest_reg
+ 2) != 0)
2418 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2428 case R_XTENSA_TLS_FUNC
:
2429 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2430 if (new_op
== XTENSA_UNDEFINED
2431 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2432 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2433 sbuff
, dest_reg
) != 0)
2435 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2440 case R_XTENSA_TLS_ARG
:
2441 /* Nothing to do. Keep the original L32R instruction. */
2444 case R_XTENSA_TLS_CALL
:
2445 /* Add the CALLX's src register (holding the THREADPTR value)
2446 to the first argument register (holding the offset) and put
2447 the result in the CALLX's return value register. */
2448 new_op
= xtensa_opcode_lookup (isa
, "add");
2449 if (new_op
== XTENSA_UNDEFINED
2450 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2451 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2452 sbuff
, dest_reg
+ 2) != 0
2453 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2454 sbuff
, dest_reg
+ 2) != 0
2455 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2456 sbuff
, src_reg
) != 0)
2458 *error_message
= "cannot encode ADD for TLS access";
2465 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2466 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2467 input_size
- rel
->r_offset
);
2473 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2474 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2475 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2476 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2477 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2478 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2479 || (R_TYPE) == R_XTENSA_TLS_ARG \
2480 || (R_TYPE) == R_XTENSA_TLS_CALL)
2482 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2483 both relocatable and final links. */
2486 elf_xtensa_relocate_section (bfd
*output_bfd
,
2487 struct bfd_link_info
*info
,
2489 asection
*input_section
,
2491 Elf_Internal_Rela
*relocs
,
2492 Elf_Internal_Sym
*local_syms
,
2493 asection
**local_sections
)
2495 struct elf_xtensa_link_hash_table
*htab
;
2496 Elf_Internal_Shdr
*symtab_hdr
;
2497 Elf_Internal_Rela
*rel
;
2498 Elf_Internal_Rela
*relend
;
2499 struct elf_link_hash_entry
**sym_hashes
;
2500 property_table_entry
*lit_table
= 0;
2502 char *local_got_tls_types
;
2503 char *error_message
= NULL
;
2504 bfd_size_type input_size
;
2507 if (!xtensa_default_isa
)
2508 xtensa_default_isa
= xtensa_isa_init (0, 0);
2510 if (!is_xtensa_elf (input_bfd
))
2512 bfd_set_error (bfd_error_wrong_format
);
2516 htab
= elf_xtensa_hash_table (info
);
2520 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2521 sym_hashes
= elf_sym_hashes (input_bfd
);
2522 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2524 if (elf_hash_table (info
)->dynamic_sections_created
)
2526 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2527 &lit_table
, XTENSA_LIT_SEC_NAME
,
2533 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2536 relend
= relocs
+ input_section
->reloc_count
;
2537 for (; rel
< relend
; rel
++)
2540 reloc_howto_type
*howto
;
2541 unsigned long r_symndx
;
2542 struct elf_link_hash_entry
*h
;
2543 Elf_Internal_Sym
*sym
;
2548 bfd_reloc_status_type r
;
2549 bfd_boolean is_weak_undef
;
2550 bfd_boolean unresolved_reloc
;
2552 bfd_boolean dynamic_symbol
;
2554 r_type
= ELF32_R_TYPE (rel
->r_info
);
2555 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2556 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2559 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2561 bfd_set_error (bfd_error_bad_value
);
2564 howto
= &elf_howto_table
[r_type
];
2566 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2571 is_weak_undef
= FALSE
;
2572 unresolved_reloc
= FALSE
;
2575 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2577 /* Because R_XTENSA_32 was made partial_inplace to fix some
2578 problems with DWARF info in partial links, there may be
2579 an addend stored in the contents. Take it out of there
2580 and move it back into the addend field of the reloc. */
2581 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2582 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2585 if (r_symndx
< symtab_hdr
->sh_info
)
2587 sym
= local_syms
+ r_symndx
;
2588 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2589 sec
= local_sections
[r_symndx
];
2590 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2594 bfd_boolean ignored
;
2596 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2597 r_symndx
, symtab_hdr
, sym_hashes
,
2599 unresolved_reloc
, warned
, ignored
);
2602 && !unresolved_reloc
2603 && h
->root
.type
== bfd_link_hash_undefweak
)
2604 is_weak_undef
= TRUE
;
2609 if (sec
!= NULL
&& discarded_section (sec
))
2610 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2611 rel
, 1, relend
, howto
, 0, contents
);
2613 if (bfd_link_relocatable (info
))
2616 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2618 /* This is a relocatable link.
2619 1) If the reloc is against a section symbol, adjust
2620 according to the output section.
2621 2) If there is a new target for this relocation,
2622 the new target will be in the same output section.
2623 We adjust the relocation by the output section
2626 if (relaxing_section
)
2628 /* Check if this references a section in another input file. */
2629 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2634 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2635 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2637 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2639 error_message
= NULL
;
2640 /* Convert ASM_SIMPLIFY into the simpler relocation
2641 so that they never escape a relaxing link. */
2642 r
= contract_asm_expansion (contents
, input_size
, rel
,
2644 if (r
!= bfd_reloc_ok
)
2645 (*info
->callbacks
->reloc_dangerous
)
2646 (info
, error_message
,
2647 input_bfd
, input_section
, rel
->r_offset
);
2649 r_type
= ELF32_R_TYPE (rel
->r_info
);
2652 /* This is a relocatable link, so we don't have to change
2653 anything unless the reloc is against a section symbol,
2654 in which case we have to adjust according to where the
2655 section symbol winds up in the output section. */
2656 if (r_symndx
< symtab_hdr
->sh_info
)
2658 sym
= local_syms
+ r_symndx
;
2659 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2661 sec
= local_sections
[r_symndx
];
2662 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2666 /* If there is an addend with a partial_inplace howto,
2667 then move the addend to the contents. This is a hack
2668 to work around problems with DWARF in relocatable links
2669 with some previous version of BFD. Now we can't easily get
2670 rid of the hack without breaking backward compatibility.... */
2672 howto
= &elf_howto_table
[r_type
];
2673 if (howto
->partial_inplace
&& rel
->r_addend
)
2675 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2676 rel
->r_addend
, contents
,
2677 rel
->r_offset
, FALSE
,
2683 /* Put the correct bits in the target instruction, even
2684 though the relocation will still be present in the output
2685 file. This makes disassembly clearer, as well as
2686 allowing loadable kernel modules to work without needing
2687 relocations on anything other than calls and l32r's. */
2689 /* If it is not in the same section, there is nothing we can do. */
2690 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2691 sym_sec
->output_section
== input_section
->output_section
)
2693 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2694 dest_addr
, contents
,
2695 rel
->r_offset
, FALSE
,
2699 if (r
!= bfd_reloc_ok
)
2700 (*info
->callbacks
->reloc_dangerous
)
2701 (info
, error_message
,
2702 input_bfd
, input_section
, rel
->r_offset
);
2704 /* Done with work for relocatable link; continue with next reloc. */
2708 /* This is a final link. */
2710 if (relaxing_section
)
2712 /* Check if this references a section in another input file. */
2713 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2717 /* Sanity check the address. */
2718 if (rel
->r_offset
>= input_size
2719 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2722 /* xgettext:c-format */
2723 (_("%pB(%pA+%#" PRIx64
"): "
2724 "relocation offset out of range (size=%#" PRIx64
")"),
2725 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2726 (uint64_t) input_size
);
2727 bfd_set_error (bfd_error_bad_value
);
2732 name
= h
->root
.root
.string
;
2735 name
= (bfd_elf_string_from_elf_section
2736 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2737 if (name
== NULL
|| *name
== '\0')
2738 name
= bfd_section_name (sec
);
2741 if (r_symndx
!= STN_UNDEF
2742 && r_type
!= R_XTENSA_NONE
2744 || h
->root
.type
== bfd_link_hash_defined
2745 || h
->root
.type
== bfd_link_hash_defweak
)
2746 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2749 ((sym_type
== STT_TLS
2750 /* xgettext:c-format */
2751 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2752 /* xgettext:c-format */
2753 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2756 (uint64_t) rel
->r_offset
,
2761 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2763 tls_type
= GOT_UNKNOWN
;
2765 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2766 else if (local_got_tls_types
)
2767 tls_type
= local_got_tls_types
[r_symndx
];
2773 if (elf_hash_table (info
)->dynamic_sections_created
2774 && (input_section
->flags
& SEC_ALLOC
) != 0
2775 && (dynamic_symbol
|| bfd_link_pic (info
)))
2777 Elf_Internal_Rela outrel
;
2781 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2782 srel
= htab
->elf
.srelplt
;
2784 srel
= htab
->elf
.srelgot
;
2786 BFD_ASSERT (srel
!= NULL
);
2789 _bfd_elf_section_offset (output_bfd
, info
,
2790 input_section
, rel
->r_offset
);
2792 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2793 memset (&outrel
, 0, sizeof outrel
);
2796 outrel
.r_offset
+= (input_section
->output_section
->vma
2797 + input_section
->output_offset
);
2799 /* Complain if the relocation is in a read-only section
2800 and not in a literal pool. */
2801 if ((input_section
->flags
& SEC_READONLY
) != 0
2802 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2806 _("dynamic relocation in read-only section");
2807 (*info
->callbacks
->reloc_dangerous
)
2808 (info
, error_message
,
2809 input_bfd
, input_section
, rel
->r_offset
);
2814 outrel
.r_addend
= rel
->r_addend
;
2817 if (r_type
== R_XTENSA_32
)
2820 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2823 else /* r_type == R_XTENSA_PLT */
2826 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2828 /* Create the PLT entry and set the initial
2829 contents of the literal entry to the address of
2832 elf_xtensa_create_plt_entry (info
, output_bfd
,
2835 unresolved_reloc
= FALSE
;
2837 else if (!is_weak_undef
)
2839 /* Generate a RELATIVE relocation. */
2840 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2841 outrel
.r_addend
= 0;
2849 loc
= (srel
->contents
2850 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2851 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2852 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2855 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2857 /* This should only happen for non-PIC code, which is not
2858 supposed to be used on systems with dynamic linking.
2859 Just ignore these relocations. */
2864 case R_XTENSA_TLS_TPOFF
:
2865 /* Switch to LE model for local symbols in an executable. */
2866 if (! bfd_link_pic (info
) && ! dynamic_symbol
)
2868 relocation
= tpoff (info
, relocation
);
2873 case R_XTENSA_TLSDESC_FN
:
2874 case R_XTENSA_TLSDESC_ARG
:
2876 if (r_type
== R_XTENSA_TLSDESC_FN
)
2878 if (! bfd_link_pic (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2879 r_type
= R_XTENSA_NONE
;
2881 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2883 if (bfd_link_pic (info
))
2885 if ((tls_type
& GOT_TLS_IE
) != 0)
2886 r_type
= R_XTENSA_TLS_TPOFF
;
2890 r_type
= R_XTENSA_TLS_TPOFF
;
2891 if (! dynamic_symbol
)
2893 relocation
= tpoff (info
, relocation
);
2899 if (r_type
== R_XTENSA_NONE
)
2900 /* Nothing to do here; skip to the next reloc. */
2903 if (! elf_hash_table (info
)->dynamic_sections_created
)
2906 _("TLS relocation invalid without dynamic sections");
2907 (*info
->callbacks
->reloc_dangerous
)
2908 (info
, error_message
,
2909 input_bfd
, input_section
, rel
->r_offset
);
2913 Elf_Internal_Rela outrel
;
2915 asection
*srel
= htab
->elf
.srelgot
;
2918 outrel
.r_offset
= (input_section
->output_section
->vma
2919 + input_section
->output_offset
2922 /* Complain if the relocation is in a read-only section
2923 and not in a literal pool. */
2924 if ((input_section
->flags
& SEC_READONLY
) != 0
2925 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2929 _("dynamic relocation in read-only section");
2930 (*info
->callbacks
->reloc_dangerous
)
2931 (info
, error_message
,
2932 input_bfd
, input_section
, rel
->r_offset
);
2935 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2937 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2939 outrel
.r_addend
= 0;
2942 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2944 unresolved_reloc
= FALSE
;
2947 loc
= (srel
->contents
2948 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2949 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2950 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2956 case R_XTENSA_TLS_DTPOFF
:
2957 if (! bfd_link_pic (info
))
2958 /* Switch from LD model to LE model. */
2959 relocation
= tpoff (info
, relocation
);
2961 relocation
-= dtpoff_base (info
);
2964 case R_XTENSA_TLS_FUNC
:
2965 case R_XTENSA_TLS_ARG
:
2966 case R_XTENSA_TLS_CALL
:
2967 /* Check if optimizing to IE or LE model. */
2968 if ((tls_type
& GOT_TLS_IE
) != 0)
2970 bfd_boolean is_ld_model
=
2971 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
2972 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
2973 is_ld_model
, &error_message
))
2974 (*info
->callbacks
->reloc_dangerous
)
2975 (info
, error_message
,
2976 input_bfd
, input_section
, rel
->r_offset
);
2978 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
2980 /* Skip subsequent relocations on the same instruction. */
2981 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
2988 if (elf_hash_table (info
)->dynamic_sections_created
2989 && dynamic_symbol
&& (is_operand_relocation (r_type
)
2990 || r_type
== R_XTENSA_32_PCREL
))
2993 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
2994 strlen (name
) + 2, name
);
2995 (*info
->callbacks
->reloc_dangerous
)
2996 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3002 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3003 because such sections are not SEC_ALLOC and thus ld.so will
3004 not process them. */
3005 if (unresolved_reloc
3006 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3008 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3009 rel
->r_offset
) != (bfd_vma
) -1)
3012 /* xgettext:c-format */
3013 (_("%pB(%pA+%#" PRIx64
"): "
3014 "unresolvable %s relocation against symbol `%s'"),
3017 (uint64_t) rel
->r_offset
,
3023 /* TLS optimizations may have changed r_type; update "howto". */
3024 howto
= &elf_howto_table
[r_type
];
3026 /* There's no point in calling bfd_perform_relocation here.
3027 Just go directly to our "special function". */
3028 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
3029 relocation
+ rel
->r_addend
,
3030 contents
, rel
->r_offset
, is_weak_undef
,
3033 if (r
!= bfd_reloc_ok
&& !warned
)
3035 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
3036 BFD_ASSERT (error_message
!= NULL
);
3038 if (rel
->r_addend
== 0)
3039 error_message
= vsprint_msg (error_message
, ": %s",
3040 strlen (name
) + 2, name
);
3042 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
3044 name
, (int) rel
->r_addend
);
3046 (*info
->callbacks
->reloc_dangerous
)
3047 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3054 input_section
->reloc_done
= TRUE
;
3060 /* Finish up dynamic symbol handling. There's not much to do here since
3061 the PLT and GOT entries are all set up by relocate_section. */
3064 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3065 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3066 struct elf_link_hash_entry
*h
,
3067 Elf_Internal_Sym
*sym
)
3069 if (h
->needs_plt
&& !h
->def_regular
)
3071 /* Mark the symbol as undefined, rather than as defined in
3072 the .plt section. Leave the value alone. */
3073 sym
->st_shndx
= SHN_UNDEF
;
3074 /* If the symbol is weak, we do need to clear the value.
3075 Otherwise, the PLT entry would provide a definition for
3076 the symbol even if the symbol wasn't defined anywhere,
3077 and so the symbol would never be NULL. */
3078 if (!h
->ref_regular_nonweak
)
3082 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3083 if (h
== elf_hash_table (info
)->hdynamic
3084 || h
== elf_hash_table (info
)->hgot
)
3085 sym
->st_shndx
= SHN_ABS
;
3091 /* Combine adjacent literal table entries in the output. Adjacent
3092 entries within each input section may have been removed during
3093 relaxation, but we repeat the process here, even though it's too late
3094 to shrink the output section, because it's important to minimize the
3095 number of literal table entries to reduce the start-up work for the
3096 runtime linker. Returns the number of remaining table entries or -1
3100 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3105 property_table_entry
*table
;
3106 bfd_size_type section_size
, sgotloc_size
;
3110 section_size
= sxtlit
->size
;
3111 BFD_ASSERT (section_size
% 8 == 0);
3112 num
= section_size
/ 8;
3114 sgotloc_size
= sgotloc
->size
;
3115 if (sgotloc_size
!= section_size
)
3118 (_("internal inconsistency in size of .got.loc section"));
3122 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3126 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3127 propagates to the output section, where it doesn't really apply and
3128 where it breaks the following call to bfd_malloc_and_get_section. */
3129 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3131 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3139 /* There should never be any relocations left at this point, so this
3140 is quite a bit easier than what is done during relaxation. */
3142 /* Copy the raw contents into a property table array and sort it. */
3144 for (n
= 0; n
< num
; n
++)
3146 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3147 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3150 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3152 for (n
= 0; n
< num
; n
++)
3154 bfd_boolean remove_entry
= FALSE
;
3156 if (table
[n
].size
== 0)
3157 remove_entry
= TRUE
;
3159 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3161 table
[n
-1].size
+= table
[n
].size
;
3162 remove_entry
= TRUE
;
3167 for (m
= n
; m
< num
- 1; m
++)
3169 table
[m
].address
= table
[m
+1].address
;
3170 table
[m
].size
= table
[m
+1].size
;
3178 /* Copy the data back to the raw contents. */
3180 for (n
= 0; n
< num
; n
++)
3182 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3183 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3187 /* Clear the removed bytes. */
3188 if ((bfd_size_type
) (num
* 8) < section_size
)
3189 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3191 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3195 /* Copy the contents to ".got.loc". */
3196 memcpy (sgotloc
->contents
, contents
, section_size
);
3204 /* Finish up the dynamic sections. */
3207 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3208 struct bfd_link_info
*info
)
3210 struct elf_xtensa_link_hash_table
*htab
;
3212 asection
*sdyn
, *srelplt
, *srelgot
, *sgot
, *sxtlit
, *sgotloc
;
3213 Elf32_External_Dyn
*dyncon
, *dynconend
;
3214 int num_xtlit_entries
= 0;
3216 if (! elf_hash_table (info
)->dynamic_sections_created
)
3219 htab
= elf_xtensa_hash_table (info
);
3223 dynobj
= elf_hash_table (info
)->dynobj
;
3224 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3225 BFD_ASSERT (sdyn
!= NULL
);
3227 /* Set the first entry in the global offset table to the address of
3228 the dynamic section. */
3229 sgot
= htab
->elf
.sgot
;
3232 BFD_ASSERT (sgot
->size
== 4);
3234 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3236 bfd_put_32 (output_bfd
,
3237 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3241 srelplt
= htab
->elf
.srelplt
;
3242 srelgot
= htab
->elf
.srelgot
;
3243 if (srelplt
&& srelplt
->size
!= 0)
3245 asection
*sgotplt
, *spltlittbl
;
3246 int chunk
, plt_chunks
, plt_entries
;
3247 Elf_Internal_Rela irela
;
3249 unsigned rtld_reloc
;
3251 spltlittbl
= htab
->spltlittbl
;
3252 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3254 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3255 of them follow immediately after.... */
3256 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3258 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3259 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3260 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3263 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3265 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3267 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3269 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3271 int chunk_entries
= 0;
3273 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3274 BFD_ASSERT (sgotplt
!= NULL
);
3276 /* Emit special RTLD relocations for the first two entries in
3277 each chunk of the .got.plt section. */
3279 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3280 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3281 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3282 irela
.r_offset
= (sgotplt
->output_section
->vma
3283 + sgotplt
->output_offset
);
3284 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3285 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3287 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3289 /* Next literal immediately follows the first. */
3290 loc
+= sizeof (Elf32_External_Rela
);
3291 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3292 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3293 irela
.r_offset
= (sgotplt
->output_section
->vma
3294 + sgotplt
->output_offset
+ 4);
3295 /* Tell rtld to set value to object's link map. */
3297 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3299 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3301 /* Fill in the literal table. */
3302 if (chunk
< plt_chunks
- 1)
3303 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3305 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3307 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3308 bfd_put_32 (output_bfd
,
3309 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3310 spltlittbl
->contents
+ (chunk
* 8) + 0);
3311 bfd_put_32 (output_bfd
,
3312 8 + (chunk_entries
* 4),
3313 spltlittbl
->contents
+ (chunk
* 8) + 4);
3316 /* The .xt.lit.plt section has just been modified. This must
3317 happen before the code below which combines adjacent literal
3318 table entries, and the .xt.lit.plt contents have to be forced to
3320 if (! bfd_set_section_contents (output_bfd
,
3321 spltlittbl
->output_section
,
3322 spltlittbl
->contents
,
3323 spltlittbl
->output_offset
,
3326 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3327 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3330 /* All the dynamic relocations have been emitted at this point.
3331 Make sure the relocation sections are the correct size. */
3332 if ((srelgot
&& srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3333 * srelgot
->reloc_count
))
3334 || (srelplt
&& srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3335 * srelplt
->reloc_count
)))
3338 /* Combine adjacent literal table entries. */
3339 BFD_ASSERT (! bfd_link_relocatable (info
));
3340 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3341 sgotloc
= htab
->sgotloc
;
3342 BFD_ASSERT (sgotloc
);
3346 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3347 if (num_xtlit_entries
< 0)
3351 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3352 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3353 for (; dyncon
< dynconend
; dyncon
++)
3355 Elf_Internal_Dyn dyn
;
3357 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3364 case DT_XTENSA_GOT_LOC_SZ
:
3365 dyn
.d_un
.d_val
= num_xtlit_entries
;
3368 case DT_XTENSA_GOT_LOC_OFF
:
3369 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3370 + htab
->sgotloc
->output_offset
);
3374 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3375 + htab
->elf
.sgot
->output_offset
);
3379 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3380 + htab
->elf
.srelplt
->output_offset
);
3384 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3388 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3395 /* Functions for dealing with the e_flags field. */
3397 /* Merge backend specific data from an object file to the output
3398 object file when linking. */
3401 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3403 bfd
*obfd
= info
->output_bfd
;
3404 unsigned out_mach
, in_mach
;
3405 flagword out_flag
, in_flag
;
3407 /* Check if we have the same endianness. */
3408 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3411 /* Don't even pretend to support mixed-format linking. */
3412 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3413 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3416 out_flag
= elf_elfheader (obfd
)->e_flags
;
3417 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3419 out_mach
= out_flag
& EF_XTENSA_MACH
;
3420 in_mach
= in_flag
& EF_XTENSA_MACH
;
3421 if (out_mach
!= in_mach
)
3424 /* xgettext:c-format */
3425 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3426 ibfd
, out_mach
, in_mach
);
3427 bfd_set_error (bfd_error_wrong_format
);
3431 if (! elf_flags_init (obfd
))
3433 elf_flags_init (obfd
) = TRUE
;
3434 elf_elfheader (obfd
)->e_flags
= in_flag
;
3436 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3437 && bfd_get_arch_info (obfd
)->the_default
)
3438 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3439 bfd_get_mach (ibfd
));
3444 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3445 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3447 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3448 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3455 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3457 BFD_ASSERT (!elf_flags_init (abfd
)
3458 || elf_elfheader (abfd
)->e_flags
== flags
);
3460 elf_elfheader (abfd
)->e_flags
|= flags
;
3461 elf_flags_init (abfd
) = TRUE
;
3468 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3470 FILE *f
= (FILE *) farg
;
3471 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3473 fprintf (f
, "\nXtensa header:\n");
3474 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3475 fprintf (f
, "\nMachine = Base\n");
3477 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3479 fprintf (f
, "Insn tables = %s\n",
3480 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3482 fprintf (f
, "Literal tables = %s\n",
3483 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3485 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3489 /* Set the right machine number for an Xtensa ELF file. */
3492 elf_xtensa_object_p (bfd
*abfd
)
3495 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3500 mach
= bfd_mach_xtensa
;
3506 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3511 /* The final processing done just before writing out an Xtensa ELF object
3512 file. This gets the Xtensa architecture right based on the machine
3516 elf_xtensa_final_write_processing (bfd
*abfd
)
3519 unsigned long val
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3521 switch (mach
= bfd_get_mach (abfd
))
3523 case bfd_mach_xtensa
:
3524 val
= E_XTENSA_MACH
;
3530 elf_elfheader (abfd
)->e_flags
&= ~EF_XTENSA_MACH
;
3531 elf_elfheader (abfd
)->e_flags
|= val
;
3532 return _bfd_elf_final_write_processing (abfd
);
3536 static enum elf_reloc_type_class
3537 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3538 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3539 const Elf_Internal_Rela
*rela
)
3541 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3543 case R_XTENSA_RELATIVE
:
3544 return reloc_class_relative
;
3545 case R_XTENSA_JMP_SLOT
:
3546 return reloc_class_plt
;
3548 return reloc_class_normal
;
3554 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3555 struct elf_reloc_cookie
*cookie
,
3556 struct bfd_link_info
*info
,
3560 bfd_vma offset
, actual_offset
;
3561 bfd_size_type removed_bytes
= 0;
3562 bfd_size_type entry_size
;
3564 if (sec
->output_section
3565 && bfd_is_abs_section (sec
->output_section
))
3568 if (xtensa_is_proptable_section (sec
))
3573 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3576 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3580 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3583 release_contents (sec
, contents
);
3587 /* Sort the relocations. They should already be in order when
3588 relaxation is enabled, but it might not be. */
3589 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3590 internal_reloc_compare
);
3592 cookie
->rel
= cookie
->rels
;
3593 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3595 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3597 actual_offset
= offset
- removed_bytes
;
3599 /* The ...symbol_deleted_p function will skip over relocs but it
3600 won't adjust their offsets, so do that here. */
3601 while (cookie
->rel
< cookie
->relend
3602 && cookie
->rel
->r_offset
< offset
)
3604 cookie
->rel
->r_offset
-= removed_bytes
;
3608 while (cookie
->rel
< cookie
->relend
3609 && cookie
->rel
->r_offset
== offset
)
3611 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3613 /* Remove the table entry. (If the reloc type is NONE, then
3614 the entry has already been merged with another and deleted
3615 during relaxation.) */
3616 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3618 /* Shift the contents up. */
3619 if (offset
+ entry_size
< sec
->size
)
3620 memmove (&contents
[actual_offset
],
3621 &contents
[actual_offset
+ entry_size
],
3622 sec
->size
- offset
- entry_size
);
3623 removed_bytes
+= entry_size
;
3626 /* Remove this relocation. */
3627 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3630 /* Adjust the relocation offset for previous removals. This
3631 should not be done before calling ...symbol_deleted_p
3632 because it might mess up the offset comparisons there.
3633 Make sure the offset doesn't underflow in the case where
3634 the first entry is removed. */
3635 if (cookie
->rel
->r_offset
>= removed_bytes
)
3636 cookie
->rel
->r_offset
-= removed_bytes
;
3638 cookie
->rel
->r_offset
= 0;
3644 if (removed_bytes
!= 0)
3646 /* Adjust any remaining relocs (shouldn't be any). */
3647 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3649 if (cookie
->rel
->r_offset
>= removed_bytes
)
3650 cookie
->rel
->r_offset
-= removed_bytes
;
3652 cookie
->rel
->r_offset
= 0;
3655 /* Clear the removed bytes. */
3656 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3658 pin_contents (sec
, contents
);
3659 pin_internal_relocs (sec
, cookie
->rels
);
3662 if (sec
->rawsize
== 0)
3663 sec
->rawsize
= sec
->size
;
3664 sec
->size
-= removed_bytes
;
3666 if (xtensa_is_littable_section (sec
))
3668 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3670 sgotloc
->size
-= removed_bytes
;
3675 release_contents (sec
, contents
);
3676 release_internal_relocs (sec
, cookie
->rels
);
3679 return (removed_bytes
!= 0);
3684 elf_xtensa_discard_info (bfd
*abfd
,
3685 struct elf_reloc_cookie
*cookie
,
3686 struct bfd_link_info
*info
)
3689 bfd_boolean changed
= FALSE
;
3691 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3693 if (xtensa_is_property_section (sec
))
3695 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3705 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3707 return xtensa_is_property_section (sec
);
3712 elf_xtensa_action_discarded (asection
*sec
)
3714 if (strcmp (".xt_except_table", sec
->name
) == 0)
3717 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3720 return _bfd_elf_default_action_discarded (sec
);
3724 /* Support for core dump NOTE sections. */
3727 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3732 /* The size for Xtensa is variable, so don't try to recognize the format
3733 based on the size. Just assume this is GNU/Linux. */
3736 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3739 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3743 size
= note
->descsz
- offset
- 4;
3745 /* Make a ".reg/999" section. */
3746 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3747 size
, note
->descpos
+ offset
);
3752 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3754 switch (note
->descsz
)
3759 case 128: /* GNU/Linux elf_prpsinfo */
3760 elf_tdata (abfd
)->core
->program
3761 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3762 elf_tdata (abfd
)->core
->command
3763 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3766 /* Note that for some reason, a spurious space is tacked
3767 onto the end of the args in some (at least one anyway)
3768 implementations, so strip it off if it exists. */
3771 char *command
= elf_tdata (abfd
)->core
->command
;
3772 int n
= strlen (command
);
3774 if (0 < n
&& command
[n
- 1] == ' ')
3775 command
[n
- 1] = '\0';
3782 /* Generic Xtensa configurability stuff. */
3784 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3785 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3786 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3787 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3788 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3789 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3790 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3791 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3794 init_call_opcodes (void)
3796 if (callx0_op
== XTENSA_UNDEFINED
)
3798 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3799 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3800 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3801 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3802 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3803 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3804 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3805 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3811 is_indirect_call_opcode (xtensa_opcode opcode
)
3813 init_call_opcodes ();
3814 return (opcode
== callx0_op
3815 || opcode
== callx4_op
3816 || opcode
== callx8_op
3817 || opcode
== callx12_op
);
3822 is_direct_call_opcode (xtensa_opcode opcode
)
3824 init_call_opcodes ();
3825 return (opcode
== call0_op
3826 || opcode
== call4_op
3827 || opcode
== call8_op
3828 || opcode
== call12_op
);
3833 is_windowed_call_opcode (xtensa_opcode opcode
)
3835 init_call_opcodes ();
3836 return (opcode
== call4_op
3837 || opcode
== call8_op
3838 || opcode
== call12_op
3839 || opcode
== callx4_op
3840 || opcode
== callx8_op
3841 || opcode
== callx12_op
);
3846 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3848 unsigned dst
= (unsigned) -1;
3850 init_call_opcodes ();
3851 if (opcode
== callx0_op
)
3853 else if (opcode
== callx4_op
)
3855 else if (opcode
== callx8_op
)
3857 else if (opcode
== callx12_op
)
3860 if (dst
== (unsigned) -1)
3868 static xtensa_opcode
3869 get_const16_opcode (void)
3871 static bfd_boolean done_lookup
= FALSE
;
3872 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3875 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3878 return const16_opcode
;
3882 static xtensa_opcode
3883 get_l32r_opcode (void)
3885 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3886 static bfd_boolean done_lookup
= FALSE
;
3890 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3898 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3902 offset
= addr
- ((pc
+3) & -4);
3903 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3904 offset
= (signed int) offset
>> 2;
3905 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3910 static xtensa_opcode
3911 get_rsr_lend_opcode (void)
3913 static xtensa_opcode rsr_lend_opcode
= XTENSA_UNDEFINED
;
3914 static bfd_boolean done_lookup
= FALSE
;
3917 rsr_lend_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "rsr.lend");
3920 return rsr_lend_opcode
;
3923 static xtensa_opcode
3924 get_wsr_lbeg_opcode (void)
3926 static xtensa_opcode wsr_lbeg_opcode
= XTENSA_UNDEFINED
;
3927 static bfd_boolean done_lookup
= FALSE
;
3930 wsr_lbeg_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "wsr.lbeg");
3933 return wsr_lbeg_opcode
;
3938 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3940 xtensa_isa isa
= xtensa_default_isa
;
3941 int last_immed
, last_opnd
, opi
;
3943 if (opcode
== XTENSA_UNDEFINED
)
3944 return XTENSA_UNDEFINED
;
3946 /* Find the last visible PC-relative immediate operand for the opcode.
3947 If there are no PC-relative immediates, then choose the last visible
3948 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3949 last_immed
= XTENSA_UNDEFINED
;
3950 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3951 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3953 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3955 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3960 if (last_immed
== XTENSA_UNDEFINED
3961 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3965 return XTENSA_UNDEFINED
;
3967 /* If the operand number was specified in an old-style relocation,
3968 check for consistency with the operand computed above. */
3969 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3971 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3972 if (reloc_opnd
!= last_immed
)
3973 return XTENSA_UNDEFINED
;
3981 get_relocation_slot (int r_type
)
3991 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
3992 return r_type
- R_XTENSA_SLOT0_OP
;
3993 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
3994 return r_type
- R_XTENSA_SLOT0_ALT
;
3998 return XTENSA_UNDEFINED
;
4002 /* Get the opcode for a relocation. */
4004 static xtensa_opcode
4005 get_relocation_opcode (bfd
*abfd
,
4008 Elf_Internal_Rela
*irel
)
4010 static xtensa_insnbuf ibuff
= NULL
;
4011 static xtensa_insnbuf sbuff
= NULL
;
4012 xtensa_isa isa
= xtensa_default_isa
;
4016 if (contents
== NULL
)
4017 return XTENSA_UNDEFINED
;
4019 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
4020 return XTENSA_UNDEFINED
;
4024 ibuff
= xtensa_insnbuf_alloc (isa
);
4025 sbuff
= xtensa_insnbuf_alloc (isa
);
4028 /* Decode the instruction. */
4029 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
4030 sec
->size
- irel
->r_offset
);
4031 fmt
= xtensa_format_decode (isa
, ibuff
);
4032 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
4033 if (slot
== XTENSA_UNDEFINED
)
4034 return XTENSA_UNDEFINED
;
4035 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
4036 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
4041 is_l32r_relocation (bfd
*abfd
,
4044 Elf_Internal_Rela
*irel
)
4046 xtensa_opcode opcode
;
4047 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
4049 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
4050 return (opcode
== get_l32r_opcode ());
4054 static bfd_size_type
4055 get_asm_simplify_size (bfd_byte
*contents
,
4056 bfd_size_type content_len
,
4057 bfd_size_type offset
)
4059 bfd_size_type insnlen
, size
= 0;
4061 /* Decode the size of the next two instructions. */
4062 insnlen
= insn_decode_len (contents
, content_len
, offset
);
4068 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
4078 is_alt_relocation (int r_type
)
4080 return (r_type
>= R_XTENSA_SLOT0_ALT
4081 && r_type
<= R_XTENSA_SLOT14_ALT
);
4086 is_operand_relocation (int r_type
)
4096 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4098 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4107 #define MIN_INSN_LENGTH 2
4109 /* Return 0 if it fails to decode. */
4112 insn_decode_len (bfd_byte
*contents
,
4113 bfd_size_type content_len
,
4114 bfd_size_type offset
)
4117 xtensa_isa isa
= xtensa_default_isa
;
4119 static xtensa_insnbuf ibuff
= NULL
;
4121 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4125 ibuff
= xtensa_insnbuf_alloc (isa
);
4126 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4127 content_len
- offset
);
4128 fmt
= xtensa_format_decode (isa
, ibuff
);
4129 if (fmt
== XTENSA_UNDEFINED
)
4131 insn_len
= xtensa_format_length (isa
, fmt
);
4132 if (insn_len
== XTENSA_UNDEFINED
)
4138 insn_num_slots (bfd_byte
*contents
,
4139 bfd_size_type content_len
,
4140 bfd_size_type offset
)
4142 xtensa_isa isa
= xtensa_default_isa
;
4144 static xtensa_insnbuf ibuff
= NULL
;
4146 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4147 return XTENSA_UNDEFINED
;
4150 ibuff
= xtensa_insnbuf_alloc (isa
);
4151 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4152 content_len
- offset
);
4153 fmt
= xtensa_format_decode (isa
, ibuff
);
4154 if (fmt
== XTENSA_UNDEFINED
)
4155 return XTENSA_UNDEFINED
;
4156 return xtensa_format_num_slots (isa
, fmt
);
4160 /* Decode the opcode for a single slot instruction.
4161 Return 0 if it fails to decode or the instruction is multi-slot. */
4164 insn_decode_opcode (bfd_byte
*contents
,
4165 bfd_size_type content_len
,
4166 bfd_size_type offset
,
4169 xtensa_isa isa
= xtensa_default_isa
;
4171 static xtensa_insnbuf insnbuf
= NULL
;
4172 static xtensa_insnbuf slotbuf
= NULL
;
4174 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4175 return XTENSA_UNDEFINED
;
4177 if (insnbuf
== NULL
)
4179 insnbuf
= xtensa_insnbuf_alloc (isa
);
4180 slotbuf
= xtensa_insnbuf_alloc (isa
);
4183 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4184 content_len
- offset
);
4185 fmt
= xtensa_format_decode (isa
, insnbuf
);
4186 if (fmt
== XTENSA_UNDEFINED
)
4187 return XTENSA_UNDEFINED
;
4189 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4190 return XTENSA_UNDEFINED
;
4192 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4193 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4197 /* The offset is the offset in the contents.
4198 The address is the address of that offset. */
4201 check_branch_target_aligned (bfd_byte
*contents
,
4202 bfd_size_type content_length
,
4206 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4209 return check_branch_target_aligned_address (address
, insn_len
);
4214 check_loop_aligned (bfd_byte
*contents
,
4215 bfd_size_type content_length
,
4219 bfd_size_type loop_len
, insn_len
;
4220 xtensa_opcode opcode
;
4222 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4223 if (opcode
== XTENSA_UNDEFINED
4224 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4230 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4231 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4232 if (loop_len
== 0 || insn_len
== 0)
4238 /* If this is relaxed loop, analyze first instruction of the actual loop
4239 body. It must be at offset 27 from the loop instruction address. */
4241 && insn_num_slots (contents
, content_length
, offset
+ loop_len
) == 1
4242 && insn_decode_opcode (contents
, content_length
,
4243 offset
+ loop_len
, 0) == get_rsr_lend_opcode()
4244 && insn_decode_len (contents
, content_length
, offset
+ loop_len
+ 3) == 3
4245 && insn_num_slots (contents
, content_length
, offset
+ loop_len
+ 3) == 1
4246 && insn_decode_opcode (contents
, content_length
,
4247 offset
+ loop_len
+ 3, 0) == get_wsr_lbeg_opcode())
4250 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4252 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4257 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4260 return (addr
% 8 == 0);
4261 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4265 /* Instruction widening and narrowing. */
4267 /* When FLIX is available we need to access certain instructions only
4268 when they are 16-bit or 24-bit instructions. This table caches
4269 information about such instructions by walking through all the
4270 opcodes and finding the smallest single-slot format into which each
4273 static xtensa_format
*op_single_fmt_table
= NULL
;
4277 init_op_single_format_table (void)
4279 xtensa_isa isa
= xtensa_default_isa
;
4280 xtensa_insnbuf ibuf
;
4281 xtensa_opcode opcode
;
4285 if (op_single_fmt_table
)
4288 ibuf
= xtensa_insnbuf_alloc (isa
);
4289 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4291 op_single_fmt_table
= (xtensa_format
*)
4292 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4293 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4295 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4296 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4298 if (xtensa_format_num_slots (isa
, fmt
) == 1
4299 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4301 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4302 int fmt_length
= xtensa_format_length (isa
, fmt
);
4303 if (old_fmt
== XTENSA_UNDEFINED
4304 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4305 op_single_fmt_table
[opcode
] = fmt
;
4309 xtensa_insnbuf_free (isa
, ibuf
);
4313 static xtensa_format
4314 get_single_format (xtensa_opcode opcode
)
4316 init_op_single_format_table ();
4317 return op_single_fmt_table
[opcode
];
4321 /* For the set of narrowable instructions we do NOT include the
4322 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4323 involved during linker relaxation that may require these to
4324 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4325 requires special case code to ensure it only works when op1 == op2. */
4333 struct string_pair narrowable
[] =
4336 { "addi", "addi.n" },
4337 { "addmi", "addi.n" },
4338 { "l32i", "l32i.n" },
4339 { "movi", "movi.n" },
4341 { "retw", "retw.n" },
4342 { "s32i", "s32i.n" },
4343 { "or", "mov.n" } /* special case only when op1 == op2 */
4346 struct string_pair widenable
[] =
4349 { "addi", "addi.n" },
4350 { "addmi", "addi.n" },
4351 { "beqz", "beqz.n" },
4352 { "bnez", "bnez.n" },
4353 { "l32i", "l32i.n" },
4354 { "movi", "movi.n" },
4356 { "retw", "retw.n" },
4357 { "s32i", "s32i.n" },
4358 { "or", "mov.n" } /* special case only when op1 == op2 */
4362 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4363 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4364 return the instruction buffer holding the narrow instruction. Otherwise,
4365 return 0. The set of valid narrowing are specified by a string table
4366 but require some special case operand checks in some cases. */
4368 static xtensa_insnbuf
4369 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4371 xtensa_opcode opcode
)
4373 xtensa_isa isa
= xtensa_default_isa
;
4374 xtensa_format o_fmt
;
4377 static xtensa_insnbuf o_insnbuf
= NULL
;
4378 static xtensa_insnbuf o_slotbuf
= NULL
;
4380 if (o_insnbuf
== NULL
)
4382 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4383 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4386 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4388 bfd_boolean is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4390 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4392 uint32 value
, newval
;
4393 int i
, operand_count
, o_operand_count
;
4394 xtensa_opcode o_opcode
;
4396 /* Address does not matter in this case. We might need to
4397 fix it to handle branches/jumps. */
4398 bfd_vma self_address
= 0;
4400 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4401 if (o_opcode
== XTENSA_UNDEFINED
)
4403 o_fmt
= get_single_format (o_opcode
);
4404 if (o_fmt
== XTENSA_UNDEFINED
)
4407 if (xtensa_format_length (isa
, fmt
) != 3
4408 || xtensa_format_length (isa
, o_fmt
) != 2)
4411 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4412 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4413 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4415 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4420 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4425 uint32 rawval0
, rawval1
, rawval2
;
4427 if (o_operand_count
+ 1 != operand_count
4428 || xtensa_operand_get_field (isa
, opcode
, 0,
4429 fmt
, 0, slotbuf
, &rawval0
) != 0
4430 || xtensa_operand_get_field (isa
, opcode
, 1,
4431 fmt
, 0, slotbuf
, &rawval1
) != 0
4432 || xtensa_operand_get_field (isa
, opcode
, 2,
4433 fmt
, 0, slotbuf
, &rawval2
) != 0
4434 || rawval1
!= rawval2
4435 || rawval0
== rawval1
/* it is a nop */)
4439 for (i
= 0; i
< o_operand_count
; ++i
)
4441 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4443 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4446 /* PC-relative branches need adjustment, but
4447 the PC-rel operand will always have a relocation. */
4449 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4451 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4452 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4457 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4467 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4468 the action in-place directly into the contents and return TRUE. Otherwise,
4469 the return value is FALSE and the contents are not modified. */
4472 narrow_instruction (bfd_byte
*contents
,
4473 bfd_size_type content_length
,
4474 bfd_size_type offset
)
4476 xtensa_opcode opcode
;
4477 bfd_size_type insn_len
;
4478 xtensa_isa isa
= xtensa_default_isa
;
4480 xtensa_insnbuf o_insnbuf
;
4482 static xtensa_insnbuf insnbuf
= NULL
;
4483 static xtensa_insnbuf slotbuf
= NULL
;
4485 if (insnbuf
== NULL
)
4487 insnbuf
= xtensa_insnbuf_alloc (isa
);
4488 slotbuf
= xtensa_insnbuf_alloc (isa
);
4491 BFD_ASSERT (offset
< content_length
);
4493 if (content_length
< 2)
4496 /* We will hand-code a few of these for a little while.
4497 These have all been specified in the assembler aleady. */
4498 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4499 content_length
- offset
);
4500 fmt
= xtensa_format_decode (isa
, insnbuf
);
4501 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4504 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4507 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4508 if (opcode
== XTENSA_UNDEFINED
)
4510 insn_len
= xtensa_format_length (isa
, fmt
);
4511 if (insn_len
> content_length
)
4514 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4517 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4518 content_length
- offset
);
4526 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4527 "density" instruction to a standard 3-byte instruction. If it is valid,
4528 return the instruction buffer holding the wide instruction. Otherwise,
4529 return 0. The set of valid widenings are specified by a string table
4530 but require some special case operand checks in some cases. */
4532 static xtensa_insnbuf
4533 can_widen_instruction (xtensa_insnbuf slotbuf
,
4535 xtensa_opcode opcode
)
4537 xtensa_isa isa
= xtensa_default_isa
;
4538 xtensa_format o_fmt
;
4541 static xtensa_insnbuf o_insnbuf
= NULL
;
4542 static xtensa_insnbuf o_slotbuf
= NULL
;
4544 if (o_insnbuf
== NULL
)
4546 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4547 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4550 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4552 bfd_boolean is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4553 bfd_boolean is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4554 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4556 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4558 uint32 value
, newval
;
4559 int i
, operand_count
, o_operand_count
, check_operand_count
;
4560 xtensa_opcode o_opcode
;
4562 /* Address does not matter in this case. We might need to fix it
4563 to handle branches/jumps. */
4564 bfd_vma self_address
= 0;
4566 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4567 if (o_opcode
== XTENSA_UNDEFINED
)
4569 o_fmt
= get_single_format (o_opcode
);
4570 if (o_fmt
== XTENSA_UNDEFINED
)
4573 if (xtensa_format_length (isa
, fmt
) != 2
4574 || xtensa_format_length (isa
, o_fmt
) != 3)
4577 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4578 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4579 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4580 check_operand_count
= o_operand_count
;
4582 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4587 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4592 uint32 rawval0
, rawval1
;
4594 if (o_operand_count
!= operand_count
+ 1
4595 || xtensa_operand_get_field (isa
, opcode
, 0,
4596 fmt
, 0, slotbuf
, &rawval0
) != 0
4597 || xtensa_operand_get_field (isa
, opcode
, 1,
4598 fmt
, 0, slotbuf
, &rawval1
) != 0
4599 || rawval0
== rawval1
/* it is a nop */)
4603 check_operand_count
--;
4605 for (i
= 0; i
< check_operand_count
; i
++)
4608 if (is_or
&& i
== o_operand_count
- 1)
4610 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4612 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4615 /* PC-relative branches need adjustment, but
4616 the PC-rel operand will always have a relocation. */
4618 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4620 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4621 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4626 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4636 /* Attempt to widen an instruction. If the widening is valid, perform
4637 the action in-place directly into the contents and return TRUE. Otherwise,
4638 the return value is FALSE and the contents are not modified. */
4641 widen_instruction (bfd_byte
*contents
,
4642 bfd_size_type content_length
,
4643 bfd_size_type offset
)
4645 xtensa_opcode opcode
;
4646 bfd_size_type insn_len
;
4647 xtensa_isa isa
= xtensa_default_isa
;
4649 xtensa_insnbuf o_insnbuf
;
4651 static xtensa_insnbuf insnbuf
= NULL
;
4652 static xtensa_insnbuf slotbuf
= NULL
;
4654 if (insnbuf
== NULL
)
4656 insnbuf
= xtensa_insnbuf_alloc (isa
);
4657 slotbuf
= xtensa_insnbuf_alloc (isa
);
4660 BFD_ASSERT (offset
< content_length
);
4662 if (content_length
< 2)
4665 /* We will hand-code a few of these for a little while.
4666 These have all been specified in the assembler aleady. */
4667 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4668 content_length
- offset
);
4669 fmt
= xtensa_format_decode (isa
, insnbuf
);
4670 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4673 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4676 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4677 if (opcode
== XTENSA_UNDEFINED
)
4679 insn_len
= xtensa_format_length (isa
, fmt
);
4680 if (insn_len
> content_length
)
4683 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4686 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4687 content_length
- offset
);
4694 /* Code for transforming CALLs at link-time. */
4696 static bfd_reloc_status_type
4697 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4699 bfd_vma content_length
,
4700 char **error_message
)
4702 static xtensa_insnbuf insnbuf
= NULL
;
4703 static xtensa_insnbuf slotbuf
= NULL
;
4704 xtensa_format core_format
= XTENSA_UNDEFINED
;
4705 xtensa_opcode opcode
;
4706 xtensa_opcode direct_call_opcode
;
4707 xtensa_isa isa
= xtensa_default_isa
;
4708 bfd_byte
*chbuf
= contents
+ address
;
4711 if (insnbuf
== NULL
)
4713 insnbuf
= xtensa_insnbuf_alloc (isa
);
4714 slotbuf
= xtensa_insnbuf_alloc (isa
);
4717 if (content_length
< address
)
4719 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4720 return bfd_reloc_other
;
4723 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4724 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4725 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4727 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4728 return bfd_reloc_other
;
4731 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4732 core_format
= xtensa_format_lookup (isa
, "x24");
4733 opcode
= xtensa_opcode_lookup (isa
, "or");
4734 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4735 for (opn
= 0; opn
< 3; opn
++)
4738 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4739 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4742 xtensa_format_encode (isa
, core_format
, insnbuf
);
4743 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4744 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4746 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4747 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4748 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 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
+ 3,
4753 content_length
- address
- 3);
4755 return bfd_reloc_ok
;
4759 static bfd_reloc_status_type
4760 contract_asm_expansion (bfd_byte
*contents
,
4761 bfd_vma content_length
,
4762 Elf_Internal_Rela
*irel
,
4763 char **error_message
)
4765 bfd_reloc_status_type retval
=
4766 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4769 if (retval
!= bfd_reloc_ok
)
4770 return bfd_reloc_dangerous
;
4772 /* Update the irel->r_offset field so that the right immediate and
4773 the right instruction are modified during the relocation. */
4774 irel
->r_offset
+= 3;
4775 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4776 return bfd_reloc_ok
;
4780 static xtensa_opcode
4781 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4783 init_call_opcodes ();
4785 if (opcode
== callx0_op
) return call0_op
;
4786 if (opcode
== callx4_op
) return call4_op
;
4787 if (opcode
== callx8_op
) return call8_op
;
4788 if (opcode
== callx12_op
) return call12_op
;
4790 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4791 return XTENSA_UNDEFINED
;
4795 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4796 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4797 If not, return XTENSA_UNDEFINED. */
4799 #define L32R_TARGET_REG_OPERAND 0
4800 #define CONST16_TARGET_REG_OPERAND 0
4801 #define CALLN_SOURCE_OPERAND 0
4803 static xtensa_opcode
4804 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bfd_boolean
*p_uses_l32r
)
4806 static xtensa_insnbuf insnbuf
= NULL
;
4807 static xtensa_insnbuf slotbuf
= NULL
;
4809 xtensa_opcode opcode
;
4810 xtensa_isa isa
= xtensa_default_isa
;
4811 uint32 regno
, const16_regno
, call_regno
;
4814 if (insnbuf
== NULL
)
4816 insnbuf
= xtensa_insnbuf_alloc (isa
);
4817 slotbuf
= xtensa_insnbuf_alloc (isa
);
4820 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4821 fmt
= xtensa_format_decode (isa
, insnbuf
);
4822 if (fmt
== XTENSA_UNDEFINED
4823 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4824 return XTENSA_UNDEFINED
;
4826 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4827 if (opcode
== XTENSA_UNDEFINED
)
4828 return XTENSA_UNDEFINED
;
4830 if (opcode
== get_l32r_opcode ())
4833 *p_uses_l32r
= TRUE
;
4834 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4835 fmt
, 0, slotbuf
, ®no
)
4836 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4838 return XTENSA_UNDEFINED
;
4840 else if (opcode
== get_const16_opcode ())
4843 *p_uses_l32r
= FALSE
;
4844 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4845 fmt
, 0, slotbuf
, ®no
)
4846 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4848 return XTENSA_UNDEFINED
;
4850 /* Check that the next instruction is also CONST16. */
4851 offset
+= xtensa_format_length (isa
, fmt
);
4852 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4853 fmt
= xtensa_format_decode (isa
, insnbuf
);
4854 if (fmt
== XTENSA_UNDEFINED
4855 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4856 return XTENSA_UNDEFINED
;
4857 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4858 if (opcode
!= get_const16_opcode ())
4859 return XTENSA_UNDEFINED
;
4861 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4862 fmt
, 0, slotbuf
, &const16_regno
)
4863 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4865 || const16_regno
!= regno
)
4866 return XTENSA_UNDEFINED
;
4869 return XTENSA_UNDEFINED
;
4871 /* Next instruction should be an CALLXn with operand 0 == regno. */
4872 offset
+= xtensa_format_length (isa
, fmt
);
4873 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4874 fmt
= xtensa_format_decode (isa
, insnbuf
);
4875 if (fmt
== XTENSA_UNDEFINED
4876 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4877 return XTENSA_UNDEFINED
;
4878 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4879 if (opcode
== XTENSA_UNDEFINED
4880 || !is_indirect_call_opcode (opcode
))
4881 return XTENSA_UNDEFINED
;
4883 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4884 fmt
, 0, slotbuf
, &call_regno
)
4885 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4887 return XTENSA_UNDEFINED
;
4889 if (call_regno
!= regno
)
4890 return XTENSA_UNDEFINED
;
4896 /* Data structures used during relaxation. */
4898 /* r_reloc: relocation values. */
4900 /* Through the relaxation process, we need to keep track of the values
4901 that will result from evaluating relocations. The standard ELF
4902 relocation structure is not sufficient for this purpose because we're
4903 operating on multiple input files at once, so we need to know which
4904 input file a relocation refers to. The r_reloc structure thus
4905 records both the input file (bfd) and ELF relocation.
4907 For efficiency, an r_reloc also contains a "target_offset" field to
4908 cache the target-section-relative offset value that is represented by
4911 The r_reloc also contains a virtual offset that allows multiple
4912 inserted literals to be placed at the same "address" with
4913 different offsets. */
4915 typedef struct r_reloc_struct r_reloc
;
4917 struct r_reloc_struct
4920 Elf_Internal_Rela rela
;
4921 bfd_vma target_offset
;
4922 bfd_vma virtual_offset
;
4926 /* The r_reloc structure is included by value in literal_value, but not
4927 every literal_value has an associated relocation -- some are simple
4928 constants. In such cases, we set all the fields in the r_reloc
4929 struct to zero. The r_reloc_is_const function should be used to
4930 detect this case. */
4933 r_reloc_is_const (const r_reloc
*r_rel
)
4935 return (r_rel
->abfd
== NULL
);
4940 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4942 bfd_vma target_offset
;
4943 unsigned long r_symndx
;
4945 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4946 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4947 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4948 return (target_offset
+ r_rel
->rela
.r_addend
);
4952 static struct elf_link_hash_entry
*
4953 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4955 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4956 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4961 r_reloc_get_section (const r_reloc
*r_rel
)
4963 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4964 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4969 r_reloc_is_defined (const r_reloc
*r_rel
)
4975 sec
= r_reloc_get_section (r_rel
);
4976 if (sec
== bfd_abs_section_ptr
4977 || sec
== bfd_com_section_ptr
4978 || sec
== bfd_und_section_ptr
)
4985 r_reloc_init (r_reloc
*r_rel
,
4987 Elf_Internal_Rela
*irel
,
4989 bfd_size_type content_length
)
4992 reloc_howto_type
*howto
;
4996 r_rel
->rela
= *irel
;
4998 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
4999 r_rel
->virtual_offset
= 0;
5000 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
5001 howto
= &elf_howto_table
[r_type
];
5002 if (howto
->partial_inplace
)
5004 bfd_vma inplace_val
;
5005 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
5007 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
5008 r_rel
->target_offset
+= inplace_val
;
5012 memset (r_rel
, 0, sizeof (r_reloc
));
5019 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
5021 if (r_reloc_is_defined (r_rel
))
5023 asection
*sec
= r_reloc_get_section (r_rel
);
5024 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
5026 else if (r_reloc_get_hash_entry (r_rel
))
5027 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
5029 fprintf (fp
, " ?? + ");
5031 fprintf_vma (fp
, r_rel
->target_offset
);
5032 if (r_rel
->virtual_offset
)
5034 fprintf (fp
, " + ");
5035 fprintf_vma (fp
, r_rel
->virtual_offset
);
5044 /* source_reloc: relocations that reference literals. */
5046 /* To determine whether literals can be coalesced, we need to first
5047 record all the relocations that reference the literals. The
5048 source_reloc structure below is used for this purpose. The
5049 source_reloc entries are kept in a per-literal-section array, sorted
5050 by offset within the literal section (i.e., target offset).
5052 The source_sec and r_rel.rela.r_offset fields identify the source of
5053 the relocation. The r_rel field records the relocation value, i.e.,
5054 the offset of the literal being referenced. The opnd field is needed
5055 to determine the range of the immediate field to which the relocation
5056 applies, so we can determine whether another literal with the same
5057 value is within range. The is_null field is true when the relocation
5058 is being removed (e.g., when an L32R is being removed due to a CALLX
5059 that is converted to a direct CALL). */
5061 typedef struct source_reloc_struct source_reloc
;
5063 struct source_reloc_struct
5065 asection
*source_sec
;
5067 xtensa_opcode opcode
;
5069 bfd_boolean is_null
;
5070 bfd_boolean is_abs_literal
;
5075 init_source_reloc (source_reloc
*reloc
,
5076 asection
*source_sec
,
5077 const r_reloc
*r_rel
,
5078 xtensa_opcode opcode
,
5080 bfd_boolean is_abs_literal
)
5082 reloc
->source_sec
= source_sec
;
5083 reloc
->r_rel
= *r_rel
;
5084 reloc
->opcode
= opcode
;
5086 reloc
->is_null
= FALSE
;
5087 reloc
->is_abs_literal
= is_abs_literal
;
5091 /* Find the source_reloc for a particular source offset and relocation
5092 type. Note that the array is sorted by _target_ offset, so this is
5093 just a linear search. */
5095 static source_reloc
*
5096 find_source_reloc (source_reloc
*src_relocs
,
5099 Elf_Internal_Rela
*irel
)
5103 for (i
= 0; i
< src_count
; i
++)
5105 if (src_relocs
[i
].source_sec
== sec
5106 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
5107 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
5108 == ELF32_R_TYPE (irel
->r_info
)))
5109 return &src_relocs
[i
];
5117 source_reloc_compare (const void *ap
, const void *bp
)
5119 const source_reloc
*a
= (const source_reloc
*) ap
;
5120 const source_reloc
*b
= (const source_reloc
*) bp
;
5122 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
5123 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5125 /* We don't need to sort on these criteria for correctness,
5126 but enforcing a more strict ordering prevents unstable qsort
5127 from behaving differently with different implementations.
5128 Without the code below we get correct but different results
5129 on Solaris 2.7 and 2.8. We would like to always produce the
5130 same results no matter the host. */
5132 if ((!a
->is_null
) - (!b
->is_null
))
5133 return ((!a
->is_null
) - (!b
->is_null
));
5134 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5138 /* Literal values and value hash tables. */
5140 /* Literals with the same value can be coalesced. The literal_value
5141 structure records the value of a literal: the "r_rel" field holds the
5142 information from the relocation on the literal (if there is one) and
5143 the "value" field holds the contents of the literal word itself.
5145 The value_map structure records a literal value along with the
5146 location of a literal holding that value. The value_map hash table
5147 is indexed by the literal value, so that we can quickly check if a
5148 particular literal value has been seen before and is thus a candidate
5151 typedef struct literal_value_struct literal_value
;
5152 typedef struct value_map_struct value_map
;
5153 typedef struct value_map_hash_table_struct value_map_hash_table
;
5155 struct literal_value_struct
5158 unsigned long value
;
5159 bfd_boolean is_abs_literal
;
5162 struct value_map_struct
5164 literal_value val
; /* The literal value. */
5165 r_reloc loc
; /* Location of the literal. */
5169 struct value_map_hash_table_struct
5171 unsigned bucket_count
;
5172 value_map
**buckets
;
5174 bfd_boolean has_last_loc
;
5180 init_literal_value (literal_value
*lit
,
5181 const r_reloc
*r_rel
,
5182 unsigned long value
,
5183 bfd_boolean is_abs_literal
)
5185 lit
->r_rel
= *r_rel
;
5187 lit
->is_abs_literal
= is_abs_literal
;
5192 literal_value_equal (const literal_value
*src1
,
5193 const literal_value
*src2
,
5194 bfd_boolean final_static_link
)
5196 struct elf_link_hash_entry
*h1
, *h2
;
5198 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5201 if (r_reloc_is_const (&src1
->r_rel
))
5202 return (src1
->value
== src2
->value
);
5204 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5205 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5208 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5211 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5214 if (src1
->value
!= src2
->value
)
5217 /* Now check for the same section (if defined) or the same elf_hash
5218 (if undefined or weak). */
5219 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5220 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5221 if (r_reloc_is_defined (&src1
->r_rel
)
5222 && (final_static_link
5223 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5224 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5226 if (r_reloc_get_section (&src1
->r_rel
)
5227 != r_reloc_get_section (&src2
->r_rel
))
5232 /* Require that the hash entries (i.e., symbols) be identical. */
5233 if (h1
!= h2
|| h1
== 0)
5237 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5244 /* Must be power of 2. */
5245 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5247 static value_map_hash_table
*
5248 value_map_hash_table_init (void)
5250 value_map_hash_table
*values
;
5252 values
= (value_map_hash_table
*)
5253 bfd_zmalloc (sizeof (value_map_hash_table
));
5254 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5256 values
->buckets
= (value_map
**)
5257 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5258 if (values
->buckets
== NULL
)
5263 values
->has_last_loc
= FALSE
;
5270 value_map_hash_table_delete (value_map_hash_table
*table
)
5272 free (table
->buckets
);
5278 hash_bfd_vma (bfd_vma val
)
5280 return (val
>> 2) + (val
>> 10);
5285 literal_value_hash (const literal_value
*src
)
5289 hash_val
= hash_bfd_vma (src
->value
);
5290 if (!r_reloc_is_const (&src
->r_rel
))
5294 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5295 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5296 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5298 /* Now check for the same section and the same elf_hash. */
5299 if (r_reloc_is_defined (&src
->r_rel
))
5300 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5302 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5303 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5309 /* Check if the specified literal_value has been seen before. */
5312 value_map_get_cached_value (value_map_hash_table
*map
,
5313 const literal_value
*val
,
5314 bfd_boolean final_static_link
)
5320 idx
= literal_value_hash (val
);
5321 idx
= idx
& (map
->bucket_count
- 1);
5322 bucket
= map
->buckets
[idx
];
5323 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5325 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5332 /* Record a new literal value. It is illegal to call this if VALUE
5333 already has an entry here. */
5336 add_value_map (value_map_hash_table
*map
,
5337 const literal_value
*val
,
5339 bfd_boolean final_static_link
)
5341 value_map
**bucket_p
;
5344 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5347 bfd_set_error (bfd_error_no_memory
);
5351 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5355 idx
= literal_value_hash (val
);
5356 idx
= idx
& (map
->bucket_count
- 1);
5357 bucket_p
= &map
->buckets
[idx
];
5359 val_e
->next
= *bucket_p
;
5362 /* FIXME: Consider resizing the hash table if we get too many entries. */
5368 /* Lists of text actions (ta_) for narrowing, widening, longcall
5369 conversion, space fill, code & literal removal, etc. */
5371 /* The following text actions are generated:
5373 "ta_remove_insn" remove an instruction or instructions
5374 "ta_remove_longcall" convert longcall to call
5375 "ta_convert_longcall" convert longcall to nop/call
5376 "ta_narrow_insn" narrow a wide instruction
5377 "ta_widen" widen a narrow instruction
5378 "ta_fill" add fill or remove fill
5379 removed < 0 is a fill; branches to the fill address will be
5380 changed to address + fill size (e.g., address - removed)
5381 removed >= 0 branches to the fill address will stay unchanged
5382 "ta_remove_literal" remove a literal; this action is
5383 indicated when a literal is removed
5385 "ta_add_literal" insert a new literal; this action is
5386 indicated when a literal has been moved.
5387 It may use a virtual_offset because
5388 multiple literals can be placed at the
5391 For each of these text actions, we also record the number of bytes
5392 removed by performing the text action. In the case of a "ta_widen"
5393 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5395 typedef struct text_action_struct text_action
;
5396 typedef struct text_action_list_struct text_action_list
;
5397 typedef enum text_action_enum_t text_action_t
;
5399 enum text_action_enum_t
5402 ta_remove_insn
, /* removed = -size */
5403 ta_remove_longcall
, /* removed = -size */
5404 ta_convert_longcall
, /* removed = 0 */
5405 ta_narrow_insn
, /* removed = -1 */
5406 ta_widen_insn
, /* removed = +1 */
5407 ta_fill
, /* removed = +size */
5413 /* Structure for a text action record. */
5414 struct text_action_struct
5416 text_action_t action
;
5417 asection
*sec
; /* Optional */
5419 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5421 literal_value value
; /* Only valid when adding literals. */
5424 struct removal_by_action_entry_struct
5429 int eq_removed_before_fill
;
5431 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5433 struct removal_by_action_map_struct
5436 removal_by_action_entry
*entry
;
5438 typedef struct removal_by_action_map_struct removal_by_action_map
;
5441 /* List of all of the actions taken on a text section. */
5442 struct text_action_list_struct
5446 removal_by_action_map map
;
5450 static text_action
*
5451 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5455 /* It is not necessary to fill at the end of a section. */
5456 if (sec
->size
== offset
)
5462 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5464 return (text_action
*)node
->value
;
5470 compute_removed_action_diff (const text_action
*ta
,
5474 int removable_space
)
5477 int current_removed
= 0;
5480 current_removed
= ta
->removed_bytes
;
5482 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5483 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5485 /* It is not necessary to fill at the end of a section. Clean this up. */
5486 if (sec
->size
== offset
)
5487 new_removed
= removable_space
- 0;
5491 int added
= -removed
- current_removed
;
5492 /* Ignore multiples of the section alignment. */
5493 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5494 new_removed
= (-added
);
5496 /* Modify for removable. */
5497 space
= removable_space
- new_removed
;
5498 new_removed
= (removable_space
5499 - (((1 << sec
->alignment_power
) - 1) & space
));
5501 return (new_removed
- current_removed
);
5506 adjust_fill_action (text_action
*ta
, int fill_diff
)
5508 ta
->removed_bytes
+= fill_diff
;
5513 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5515 text_action
*pa
= (text_action
*)a
;
5516 text_action
*pb
= (text_action
*)b
;
5517 static const int action_priority
[] =
5521 [ta_convert_longcall
] = 2,
5522 [ta_narrow_insn
] = 3,
5523 [ta_remove_insn
] = 4,
5524 [ta_remove_longcall
] = 5,
5525 [ta_remove_literal
] = 6,
5526 [ta_widen_insn
] = 7,
5527 [ta_add_literal
] = 8,
5530 if (pa
->offset
== pb
->offset
)
5532 if (pa
->action
== pb
->action
)
5534 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5537 return pa
->offset
< pb
->offset
? -1 : 1;
5540 static text_action
*
5541 action_first (text_action_list
*action_list
)
5543 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5544 return node
? (text_action
*)node
->value
: NULL
;
5547 static text_action
*
5548 action_next (text_action_list
*action_list
, text_action
*action
)
5550 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5551 (splay_tree_key
)action
);
5552 return node
? (text_action
*)node
->value
: NULL
;
5555 /* Add a modification action to the text. For the case of adding or
5556 removing space, modify any current fill and assume that
5557 "unreachable_space" bytes can be freely contracted. Note that a
5558 negative removed value is a fill. */
5561 text_action_add (text_action_list
*l
,
5562 text_action_t action
,
5570 /* It is not necessary to fill at the end of a section. */
5571 if (action
== ta_fill
&& sec
->size
== offset
)
5574 /* It is not necessary to fill 0 bytes. */
5575 if (action
== ta_fill
&& removed
== 0)
5581 if (action
== ta_fill
)
5583 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5587 ta
= (text_action
*)node
->value
;
5588 ta
->removed_bytes
+= removed
;
5593 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5595 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5596 ta
->action
= action
;
5598 ta
->offset
= offset
;
5599 ta
->removed_bytes
= removed
;
5600 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5606 text_action_add_literal (text_action_list
*l
,
5607 text_action_t action
,
5609 const literal_value
*value
,
5613 asection
*sec
= r_reloc_get_section (loc
);
5614 bfd_vma offset
= loc
->target_offset
;
5615 bfd_vma virtual_offset
= loc
->virtual_offset
;
5617 BFD_ASSERT (action
== ta_add_literal
);
5619 /* Create a new record and fill it up. */
5620 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5621 ta
->action
= action
;
5623 ta
->offset
= offset
;
5624 ta
->virtual_offset
= virtual_offset
;
5626 ta
->removed_bytes
= removed
;
5628 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5629 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5634 /* Find the total offset adjustment for the relaxations specified by
5635 text_actions, beginning from a particular starting action. This is
5636 typically used from offset_with_removed_text to search an entire list of
5637 actions, but it may also be called directly when adjusting adjacent offsets
5638 so that each search may begin where the previous one left off. */
5641 removed_by_actions (text_action_list
*action_list
,
5642 text_action
**p_start_action
,
5644 bfd_boolean before_fill
)
5649 r
= *p_start_action
;
5652 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5654 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5659 if (r
->offset
> offset
)
5662 if (r
->offset
== offset
5663 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5666 removed
+= r
->removed_bytes
;
5668 r
= action_next (action_list
, r
);
5671 *p_start_action
= r
;
5677 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5679 text_action
*r
= action_first (action_list
);
5681 return offset
- removed_by_actions (action_list
, &r
, offset
, FALSE
);
5686 action_list_count (text_action_list
*action_list
)
5688 return action_list
->count
;
5691 typedef struct map_action_fn_context_struct map_action_fn_context
;
5692 struct map_action_fn_context_struct
5695 removal_by_action_map map
;
5696 bfd_boolean eq_complete
;
5700 map_action_fn (splay_tree_node node
, void *p
)
5702 map_action_fn_context
*ctx
= p
;
5703 text_action
*r
= (text_action
*)node
->value
;
5704 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5706 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5712 ++ctx
->map
.n_entries
;
5713 ctx
->eq_complete
= FALSE
;
5714 ientry
->offset
= r
->offset
;
5715 ientry
->eq_removed_before_fill
= ctx
->removed
;
5718 if (!ctx
->eq_complete
)
5720 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5722 ientry
->eq_removed
= ctx
->removed
;
5723 ctx
->eq_complete
= TRUE
;
5726 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5729 ctx
->removed
+= r
->removed_bytes
;
5730 ientry
->removed
= ctx
->removed
;
5735 map_removal_by_action (text_action_list
*action_list
)
5737 map_action_fn_context ctx
;
5740 ctx
.map
.n_entries
= 0;
5741 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5742 sizeof (removal_by_action_entry
));
5743 ctx
.eq_complete
= FALSE
;
5745 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5746 action_list
->map
= ctx
.map
;
5750 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5751 bfd_boolean before_fill
)
5755 if (!action_list
->map
.entry
)
5756 map_removal_by_action (action_list
);
5758 if (!action_list
->map
.n_entries
)
5762 b
= action_list
->map
.n_entries
;
5766 unsigned c
= (a
+ b
) / 2;
5768 if (action_list
->map
.entry
[c
].offset
<= offset
)
5774 if (action_list
->map
.entry
[a
].offset
< offset
)
5776 return action_list
->map
.entry
[a
].removed
;
5778 else if (action_list
->map
.entry
[a
].offset
== offset
)
5780 return before_fill
?
5781 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5782 action_list
->map
.entry
[a
].eq_removed
;
5791 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5793 int removed
= removed_by_actions_map (action_list
, offset
, FALSE
);
5794 return offset
- removed
;
5798 /* The find_insn_action routine will only find non-fill actions. */
5800 static text_action
*
5801 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5803 static const text_action_t action
[] =
5805 ta_convert_longcall
,
5815 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5817 splay_tree_node node
;
5819 a
.action
= action
[i
];
5820 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5822 return (text_action
*)node
->value
;
5831 print_action (FILE *fp
, text_action
*r
)
5833 const char *t
= "unknown";
5836 case ta_remove_insn
:
5837 t
= "remove_insn"; break;
5838 case ta_remove_longcall
:
5839 t
= "remove_longcall"; break;
5840 case ta_convert_longcall
:
5841 t
= "convert_longcall"; break;
5842 case ta_narrow_insn
:
5843 t
= "narrow_insn"; break;
5845 t
= "widen_insn"; break;
5850 case ta_remove_literal
:
5851 t
= "remove_literal"; break;
5852 case ta_add_literal
:
5853 t
= "add_literal"; break;
5856 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5857 r
->sec
->owner
->filename
,
5858 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5862 print_action_list_fn (splay_tree_node node
, void *p
)
5864 text_action
*r
= (text_action
*)node
->value
;
5866 print_action (p
, r
);
5871 print_action_list (FILE *fp
, text_action_list
*action_list
)
5873 fprintf (fp
, "Text Action\n");
5874 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5880 /* Lists of literals being coalesced or removed. */
5882 /* In the usual case, the literal identified by "from" is being
5883 coalesced with another literal identified by "to". If the literal is
5884 unused and is being removed altogether, "to.abfd" will be NULL.
5885 The removed_literal entries are kept on a per-section list, sorted
5886 by the "from" offset field. */
5888 typedef struct removed_literal_struct removed_literal
;
5889 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5890 typedef struct removed_literal_list_struct removed_literal_list
;
5892 struct removed_literal_struct
5896 removed_literal
*next
;
5899 struct removed_literal_map_entry_struct
5902 removed_literal
*literal
;
5905 struct removed_literal_list_struct
5907 removed_literal
*head
;
5908 removed_literal
*tail
;
5911 removed_literal_map_entry
*map
;
5915 /* Record that the literal at "from" is being removed. If "to" is not
5916 NULL, the "from" literal is being coalesced with the "to" literal. */
5919 add_removed_literal (removed_literal_list
*removed_list
,
5920 const r_reloc
*from
,
5923 removed_literal
*r
, *new_r
, *next_r
;
5925 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5927 new_r
->from
= *from
;
5931 new_r
->to
.abfd
= NULL
;
5934 r
= removed_list
->head
;
5937 removed_list
->head
= new_r
;
5938 removed_list
->tail
= new_r
;
5940 /* Special check for common case of append. */
5941 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5943 removed_list
->tail
->next
= new_r
;
5944 removed_list
->tail
= new_r
;
5948 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5954 new_r
->next
= next_r
;
5956 removed_list
->tail
= new_r
;
5961 map_removed_literal (removed_literal_list
*removed_list
)
5965 removed_literal_map_entry
*map
= NULL
;
5966 removed_literal
*r
= removed_list
->head
;
5968 for (i
= 0; r
; ++i
, r
= r
->next
)
5972 n_map
= (n_map
* 2) + 2;
5973 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5975 map
[i
].addr
= r
->from
.target_offset
;
5978 removed_list
->map
= map
;
5979 removed_list
->n_map
= i
;
5983 removed_literal_compare (const void *a
, const void *b
)
5985 const removed_literal_map_entry
*pa
= a
;
5986 const removed_literal_map_entry
*pb
= b
;
5988 if (pa
->addr
== pb
->addr
)
5991 return pa
->addr
< pb
->addr
? -1 : 1;
5994 /* Check if the list of removed literals contains an entry for the
5995 given address. Return the entry if found. */
5997 static removed_literal
*
5998 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
6000 removed_literal_map_entry
*p
;
6001 removed_literal
*r
= NULL
;
6003 if (removed_list
->map
== NULL
)
6004 map_removed_literal (removed_list
);
6006 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
6007 sizeof (*removed_list
->map
), removed_literal_compare
);
6010 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
6021 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
6024 r
= removed_list
->head
;
6026 fprintf (fp
, "Removed Literals\n");
6027 for (; r
!= NULL
; r
= r
->next
)
6029 print_r_reloc (fp
, &r
->from
);
6030 fprintf (fp
, " => ");
6031 if (r
->to
.abfd
== NULL
)
6032 fprintf (fp
, "REMOVED");
6034 print_r_reloc (fp
, &r
->to
);
6042 /* Per-section data for relaxation. */
6044 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
6046 struct xtensa_relax_info_struct
6048 bfd_boolean is_relaxable_literal_section
;
6049 bfd_boolean is_relaxable_asm_section
;
6050 int visited
; /* Number of times visited. */
6052 source_reloc
*src_relocs
; /* Array[src_count]. */
6054 int src_next
; /* Next src_relocs entry to assign. */
6056 removed_literal_list removed_list
;
6057 text_action_list action_list
;
6059 reloc_bfd_fix
*fix_list
;
6060 reloc_bfd_fix
*fix_array
;
6061 unsigned fix_array_count
;
6063 /* Support for expanding the reloc array that is stored
6064 in the section structure. If the relocations have been
6065 reallocated, the newly allocated relocations will be referenced
6066 here along with the actual size allocated. The relocation
6067 count will always be found in the section structure. */
6068 Elf_Internal_Rela
*allocated_relocs
;
6069 unsigned relocs_count
;
6070 unsigned allocated_relocs_count
;
6073 struct elf_xtensa_section_data
6075 struct bfd_elf_section_data elf
;
6076 xtensa_relax_info relax_info
;
6081 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
6083 if (!sec
->used_by_bfd
)
6085 struct elf_xtensa_section_data
*sdata
;
6086 size_t amt
= sizeof (*sdata
);
6088 sdata
= bfd_zalloc (abfd
, amt
);
6091 sec
->used_by_bfd
= sdata
;
6094 return _bfd_elf_new_section_hook (abfd
, sec
);
6098 static xtensa_relax_info
*
6099 get_xtensa_relax_info (asection
*sec
)
6101 struct elf_xtensa_section_data
*section_data
;
6103 /* No info available if no section or if it is an output section. */
6104 if (!sec
|| sec
== sec
->output_section
)
6107 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
6108 return §ion_data
->relax_info
;
6113 init_xtensa_relax_info (asection
*sec
)
6115 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6117 relax_info
->is_relaxable_literal_section
= FALSE
;
6118 relax_info
->is_relaxable_asm_section
= FALSE
;
6119 relax_info
->visited
= 0;
6121 relax_info
->src_relocs
= NULL
;
6122 relax_info
->src_count
= 0;
6123 relax_info
->src_next
= 0;
6125 relax_info
->removed_list
.head
= NULL
;
6126 relax_info
->removed_list
.tail
= NULL
;
6128 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6130 relax_info
->action_list
.map
.n_entries
= 0;
6131 relax_info
->action_list
.map
.entry
= NULL
;
6133 relax_info
->fix_list
= NULL
;
6134 relax_info
->fix_array
= NULL
;
6135 relax_info
->fix_array_count
= 0;
6137 relax_info
->allocated_relocs
= NULL
;
6138 relax_info
->relocs_count
= 0;
6139 relax_info
->allocated_relocs_count
= 0;
6143 /* Coalescing literals may require a relocation to refer to a section in
6144 a different input file, but the standard relocation information
6145 cannot express that. Instead, the reloc_bfd_fix structures are used
6146 to "fix" the relocations that refer to sections in other input files.
6147 These structures are kept on per-section lists. The "src_type" field
6148 records the relocation type in case there are multiple relocations on
6149 the same location. FIXME: This is ugly; an alternative might be to
6150 add new symbols with the "owner" field to some other input file. */
6152 struct reloc_bfd_fix_struct
6156 unsigned src_type
; /* Relocation type. */
6158 asection
*target_sec
;
6159 bfd_vma target_offset
;
6160 bfd_boolean translated
;
6162 reloc_bfd_fix
*next
;
6166 static reloc_bfd_fix
*
6167 reloc_bfd_fix_init (asection
*src_sec
,
6170 asection
*target_sec
,
6171 bfd_vma target_offset
,
6172 bfd_boolean translated
)
6176 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6177 fix
->src_sec
= src_sec
;
6178 fix
->src_offset
= src_offset
;
6179 fix
->src_type
= src_type
;
6180 fix
->target_sec
= target_sec
;
6181 fix
->target_offset
= target_offset
;
6182 fix
->translated
= translated
;
6189 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6191 xtensa_relax_info
*relax_info
;
6193 relax_info
= get_xtensa_relax_info (src_sec
);
6194 fix
->next
= relax_info
->fix_list
;
6195 relax_info
->fix_list
= fix
;
6200 fix_compare (const void *ap
, const void *bp
)
6202 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6203 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6205 if (a
->src_offset
!= b
->src_offset
)
6206 return (a
->src_offset
- b
->src_offset
);
6207 return (a
->src_type
- b
->src_type
);
6212 cache_fix_array (asection
*sec
)
6214 unsigned i
, count
= 0;
6216 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6218 if (relax_info
== NULL
)
6220 if (relax_info
->fix_list
== NULL
)
6223 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6226 relax_info
->fix_array
=
6227 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6228 relax_info
->fix_array_count
= count
;
6230 r
= relax_info
->fix_list
;
6231 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6233 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6234 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6237 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6238 sizeof (reloc_bfd_fix
), fix_compare
);
6242 static reloc_bfd_fix
*
6243 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6245 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6249 if (relax_info
== NULL
)
6251 if (relax_info
->fix_list
== NULL
)
6254 if (relax_info
->fix_array
== NULL
)
6255 cache_fix_array (sec
);
6257 key
.src_offset
= offset
;
6258 key
.src_type
= type
;
6259 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6260 sizeof (reloc_bfd_fix
), fix_compare
);
6265 /* Section caching. */
6267 typedef struct section_cache_struct section_cache_t
;
6269 struct section_cache_struct
6273 bfd_byte
*contents
; /* Cache of the section contents. */
6274 bfd_size_type content_length
;
6276 property_table_entry
*ptbl
; /* Cache of the section property table. */
6279 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6280 unsigned reloc_count
;
6285 init_section_cache (section_cache_t
*sec_cache
)
6287 memset (sec_cache
, 0, sizeof (*sec_cache
));
6292 free_section_cache (section_cache_t
*sec_cache
)
6296 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6297 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6298 if (sec_cache
->ptbl
)
6299 free (sec_cache
->ptbl
);
6305 section_cache_section (section_cache_t
*sec_cache
,
6307 struct bfd_link_info
*link_info
)
6310 property_table_entry
*prop_table
= NULL
;
6312 bfd_byte
*contents
= NULL
;
6313 Elf_Internal_Rela
*internal_relocs
= NULL
;
6314 bfd_size_type sec_size
;
6318 if (sec
== sec_cache
->sec
)
6322 sec_size
= bfd_get_section_limit (abfd
, sec
);
6324 /* Get the contents. */
6325 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6326 if (contents
== NULL
&& sec_size
!= 0)
6329 /* Get the relocations. */
6330 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6331 link_info
->keep_memory
);
6333 /* Get the entry table. */
6334 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6335 XTENSA_PROP_SEC_NAME
, FALSE
);
6339 /* Fill in the new section cache. */
6340 free_section_cache (sec_cache
);
6341 init_section_cache (sec_cache
);
6343 sec_cache
->sec
= sec
;
6344 sec_cache
->contents
= contents
;
6345 sec_cache
->content_length
= sec_size
;
6346 sec_cache
->relocs
= internal_relocs
;
6347 sec_cache
->reloc_count
= sec
->reloc_count
;
6348 sec_cache
->pte_count
= ptblsize
;
6349 sec_cache
->ptbl
= prop_table
;
6354 release_contents (sec
, contents
);
6355 release_internal_relocs (sec
, internal_relocs
);
6362 /* Extended basic blocks. */
6364 /* An ebb_struct represents an Extended Basic Block. Within this
6365 range, we guarantee that all instructions are decodable, the
6366 property table entries are contiguous, and no property table
6367 specifies a segment that cannot have instructions moved. This
6368 structure contains caches of the contents, property table and
6369 relocations for the specified section for easy use. The range is
6370 specified by ranges of indices for the byte offset, property table
6371 offsets and relocation offsets. These must be consistent. */
6373 typedef struct ebb_struct ebb_t
;
6379 bfd_byte
*contents
; /* Cache of the section contents. */
6380 bfd_size_type content_length
;
6382 property_table_entry
*ptbl
; /* Cache of the section property table. */
6385 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6386 unsigned reloc_count
;
6388 bfd_vma start_offset
; /* Offset in section. */
6389 unsigned start_ptbl_idx
; /* Offset in the property table. */
6390 unsigned start_reloc_idx
; /* Offset in the relocations. */
6393 unsigned end_ptbl_idx
;
6394 unsigned end_reloc_idx
;
6396 bfd_boolean ends_section
; /* Is this the last ebb in a section? */
6398 /* The unreachable property table at the end of this set of blocks;
6399 NULL if the end is not an unreachable block. */
6400 property_table_entry
*ends_unreachable
;
6404 enum ebb_target_enum
6407 EBB_DESIRE_TGT_ALIGN
,
6408 EBB_REQUIRE_TGT_ALIGN
,
6409 EBB_REQUIRE_LOOP_ALIGN
,
6414 /* proposed_action_struct is similar to the text_action_struct except
6415 that is represents a potential transformation, not one that will
6416 occur. We build a list of these for an extended basic block
6417 and use them to compute the actual actions desired. We must be
6418 careful that the entire set of actual actions we perform do not
6419 break any relocations that would fit if the actions were not
6422 typedef struct proposed_action_struct proposed_action
;
6424 struct proposed_action_struct
6426 enum ebb_target_enum align_type
; /* for the target alignment */
6427 bfd_vma alignment_pow
;
6428 text_action_t action
;
6431 bfd_boolean do_action
; /* If false, then we will not perform the action. */
6435 /* The ebb_constraint_struct keeps a set of proposed actions for an
6436 extended basic block. */
6438 typedef struct ebb_constraint_struct ebb_constraint
;
6440 struct ebb_constraint_struct
6443 bfd_boolean start_movable
;
6445 /* Bytes of extra space at the beginning if movable. */
6446 int start_extra_space
;
6448 enum ebb_target_enum start_align
;
6450 bfd_boolean end_movable
;
6452 /* Bytes of extra space at the end if movable. */
6453 int end_extra_space
;
6455 unsigned action_count
;
6456 unsigned action_allocated
;
6458 /* Array of proposed actions. */
6459 proposed_action
*actions
;
6461 /* Action alignments -- one for each proposed action. */
6462 enum ebb_target_enum
*action_aligns
;
6467 init_ebb_constraint (ebb_constraint
*c
)
6469 memset (c
, 0, sizeof (ebb_constraint
));
6474 free_ebb_constraint (ebb_constraint
*c
)
6482 init_ebb (ebb_t
*ebb
,
6485 bfd_size_type content_length
,
6486 property_table_entry
*prop_table
,
6488 Elf_Internal_Rela
*internal_relocs
,
6489 unsigned reloc_count
)
6491 memset (ebb
, 0, sizeof (ebb_t
));
6493 ebb
->contents
= contents
;
6494 ebb
->content_length
= content_length
;
6495 ebb
->ptbl
= prop_table
;
6496 ebb
->pte_count
= ptblsize
;
6497 ebb
->relocs
= internal_relocs
;
6498 ebb
->reloc_count
= reloc_count
;
6499 ebb
->start_offset
= 0;
6500 ebb
->end_offset
= ebb
->content_length
- 1;
6501 ebb
->start_ptbl_idx
= 0;
6502 ebb
->end_ptbl_idx
= ptblsize
;
6503 ebb
->start_reloc_idx
= 0;
6504 ebb
->end_reloc_idx
= reloc_count
;
6508 /* Extend the ebb to all decodable contiguous sections. The algorithm
6509 for building a basic block around an instruction is to push it
6510 forward until we hit the end of a section, an unreachable block or
6511 a block that cannot be transformed. Then we push it backwards
6512 searching for similar conditions. */
6514 static bfd_boolean
extend_ebb_bounds_forward (ebb_t
*);
6515 static bfd_boolean
extend_ebb_bounds_backward (ebb_t
*);
6516 static bfd_size_type insn_block_decodable_len
6517 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6520 extend_ebb_bounds (ebb_t
*ebb
)
6522 if (!extend_ebb_bounds_forward (ebb
))
6524 if (!extend_ebb_bounds_backward (ebb
))
6531 extend_ebb_bounds_forward (ebb_t
*ebb
)
6533 property_table_entry
*the_entry
, *new_entry
;
6535 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6537 /* Stop when (1) we cannot decode an instruction, (2) we are at
6538 the end of the property tables, (3) we hit a non-contiguous property
6539 table entry, (4) we hit a NO_TRANSFORM region. */
6544 bfd_size_type insn_block_len
;
6546 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6548 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6550 entry_end
- ebb
->end_offset
);
6551 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6554 /* xgettext:c-format */
6555 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6556 "possible configuration mismatch"),
6557 ebb
->sec
->owner
, ebb
->sec
,
6558 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6561 ebb
->end_offset
+= insn_block_len
;
6563 if (ebb
->end_offset
== ebb
->sec
->size
)
6564 ebb
->ends_section
= TRUE
;
6566 /* Update the reloc counter. */
6567 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6568 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6571 ebb
->end_reloc_idx
++;
6574 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6577 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6578 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6579 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6580 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6583 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6586 the_entry
= new_entry
;
6587 ebb
->end_ptbl_idx
++;
6590 /* Quick check for an unreachable or end of file just at the end. */
6591 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6593 if (ebb
->end_offset
== ebb
->content_length
)
6594 ebb
->ends_section
= TRUE
;
6598 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6599 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6600 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6601 ebb
->ends_unreachable
= new_entry
;
6604 /* Any other ending requires exact alignment. */
6610 extend_ebb_bounds_backward (ebb_t
*ebb
)
6612 property_table_entry
*the_entry
, *new_entry
;
6614 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6616 /* Stop when (1) we cannot decode the instructions in the current entry.
6617 (2) we are at the beginning of the property tables, (3) we hit a
6618 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6622 bfd_vma block_begin
;
6623 bfd_size_type insn_block_len
;
6625 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6627 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6629 ebb
->start_offset
- block_begin
);
6630 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6633 /* xgettext:c-format */
6634 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6635 "possible configuration mismatch"),
6636 ebb
->sec
->owner
, ebb
->sec
,
6637 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6640 ebb
->start_offset
-= insn_block_len
;
6642 /* Update the reloc counter. */
6643 while (ebb
->start_reloc_idx
> 0
6644 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6645 >= ebb
->start_offset
))
6647 ebb
->start_reloc_idx
--;
6650 if (ebb
->start_ptbl_idx
== 0)
6653 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6654 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6655 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6656 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6658 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6661 the_entry
= new_entry
;
6662 ebb
->start_ptbl_idx
--;
6668 static bfd_size_type
6669 insn_block_decodable_len (bfd_byte
*contents
,
6670 bfd_size_type content_len
,
6671 bfd_vma block_offset
,
6672 bfd_size_type block_len
)
6674 bfd_vma offset
= block_offset
;
6676 while (offset
< block_offset
+ block_len
)
6678 bfd_size_type insn_len
= 0;
6680 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6682 return (offset
- block_offset
);
6685 return (offset
- block_offset
);
6690 ebb_propose_action (ebb_constraint
*c
,
6691 enum ebb_target_enum align_type
,
6692 bfd_vma alignment_pow
,
6693 text_action_t action
,
6696 bfd_boolean do_action
)
6698 proposed_action
*act
;
6700 if (c
->action_allocated
<= c
->action_count
)
6702 unsigned new_allocated
, i
;
6703 proposed_action
*new_actions
;
6705 new_allocated
= (c
->action_count
+ 2) * 2;
6706 new_actions
= (proposed_action
*)
6707 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6709 for (i
= 0; i
< c
->action_count
; i
++)
6710 new_actions
[i
] = c
->actions
[i
];
6713 c
->actions
= new_actions
;
6714 c
->action_allocated
= new_allocated
;
6717 act
= &c
->actions
[c
->action_count
];
6718 act
->align_type
= align_type
;
6719 act
->alignment_pow
= alignment_pow
;
6720 act
->action
= action
;
6721 act
->offset
= offset
;
6722 act
->removed_bytes
= removed_bytes
;
6723 act
->do_action
= do_action
;
6729 /* Access to internal relocations, section contents and symbols. */
6731 /* During relaxation, we need to modify relocations, section contents,
6732 and symbol definitions, and we need to keep the original values from
6733 being reloaded from the input files, i.e., we need to "pin" the
6734 modified values in memory. We also want to continue to observe the
6735 setting of the "keep-memory" flag. The following functions wrap the
6736 standard BFD functions to take care of this for us. */
6738 static Elf_Internal_Rela
*
6739 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6741 Elf_Internal_Rela
*internal_relocs
;
6743 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6746 internal_relocs
= elf_section_data (sec
)->relocs
;
6747 if (internal_relocs
== NULL
)
6748 internal_relocs
= (_bfd_elf_link_read_relocs
6749 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6750 return internal_relocs
;
6755 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6757 elf_section_data (sec
)->relocs
= internal_relocs
;
6762 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6765 && elf_section_data (sec
)->relocs
!= internal_relocs
)
6766 free (internal_relocs
);
6771 retrieve_contents (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6774 bfd_size_type sec_size
;
6776 sec_size
= bfd_get_section_limit (abfd
, sec
);
6777 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6779 if (contents
== NULL
&& sec_size
!= 0)
6781 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6788 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6795 pin_contents (asection
*sec
, bfd_byte
*contents
)
6797 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6802 release_contents (asection
*sec
, bfd_byte
*contents
)
6804 if (contents
&& elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6809 static Elf_Internal_Sym
*
6810 retrieve_local_syms (bfd
*input_bfd
)
6812 Elf_Internal_Shdr
*symtab_hdr
;
6813 Elf_Internal_Sym
*isymbuf
;
6816 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6817 locsymcount
= symtab_hdr
->sh_info
;
6819 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6820 if (isymbuf
== NULL
&& locsymcount
!= 0)
6821 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6824 /* Save the symbols for this input file so they won't be read again. */
6825 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6826 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6832 /* Code for link-time relaxation. */
6834 /* Initialization for relaxation: */
6835 static bfd_boolean
analyze_relocations (struct bfd_link_info
*);
6836 static bfd_boolean find_relaxable_sections
6837 (bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*);
6838 static bfd_boolean collect_source_relocs
6839 (bfd
*, asection
*, struct bfd_link_info
*);
6840 static bfd_boolean is_resolvable_asm_expansion
6841 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6843 static Elf_Internal_Rela
*find_associated_l32r_irel
6844 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6845 static bfd_boolean compute_text_actions
6846 (bfd
*, asection
*, struct bfd_link_info
*);
6847 static bfd_boolean
compute_ebb_proposed_actions (ebb_constraint
*);
6848 static bfd_boolean
compute_ebb_actions (ebb_constraint
*);
6849 typedef struct reloc_range_list_struct reloc_range_list
;
6850 static bfd_boolean check_section_ebb_pcrels_fit
6851 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6852 reloc_range_list
*, const ebb_constraint
*,
6853 const xtensa_opcode
*);
6854 static bfd_boolean
check_section_ebb_reduces (const ebb_constraint
*);
6855 static void text_action_add_proposed
6856 (text_action_list
*, const ebb_constraint
*, asection
*);
6859 static bfd_boolean compute_removed_literals
6860 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6861 static Elf_Internal_Rela
*get_irel_at_offset
6862 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6863 static bfd_boolean is_removable_literal
6864 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6865 property_table_entry
*, int);
6866 static bfd_boolean remove_dead_literal
6867 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6868 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6869 static bfd_boolean identify_literal_placement
6870 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6871 value_map_hash_table
*, bfd_boolean
*, Elf_Internal_Rela
*, int,
6872 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6874 static bfd_boolean
relocations_reach (source_reloc
*, int, const r_reloc
*);
6875 static bfd_boolean coalesce_shared_literal
6876 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6877 static bfd_boolean move_shared_literal
6878 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6879 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6882 static bfd_boolean
relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6883 static bfd_boolean
translate_section_fixes (asection
*);
6884 static bfd_boolean
translate_reloc_bfd_fix (reloc_bfd_fix
*);
6885 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6886 static void shrink_dynamic_reloc_sections
6887 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6888 static bfd_boolean move_literal
6889 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6890 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6891 static bfd_boolean relax_property_section
6892 (bfd
*, asection
*, struct bfd_link_info
*);
6895 static bfd_boolean
relax_section_symbols (bfd
*, asection
*);
6899 elf_xtensa_relax_section (bfd
*abfd
,
6901 struct bfd_link_info
*link_info
,
6904 static value_map_hash_table
*values
= NULL
;
6905 static bfd_boolean relocations_analyzed
= FALSE
;
6906 xtensa_relax_info
*relax_info
;
6908 if (!relocations_analyzed
)
6910 /* Do some overall initialization for relaxation. */
6911 values
= value_map_hash_table_init ();
6914 relaxing_section
= TRUE
;
6915 if (!analyze_relocations (link_info
))
6917 relocations_analyzed
= TRUE
;
6921 /* Don't mess with linker-created sections. */
6922 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6925 relax_info
= get_xtensa_relax_info (sec
);
6926 BFD_ASSERT (relax_info
!= NULL
);
6928 switch (relax_info
->visited
)
6931 /* Note: It would be nice to fold this pass into
6932 analyze_relocations, but it is important for this step that the
6933 sections be examined in link order. */
6934 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6941 value_map_hash_table_delete (values
);
6943 if (!relax_section (abfd
, sec
, link_info
))
6949 if (!relax_section_symbols (abfd
, sec
))
6954 relax_info
->visited
++;
6959 /* Initialization for relaxation. */
6961 /* This function is called once at the start of relaxation. It scans
6962 all the input sections and marks the ones that are relaxable (i.e.,
6963 literal sections with L32R relocations against them), and then
6964 collects source_reloc information for all the relocations against
6965 those relaxable sections. During this process, it also detects
6966 longcalls, i.e., calls relaxed by the assembler into indirect
6967 calls, that can be optimized back into direct calls. Within each
6968 extended basic block (ebb) containing an optimized longcall, it
6969 computes a set of "text actions" that can be performed to remove
6970 the L32R associated with the longcall while optionally preserving
6971 branch target alignments. */
6974 analyze_relocations (struct bfd_link_info
*link_info
)
6978 bfd_boolean is_relaxable
= FALSE
;
6980 /* Initialize the per-section relaxation info. */
6981 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6982 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6984 init_xtensa_relax_info (sec
);
6987 /* Mark relaxable sections (and count relocations against each one). */
6988 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6989 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6991 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
6995 /* Bail out if there are no relaxable sections. */
6999 /* Allocate space for source_relocs. */
7000 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7001 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7003 xtensa_relax_info
*relax_info
;
7005 relax_info
= get_xtensa_relax_info (sec
);
7006 if (relax_info
->is_relaxable_literal_section
7007 || relax_info
->is_relaxable_asm_section
)
7009 relax_info
->src_relocs
= (source_reloc
*)
7010 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
7013 relax_info
->src_count
= 0;
7016 /* Collect info on relocations against each relaxable section. */
7017 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7018 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7020 if (!collect_source_relocs (abfd
, sec
, link_info
))
7024 /* Compute the text actions. */
7025 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7026 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7028 if (!compute_text_actions (abfd
, sec
, link_info
))
7036 /* Find all the sections that might be relaxed. The motivation for
7037 this pass is that collect_source_relocs() needs to record _all_ the
7038 relocations that target each relaxable section. That is expensive
7039 and unnecessary unless the target section is actually going to be
7040 relaxed. This pass identifies all such sections by checking if
7041 they have L32Rs pointing to them. In the process, the total number
7042 of relocations targeting each section is also counted so that we
7043 know how much space to allocate for source_relocs against each
7044 relaxable literal section. */
7047 find_relaxable_sections (bfd
*abfd
,
7049 struct bfd_link_info
*link_info
,
7050 bfd_boolean
*is_relaxable_p
)
7052 Elf_Internal_Rela
*internal_relocs
;
7054 bfd_boolean ok
= TRUE
;
7056 xtensa_relax_info
*source_relax_info
;
7057 bfd_boolean is_l32r_reloc
;
7059 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7060 link_info
->keep_memory
);
7061 if (internal_relocs
== NULL
)
7064 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7065 if (contents
== NULL
&& sec
->size
!= 0)
7071 source_relax_info
= get_xtensa_relax_info (sec
);
7072 for (i
= 0; i
< sec
->reloc_count
; i
++)
7074 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7076 asection
*target_sec
;
7077 xtensa_relax_info
*target_relax_info
;
7079 /* If this section has not already been marked as "relaxable", and
7080 if it contains any ASM_EXPAND relocations (marking expanded
7081 longcalls) that can be optimized into direct calls, then mark
7082 the section as "relaxable". */
7083 if (source_relax_info
7084 && !source_relax_info
->is_relaxable_asm_section
7085 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
7087 bfd_boolean is_reachable
= FALSE
;
7088 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
7089 link_info
, &is_reachable
)
7092 source_relax_info
->is_relaxable_asm_section
= TRUE
;
7093 *is_relaxable_p
= TRUE
;
7097 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7098 bfd_get_section_limit (abfd
, sec
));
7100 target_sec
= r_reloc_get_section (&r_rel
);
7101 target_relax_info
= get_xtensa_relax_info (target_sec
);
7102 if (!target_relax_info
)
7105 /* Count PC-relative operand relocations against the target section.
7106 Note: The conditions tested here must match the conditions under
7107 which init_source_reloc is called in collect_source_relocs(). */
7108 is_l32r_reloc
= FALSE
;
7109 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7111 xtensa_opcode opcode
=
7112 get_relocation_opcode (abfd
, sec
, contents
, irel
);
7113 if (opcode
!= XTENSA_UNDEFINED
)
7115 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
7116 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
7118 target_relax_info
->src_count
++;
7122 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7124 /* Mark the target section as relaxable. */
7125 target_relax_info
->is_relaxable_literal_section
= TRUE
;
7126 *is_relaxable_p
= TRUE
;
7131 release_contents (sec
, contents
);
7132 release_internal_relocs (sec
, internal_relocs
);
7137 /* Record _all_ the relocations that point to relaxable sections, and
7138 get rid of ASM_EXPAND relocs by either converting them to
7139 ASM_SIMPLIFY or by removing them. */
7142 collect_source_relocs (bfd
*abfd
,
7144 struct bfd_link_info
*link_info
)
7146 Elf_Internal_Rela
*internal_relocs
;
7148 bfd_boolean ok
= TRUE
;
7150 bfd_size_type sec_size
;
7152 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7153 link_info
->keep_memory
);
7154 if (internal_relocs
== NULL
)
7157 sec_size
= bfd_get_section_limit (abfd
, sec
);
7158 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7159 if (contents
== NULL
&& sec_size
!= 0)
7165 /* Record relocations against relaxable literal sections. */
7166 for (i
= 0; i
< sec
->reloc_count
; i
++)
7168 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7170 asection
*target_sec
;
7171 xtensa_relax_info
*target_relax_info
;
7173 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7175 target_sec
= r_reloc_get_section (&r_rel
);
7176 target_relax_info
= get_xtensa_relax_info (target_sec
);
7178 if (target_relax_info
7179 && (target_relax_info
->is_relaxable_literal_section
7180 || target_relax_info
->is_relaxable_asm_section
))
7182 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7184 bfd_boolean is_abs_literal
= FALSE
;
7186 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7188 /* None of the current alternate relocs are PC-relative,
7189 and only PC-relative relocs matter here. However, we
7190 still need to record the opcode for literal
7192 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7193 if (opcode
== get_l32r_opcode ())
7195 is_abs_literal
= TRUE
;
7199 opcode
= XTENSA_UNDEFINED
;
7201 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7203 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7204 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7207 if (opcode
!= XTENSA_UNDEFINED
)
7209 int src_next
= target_relax_info
->src_next
++;
7210 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7212 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7218 /* Now get rid of ASM_EXPAND relocations. At this point, the
7219 src_relocs array for the target literal section may still be
7220 incomplete, but it must at least contain the entries for the L32R
7221 relocations associated with ASM_EXPANDs because they were just
7222 added in the preceding loop over the relocations. */
7224 for (i
= 0; i
< sec
->reloc_count
; i
++)
7226 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7227 bfd_boolean is_reachable
;
7229 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7235 Elf_Internal_Rela
*l32r_irel
;
7237 asection
*target_sec
;
7238 xtensa_relax_info
*target_relax_info
;
7240 /* Mark the source_reloc for the L32R so that it will be
7241 removed in compute_removed_literals(), along with the
7242 associated literal. */
7243 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7244 irel
, internal_relocs
);
7245 if (l32r_irel
== NULL
)
7248 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7250 target_sec
= r_reloc_get_section (&r_rel
);
7251 target_relax_info
= get_xtensa_relax_info (target_sec
);
7253 if (target_relax_info
7254 && (target_relax_info
->is_relaxable_literal_section
7255 || target_relax_info
->is_relaxable_asm_section
))
7257 source_reloc
*s_reloc
;
7259 /* Search the source_relocs for the entry corresponding to
7260 the l32r_irel. Note: The src_relocs array is not yet
7261 sorted, but it wouldn't matter anyway because we're
7262 searching by source offset instead of target offset. */
7263 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7264 target_relax_info
->src_next
,
7266 BFD_ASSERT (s_reloc
);
7267 s_reloc
->is_null
= TRUE
;
7270 /* Convert this reloc to ASM_SIMPLIFY. */
7271 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7272 R_XTENSA_ASM_SIMPLIFY
);
7273 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7275 pin_internal_relocs (sec
, internal_relocs
);
7279 /* It is resolvable but doesn't reach. We resolve now
7280 by eliminating the relocation -- the call will remain
7281 expanded into L32R/CALLX. */
7282 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7283 pin_internal_relocs (sec
, internal_relocs
);
7288 release_contents (sec
, contents
);
7289 release_internal_relocs (sec
, internal_relocs
);
7294 /* Return TRUE if the asm expansion can be resolved. Generally it can
7295 be resolved on a final link or when a partial link locates it in the
7296 same section as the target. Set "is_reachable" flag if the target of
7297 the call is within the range of a direct call, given the current VMA
7298 for this section and the target section. */
7301 is_resolvable_asm_expansion (bfd
*abfd
,
7304 Elf_Internal_Rela
*irel
,
7305 struct bfd_link_info
*link_info
,
7306 bfd_boolean
*is_reachable_p
)
7308 asection
*target_sec
;
7312 unsigned int first_align
;
7313 unsigned int adjust
;
7314 bfd_vma target_offset
;
7316 xtensa_opcode opcode
, direct_call_opcode
;
7317 bfd_vma self_address
;
7318 bfd_vma dest_address
;
7319 bfd_boolean uses_l32r
;
7320 bfd_size_type sec_size
;
7322 *is_reachable_p
= FALSE
;
7324 if (contents
== NULL
)
7327 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7330 sec_size
= bfd_get_section_limit (abfd
, sec
);
7331 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7332 sec_size
- irel
->r_offset
, &uses_l32r
);
7333 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7337 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7338 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7341 /* Check and see that the target resolves. */
7342 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7343 if (!r_reloc_is_defined (&r_rel
))
7346 target_sec
= r_reloc_get_section (&r_rel
);
7347 target_offset
= r_rel
.target_offset
;
7349 /* If the target is in a shared library, then it doesn't reach. This
7350 isn't supposed to come up because the compiler should never generate
7351 non-PIC calls on systems that use shared libraries, but the linker
7352 shouldn't crash regardless. */
7353 if (!target_sec
->output_section
)
7356 /* For relocatable sections, we can only simplify when the output
7357 section of the target is the same as the output section of the
7359 if (bfd_link_relocatable (link_info
)
7360 && (target_sec
->output_section
!= sec
->output_section
7361 || is_reloc_sym_weak (abfd
, irel
)))
7364 if (target_sec
->output_section
!= sec
->output_section
)
7366 /* If the two sections are sufficiently far away that relaxation
7367 might take the call out of range, we can't simplify. For
7368 example, a positive displacement call into another memory
7369 could get moved to a lower address due to literal removal,
7370 but the destination won't move, and so the displacment might
7373 If the displacement is negative, assume the destination could
7374 move as far back as the start of the output section. The
7375 self_address will be at least as far into the output section
7376 as it is prior to relaxation.
7378 If the displacement is postive, assume the destination will be in
7379 it's pre-relaxed location (because relaxation only makes sections
7380 smaller). The self_address could go all the way to the beginning
7381 of the output section. */
7383 dest_address
= target_sec
->output_section
->vma
;
7384 self_address
= sec
->output_section
->vma
;
7386 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7387 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7389 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7390 /* Call targets should be four-byte aligned. */
7391 dest_address
= (dest_address
+ 3) & ~3;
7396 self_address
= (sec
->output_section
->vma
7397 + sec
->output_offset
+ irel
->r_offset
+ 3);
7398 dest_address
= (target_sec
->output_section
->vma
7399 + target_sec
->output_offset
+ target_offset
);
7402 /* Adjust addresses with alignments for the worst case to see if call insn
7403 can fit. Don't relax l32r + callx to call if the target can be out of
7404 range due to alignment.
7405 Caller and target addresses are highest and lowest address.
7406 Search all sections between caller and target, looking for max alignment.
7407 The adjustment is max alignment bytes. If the alignment at the lowest
7408 address is less than the adjustment, apply the adjustment to highest
7411 /* Start from lowest address.
7412 Lowest address aligmnet is from input section.
7413 Initial alignment (adjust) is from input section. */
7414 if (dest_address
> self_address
)
7416 s
= sec
->output_section
;
7417 last_vma
= dest_address
;
7418 first_align
= sec
->alignment_power
;
7419 adjust
= target_sec
->alignment_power
;
7423 s
= target_sec
->output_section
;
7424 last_vma
= self_address
;
7425 first_align
= target_sec
->alignment_power
;
7426 adjust
= sec
->alignment_power
;
7431 /* Find the largest alignment in output section list. */
7432 for (; s
&& s
->vma
>= first_vma
&& s
->vma
<= last_vma
; s
= s
->next
)
7434 if (s
->alignment_power
> adjust
)
7435 adjust
= s
->alignment_power
;
7438 if (adjust
> first_align
)
7440 /* Alignment may enlarge the range, adjust highest address. */
7441 adjust
= 1 << adjust
;
7442 if (dest_address
> self_address
)
7444 dest_address
+= adjust
;
7448 self_address
+= adjust
;
7452 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7453 self_address
, dest_address
);
7455 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7456 (dest_address
>> CALL_SEGMENT_BITS
))
7463 static Elf_Internal_Rela
*
7464 find_associated_l32r_irel (bfd
*abfd
,
7467 Elf_Internal_Rela
*other_irel
,
7468 Elf_Internal_Rela
*internal_relocs
)
7472 for (i
= 0; i
< sec
->reloc_count
; i
++)
7474 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7476 if (irel
== other_irel
)
7478 if (irel
->r_offset
!= other_irel
->r_offset
)
7480 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7488 static xtensa_opcode
*
7489 build_reloc_opcodes (bfd
*abfd
,
7492 Elf_Internal_Rela
*internal_relocs
)
7495 xtensa_opcode
*reloc_opcodes
=
7496 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7497 for (i
= 0; i
< sec
->reloc_count
; i
++)
7499 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7500 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7502 return reloc_opcodes
;
7505 struct reloc_range_struct
7508 bfd_boolean add
; /* TRUE if start of a range, FALSE otherwise. */
7509 /* Original irel index in the array of relocations for a section. */
7510 unsigned irel_index
;
7512 typedef struct reloc_range_struct reloc_range
;
7514 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7515 struct reloc_range_list_entry_struct
7517 reloc_range_list_entry
*next
;
7518 reloc_range_list_entry
*prev
;
7519 Elf_Internal_Rela
*irel
;
7520 xtensa_opcode opcode
;
7524 struct reloc_range_list_struct
7526 /* The rest of the structure is only meaningful when ok is TRUE. */
7529 unsigned n_range
; /* Number of range markers. */
7530 reloc_range
*range
; /* Sorted range markers. */
7532 unsigned first
; /* Index of a first range element in the list. */
7533 unsigned last
; /* One past index of a last range element in the list. */
7535 unsigned n_list
; /* Number of list elements. */
7536 reloc_range_list_entry
*reloc
; /* */
7537 reloc_range_list_entry list_root
;
7541 reloc_range_compare (const void *a
, const void *b
)
7543 const reloc_range
*ra
= a
;
7544 const reloc_range
*rb
= b
;
7546 if (ra
->addr
!= rb
->addr
)
7547 return ra
->addr
< rb
->addr
? -1 : 1;
7548 if (ra
->add
!= rb
->add
)
7549 return ra
->add
? -1 : 1;
7554 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7556 Elf_Internal_Rela
*internal_relocs
,
7557 xtensa_opcode
*reloc_opcodes
,
7558 reloc_range_list
*list
)
7563 reloc_range
*ranges
= NULL
;
7564 reloc_range_list_entry
*reloc
=
7565 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7567 memset (list
, 0, sizeof (*list
));
7570 for (i
= 0; i
< sec
->reloc_count
; i
++)
7572 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7573 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7574 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7577 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7578 || r_type
== R_XTENSA_32_PCREL
7579 || !howto
->pc_relative
)
7582 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7583 bfd_get_section_limit (abfd
, sec
));
7585 if (r_reloc_get_section (&r_rel
) != sec
)
7590 max_n
= (max_n
+ 2) * 2;
7591 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7594 ranges
[n
].addr
= irel
->r_offset
;
7595 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7597 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7598 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7600 ranges
[n
].irel_index
= i
;
7601 ranges
[n
+ 1].irel_index
= i
;
7605 reloc
[i
].irel
= irel
;
7607 /* Every relocation won't possibly be checked in the optimized version of
7608 check_section_ebb_pcrels_fit, so this needs to be done here. */
7609 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7611 /* None of the current alternate relocs are PC-relative,
7612 and only PC-relative relocs matter here. */
7616 xtensa_opcode opcode
;
7620 opcode
= reloc_opcodes
[i
];
7622 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7624 if (opcode
== XTENSA_UNDEFINED
)
7630 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7631 if (opnum
== XTENSA_UNDEFINED
)
7637 /* Record relocation opcode and opnum as we've calculated them
7638 anyway and they won't change. */
7639 reloc
[i
].opcode
= opcode
;
7640 reloc
[i
].opnum
= opnum
;
7646 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7647 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7650 list
->range
= ranges
;
7651 list
->reloc
= reloc
;
7652 list
->list_root
.prev
= &list
->list_root
;
7653 list
->list_root
.next
= &list
->list_root
;
7662 static void reloc_range_list_append (reloc_range_list
*list
,
7663 unsigned irel_index
)
7665 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7667 entry
->prev
= list
->list_root
.prev
;
7668 entry
->next
= &list
->list_root
;
7669 entry
->prev
->next
= entry
;
7670 entry
->next
->prev
= entry
;
7674 static void reloc_range_list_remove (reloc_range_list
*list
,
7675 unsigned irel_index
)
7677 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7679 entry
->next
->prev
= entry
->prev
;
7680 entry
->prev
->next
= entry
->next
;
7684 /* Update relocation list object so that it lists all relocations that cross
7685 [first; last] range. Range bounds should not decrease with successive
7687 static void reloc_range_list_update_range (reloc_range_list
*list
,
7688 bfd_vma first
, bfd_vma last
)
7690 /* This should not happen: EBBs are iterated from lower addresses to higher.
7691 But even if that happens there's no need to break: just flush current list
7692 and start from scratch. */
7693 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7694 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7699 list
->list_root
.next
= &list
->list_root
;
7700 list
->list_root
.prev
= &list
->list_root
;
7701 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7704 for (; list
->last
< list
->n_range
&&
7705 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7706 if (list
->range
[list
->last
].add
)
7707 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7709 for (; list
->first
< list
->n_range
&&
7710 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7711 if (!list
->range
[list
->first
].add
)
7712 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7715 static void free_reloc_range_list (reloc_range_list
*list
)
7721 /* The compute_text_actions function will build a list of potential
7722 transformation actions for code in the extended basic block of each
7723 longcall that is optimized to a direct call. From this list we
7724 generate a set of actions to actually perform that optimizes for
7725 space and, if not using size_opt, maintains branch target
7728 These actions to be performed are placed on a per-section list.
7729 The actual changes are performed by relax_section() in the second
7733 compute_text_actions (bfd
*abfd
,
7735 struct bfd_link_info
*link_info
)
7737 xtensa_opcode
*reloc_opcodes
= NULL
;
7738 xtensa_relax_info
*relax_info
;
7740 Elf_Internal_Rela
*internal_relocs
;
7741 bfd_boolean ok
= TRUE
;
7743 property_table_entry
*prop_table
= 0;
7745 bfd_size_type sec_size
;
7746 reloc_range_list relevant_relocs
;
7748 relax_info
= get_xtensa_relax_info (sec
);
7749 BFD_ASSERT (relax_info
);
7750 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7752 /* Do nothing if the section contains no optimized longcalls. */
7753 if (!relax_info
->is_relaxable_asm_section
)
7756 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7757 link_info
->keep_memory
);
7759 if (internal_relocs
)
7760 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7761 internal_reloc_compare
);
7763 sec_size
= bfd_get_section_limit (abfd
, sec
);
7764 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7765 if (contents
== NULL
&& sec_size
!= 0)
7771 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7772 XTENSA_PROP_SEC_NAME
, FALSE
);
7779 /* Precompute the opcode for each relocation. */
7780 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7782 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7785 for (i
= 0; i
< sec
->reloc_count
; i
++)
7787 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7789 property_table_entry
*the_entry
;
7792 ebb_constraint ebb_table
;
7793 bfd_size_type simplify_size
;
7795 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7797 r_offset
= irel
->r_offset
;
7799 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7800 if (simplify_size
== 0)
7803 /* xgettext:c-format */
7804 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7805 "XTENSA_ASM_SIMPLIFY relocation; "
7806 "possible configuration mismatch"),
7807 sec
->owner
, sec
, (uint64_t) r_offset
);
7811 /* If the instruction table is not around, then don't do this
7813 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7814 sec
->vma
+ irel
->r_offset
);
7815 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7817 text_action_add (&relax_info
->action_list
,
7818 ta_convert_longcall
, sec
, r_offset
,
7823 /* If the next longcall happens to be at the same address as an
7824 unreachable section of size 0, then skip forward. */
7825 ptbl_idx
= the_entry
- prop_table
;
7826 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7827 && the_entry
->size
== 0
7828 && ptbl_idx
+ 1 < ptblsize
7829 && (prop_table
[ptbl_idx
+ 1].address
7830 == prop_table
[ptbl_idx
].address
))
7836 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7837 /* NO_REORDER is OK */
7840 init_ebb_constraint (&ebb_table
);
7841 ebb
= &ebb_table
.ebb
;
7842 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7843 internal_relocs
, sec
->reloc_count
);
7844 ebb
->start_offset
= r_offset
+ simplify_size
;
7845 ebb
->end_offset
= r_offset
+ simplify_size
;
7846 ebb
->start_ptbl_idx
= ptbl_idx
;
7847 ebb
->end_ptbl_idx
= ptbl_idx
;
7848 ebb
->start_reloc_idx
= i
;
7849 ebb
->end_reloc_idx
= i
;
7851 if (!extend_ebb_bounds (ebb
)
7852 || !compute_ebb_proposed_actions (&ebb_table
)
7853 || !compute_ebb_actions (&ebb_table
)
7854 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7857 &ebb_table
, reloc_opcodes
)
7858 || !check_section_ebb_reduces (&ebb_table
))
7860 /* If anything goes wrong or we get unlucky and something does
7861 not fit, with our plan because of expansion between
7862 critical branches, just convert to a NOP. */
7864 text_action_add (&relax_info
->action_list
,
7865 ta_convert_longcall
, sec
, r_offset
, 0);
7866 i
= ebb_table
.ebb
.end_reloc_idx
;
7867 free_ebb_constraint (&ebb_table
);
7871 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7873 /* Update the index so we do not go looking at the relocations
7874 we have already processed. */
7875 i
= ebb_table
.ebb
.end_reloc_idx
;
7876 free_ebb_constraint (&ebb_table
);
7879 free_reloc_range_list (&relevant_relocs
);
7882 if (action_list_count (&relax_info
->action_list
))
7883 print_action_list (stderr
, &relax_info
->action_list
);
7887 release_contents (sec
, contents
);
7888 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
)
8492 if (map
&& map
->entry
)
8499 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8500 relocations in a section will fit if a proposed set of actions
8504 check_section_ebb_pcrels_fit (bfd
*abfd
,
8507 Elf_Internal_Rela
*internal_relocs
,
8508 reloc_range_list
*relevant_relocs
,
8509 const ebb_constraint
*constraint
,
8510 const xtensa_opcode
*reloc_opcodes
)
8513 unsigned n
= sec
->reloc_count
;
8514 Elf_Internal_Rela
*irel
;
8515 xlate_map_t
*xmap
= NULL
;
8516 bfd_boolean ok
= TRUE
;
8517 xtensa_relax_info
*relax_info
;
8518 reloc_range_list_entry
*entry
= NULL
;
8520 relax_info
= get_xtensa_relax_info (sec
);
8522 if (relax_info
&& sec
->reloc_count
> 100)
8524 xmap
= build_xlate_map (sec
, relax_info
);
8525 /* NULL indicates out of memory, but the slow version
8526 can still be used. */
8529 if (relevant_relocs
&& constraint
->action_count
)
8531 if (!relevant_relocs
->ok
)
8538 bfd_vma min_offset
, max_offset
;
8539 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8541 for (i
= 1; i
< constraint
->action_count
; ++i
)
8543 proposed_action
*action
= &constraint
->actions
[i
];
8544 bfd_vma offset
= action
->offset
;
8546 if (offset
< min_offset
)
8547 min_offset
= offset
;
8548 if (offset
> max_offset
)
8549 max_offset
= offset
;
8551 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8553 n
= relevant_relocs
->n_list
;
8554 entry
= &relevant_relocs
->list_root
;
8559 relevant_relocs
= NULL
;
8562 for (i
= 0; i
< n
; i
++)
8565 bfd_vma orig_self_offset
, orig_target_offset
;
8566 bfd_vma self_offset
, target_offset
;
8568 reloc_howto_type
*howto
;
8569 int self_removed_bytes
, target_removed_bytes
;
8571 if (relevant_relocs
)
8573 entry
= entry
->next
;
8578 irel
= internal_relocs
+ i
;
8580 r_type
= ELF32_R_TYPE (irel
->r_info
);
8582 howto
= &elf_howto_table
[r_type
];
8583 /* We maintain the required invariant: PC-relative relocations
8584 that fit before linking must fit after linking. Thus we only
8585 need to deal with relocations to the same section that are
8587 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8588 || r_type
== R_XTENSA_32_PCREL
8589 || !howto
->pc_relative
)
8592 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8593 bfd_get_section_limit (abfd
, sec
));
8595 if (r_reloc_get_section (&r_rel
) != sec
)
8598 orig_self_offset
= irel
->r_offset
;
8599 orig_target_offset
= r_rel
.target_offset
;
8601 self_offset
= orig_self_offset
;
8602 target_offset
= orig_target_offset
;
8607 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8610 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8611 orig_target_offset
);
8614 self_removed_bytes
= 0;
8615 target_removed_bytes
= 0;
8617 for (j
= 0; j
< constraint
->action_count
; ++j
)
8619 proposed_action
*action
= &constraint
->actions
[j
];
8620 bfd_vma offset
= action
->offset
;
8621 int removed_bytes
= action
->removed_bytes
;
8622 if (offset
< orig_self_offset
8623 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8624 && action
->removed_bytes
< 0))
8625 self_removed_bytes
+= removed_bytes
;
8626 if (offset
< orig_target_offset
8627 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8628 && action
->removed_bytes
< 0))
8629 target_removed_bytes
+= removed_bytes
;
8631 self_offset
-= self_removed_bytes
;
8632 target_offset
-= target_removed_bytes
;
8634 /* Try to encode it. Get the operand and check. */
8635 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8637 /* None of the current alternate relocs are PC-relative,
8638 and only PC-relative relocs matter here. */
8642 xtensa_opcode opcode
;
8645 if (relevant_relocs
)
8647 opcode
= entry
->opcode
;
8648 opnum
= entry
->opnum
;
8653 opcode
= reloc_opcodes
[relevant_relocs
?
8654 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8656 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8657 if (opcode
== XTENSA_UNDEFINED
)
8663 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8664 if (opnum
== XTENSA_UNDEFINED
)
8671 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
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
);
8894 free_section_cache (&target_sec_cache
);
8896 release_contents (sec
, contents
);
8897 release_internal_relocs (sec
, internal_relocs
);
8902 static Elf_Internal_Rela
*
8903 get_irel_at_offset (asection
*sec
,
8904 Elf_Internal_Rela
*internal_relocs
,
8908 Elf_Internal_Rela
*irel
;
8910 Elf_Internal_Rela key
;
8912 if (!internal_relocs
)
8915 key
.r_offset
= offset
;
8916 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8917 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8921 /* bsearch does not guarantee which will be returned if there are
8922 multiple matches. We need the first that is not an alignment. */
8923 i
= irel
- internal_relocs
;
8926 if (internal_relocs
[i
-1].r_offset
!= offset
)
8930 for ( ; i
< sec
->reloc_count
; i
++)
8932 irel
= &internal_relocs
[i
];
8933 r_type
= ELF32_R_TYPE (irel
->r_info
);
8934 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8943 is_removable_literal (const source_reloc
*rel
,
8945 const source_reloc
*src_relocs
,
8948 property_table_entry
*prop_table
,
8951 const source_reloc
*curr_rel
;
8952 property_table_entry
*entry
;
8957 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8958 sec
->vma
+ rel
->r_rel
.target_offset
);
8959 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8962 for (++i
; i
< src_count
; ++i
)
8964 curr_rel
= &src_relocs
[i
];
8965 /* If all others have the same target offset.... */
8966 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8969 if (!curr_rel
->is_null
8970 && !xtensa_is_property_section (curr_rel
->source_sec
)
8971 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8979 remove_dead_literal (bfd
*abfd
,
8981 struct bfd_link_info
*link_info
,
8982 Elf_Internal_Rela
*internal_relocs
,
8983 Elf_Internal_Rela
*irel
,
8985 property_table_entry
*prop_table
,
8988 property_table_entry
*entry
;
8989 xtensa_relax_info
*relax_info
;
8991 relax_info
= get_xtensa_relax_info (sec
);
8995 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8996 sec
->vma
+ rel
->r_rel
.target_offset
);
8998 /* Mark the unused literal so that it will be removed. */
8999 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
9001 text_action_add (&relax_info
->action_list
,
9002 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9004 /* If the section is 4-byte aligned, do not add fill. */
9005 if (sec
->alignment_power
> 2)
9007 int fill_extra_space
;
9008 bfd_vma entry_sec_offset
;
9010 property_table_entry
*the_add_entry
;
9014 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9016 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9018 /* If the literal range is at the end of the section,
9020 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9022 fill_extra_space
= xtensa_compute_fill_extra_space (the_add_entry
);
9024 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9025 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9026 -4, fill_extra_space
);
9028 adjust_fill_action (fa
, removed_diff
);
9030 text_action_add (&relax_info
->action_list
,
9031 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9034 /* Zero out the relocation on this literal location. */
9037 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9038 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9040 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9041 pin_internal_relocs (sec
, internal_relocs
);
9044 /* Do not modify "last_loc_is_prev". */
9050 identify_literal_placement (bfd
*abfd
,
9053 struct bfd_link_info
*link_info
,
9054 value_map_hash_table
*values
,
9055 bfd_boolean
*last_loc_is_prev_p
,
9056 Elf_Internal_Rela
*irel
,
9057 int remaining_src_rels
,
9059 property_table_entry
*prop_table
,
9061 section_cache_t
*target_sec_cache
,
9062 bfd_boolean is_abs_literal
)
9066 xtensa_relax_info
*relax_info
;
9067 bfd_boolean literal_placed
= FALSE
;
9069 unsigned long value
;
9070 bfd_boolean final_static_link
;
9071 bfd_size_type sec_size
;
9073 relax_info
= get_xtensa_relax_info (sec
);
9077 sec_size
= bfd_get_section_limit (abfd
, sec
);
9080 (!bfd_link_relocatable (link_info
)
9081 && !elf_hash_table (link_info
)->dynamic_sections_created
);
9083 /* The placement algorithm first checks to see if the literal is
9084 already in the value map. If so and the value map is reachable
9085 from all uses, then the literal is moved to that location. If
9086 not, then we identify the last location where a fresh literal was
9087 placed. If the literal can be safely moved there, then we do so.
9088 If not, then we assume that the literal is not to move and leave
9089 the literal where it is, marking it as the last literal
9092 /* Find the literal value. */
9094 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9097 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
9098 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
9100 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
9102 /* Check if we've seen another literal with the same value that
9103 is in the same output section. */
9104 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
9107 && (r_reloc_get_section (&val_map
->loc
)->output_section
9108 == sec
->output_section
)
9109 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
9110 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
9112 /* No change to last_loc_is_prev. */
9113 literal_placed
= TRUE
;
9116 /* For relocatable links, do not try to move literals. To do it
9117 correctly might increase the number of relocations in an input
9118 section making the default relocatable linking fail. */
9119 if (!bfd_link_relocatable (link_info
) && !literal_placed
9120 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
9122 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
9123 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
9125 /* Increment the virtual offset. */
9126 r_reloc try_loc
= values
->last_loc
;
9127 try_loc
.virtual_offset
+= 4;
9129 /* There is a last loc that was in the same output section. */
9130 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
9131 && move_shared_literal (sec
, link_info
, rel
,
9132 prop_table
, ptblsize
,
9133 &try_loc
, &val
, target_sec_cache
))
9135 values
->last_loc
.virtual_offset
+= 4;
9136 literal_placed
= TRUE
;
9138 val_map
= add_value_map (values
, &val
, &try_loc
,
9141 val_map
->loc
= try_loc
;
9146 if (!literal_placed
)
9148 /* Nothing worked, leave the literal alone but update the last loc. */
9149 values
->has_last_loc
= TRUE
;
9150 values
->last_loc
= rel
->r_rel
;
9152 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
9154 val_map
->loc
= rel
->r_rel
;
9155 *last_loc_is_prev_p
= TRUE
;
9162 /* Check if the original relocations (presumably on L32R instructions)
9163 identified by reloc[0..N] can be changed to reference the literal
9164 identified by r_rel. If r_rel is out of range for any of the
9165 original relocations, then we don't want to coalesce the original
9166 literal with the one at r_rel. We only check reloc[0..N], where the
9167 offsets are all the same as for reloc[0] (i.e., they're all
9168 referencing the same literal) and where N is also bounded by the
9169 number of remaining entries in the "reloc" array. The "reloc" array
9170 is sorted by target offset so we know all the entries for the same
9171 literal will be contiguous. */
9174 relocations_reach (source_reloc
*reloc
,
9175 int remaining_relocs
,
9176 const r_reloc
*r_rel
)
9178 bfd_vma from_offset
, source_address
, dest_address
;
9182 if (!r_reloc_is_defined (r_rel
))
9185 sec
= r_reloc_get_section (r_rel
);
9186 from_offset
= reloc
[0].r_rel
.target_offset
;
9188 for (i
= 0; i
< remaining_relocs
; i
++)
9190 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9193 /* Ignore relocations that have been removed. */
9194 if (reloc
[i
].is_null
)
9197 /* The original and new output section for these must be the same
9198 in order to coalesce. */
9199 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9200 != sec
->output_section
)
9203 /* Absolute literals in the same output section can always be
9205 if (reloc
[i
].is_abs_literal
)
9208 /* A literal with no PC-relative relocations can be moved anywhere. */
9209 if (reloc
[i
].opnd
!= -1)
9211 /* Otherwise, check to see that it fits. */
9212 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9213 + reloc
[i
].source_sec
->output_offset
9214 + reloc
[i
].r_rel
.rela
.r_offset
);
9215 dest_address
= (sec
->output_section
->vma
9216 + sec
->output_offset
9217 + r_rel
->target_offset
);
9219 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9220 source_address
, dest_address
))
9229 /* Move a literal to another literal location because it is
9230 the same as the other literal value. */
9233 coalesce_shared_literal (asection
*sec
,
9235 property_table_entry
*prop_table
,
9239 property_table_entry
*entry
;
9241 property_table_entry
*the_add_entry
;
9243 xtensa_relax_info
*relax_info
;
9245 relax_info
= get_xtensa_relax_info (sec
);
9249 entry
= elf_xtensa_find_property_entry
9250 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9251 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9254 /* Mark that the literal will be coalesced. */
9255 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9257 text_action_add (&relax_info
->action_list
,
9258 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9260 /* If the section is 4-byte aligned, do not add fill. */
9261 if (sec
->alignment_power
> 2)
9263 int fill_extra_space
;
9264 bfd_vma entry_sec_offset
;
9267 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9269 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9271 /* If the literal range is at the end of the section,
9273 fill_extra_space
= 0;
9274 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9276 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9277 fill_extra_space
= the_add_entry
->size
;
9279 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9280 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9281 -4, fill_extra_space
);
9283 adjust_fill_action (fa
, removed_diff
);
9285 text_action_add (&relax_info
->action_list
,
9286 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9293 /* Move a literal to another location. This may actually increase the
9294 total amount of space used because of alignments so we need to do
9295 this carefully. Also, it may make a branch go out of range. */
9298 move_shared_literal (asection
*sec
,
9299 struct bfd_link_info
*link_info
,
9301 property_table_entry
*prop_table
,
9303 const r_reloc
*target_loc
,
9304 const literal_value
*lit_value
,
9305 section_cache_t
*target_sec_cache
)
9307 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9308 text_action
*fa
, *target_fa
;
9310 xtensa_relax_info
*relax_info
, *target_relax_info
;
9311 asection
*target_sec
;
9313 ebb_constraint ebb_table
;
9314 bfd_boolean relocs_fit
;
9316 /* If this routine always returns FALSE, the literals that cannot be
9317 coalesced will not be moved. */
9318 if (elf32xtensa_no_literal_movement
)
9321 relax_info
= get_xtensa_relax_info (sec
);
9325 target_sec
= r_reloc_get_section (target_loc
);
9326 target_relax_info
= get_xtensa_relax_info (target_sec
);
9328 /* Literals to undefined sections may not be moved because they
9329 must report an error. */
9330 if (bfd_is_und_section (target_sec
))
9333 src_entry
= elf_xtensa_find_property_entry
9334 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9336 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9339 target_entry
= elf_xtensa_find_property_entry
9340 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9341 target_sec
->vma
+ target_loc
->target_offset
);
9346 /* Make sure that we have not broken any branches. */
9349 init_ebb_constraint (&ebb_table
);
9350 ebb
= &ebb_table
.ebb
;
9351 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9352 target_sec_cache
->content_length
,
9353 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9354 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9356 /* Propose to add 4 bytes + worst-case alignment size increase to
9358 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9359 ta_fill
, target_loc
->target_offset
,
9360 -4 - (1 << target_sec
->alignment_power
), TRUE
);
9362 /* Check all of the PC-relative relocations to make sure they still fit. */
9363 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9364 target_sec_cache
->contents
,
9365 target_sec_cache
->relocs
, NULL
,
9371 text_action_add_literal (&target_relax_info
->action_list
,
9372 ta_add_literal
, target_loc
, lit_value
, -4);
9374 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9376 /* May need to add or remove some fill to maintain alignment. */
9377 int fill_extra_space
;
9378 bfd_vma entry_sec_offset
;
9381 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9383 /* If the literal range is at the end of the section,
9385 fill_extra_space
= 0;
9387 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9388 target_sec_cache
->pte_count
,
9390 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9391 fill_extra_space
= the_add_entry
->size
;
9393 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9394 target_sec
, entry_sec_offset
);
9395 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9396 entry_sec_offset
, 4,
9399 adjust_fill_action (target_fa
, removed_diff
);
9401 text_action_add (&target_relax_info
->action_list
,
9402 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9405 /* Mark that the literal will be moved to the new location. */
9406 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9408 /* Remove the literal. */
9409 text_action_add (&relax_info
->action_list
,
9410 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9412 /* If the section is 4-byte aligned, do not add fill. */
9413 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9415 int fill_extra_space
;
9416 bfd_vma entry_sec_offset
;
9419 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9421 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9423 /* If the literal range is at the end of the section,
9425 fill_extra_space
= 0;
9426 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9428 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9429 fill_extra_space
= the_add_entry
->size
;
9431 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9432 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9433 -4, fill_extra_space
);
9435 adjust_fill_action (fa
, removed_diff
);
9437 text_action_add (&relax_info
->action_list
,
9438 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9445 /* Second relaxation pass. */
9448 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9450 bfd_size_type
*final_size
= p
;
9451 text_action
*action
= (text_action
*)node
->value
;
9453 *final_size
-= action
->removed_bytes
;
9457 /* Modify all of the relocations to point to the right spot, and if this
9458 is a relaxable section, delete the unwanted literals and fix the
9462 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9464 Elf_Internal_Rela
*internal_relocs
;
9465 xtensa_relax_info
*relax_info
;
9467 bfd_boolean ok
= TRUE
;
9469 bfd_boolean rv
= FALSE
;
9470 bfd_boolean virtual_action
;
9471 bfd_size_type sec_size
;
9473 sec_size
= bfd_get_section_limit (abfd
, sec
);
9474 relax_info
= get_xtensa_relax_info (sec
);
9475 BFD_ASSERT (relax_info
);
9477 /* First translate any of the fixes that have been added already. */
9478 translate_section_fixes (sec
);
9480 /* Handle property sections (e.g., literal tables) specially. */
9481 if (xtensa_is_property_section (sec
))
9483 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9484 return relax_property_section (abfd
, sec
, link_info
);
9487 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9488 link_info
->keep_memory
);
9489 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9492 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9493 if (contents
== NULL
&& sec_size
!= 0)
9499 if (internal_relocs
)
9501 for (i
= 0; i
< sec
->reloc_count
; i
++)
9503 Elf_Internal_Rela
*irel
;
9504 xtensa_relax_info
*target_relax_info
;
9505 bfd_vma source_offset
, old_source_offset
;
9508 asection
*target_sec
;
9510 /* Locally change the source address.
9511 Translate the target to the new target address.
9512 If it points to this section and has been removed,
9516 irel
= &internal_relocs
[i
];
9517 source_offset
= irel
->r_offset
;
9518 old_source_offset
= source_offset
;
9520 r_type
= ELF32_R_TYPE (irel
->r_info
);
9521 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9522 bfd_get_section_limit (abfd
, sec
));
9524 /* If this section could have changed then we may need to
9525 change the relocation's offset. */
9527 if (relax_info
->is_relaxable_literal_section
9528 || relax_info
->is_relaxable_asm_section
)
9530 pin_internal_relocs (sec
, internal_relocs
);
9532 if (r_type
!= R_XTENSA_NONE
9533 && find_removed_literal (&relax_info
->removed_list
,
9536 /* Remove this relocation. */
9537 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9538 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9539 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9540 irel
->r_offset
= offset_with_removed_text_map
9541 (&relax_info
->action_list
, irel
->r_offset
);
9545 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9547 text_action
*action
=
9548 find_insn_action (&relax_info
->action_list
,
9550 if (action
&& (action
->action
== ta_convert_longcall
9551 || action
->action
== ta_remove_longcall
))
9553 bfd_reloc_status_type retval
;
9554 char *error_message
= NULL
;
9556 retval
= contract_asm_expansion (contents
, sec_size
,
9557 irel
, &error_message
);
9558 if (retval
!= bfd_reloc_ok
)
9560 (*link_info
->callbacks
->reloc_dangerous
)
9561 (link_info
, error_message
, abfd
, sec
,
9565 /* Update the action so that the code that moves
9566 the contents will do the right thing. */
9567 /* ta_remove_longcall and ta_remove_insn actions are
9568 grouped together in the tree as well as
9569 ta_convert_longcall and ta_none, so that changes below
9570 can be done w/o removing and reinserting action into
9573 if (action
->action
== ta_remove_longcall
)
9574 action
->action
= ta_remove_insn
;
9576 action
->action
= ta_none
;
9577 /* Refresh the info in the r_rel. */
9578 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9579 r_type
= ELF32_R_TYPE (irel
->r_info
);
9583 source_offset
= offset_with_removed_text_map
9584 (&relax_info
->action_list
, irel
->r_offset
);
9585 irel
->r_offset
= source_offset
;
9588 /* If the target section could have changed then
9589 we may need to change the relocation's target offset. */
9591 target_sec
= r_reloc_get_section (&r_rel
);
9593 /* For a reference to a discarded section from a DWARF section,
9594 i.e., where action_discarded is PRETEND, the symbol will
9595 eventually be modified to refer to the kept section (at least if
9596 the kept and discarded sections are the same size). Anticipate
9597 that here and adjust things accordingly. */
9598 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9599 && elf_xtensa_action_discarded (sec
) == PRETEND
9600 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9601 && target_sec
!= NULL
9602 && discarded_section (target_sec
))
9604 /* It would be natural to call _bfd_elf_check_kept_section
9605 here, but it's not exported from elflink.c. It's also a
9606 fairly expensive check. Adjusting the relocations to the
9607 discarded section is fairly harmless; it will only adjust
9608 some addends and difference values. If it turns out that
9609 _bfd_elf_check_kept_section fails later, it won't matter,
9610 so just compare the section names to find the right group
9612 asection
*kept
= target_sec
->kept_section
;
9615 if ((kept
->flags
& SEC_GROUP
) != 0)
9617 asection
*first
= elf_next_in_group (kept
);
9618 asection
*s
= first
;
9623 if (strcmp (s
->name
, target_sec
->name
) == 0)
9628 s
= elf_next_in_group (s
);
9635 && ((target_sec
->rawsize
!= 0
9636 ? target_sec
->rawsize
: target_sec
->size
)
9637 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9641 target_relax_info
= get_xtensa_relax_info (target_sec
);
9642 if (target_relax_info
9643 && (target_relax_info
->is_relaxable_literal_section
9644 || target_relax_info
->is_relaxable_asm_section
))
9647 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9649 if (r_type
== R_XTENSA_DIFF8
9650 || r_type
== R_XTENSA_DIFF16
9651 || r_type
== R_XTENSA_DIFF32
9652 || r_type
== R_XTENSA_PDIFF8
9653 || r_type
== R_XTENSA_PDIFF16
9654 || r_type
== R_XTENSA_PDIFF32
9655 || r_type
== R_XTENSA_NDIFF8
9656 || r_type
== R_XTENSA_NDIFF16
9657 || r_type
== R_XTENSA_NDIFF32
)
9659 bfd_signed_vma diff_value
= 0;
9660 bfd_vma new_end_offset
, diff_mask
= 0;
9662 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9664 (*link_info
->callbacks
->reloc_dangerous
)
9665 (link_info
, _("invalid relocation address"),
9666 abfd
, sec
, old_source_offset
);
9672 case R_XTENSA_DIFF8
:
9675 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9677 case R_XTENSA_DIFF16
:
9680 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9682 case R_XTENSA_DIFF32
:
9683 diff_mask
= 0x7fffffff;
9685 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9687 case R_XTENSA_PDIFF8
:
9688 case R_XTENSA_NDIFF8
:
9691 bfd_get_8 (abfd
, &contents
[old_source_offset
]);
9693 case R_XTENSA_PDIFF16
:
9694 case R_XTENSA_NDIFF16
:
9697 bfd_get_16 (abfd
, &contents
[old_source_offset
]);
9699 case R_XTENSA_PDIFF32
:
9700 case R_XTENSA_NDIFF32
:
9701 diff_mask
= 0xffffffff;
9703 bfd_get_32 (abfd
, &contents
[old_source_offset
]);
9707 if (r_type
>= R_XTENSA_NDIFF8
9708 && r_type
<= R_XTENSA_NDIFF32
9710 diff_value
|= ~diff_mask
;
9712 new_end_offset
= offset_with_removed_text_map
9713 (&target_relax_info
->action_list
,
9714 r_rel
.target_offset
+ diff_value
);
9715 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9719 case R_XTENSA_DIFF8
:
9720 bfd_put_signed_8 (abfd
, diff_value
,
9721 &contents
[old_source_offset
]);
9723 case R_XTENSA_DIFF16
:
9724 bfd_put_signed_16 (abfd
, diff_value
,
9725 &contents
[old_source_offset
]);
9727 case R_XTENSA_DIFF32
:
9728 bfd_put_signed_32 (abfd
, diff_value
,
9729 &contents
[old_source_offset
]);
9731 case R_XTENSA_PDIFF8
:
9732 case R_XTENSA_NDIFF8
:
9733 bfd_put_8 (abfd
, diff_value
,
9734 &contents
[old_source_offset
]);
9736 case R_XTENSA_PDIFF16
:
9737 case R_XTENSA_NDIFF16
:
9738 bfd_put_16 (abfd
, diff_value
,
9739 &contents
[old_source_offset
]);
9741 case R_XTENSA_PDIFF32
:
9742 case R_XTENSA_NDIFF32
:
9743 bfd_put_32 (abfd
, diff_value
,
9744 &contents
[old_source_offset
]);
9748 /* Check for overflow. Sign bits must be all zeroes or
9749 all ones. When sign bits are all ones diff_value
9751 if (((diff_value
& ~diff_mask
) != 0
9752 && (diff_value
& ~diff_mask
) != ~diff_mask
)
9753 || (diff_value
&& (bfd_vma
) diff_value
== ~diff_mask
))
9755 (*link_info
->callbacks
->reloc_dangerous
)
9756 (link_info
, _("overflow after relaxation"),
9757 abfd
, sec
, old_source_offset
);
9761 pin_contents (sec
, contents
);
9764 /* If the relocation still references a section in the same
9765 input file, modify the relocation directly instead of
9766 adding a "fix" record. */
9767 if (target_sec
->owner
== abfd
)
9769 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9770 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9771 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9772 pin_internal_relocs (sec
, internal_relocs
);
9776 bfd_vma addend_displacement
;
9779 addend_displacement
=
9780 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9781 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9783 addend_displacement
, TRUE
);
9790 if ((relax_info
->is_relaxable_literal_section
9791 || relax_info
->is_relaxable_asm_section
)
9792 && action_list_count (&relax_info
->action_list
))
9794 /* Walk through the planned actions and build up a table
9795 of move, copy and fill records. Use the move, copy and
9796 fill records to perform the actions once. */
9798 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9799 bfd_byte
*scratch
= NULL
;
9800 bfd_byte
*dup_contents
= NULL
;
9801 bfd_size_type orig_size
= sec
->size
;
9802 bfd_vma orig_dot
= 0;
9803 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9804 orig dot in physical memory. */
9805 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9806 bfd_vma dup_dot
= 0;
9808 text_action
*action
;
9810 final_size
= sec
->size
;
9812 splay_tree_foreach (relax_info
->action_list
.tree
,
9813 action_remove_bytes_fn
, &final_size
);
9814 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9815 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9817 /* The dot is the current fill location. */
9819 print_action_list (stderr
, &relax_info
->action_list
);
9822 for (action
= action_first (&relax_info
->action_list
); action
;
9823 action
= action_next (&relax_info
->action_list
, action
))
9825 virtual_action
= FALSE
;
9826 if (action
->offset
> orig_dot
)
9828 orig_dot
+= orig_dot_copied
;
9829 orig_dot_copied
= 0;
9831 /* Out of the virtual world. */
9834 if (action
->offset
> orig_dot
)
9836 copy_size
= action
->offset
- orig_dot
;
9837 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9838 orig_dot
+= copy_size
;
9839 dup_dot
+= copy_size
;
9840 BFD_ASSERT (action
->offset
== orig_dot
);
9842 else if (action
->offset
< orig_dot
)
9844 if (action
->action
== ta_fill
9845 && action
->offset
- action
->removed_bytes
== orig_dot
)
9847 /* This is OK because the fill only effects the dup_dot. */
9849 else if (action
->action
== ta_add_literal
)
9851 /* TBD. Might need to handle this. */
9854 if (action
->offset
== orig_dot
)
9856 if (action
->virtual_offset
> orig_dot_vo
)
9858 if (orig_dot_vo
== 0)
9860 /* Need to copy virtual_offset bytes. Probably four. */
9861 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9862 memmove (&dup_contents
[dup_dot
],
9863 &contents
[orig_dot
], copy_size
);
9864 orig_dot_copied
= copy_size
;
9865 dup_dot
+= copy_size
;
9867 virtual_action
= TRUE
;
9870 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9872 switch (action
->action
)
9874 case ta_remove_literal
:
9875 case ta_remove_insn
:
9876 BFD_ASSERT (action
->removed_bytes
>= 0);
9877 orig_dot
+= action
->removed_bytes
;
9880 case ta_narrow_insn
:
9883 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9884 BFD_ASSERT (action
->removed_bytes
== 1);
9885 rv
= narrow_instruction (scratch
, final_size
, 0);
9887 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9888 orig_dot
+= orig_insn_size
;
9889 dup_dot
+= copy_size
;
9893 if (action
->removed_bytes
>= 0)
9894 orig_dot
+= action
->removed_bytes
;
9897 /* Already zeroed in dup_contents. Just bump the
9899 dup_dot
+= (-action
->removed_bytes
);
9904 BFD_ASSERT (action
->removed_bytes
== 0);
9907 case ta_convert_longcall
:
9908 case ta_remove_longcall
:
9909 /* These will be removed or converted before we get here. */
9916 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9917 BFD_ASSERT (action
->removed_bytes
== -1);
9918 rv
= widen_instruction (scratch
, final_size
, 0);
9920 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9921 orig_dot
+= orig_insn_size
;
9922 dup_dot
+= copy_size
;
9925 case ta_add_literal
:
9928 BFD_ASSERT (action
->removed_bytes
== -4);
9929 /* TBD -- place the literal value here and insert
9931 memset (&dup_contents
[dup_dot
], 0, 4);
9932 pin_internal_relocs (sec
, internal_relocs
);
9933 pin_contents (sec
, contents
);
9935 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9936 relax_info
, &internal_relocs
, &action
->value
))
9940 orig_dot_vo
+= copy_size
;
9942 orig_dot
+= orig_insn_size
;
9943 dup_dot
+= copy_size
;
9947 /* Not implemented yet. */
9952 BFD_ASSERT (dup_dot
<= final_size
);
9953 BFD_ASSERT (orig_dot
<= orig_size
);
9956 orig_dot
+= orig_dot_copied
;
9957 orig_dot_copied
= 0;
9959 if (orig_dot
!= orig_size
)
9961 copy_size
= orig_size
- orig_dot
;
9962 BFD_ASSERT (orig_size
> orig_dot
);
9963 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9964 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9965 orig_dot
+= copy_size
;
9966 dup_dot
+= copy_size
;
9968 BFD_ASSERT (orig_size
== orig_dot
);
9969 BFD_ASSERT (final_size
== dup_dot
);
9971 /* Move the dup_contents back. */
9972 if (final_size
> orig_size
)
9974 /* Contents need to be reallocated. Swap the dup_contents into
9976 sec
->contents
= dup_contents
;
9978 contents
= dup_contents
;
9979 pin_contents (sec
, contents
);
9983 BFD_ASSERT (final_size
<= orig_size
);
9984 memset (contents
, 0, orig_size
);
9985 memcpy (contents
, dup_contents
, final_size
);
9986 free (dup_contents
);
9989 pin_contents (sec
, contents
);
9991 if (sec
->rawsize
== 0)
9992 sec
->rawsize
= sec
->size
;
9993 sec
->size
= final_size
;
9997 release_internal_relocs (sec
, internal_relocs
);
9998 release_contents (sec
, contents
);
10004 translate_section_fixes (asection
*sec
)
10006 xtensa_relax_info
*relax_info
;
10009 relax_info
= get_xtensa_relax_info (sec
);
10013 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
10014 if (!translate_reloc_bfd_fix (r
))
10021 /* Translate a fix given the mapping in the relax info for the target
10022 section. If it has already been translated, no work is required. */
10025 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
10027 reloc_bfd_fix new_fix
;
10029 xtensa_relax_info
*relax_info
;
10030 removed_literal
*removed
;
10031 bfd_vma new_offset
, target_offset
;
10033 if (fix
->translated
)
10036 sec
= fix
->target_sec
;
10037 target_offset
= fix
->target_offset
;
10039 relax_info
= get_xtensa_relax_info (sec
);
10042 fix
->translated
= TRUE
;
10048 /* The fix does not need to be translated if the section cannot change. */
10049 if (!relax_info
->is_relaxable_literal_section
10050 && !relax_info
->is_relaxable_asm_section
)
10052 fix
->translated
= TRUE
;
10056 /* If the literal has been moved and this relocation was on an
10057 opcode, then the relocation should move to the new literal
10058 location. Otherwise, the relocation should move within the
10062 if (is_operand_relocation (fix
->src_type
))
10064 /* Check if the original relocation is against a literal being
10066 removed
= find_removed_literal (&relax_info
->removed_list
,
10074 /* The fact that there is still a relocation to this literal indicates
10075 that the literal is being coalesced, not simply removed. */
10076 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10078 /* This was moved to some other address (possibly another section). */
10079 new_sec
= r_reloc_get_section (&removed
->to
);
10080 if (new_sec
!= sec
)
10083 relax_info
= get_xtensa_relax_info (sec
);
10085 (!relax_info
->is_relaxable_literal_section
10086 && !relax_info
->is_relaxable_asm_section
))
10088 target_offset
= removed
->to
.target_offset
;
10089 new_fix
.target_sec
= new_sec
;
10090 new_fix
.target_offset
= target_offset
;
10091 new_fix
.translated
= TRUE
;
10096 target_offset
= removed
->to
.target_offset
;
10097 new_fix
.target_sec
= new_sec
;
10100 /* The target address may have been moved within its section. */
10101 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
10104 new_fix
.target_offset
= new_offset
;
10105 new_fix
.target_offset
= new_offset
;
10106 new_fix
.translated
= TRUE
;
10112 /* Fix up a relocation to take account of removed literals. */
10115 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
10117 xtensa_relax_info
*relax_info
;
10118 removed_literal
*removed
;
10119 bfd_vma target_offset
, base_offset
;
10121 *new_rel
= *orig_rel
;
10123 if (!r_reloc_is_defined (orig_rel
))
10126 relax_info
= get_xtensa_relax_info (sec
);
10127 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
10128 || relax_info
->is_relaxable_asm_section
));
10130 target_offset
= orig_rel
->target_offset
;
10133 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
10135 /* Check if the original relocation is against a literal being
10137 removed
= find_removed_literal (&relax_info
->removed_list
,
10140 if (removed
&& removed
->to
.abfd
)
10144 /* The fact that there is still a relocation to this literal indicates
10145 that the literal is being coalesced, not simply removed. */
10146 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10148 /* This was moved to some other address
10149 (possibly in another section). */
10150 *new_rel
= removed
->to
;
10151 new_sec
= r_reloc_get_section (new_rel
);
10152 if (new_sec
!= sec
)
10155 relax_info
= get_xtensa_relax_info (sec
);
10157 || (!relax_info
->is_relaxable_literal_section
10158 && !relax_info
->is_relaxable_asm_section
))
10161 target_offset
= new_rel
->target_offset
;
10164 /* Find the base offset of the reloc symbol, excluding any addend from the
10165 reloc or from the section contents (for a partial_inplace reloc). Then
10166 find the adjusted values of the offsets due to relaxation. The base
10167 offset is needed to determine the change to the reloc's addend; the reloc
10168 addend should not be adjusted due to relaxations located before the base
10171 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
10172 if (base_offset
<= target_offset
)
10174 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
10175 base_offset
, FALSE
);
10176 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10177 target_offset
, FALSE
) -
10180 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
10181 new_rel
->rela
.r_addend
-= addend_removed
;
10185 /* Handle a negative addend. The base offset comes first. */
10186 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
10187 target_offset
, FALSE
);
10188 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10189 base_offset
, FALSE
) -
10192 new_rel
->target_offset
= target_offset
- tgt_removed
;
10193 new_rel
->rela
.r_addend
+= addend_removed
;
10200 /* For dynamic links, there may be a dynamic relocation for each
10201 literal. The number of dynamic relocations must be computed in
10202 size_dynamic_sections, which occurs before relaxation. When a
10203 literal is removed, this function checks if there is a corresponding
10204 dynamic relocation and shrinks the size of the appropriate dynamic
10205 relocation section accordingly. At this point, the contents of the
10206 dynamic relocation sections have not yet been filled in, so there's
10207 nothing else that needs to be done. */
10210 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
10212 asection
*input_section
,
10213 Elf_Internal_Rela
*rel
)
10215 struct elf_xtensa_link_hash_table
*htab
;
10216 Elf_Internal_Shdr
*symtab_hdr
;
10217 struct elf_link_hash_entry
**sym_hashes
;
10218 unsigned long r_symndx
;
10220 struct elf_link_hash_entry
*h
;
10221 bfd_boolean dynamic_symbol
;
10223 htab
= elf_xtensa_hash_table (info
);
10227 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10228 sym_hashes
= elf_sym_hashes (abfd
);
10230 r_type
= ELF32_R_TYPE (rel
->r_info
);
10231 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10233 if (r_symndx
< symtab_hdr
->sh_info
)
10236 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10238 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10240 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10241 && (input_section
->flags
& SEC_ALLOC
) != 0
10243 || (bfd_link_pic (info
)
10244 && (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
))))
10247 bfd_boolean is_plt
= FALSE
;
10249 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10251 srel
= htab
->elf
.srelplt
;
10255 srel
= htab
->elf
.srelgot
;
10257 /* Reduce size of the .rela.* section by one reloc. */
10258 BFD_ASSERT (srel
!= NULL
);
10259 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10260 srel
->size
-= sizeof (Elf32_External_Rela
);
10264 asection
*splt
, *sgotplt
, *srelgot
;
10265 int reloc_index
, chunk
;
10267 /* Find the PLT reloc index of the entry being removed. This
10268 is computed from the size of ".rela.plt". It is needed to
10269 figure out which PLT chunk to resize. Usually "last index
10270 = size - 1" since the index starts at zero, but in this
10271 context, the size has just been decremented so there's no
10272 need to subtract one. */
10273 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10275 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10276 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10277 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10278 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10280 /* Check if an entire PLT chunk has just been eliminated. */
10281 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10283 /* The two magic GOT entries for that chunk can go away. */
10284 srelgot
= htab
->elf
.srelgot
;
10285 BFD_ASSERT (srelgot
!= NULL
);
10286 srelgot
->reloc_count
-= 2;
10287 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10288 sgotplt
->size
-= 8;
10290 /* There should be only one entry left (and it will be
10292 BFD_ASSERT (sgotplt
->size
== 4);
10293 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10296 BFD_ASSERT (sgotplt
->size
>= 4);
10297 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10299 sgotplt
->size
-= 4;
10300 splt
->size
-= PLT_ENTRY_SIZE
;
10306 /* Take an r_rel and move it to another section. This usually
10307 requires extending the interal_relocation array and pinning it. If
10308 the original r_rel is from the same BFD, we can complete this here.
10309 Otherwise, we add a fix record to let the final link fix the
10310 appropriate address. Contents and internal relocations for the
10311 section must be pinned after calling this routine. */
10314 move_literal (bfd
*abfd
,
10315 struct bfd_link_info
*link_info
,
10318 bfd_byte
*contents
,
10319 xtensa_relax_info
*relax_info
,
10320 Elf_Internal_Rela
**internal_relocs_p
,
10321 const literal_value
*lit
)
10323 Elf_Internal_Rela
*new_relocs
= NULL
;
10324 size_t new_relocs_count
= 0;
10325 Elf_Internal_Rela this_rela
;
10326 const r_reloc
*r_rel
;
10328 r_rel
= &lit
->r_rel
;
10329 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10331 if (r_reloc_is_const (r_rel
))
10332 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10337 reloc_bfd_fix
*fix
;
10338 unsigned insert_at
;
10340 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10342 /* This is the difficult case. We have to create a fix up. */
10343 this_rela
.r_offset
= offset
;
10344 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10345 this_rela
.r_addend
=
10346 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10347 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10349 /* Currently, we cannot move relocations during a relocatable link. */
10350 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10351 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10352 r_reloc_get_section (r_rel
),
10353 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10355 /* We also need to mark that relocations are needed here. */
10356 sec
->flags
|= SEC_RELOC
;
10358 translate_reloc_bfd_fix (fix
);
10359 /* This fix has not yet been translated. */
10360 add_fix (sec
, fix
);
10362 /* Add the relocation. If we have already allocated our own
10363 space for the relocations and we have room for more, then use
10364 it. Otherwise, allocate new space and move the literals. */
10365 insert_at
= sec
->reloc_count
;
10366 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10368 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10375 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10376 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10378 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10379 || sec
->reloc_count
== relax_info
->relocs_count
);
10381 if (relax_info
->allocated_relocs_count
== 0)
10382 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10384 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10386 new_relocs
= (Elf_Internal_Rela
*)
10387 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10391 /* We could handle this more quickly by finding the split point. */
10392 if (insert_at
!= 0)
10393 memcpy (new_relocs
, *internal_relocs_p
,
10394 insert_at
* sizeof (Elf_Internal_Rela
));
10396 new_relocs
[insert_at
] = this_rela
;
10398 if (insert_at
!= sec
->reloc_count
)
10399 memcpy (new_relocs
+ insert_at
+ 1,
10400 (*internal_relocs_p
) + insert_at
,
10401 (sec
->reloc_count
- insert_at
)
10402 * sizeof (Elf_Internal_Rela
));
10404 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10406 /* The first time we re-allocate, we can only free the
10407 old relocs if they were allocated with bfd_malloc.
10408 This is not true when keep_memory is in effect. */
10409 if (!link_info
->keep_memory
)
10410 free (*internal_relocs_p
);
10413 free (*internal_relocs_p
);
10414 relax_info
->allocated_relocs
= new_relocs
;
10415 relax_info
->allocated_relocs_count
= new_relocs_count
;
10416 elf_section_data (sec
)->relocs
= new_relocs
;
10417 sec
->reloc_count
++;
10418 relax_info
->relocs_count
= sec
->reloc_count
;
10419 *internal_relocs_p
= new_relocs
;
10423 if (insert_at
!= sec
->reloc_count
)
10426 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10427 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10429 (*internal_relocs_p
)[insert_at
] = this_rela
;
10430 sec
->reloc_count
++;
10431 if (relax_info
->allocated_relocs
)
10432 relax_info
->relocs_count
= sec
->reloc_count
;
10439 /* This is similar to relax_section except that when a target is moved,
10440 we shift addresses up. We also need to modify the size. This
10441 algorithm does NOT allow for relocations into the middle of the
10442 property sections. */
10445 relax_property_section (bfd
*abfd
,
10447 struct bfd_link_info
*link_info
)
10449 Elf_Internal_Rela
*internal_relocs
;
10450 bfd_byte
*contents
;
10452 bfd_boolean ok
= TRUE
;
10453 bfd_boolean is_full_prop_section
;
10454 size_t last_zfill_target_offset
= 0;
10455 asection
*last_zfill_target_sec
= NULL
;
10456 bfd_size_type sec_size
;
10457 bfd_size_type entry_size
;
10459 sec_size
= bfd_get_section_limit (abfd
, sec
);
10460 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10461 link_info
->keep_memory
);
10462 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10463 if (contents
== NULL
&& sec_size
!= 0)
10469 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10470 if (is_full_prop_section
)
10475 if (internal_relocs
)
10477 for (i
= 0; i
< sec
->reloc_count
; i
++)
10479 Elf_Internal_Rela
*irel
;
10480 xtensa_relax_info
*target_relax_info
;
10482 asection
*target_sec
;
10484 bfd_byte
*size_p
, *flags_p
;
10486 /* Locally change the source address.
10487 Translate the target to the new target address.
10488 If it points to this section and has been removed, MOVE IT.
10489 Also, don't forget to modify the associated SIZE at
10492 irel
= &internal_relocs
[i
];
10493 r_type
= ELF32_R_TYPE (irel
->r_info
);
10494 if (r_type
== R_XTENSA_NONE
)
10497 /* Find the literal value. */
10498 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10499 size_p
= &contents
[irel
->r_offset
+ 4];
10501 if (is_full_prop_section
)
10502 flags_p
= &contents
[irel
->r_offset
+ 8];
10503 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10505 target_sec
= r_reloc_get_section (&val
.r_rel
);
10506 target_relax_info
= get_xtensa_relax_info (target_sec
);
10508 if (target_relax_info
10509 && (target_relax_info
->is_relaxable_literal_section
10510 || target_relax_info
->is_relaxable_asm_section
))
10512 /* Translate the relocation's destination. */
10513 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10514 bfd_vma new_offset
;
10515 long old_size
, new_size
;
10516 int removed_by_old_offset
=
10517 removed_by_actions_map (&target_relax_info
->action_list
,
10518 old_offset
, FALSE
);
10519 new_offset
= old_offset
- removed_by_old_offset
;
10521 /* Assert that we are not out of bounds. */
10522 old_size
= bfd_get_32 (abfd
, size_p
);
10523 new_size
= old_size
;
10527 /* Only the first zero-sized unreachable entry is
10528 allowed to expand. In this case the new offset
10529 should be the offset before the fill and the new
10530 size is the expansion size. For other zero-sized
10531 entries the resulting size should be zero with an
10532 offset before or after the fill address depending
10533 on whether the expanding unreachable entry
10535 if (last_zfill_target_sec
== 0
10536 || last_zfill_target_sec
!= target_sec
10537 || last_zfill_target_offset
!= old_offset
)
10539 bfd_vma new_end_offset
= new_offset
;
10541 /* Recompute the new_offset, but this time don't
10542 include any fill inserted by relaxation. */
10543 removed_by_old_offset
=
10544 removed_by_actions_map (&target_relax_info
->action_list
,
10546 new_offset
= old_offset
- removed_by_old_offset
;
10548 /* If it is not unreachable and we have not yet
10549 seen an unreachable at this address, place it
10550 before the fill address. */
10551 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10552 & XTENSA_PROP_UNREACHABLE
) != 0)
10554 new_size
= new_end_offset
- new_offset
;
10556 last_zfill_target_sec
= target_sec
;
10557 last_zfill_target_offset
= old_offset
;
10563 int removed_by_old_offset_size
=
10564 removed_by_actions_map (&target_relax_info
->action_list
,
10565 old_offset
+ old_size
, TRUE
);
10566 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10569 if (new_size
!= old_size
)
10571 bfd_put_32 (abfd
, new_size
, size_p
);
10572 pin_contents (sec
, contents
);
10575 if (new_offset
!= old_offset
)
10577 bfd_vma diff
= new_offset
- old_offset
;
10578 irel
->r_addend
+= diff
;
10579 pin_internal_relocs (sec
, internal_relocs
);
10585 /* Combine adjacent property table entries. This is also done in
10586 finish_dynamic_sections() but at that point it's too late to
10587 reclaim the space in the output section, so we do this twice. */
10589 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10590 || xtensa_is_littable_section (sec
)))
10592 Elf_Internal_Rela
*last_irel
= NULL
;
10593 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10594 int removed_bytes
= 0;
10596 flagword predef_flags
;
10598 predef_flags
= xtensa_get_property_predef_flags (sec
);
10600 /* Walk over memory and relocations at the same time.
10601 This REQUIRES that the internal_relocs be sorted by offset. */
10602 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10603 internal_reloc_compare
);
10605 pin_internal_relocs (sec
, internal_relocs
);
10606 pin_contents (sec
, contents
);
10608 next_rel
= internal_relocs
;
10609 rel_end
= internal_relocs
+ sec
->reloc_count
;
10611 BFD_ASSERT (sec
->size
% entry_size
== 0);
10613 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10615 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10616 bfd_vma bytes_to_remove
, size
, actual_offset
;
10617 bfd_boolean remove_this_rel
;
10620 /* Find the first relocation for the entry at the current offset.
10621 Adjust the offsets of any extra relocations for the previous
10626 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10628 if ((irel
->r_offset
== offset
10629 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10630 || irel
->r_offset
> offset
)
10635 irel
->r_offset
-= removed_bytes
;
10639 /* Find the next relocation (if there are any left). */
10643 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10645 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10653 /* Check if there are relocations on the current entry. There
10654 should usually be a relocation on the offset field. If there
10655 are relocations on the size or flags, then we can't optimize
10656 this entry. Also, find the next relocation to examine on the
10660 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10662 next_rel
= offset_rel
;
10663 /* There are no relocations on the current entry, but we
10664 might still be able to remove it if the size is zero. */
10667 else if (offset_rel
->r_offset
> offset
10669 && extra_rel
->r_offset
< offset
+ entry_size
))
10671 /* There is a relocation on the size or flags, so we can't
10672 do anything with this entry. Continue with the next. */
10673 next_rel
= offset_rel
;
10678 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10679 offset_rel
->r_offset
-= removed_bytes
;
10680 next_rel
= offset_rel
+ 1;
10686 remove_this_rel
= FALSE
;
10687 bytes_to_remove
= 0;
10688 actual_offset
= offset
- removed_bytes
;
10689 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10691 if (is_full_prop_section
)
10692 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10694 flags
= predef_flags
;
10697 && (flags
& XTENSA_PROP_ALIGN
) == 0
10698 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10700 /* Always remove entries with zero size and no alignment. */
10701 bytes_to_remove
= entry_size
;
10703 remove_this_rel
= TRUE
;
10705 else if (offset_rel
10706 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10710 flagword old_flags
;
10712 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10713 bfd_vma old_address
=
10714 (last_irel
->r_addend
10715 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10716 bfd_vma new_address
=
10717 (offset_rel
->r_addend
10718 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10719 if (is_full_prop_section
)
10720 old_flags
= bfd_get_32
10721 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10723 old_flags
= predef_flags
;
10725 if ((ELF32_R_SYM (offset_rel
->r_info
)
10726 == ELF32_R_SYM (last_irel
->r_info
))
10727 && old_address
+ old_size
== new_address
10728 && old_flags
== flags
10729 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10730 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10732 /* Fix the old size. */
10733 bfd_put_32 (abfd
, old_size
+ size
,
10734 &contents
[last_irel
->r_offset
+ 4]);
10735 bytes_to_remove
= entry_size
;
10736 remove_this_rel
= TRUE
;
10739 last_irel
= offset_rel
;
10742 last_irel
= offset_rel
;
10745 if (remove_this_rel
)
10747 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10748 offset_rel
->r_offset
= 0;
10751 if (bytes_to_remove
!= 0)
10753 removed_bytes
+= bytes_to_remove
;
10754 if (offset
+ bytes_to_remove
< sec
->size
)
10755 memmove (&contents
[actual_offset
],
10756 &contents
[actual_offset
+ bytes_to_remove
],
10757 sec
->size
- offset
- bytes_to_remove
);
10763 /* Fix up any extra relocations on the last entry. */
10764 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10765 irel
->r_offset
-= removed_bytes
;
10767 /* Clear the removed bytes. */
10768 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10770 if (sec
->rawsize
== 0)
10771 sec
->rawsize
= sec
->size
;
10772 sec
->size
-= removed_bytes
;
10774 if (xtensa_is_littable_section (sec
))
10776 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10778 sgotloc
->size
-= removed_bytes
;
10784 release_internal_relocs (sec
, internal_relocs
);
10785 release_contents (sec
, contents
);
10790 /* Third relaxation pass. */
10792 /* Change symbol values to account for removed literals. */
10795 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10797 xtensa_relax_info
*relax_info
;
10798 unsigned int sec_shndx
;
10799 Elf_Internal_Shdr
*symtab_hdr
;
10800 Elf_Internal_Sym
*isymbuf
;
10801 unsigned i
, num_syms
, num_locals
;
10803 relax_info
= get_xtensa_relax_info (sec
);
10804 BFD_ASSERT (relax_info
);
10806 if (!relax_info
->is_relaxable_literal_section
10807 && !relax_info
->is_relaxable_asm_section
)
10810 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10812 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10813 isymbuf
= retrieve_local_syms (abfd
);
10815 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10816 num_locals
= symtab_hdr
->sh_info
;
10818 /* Adjust the local symbols defined in this section. */
10819 for (i
= 0; i
< num_locals
; i
++)
10821 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10823 if (isym
->st_shndx
== sec_shndx
)
10825 bfd_vma orig_addr
= isym
->st_value
;
10826 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10829 isym
->st_value
-= removed
;
10830 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10832 removed_by_actions_map (&relax_info
->action_list
,
10833 orig_addr
+ isym
->st_size
, FALSE
) -
10838 /* Now adjust the global symbols defined in this section. */
10839 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10841 struct elf_link_hash_entry
*sym_hash
;
10843 sym_hash
= elf_sym_hashes (abfd
)[i
];
10845 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10846 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10848 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10849 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10850 && sym_hash
->root
.u
.def
.section
== sec
)
10852 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10853 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10856 sym_hash
->root
.u
.def
.value
-= removed
;
10858 if (sym_hash
->type
== STT_FUNC
)
10860 removed_by_actions_map (&relax_info
->action_list
,
10861 orig_addr
+ sym_hash
->size
, FALSE
) -
10870 /* "Fix" handling functions, called while performing relocations. */
10873 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10875 asection
*input_section
,
10876 bfd_byte
*contents
)
10879 asection
*sec
, *old_sec
;
10880 bfd_vma old_offset
;
10881 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10882 reloc_bfd_fix
*fix
;
10884 if (r_type
== R_XTENSA_NONE
)
10887 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10891 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10892 bfd_get_section_limit (input_bfd
, input_section
));
10893 old_sec
= r_reloc_get_section (&r_rel
);
10894 old_offset
= r_rel
.target_offset
;
10896 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10898 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10901 /* xgettext:c-format */
10902 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10903 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10904 elf_howto_table
[r_type
].name
);
10907 /* Leave it be. Resolution will happen in a later stage. */
10911 sec
= fix
->target_sec
;
10912 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10913 - (old_sec
->output_offset
+ old_offset
));
10920 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10922 asection
*input_section
,
10923 bfd_byte
*contents
,
10924 bfd_vma
*relocationp
)
10927 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10928 reloc_bfd_fix
*fix
;
10929 bfd_vma fixup_diff
;
10931 if (r_type
== R_XTENSA_NONE
)
10934 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10938 sec
= fix
->target_sec
;
10940 fixup_diff
= rel
->r_addend
;
10941 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10943 bfd_vma inplace_val
;
10944 BFD_ASSERT (fix
->src_offset
10945 < bfd_get_section_limit (input_bfd
, input_section
));
10946 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10947 fixup_diff
+= inplace_val
;
10950 *relocationp
= (sec
->output_section
->vma
10951 + sec
->output_offset
10952 + fix
->target_offset
- fixup_diff
);
10956 /* Miscellaneous utility functions.... */
10959 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10965 return elf_hash_table (info
)->splt
;
10967 dynobj
= elf_hash_table (info
)->dynobj
;
10968 sprintf (plt_name
, ".plt.%u", chunk
);
10969 return bfd_get_linker_section (dynobj
, plt_name
);
10974 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10980 return elf_hash_table (info
)->sgotplt
;
10982 dynobj
= elf_hash_table (info
)->dynobj
;
10983 sprintf (got_name
, ".got.plt.%u", chunk
);
10984 return bfd_get_linker_section (dynobj
, got_name
);
10988 /* Get the input section for a given symbol index.
10990 . a section symbol, return the section;
10991 . a common symbol, return the common section;
10992 . an undefined symbol, return the undefined section;
10993 . an indirect symbol, follow the links;
10994 . an absolute value, return the absolute section. */
10997 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
10999 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11000 asection
*target_sec
= NULL
;
11001 if (r_symndx
< symtab_hdr
->sh_info
)
11003 Elf_Internal_Sym
*isymbuf
;
11004 unsigned int section_index
;
11006 isymbuf
= retrieve_local_syms (abfd
);
11007 section_index
= isymbuf
[r_symndx
].st_shndx
;
11009 if (section_index
== SHN_UNDEF
)
11010 target_sec
= bfd_und_section_ptr
;
11011 else if (section_index
== SHN_ABS
)
11012 target_sec
= bfd_abs_section_ptr
;
11013 else if (section_index
== SHN_COMMON
)
11014 target_sec
= bfd_com_section_ptr
;
11016 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
11020 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11021 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
11023 while (h
->root
.type
== bfd_link_hash_indirect
11024 || h
->root
.type
== bfd_link_hash_warning
)
11025 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11027 switch (h
->root
.type
)
11029 case bfd_link_hash_defined
:
11030 case bfd_link_hash_defweak
:
11031 target_sec
= h
->root
.u
.def
.section
;
11033 case bfd_link_hash_common
:
11034 target_sec
= bfd_com_section_ptr
;
11036 case bfd_link_hash_undefined
:
11037 case bfd_link_hash_undefweak
:
11038 target_sec
= bfd_und_section_ptr
;
11040 default: /* New indirect warning. */
11041 target_sec
= bfd_und_section_ptr
;
11049 static struct elf_link_hash_entry
*
11050 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
11052 unsigned long indx
;
11053 struct elf_link_hash_entry
*h
;
11054 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11056 if (r_symndx
< symtab_hdr
->sh_info
)
11059 indx
= r_symndx
- symtab_hdr
->sh_info
;
11060 h
= elf_sym_hashes (abfd
)[indx
];
11061 while (h
->root
.type
== bfd_link_hash_indirect
11062 || h
->root
.type
== bfd_link_hash_warning
)
11063 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11068 /* Get the section-relative offset for a symbol number. */
11071 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
11073 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
11074 bfd_vma offset
= 0;
11076 if (r_symndx
< symtab_hdr
->sh_info
)
11078 Elf_Internal_Sym
*isymbuf
;
11079 isymbuf
= retrieve_local_syms (abfd
);
11080 offset
= isymbuf
[r_symndx
].st_value
;
11084 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
11085 struct elf_link_hash_entry
*h
=
11086 elf_sym_hashes (abfd
)[indx
];
11088 while (h
->root
.type
== bfd_link_hash_indirect
11089 || h
->root
.type
== bfd_link_hash_warning
)
11090 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
11091 if (h
->root
.type
== bfd_link_hash_defined
11092 || h
->root
.type
== bfd_link_hash_defweak
)
11093 offset
= h
->root
.u
.def
.value
;
11100 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
11102 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
11103 struct elf_link_hash_entry
*h
;
11105 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
11106 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
11113 pcrel_reloc_fits (xtensa_opcode opc
,
11115 bfd_vma self_address
,
11116 bfd_vma dest_address
)
11118 xtensa_isa isa
= xtensa_default_isa
;
11119 uint32 valp
= dest_address
;
11120 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
11121 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
11128 xtensa_is_property_section (asection
*sec
)
11130 if (xtensa_is_insntable_section (sec
)
11131 || xtensa_is_littable_section (sec
)
11132 || xtensa_is_proptable_section (sec
))
11140 xtensa_is_insntable_section (asection
*sec
)
11142 if (CONST_STRNEQ (sec
->name
, XTENSA_INSN_SEC_NAME
)
11143 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.x."))
11151 xtensa_is_littable_section (asection
*sec
)
11153 if (CONST_STRNEQ (sec
->name
, XTENSA_LIT_SEC_NAME
)
11154 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.p."))
11162 xtensa_is_proptable_section (asection
*sec
)
11164 if (CONST_STRNEQ (sec
->name
, XTENSA_PROP_SEC_NAME
)
11165 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.prop."))
11173 internal_reloc_compare (const void *ap
, const void *bp
)
11175 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11176 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11178 if (a
->r_offset
!= b
->r_offset
)
11179 return (a
->r_offset
- b
->r_offset
);
11181 /* We don't need to sort on these criteria for correctness,
11182 but enforcing a more strict ordering prevents unstable qsort
11183 from behaving differently with different implementations.
11184 Without the code below we get correct but different results
11185 on Solaris 2.7 and 2.8. We would like to always produce the
11186 same results no matter the host. */
11188 if (a
->r_info
!= b
->r_info
)
11189 return (a
->r_info
- b
->r_info
);
11191 return (a
->r_addend
- b
->r_addend
);
11196 internal_reloc_matches (const void *ap
, const void *bp
)
11198 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11199 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11201 /* Check if one entry overlaps with the other; this shouldn't happen
11202 except when searching for a match. */
11203 return (a
->r_offset
- b
->r_offset
);
11207 /* Predicate function used to look up a section in a particular group. */
11210 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
11212 const char *gname
= inf
;
11213 const char *group_name
= elf_group_name (sec
);
11215 return (group_name
== gname
11216 || (group_name
!= NULL
11218 && strcmp (group_name
, gname
) == 0));
11223 xtensa_add_names (const char *base
, const char *suffix
)
11227 size_t base_len
= strlen (base
);
11228 size_t suffix_len
= strlen (suffix
);
11229 char *str
= bfd_malloc (base_len
+ suffix_len
+ 1);
11231 memcpy (str
, base
, base_len
);
11232 memcpy (str
+ base_len
, suffix
, suffix_len
+ 1);
11237 return strdup (base
);
11241 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11244 xtensa_property_section_name (asection
*sec
, const char *base_name
,
11245 bfd_boolean separate_sections
)
11247 const char *suffix
, *group_name
;
11248 char *prop_sec_name
;
11250 group_name
= elf_group_name (sec
);
11253 suffix
= strrchr (sec
->name
, '.');
11254 if (suffix
== sec
->name
)
11256 prop_sec_name
= xtensa_add_names (base_name
, suffix
);
11258 else if (strncmp (sec
->name
, ".gnu.linkonce.", linkonce_len
) == 0)
11260 char *linkonce_kind
= 0;
11262 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11263 linkonce_kind
= "x.";
11264 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11265 linkonce_kind
= "p.";
11266 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11267 linkonce_kind
= "prop.";
11271 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11272 + strlen (linkonce_kind
) + 1);
11273 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11274 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11276 suffix
= sec
->name
+ linkonce_len
;
11277 /* For backward compatibility, replace "t." instead of inserting
11278 the new linkonce_kind (but not for "prop" sections). */
11279 if (CONST_STRNEQ (suffix
, "t.") && linkonce_kind
[1] == '.')
11281 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11285 prop_sec_name
= xtensa_add_names (base_name
,
11286 separate_sections
? sec
->name
: NULL
);
11289 return prop_sec_name
;
11294 xtensa_get_separate_property_section (asection
*sec
, const char *base_name
,
11295 bfd_boolean separate_section
)
11297 char *prop_sec_name
;
11298 asection
*prop_sec
;
11300 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11302 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11303 match_section_group
,
11304 (void *) elf_group_name (sec
));
11305 free (prop_sec_name
);
11310 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11312 asection
*prop_sec
;
11314 /* Try individual property section first. */
11315 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, TRUE
);
11317 /* Refer to a common property section if individual is not present. */
11319 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, FALSE
);
11326 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11328 char *prop_sec_name
;
11329 asection
*prop_sec
;
11331 /* Check if the section already exists. */
11332 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11333 elf32xtensa_separate_props
);
11334 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11335 match_section_group
,
11336 (void *) elf_group_name (sec
));
11337 /* If not, create it. */
11340 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11341 flags
|= (bfd_section_flags (sec
)
11342 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11344 prop_sec
= bfd_make_section_anyway_with_flags
11345 (sec
->owner
, strdup (prop_sec_name
), flags
);
11349 elf_group_name (prop_sec
) = elf_group_name (sec
);
11352 free (prop_sec_name
);
11358 xtensa_get_property_predef_flags (asection
*sec
)
11360 if (xtensa_is_insntable_section (sec
))
11361 return (XTENSA_PROP_INSN
11362 | XTENSA_PROP_NO_TRANSFORM
11363 | XTENSA_PROP_INSN_NO_REORDER
);
11365 if (xtensa_is_littable_section (sec
))
11366 return (XTENSA_PROP_LITERAL
11367 | XTENSA_PROP_NO_TRANSFORM
11368 | XTENSA_PROP_INSN_NO_REORDER
);
11374 /* Other functions called directly by the linker. */
11377 xtensa_callback_required_dependence (bfd
*abfd
,
11379 struct bfd_link_info
*link_info
,
11380 deps_callback_t callback
,
11383 Elf_Internal_Rela
*internal_relocs
;
11384 bfd_byte
*contents
;
11386 bfd_boolean ok
= TRUE
;
11387 bfd_size_type sec_size
;
11389 sec_size
= bfd_get_section_limit (abfd
, sec
);
11391 /* ".plt*" sections have no explicit relocations but they contain L32R
11392 instructions that reference the corresponding ".got.plt*" sections. */
11393 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11394 && CONST_STRNEQ (sec
->name
, ".plt"))
11398 /* Find the corresponding ".got.plt*" section. */
11399 if (sec
->name
[4] == '\0')
11400 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11406 BFD_ASSERT (sec
->name
[4] == '.');
11407 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11409 sprintf (got_name
, ".got.plt.%u", chunk
);
11410 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11412 BFD_ASSERT (sgotplt
);
11414 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11415 section referencing a literal at the very beginning of
11416 ".got.plt". This is very close to the real dependence, anyway. */
11417 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11420 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11421 when building uclibc, which runs "ld -b binary /dev/null". */
11422 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11425 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11426 link_info
->keep_memory
);
11427 if (internal_relocs
== NULL
11428 || sec
->reloc_count
== 0)
11431 /* Cache the contents for the duration of this scan. */
11432 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11433 if (contents
== NULL
&& sec_size
!= 0)
11439 if (!xtensa_default_isa
)
11440 xtensa_default_isa
= xtensa_isa_init (0, 0);
11442 for (i
= 0; i
< sec
->reloc_count
; i
++)
11444 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11445 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11448 asection
*target_sec
;
11449 bfd_vma target_offset
;
11451 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11454 /* L32Rs must be local to the input file. */
11455 if (r_reloc_is_defined (&l32r_rel
))
11457 target_sec
= r_reloc_get_section (&l32r_rel
);
11458 target_offset
= l32r_rel
.target_offset
;
11460 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11466 release_internal_relocs (sec
, internal_relocs
);
11467 release_contents (sec
, contents
);
11471 /* The default literal sections should always be marked as "code" (i.e.,
11472 SHF_EXECINSTR). This is particularly important for the Linux kernel
11473 module loader so that the literals are not placed after the text. */
11474 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11476 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11477 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11478 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11479 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11480 { NULL
, 0, 0, 0, 0 }
11483 #define ELF_TARGET_ID XTENSA_ELF_DATA
11485 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11486 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11487 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11488 #define TARGET_BIG_NAME "elf32-xtensa-be"
11489 #define ELF_ARCH bfd_arch_xtensa
11491 #define ELF_MACHINE_CODE EM_XTENSA
11492 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11494 #define ELF_MAXPAGESIZE 0x1000
11495 #endif /* ELF_ARCH */
11497 #define elf_backend_can_gc_sections 1
11498 #define elf_backend_can_refcount 1
11499 #define elf_backend_plt_readonly 1
11500 #define elf_backend_got_header_size 4
11501 #define elf_backend_want_dynbss 0
11502 #define elf_backend_want_got_plt 1
11503 #define elf_backend_dtrel_excludes_plt 1
11505 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11507 #define bfd_elf32_mkobject elf_xtensa_mkobject
11509 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11510 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11511 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11512 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11513 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11514 #define bfd_elf32_bfd_reloc_name_lookup \
11515 elf_xtensa_reloc_name_lookup
11516 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11517 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11519 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11520 #define elf_backend_check_relocs elf_xtensa_check_relocs
11521 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11522 #define elf_backend_discard_info elf_xtensa_discard_info
11523 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11524 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11525 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11526 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11527 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11528 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11529 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11530 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11531 #define elf_backend_object_p elf_xtensa_object_p
11532 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11533 #define elf_backend_relocate_section elf_xtensa_relocate_section
11534 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11535 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11536 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11537 #define elf_backend_special_sections elf_xtensa_special_sections
11538 #define elf_backend_action_discarded elf_xtensa_action_discarded
11539 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11541 #include "elf32-target.h"