1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright (C) 2003-2018 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 #define XTENSA_NO_NOP_REMOVAL 0
37 /* Local helper functions. */
39 static bfd_boolean
add_extra_plt_sections (struct bfd_link_info
*, int);
40 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
41 static bfd_reloc_status_type bfd_elf_xtensa_reloc
42 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
43 static bfd_boolean do_fix_for_relocatable_link
44 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*);
45 static void do_fix_for_final_link
46 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*, bfd_vma
*);
48 /* Local functions to handle Xtensa configurability. */
50 static bfd_boolean
is_indirect_call_opcode (xtensa_opcode
);
51 static bfd_boolean
is_direct_call_opcode (xtensa_opcode
);
52 static bfd_boolean
is_windowed_call_opcode (xtensa_opcode
);
53 static xtensa_opcode
get_const16_opcode (void);
54 static xtensa_opcode
get_l32r_opcode (void);
55 static bfd_vma
l32r_offset (bfd_vma
, bfd_vma
);
56 static int get_relocation_opnd (xtensa_opcode
, int);
57 static int get_relocation_slot (int);
58 static xtensa_opcode get_relocation_opcode
59 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
60 static bfd_boolean is_l32r_relocation
61 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
62 static bfd_boolean
is_alt_relocation (int);
63 static bfd_boolean
is_operand_relocation (int);
64 static bfd_size_type insn_decode_len
65 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
66 static xtensa_opcode insn_decode_opcode
67 (bfd_byte
*, bfd_size_type
, bfd_size_type
, int);
68 static bfd_boolean check_branch_target_aligned
69 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
70 static bfd_boolean check_loop_aligned
71 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
72 static bfd_boolean
check_branch_target_aligned_address (bfd_vma
, int);
73 static bfd_size_type get_asm_simplify_size
74 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
76 /* Functions for link-time code simplifications. */
78 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
79 (bfd_byte
*, bfd_vma
, bfd_vma
, char **);
80 static bfd_reloc_status_type contract_asm_expansion
81 (bfd_byte
*, bfd_vma
, Elf_Internal_Rela
*, char **);
82 static xtensa_opcode
swap_callx_for_call_opcode (xtensa_opcode
);
83 static xtensa_opcode
get_expanded_call_opcode (bfd_byte
*, int, bfd_boolean
*);
85 /* Access to internal relocations, section contents and symbols. */
87 static Elf_Internal_Rela
*retrieve_internal_relocs
88 (bfd
*, asection
*, bfd_boolean
);
89 static void pin_internal_relocs (asection
*, Elf_Internal_Rela
*);
90 static void release_internal_relocs (asection
*, Elf_Internal_Rela
*);
91 static bfd_byte
*retrieve_contents (bfd
*, asection
*, bfd_boolean
);
92 static void pin_contents (asection
*, bfd_byte
*);
93 static void release_contents (asection
*, bfd_byte
*);
94 static Elf_Internal_Sym
*retrieve_local_syms (bfd
*);
96 /* Miscellaneous utility functions. */
98 static asection
*elf_xtensa_get_plt_section (struct bfd_link_info
*, int);
99 static asection
*elf_xtensa_get_gotplt_section (struct bfd_link_info
*, int);
100 static asection
*get_elf_r_symndx_section (bfd
*, unsigned long);
101 static struct elf_link_hash_entry
*get_elf_r_symndx_hash_entry
102 (bfd
*, unsigned long);
103 static bfd_vma
get_elf_r_symndx_offset (bfd
*, unsigned long);
104 static bfd_boolean
is_reloc_sym_weak (bfd
*, Elf_Internal_Rela
*);
105 static bfd_boolean
pcrel_reloc_fits (xtensa_opcode
, int, bfd_vma
, bfd_vma
);
106 static bfd_boolean
xtensa_is_property_section (asection
*);
107 static bfd_boolean
xtensa_is_insntable_section (asection
*);
108 static bfd_boolean
xtensa_is_littable_section (asection
*);
109 static bfd_boolean
xtensa_is_proptable_section (asection
*);
110 static int internal_reloc_compare (const void *, const void *);
111 static int internal_reloc_matches (const void *, const void *);
112 static asection
*xtensa_get_property_section (asection
*, const char *);
113 static flagword
xtensa_get_property_predef_flags (asection
*);
115 /* Other functions called directly by the linker. */
117 typedef void (*deps_callback_t
)
118 (asection
*, bfd_vma
, asection
*, bfd_vma
, void *);
119 extern bfd_boolean xtensa_callback_required_dependence
120 (bfd
*, asection
*, struct bfd_link_info
*, deps_callback_t
, void *);
123 /* Globally visible flag for choosing size optimization of NOP removal
124 instead of branch-target-aware minimization for NOP removal.
125 When nonzero, narrow all instructions and remove all NOPs possible
126 around longcall expansions. */
128 int elf32xtensa_size_opt
;
131 /* The "new_section_hook" is used to set up a per-section
132 "xtensa_relax_info" data structure with additional information used
133 during relaxation. */
135 typedef struct xtensa_relax_info_struct xtensa_relax_info
;
138 /* The GNU tools do not easily allow extending interfaces to pass around
139 the pointer to the Xtensa ISA information, so instead we add a global
140 variable here (in BFD) that can be used by any of the tools that need
143 xtensa_isa xtensa_default_isa
;
146 /* When this is true, relocations may have been modified to refer to
147 symbols from other input files. The per-section list of "fix"
148 records needs to be checked when resolving relocations. */
150 static bfd_boolean relaxing_section
= FALSE
;
152 /* When this is true, during final links, literals that cannot be
153 coalesced and their relocations may be moved to other sections. */
155 int elf32xtensa_no_literal_movement
= 1;
157 /* Rename one of the generic section flags to better document how it
159 /* Whether relocations have been processed. */
160 #define reloc_done sec_flg0
162 static reloc_howto_type elf_howto_table
[] =
164 HOWTO (R_XTENSA_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
165 bfd_elf_xtensa_reloc
, "R_XTENSA_NONE",
167 HOWTO (R_XTENSA_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
168 bfd_elf_xtensa_reloc
, "R_XTENSA_32",
169 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
171 /* Replace a 32-bit value with a value from the runtime linker (only
172 used by linker-generated stub functions). The r_addend value is
173 special: 1 means to substitute a pointer to the runtime linker's
174 dynamic resolver function; 2 means to substitute the link map for
175 the shared object. */
176 HOWTO (R_XTENSA_RTLD
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
177 NULL
, "R_XTENSA_RTLD", FALSE
, 0, 0, FALSE
),
179 HOWTO (R_XTENSA_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
180 bfd_elf_generic_reloc
, "R_XTENSA_GLOB_DAT",
181 FALSE
, 0, 0xffffffff, FALSE
),
182 HOWTO (R_XTENSA_JMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
183 bfd_elf_generic_reloc
, "R_XTENSA_JMP_SLOT",
184 FALSE
, 0, 0xffffffff, FALSE
),
185 HOWTO (R_XTENSA_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
186 bfd_elf_generic_reloc
, "R_XTENSA_RELATIVE",
187 FALSE
, 0, 0xffffffff, FALSE
),
188 HOWTO (R_XTENSA_PLT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
189 bfd_elf_xtensa_reloc
, "R_XTENSA_PLT",
190 FALSE
, 0, 0xffffffff, FALSE
),
194 /* Old relocations for backward compatibility. */
195 HOWTO (R_XTENSA_OP0
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
196 bfd_elf_xtensa_reloc
, "R_XTENSA_OP0", FALSE
, 0, 0, TRUE
),
197 HOWTO (R_XTENSA_OP1
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
198 bfd_elf_xtensa_reloc
, "R_XTENSA_OP1", FALSE
, 0, 0, TRUE
),
199 HOWTO (R_XTENSA_OP2
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
200 bfd_elf_xtensa_reloc
, "R_XTENSA_OP2", FALSE
, 0, 0, TRUE
),
202 /* Assembly auto-expansion. */
203 HOWTO (R_XTENSA_ASM_EXPAND
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
204 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_EXPAND", FALSE
, 0, 0, TRUE
),
205 /* Relax assembly auto-expansion. */
206 HOWTO (R_XTENSA_ASM_SIMPLIFY
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
207 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_SIMPLIFY", FALSE
, 0, 0, TRUE
),
211 HOWTO (R_XTENSA_32_PCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
212 bfd_elf_xtensa_reloc
, "R_XTENSA_32_PCREL",
213 FALSE
, 0, 0xffffffff, TRUE
),
215 /* GNU extension to record C++ vtable hierarchy. */
216 HOWTO (R_XTENSA_GNU_VTINHERIT
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
217 NULL
, "R_XTENSA_GNU_VTINHERIT",
219 /* GNU extension to record C++ vtable member usage. */
220 HOWTO (R_XTENSA_GNU_VTENTRY
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
221 _bfd_elf_rel_vtable_reloc_fn
, "R_XTENSA_GNU_VTENTRY",
224 /* Relocations for supporting difference of symbols. */
225 HOWTO (R_XTENSA_DIFF8
, 0, 0, 8, FALSE
, 0, complain_overflow_signed
,
226 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF8", FALSE
, 0, 0xff, FALSE
),
227 HOWTO (R_XTENSA_DIFF16
, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,
228 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF16", FALSE
, 0, 0xffff, FALSE
),
229 HOWTO (R_XTENSA_DIFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
230 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF32", FALSE
, 0, 0xffffffff, FALSE
),
232 /* General immediate operand relocations. */
233 HOWTO (R_XTENSA_SLOT0_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
234 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_OP", FALSE
, 0, 0, TRUE
),
235 HOWTO (R_XTENSA_SLOT1_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
236 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_OP", FALSE
, 0, 0, TRUE
),
237 HOWTO (R_XTENSA_SLOT2_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
238 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_OP", FALSE
, 0, 0, TRUE
),
239 HOWTO (R_XTENSA_SLOT3_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
240 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_OP", FALSE
, 0, 0, TRUE
),
241 HOWTO (R_XTENSA_SLOT4_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
242 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_OP", FALSE
, 0, 0, TRUE
),
243 HOWTO (R_XTENSA_SLOT5_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
244 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_OP", FALSE
, 0, 0, TRUE
),
245 HOWTO (R_XTENSA_SLOT6_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
246 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_OP", FALSE
, 0, 0, TRUE
),
247 HOWTO (R_XTENSA_SLOT7_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
248 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_OP", FALSE
, 0, 0, TRUE
),
249 HOWTO (R_XTENSA_SLOT8_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
250 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_OP", FALSE
, 0, 0, TRUE
),
251 HOWTO (R_XTENSA_SLOT9_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
252 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_OP", FALSE
, 0, 0, TRUE
),
253 HOWTO (R_XTENSA_SLOT10_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
254 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_OP", FALSE
, 0, 0, TRUE
),
255 HOWTO (R_XTENSA_SLOT11_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
256 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_OP", FALSE
, 0, 0, TRUE
),
257 HOWTO (R_XTENSA_SLOT12_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
258 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_OP", FALSE
, 0, 0, TRUE
),
259 HOWTO (R_XTENSA_SLOT13_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
260 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_OP", FALSE
, 0, 0, TRUE
),
261 HOWTO (R_XTENSA_SLOT14_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
262 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_OP", FALSE
, 0, 0, TRUE
),
264 /* "Alternate" relocations. The meaning of these is opcode-specific. */
265 HOWTO (R_XTENSA_SLOT0_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
266 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_ALT", FALSE
, 0, 0, TRUE
),
267 HOWTO (R_XTENSA_SLOT1_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
268 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_ALT", FALSE
, 0, 0, TRUE
),
269 HOWTO (R_XTENSA_SLOT2_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
270 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_ALT", FALSE
, 0, 0, TRUE
),
271 HOWTO (R_XTENSA_SLOT3_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
272 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_ALT", FALSE
, 0, 0, TRUE
),
273 HOWTO (R_XTENSA_SLOT4_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
274 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_ALT", FALSE
, 0, 0, TRUE
),
275 HOWTO (R_XTENSA_SLOT5_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
276 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_ALT", FALSE
, 0, 0, TRUE
),
277 HOWTO (R_XTENSA_SLOT6_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
278 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_ALT", FALSE
, 0, 0, TRUE
),
279 HOWTO (R_XTENSA_SLOT7_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
280 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_ALT", FALSE
, 0, 0, TRUE
),
281 HOWTO (R_XTENSA_SLOT8_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
282 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_ALT", FALSE
, 0, 0, TRUE
),
283 HOWTO (R_XTENSA_SLOT9_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
284 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_ALT", FALSE
, 0, 0, TRUE
),
285 HOWTO (R_XTENSA_SLOT10_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
286 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_ALT", FALSE
, 0, 0, TRUE
),
287 HOWTO (R_XTENSA_SLOT11_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
288 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_ALT", FALSE
, 0, 0, TRUE
),
289 HOWTO (R_XTENSA_SLOT12_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
290 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_ALT", FALSE
, 0, 0, TRUE
),
291 HOWTO (R_XTENSA_SLOT13_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
292 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_ALT", FALSE
, 0, 0, TRUE
),
293 HOWTO (R_XTENSA_SLOT14_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
294 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_ALT", FALSE
, 0, 0, TRUE
),
296 /* TLS relocations. */
297 HOWTO (R_XTENSA_TLSDESC_FN
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
298 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_FN",
299 FALSE
, 0, 0xffffffff, FALSE
),
300 HOWTO (R_XTENSA_TLSDESC_ARG
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
301 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_ARG",
302 FALSE
, 0, 0xffffffff, FALSE
),
303 HOWTO (R_XTENSA_TLS_DTPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
304 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_DTPOFF",
305 FALSE
, 0, 0xffffffff, FALSE
),
306 HOWTO (R_XTENSA_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
307 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_TPOFF",
308 FALSE
, 0, 0xffffffff, FALSE
),
309 HOWTO (R_XTENSA_TLS_FUNC
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
310 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_FUNC",
312 HOWTO (R_XTENSA_TLS_ARG
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
313 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_ARG",
315 HOWTO (R_XTENSA_TLS_CALL
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
316 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_CALL",
322 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
327 static reloc_howto_type
*
328 elf_xtensa_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
329 bfd_reloc_code_real_type code
)
334 TRACE ("BFD_RELOC_NONE");
335 return &elf_howto_table
[(unsigned) R_XTENSA_NONE
];
338 TRACE ("BFD_RELOC_32");
339 return &elf_howto_table
[(unsigned) R_XTENSA_32
];
341 case BFD_RELOC_32_PCREL
:
342 TRACE ("BFD_RELOC_32_PCREL");
343 return &elf_howto_table
[(unsigned) R_XTENSA_32_PCREL
];
345 case BFD_RELOC_XTENSA_DIFF8
:
346 TRACE ("BFD_RELOC_XTENSA_DIFF8");
347 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF8
];
349 case BFD_RELOC_XTENSA_DIFF16
:
350 TRACE ("BFD_RELOC_XTENSA_DIFF16");
351 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF16
];
353 case BFD_RELOC_XTENSA_DIFF32
:
354 TRACE ("BFD_RELOC_XTENSA_DIFF32");
355 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF32
];
357 case BFD_RELOC_XTENSA_RTLD
:
358 TRACE ("BFD_RELOC_XTENSA_RTLD");
359 return &elf_howto_table
[(unsigned) R_XTENSA_RTLD
];
361 case BFD_RELOC_XTENSA_GLOB_DAT
:
362 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
363 return &elf_howto_table
[(unsigned) R_XTENSA_GLOB_DAT
];
365 case BFD_RELOC_XTENSA_JMP_SLOT
:
366 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
367 return &elf_howto_table
[(unsigned) R_XTENSA_JMP_SLOT
];
369 case BFD_RELOC_XTENSA_RELATIVE
:
370 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
371 return &elf_howto_table
[(unsigned) R_XTENSA_RELATIVE
];
373 case BFD_RELOC_XTENSA_PLT
:
374 TRACE ("BFD_RELOC_XTENSA_PLT");
375 return &elf_howto_table
[(unsigned) R_XTENSA_PLT
];
377 case BFD_RELOC_XTENSA_OP0
:
378 TRACE ("BFD_RELOC_XTENSA_OP0");
379 return &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
381 case BFD_RELOC_XTENSA_OP1
:
382 TRACE ("BFD_RELOC_XTENSA_OP1");
383 return &elf_howto_table
[(unsigned) R_XTENSA_OP1
];
385 case BFD_RELOC_XTENSA_OP2
:
386 TRACE ("BFD_RELOC_XTENSA_OP2");
387 return &elf_howto_table
[(unsigned) R_XTENSA_OP2
];
389 case BFD_RELOC_XTENSA_ASM_EXPAND
:
390 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
391 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_EXPAND
];
393 case BFD_RELOC_XTENSA_ASM_SIMPLIFY
:
394 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
395 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_SIMPLIFY
];
397 case BFD_RELOC_VTABLE_INHERIT
:
398 TRACE ("BFD_RELOC_VTABLE_INHERIT");
399 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTINHERIT
];
401 case BFD_RELOC_VTABLE_ENTRY
:
402 TRACE ("BFD_RELOC_VTABLE_ENTRY");
403 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTENTRY
];
405 case BFD_RELOC_XTENSA_TLSDESC_FN
:
406 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
407 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_FN
];
409 case BFD_RELOC_XTENSA_TLSDESC_ARG
:
410 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
411 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_ARG
];
413 case BFD_RELOC_XTENSA_TLS_DTPOFF
:
414 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
415 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_DTPOFF
];
417 case BFD_RELOC_XTENSA_TLS_TPOFF
:
418 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
419 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_TPOFF
];
421 case BFD_RELOC_XTENSA_TLS_FUNC
:
422 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
423 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_FUNC
];
425 case BFD_RELOC_XTENSA_TLS_ARG
:
426 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
427 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_ARG
];
429 case BFD_RELOC_XTENSA_TLS_CALL
:
430 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
431 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_CALL
];
434 if (code
>= BFD_RELOC_XTENSA_SLOT0_OP
435 && code
<= BFD_RELOC_XTENSA_SLOT14_OP
)
437 unsigned n
= (R_XTENSA_SLOT0_OP
+
438 (code
- BFD_RELOC_XTENSA_SLOT0_OP
));
439 return &elf_howto_table
[n
];
442 if (code
>= BFD_RELOC_XTENSA_SLOT0_ALT
443 && code
<= BFD_RELOC_XTENSA_SLOT14_ALT
)
445 unsigned n
= (R_XTENSA_SLOT0_ALT
+
446 (code
- BFD_RELOC_XTENSA_SLOT0_ALT
));
447 return &elf_howto_table
[n
];
457 static reloc_howto_type
*
458 elf_xtensa_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
463 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
464 if (elf_howto_table
[i
].name
!= NULL
465 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
466 return &elf_howto_table
[i
];
472 /* Given an ELF "rela" relocation, find the corresponding howto and record
473 it in the BFD internal arelent representation of the relocation. */
476 elf_xtensa_info_to_howto_rela (bfd
*abfd ATTRIBUTE_UNUSED
,
478 Elf_Internal_Rela
*dst
)
480 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
482 if (r_type
>= (unsigned int) R_XTENSA_max
)
484 /* xgettext:c-format */
485 _bfd_error_handler (_("%pB: invalid XTENSA reloc number: %d"), abfd
, r_type
);
488 cache_ptr
->howto
= &elf_howto_table
[r_type
];
492 /* Functions for the Xtensa ELF linker. */
494 /* The name of the dynamic interpreter. This is put in the .interp
497 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
499 /* The size in bytes of an entry in the procedure linkage table.
500 (This does _not_ include the space for the literals associated with
503 #define PLT_ENTRY_SIZE 16
505 /* For _really_ large PLTs, we may need to alternate between literals
506 and code to keep the literals within the 256K range of the L32R
507 instructions in the code. It's unlikely that anyone would ever need
508 such a big PLT, but an arbitrary limit on the PLT size would be bad.
509 Thus, we split the PLT into chunks. Since there's very little
510 overhead (2 extra literals) for each chunk, the chunk size is kept
511 small so that the code for handling multiple chunks get used and
512 tested regularly. With 254 entries, there are 1K of literals for
513 each chunk, and that seems like a nice round number. */
515 #define PLT_ENTRIES_PER_CHUNK 254
517 /* PLT entries are actually used as stub functions for lazy symbol
518 resolution. Once the symbol is resolved, the stub function is never
519 invoked. Note: the 32-byte frame size used here cannot be changed
520 without a corresponding change in the runtime linker. */
522 static const bfd_byte elf_xtensa_be_plt_entry
[][PLT_ENTRY_SIZE
] =
525 0x6c, 0x10, 0x04, /* entry sp, 32 */
526 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
527 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
528 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
529 0x0a, 0x80, 0x00, /* jx a8 */
533 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
534 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
535 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
536 0x0a, 0x80, 0x00, /* jx a8 */
541 static const bfd_byte elf_xtensa_le_plt_entry
[][PLT_ENTRY_SIZE
] =
544 0x36, 0x41, 0x00, /* entry sp, 32 */
545 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
546 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
547 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
548 0xa0, 0x08, 0x00, /* jx a8 */
552 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
553 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
554 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
555 0xa0, 0x08, 0x00, /* jx a8 */
560 /* The size of the thread control block. */
563 struct elf_xtensa_link_hash_entry
565 struct elf_link_hash_entry elf
;
567 bfd_signed_vma tlsfunc_refcount
;
569 #define GOT_UNKNOWN 0
571 #define GOT_TLS_GD 2 /* global or local dynamic */
572 #define GOT_TLS_IE 4 /* initial or local exec */
573 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
574 unsigned char tls_type
;
577 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
579 struct elf_xtensa_obj_tdata
581 struct elf_obj_tdata root
;
583 /* tls_type for each local got entry. */
584 char *local_got_tls_type
;
586 bfd_signed_vma
*local_tlsfunc_refcounts
;
589 #define elf_xtensa_tdata(abfd) \
590 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
592 #define elf_xtensa_local_got_tls_type(abfd) \
593 (elf_xtensa_tdata (abfd)->local_got_tls_type)
595 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
596 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
598 #define is_xtensa_elf(bfd) \
599 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
600 && elf_tdata (bfd) != NULL \
601 && elf_object_id (bfd) == XTENSA_ELF_DATA)
604 elf_xtensa_mkobject (bfd
*abfd
)
606 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_xtensa_obj_tdata
),
610 /* Xtensa ELF linker hash table. */
612 struct elf_xtensa_link_hash_table
614 struct elf_link_hash_table elf
;
616 /* Short-cuts to get to dynamic linker sections. */
618 asection
*spltlittbl
;
620 /* Total count of PLT relocations seen during check_relocs.
621 The actual PLT code must be split into multiple sections and all
622 the sections have to be created before size_dynamic_sections,
623 where we figure out the exact number of PLT entries that will be
624 needed. It is OK if this count is an overestimate, e.g., some
625 relocations may be removed by GC. */
628 struct elf_xtensa_link_hash_entry
*tlsbase
;
631 /* Get the Xtensa ELF linker hash table from a link_info structure. */
633 #define elf_xtensa_hash_table(p) \
634 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
635 == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
637 /* Create an entry in an Xtensa ELF linker hash table. */
639 static struct bfd_hash_entry
*
640 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
641 struct bfd_hash_table
*table
,
644 /* Allocate the structure if it has not already been allocated by a
648 entry
= bfd_hash_allocate (table
,
649 sizeof (struct elf_xtensa_link_hash_entry
));
654 /* Call the allocation method of the superclass. */
655 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
658 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (entry
);
659 eh
->tlsfunc_refcount
= 0;
660 eh
->tls_type
= GOT_UNKNOWN
;
666 /* Create an Xtensa ELF linker hash table. */
668 static struct bfd_link_hash_table
*
669 elf_xtensa_link_hash_table_create (bfd
*abfd
)
671 struct elf_link_hash_entry
*tlsbase
;
672 struct elf_xtensa_link_hash_table
*ret
;
673 bfd_size_type amt
= sizeof (struct elf_xtensa_link_hash_table
);
675 ret
= bfd_zmalloc (amt
);
679 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
680 elf_xtensa_link_hash_newfunc
,
681 sizeof (struct elf_xtensa_link_hash_entry
),
688 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
690 tlsbase
= elf_link_hash_lookup (&ret
->elf
, "_TLS_MODULE_BASE_",
692 tlsbase
->root
.type
= bfd_link_hash_new
;
693 tlsbase
->root
.u
.undef
.abfd
= NULL
;
694 tlsbase
->non_elf
= 0;
695 ret
->tlsbase
= elf_xtensa_hash_entry (tlsbase
);
696 ret
->tlsbase
->tls_type
= GOT_UNKNOWN
;
698 return &ret
->elf
.root
;
701 /* Copy the extra info we tack onto an elf_link_hash_entry. */
704 elf_xtensa_copy_indirect_symbol (struct bfd_link_info
*info
,
705 struct elf_link_hash_entry
*dir
,
706 struct elf_link_hash_entry
*ind
)
708 struct elf_xtensa_link_hash_entry
*edir
, *eind
;
710 edir
= elf_xtensa_hash_entry (dir
);
711 eind
= elf_xtensa_hash_entry (ind
);
713 if (ind
->root
.type
== bfd_link_hash_indirect
)
715 edir
->tlsfunc_refcount
+= eind
->tlsfunc_refcount
;
716 eind
->tlsfunc_refcount
= 0;
718 if (dir
->got
.refcount
<= 0)
720 edir
->tls_type
= eind
->tls_type
;
721 eind
->tls_type
= GOT_UNKNOWN
;
725 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
728 static inline bfd_boolean
729 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
730 struct bfd_link_info
*info
)
732 /* Check if we should do dynamic things to this symbol. The
733 "ignore_protected" argument need not be set, because Xtensa code
734 does not require special handling of STV_PROTECTED to make function
735 pointer comparisons work properly. The PLT addresses are never
736 used for function pointers. */
738 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
743 property_table_compare (const void *ap
, const void *bp
)
745 const property_table_entry
*a
= (const property_table_entry
*) ap
;
746 const property_table_entry
*b
= (const property_table_entry
*) bp
;
748 if (a
->address
== b
->address
)
750 if (a
->size
!= b
->size
)
751 return (a
->size
- b
->size
);
753 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
754 return ((b
->flags
& XTENSA_PROP_ALIGN
)
755 - (a
->flags
& XTENSA_PROP_ALIGN
));
757 if ((a
->flags
& XTENSA_PROP_ALIGN
)
758 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
759 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
760 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
761 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
763 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
764 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
765 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
766 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
768 return (a
->flags
- b
->flags
);
771 return (a
->address
- b
->address
);
776 property_table_matches (const void *ap
, const void *bp
)
778 const property_table_entry
*a
= (const property_table_entry
*) ap
;
779 const property_table_entry
*b
= (const property_table_entry
*) bp
;
781 /* Check if one entry overlaps with the other. */
782 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
783 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
786 return (a
->address
- b
->address
);
790 /* Get the literal table or property table entries for the given
791 section. Sets TABLE_P and returns the number of entries. On
792 error, returns a negative value. */
795 xtensa_read_table_entries (bfd
*abfd
,
797 property_table_entry
**table_p
,
798 const char *sec_name
,
799 bfd_boolean output_addr
)
801 asection
*table_section
;
802 bfd_size_type table_size
= 0;
803 bfd_byte
*table_data
;
804 property_table_entry
*blocks
;
805 int blk
, block_count
;
806 bfd_size_type num_records
;
807 Elf_Internal_Rela
*internal_relocs
, *irel
, *rel_end
;
808 bfd_vma section_addr
, off
;
809 flagword predef_flags
;
810 bfd_size_type table_entry_size
, section_limit
;
813 || !(section
->flags
& SEC_ALLOC
)
814 || (section
->flags
& SEC_DEBUGGING
))
820 table_section
= xtensa_get_property_section (section
, sec_name
);
822 table_size
= table_section
->size
;
830 predef_flags
= xtensa_get_property_predef_flags (table_section
);
831 table_entry_size
= 12;
833 table_entry_size
-= 4;
835 num_records
= table_size
/ table_entry_size
;
836 table_data
= retrieve_contents (abfd
, table_section
, TRUE
);
837 blocks
= (property_table_entry
*)
838 bfd_malloc (num_records
* sizeof (property_table_entry
));
842 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
844 section_addr
= section
->vma
;
846 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, TRUE
);
847 if (internal_relocs
&& !table_section
->reloc_done
)
849 qsort (internal_relocs
, table_section
->reloc_count
,
850 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
851 irel
= internal_relocs
;
856 section_limit
= bfd_get_section_limit (abfd
, section
);
857 rel_end
= internal_relocs
+ table_section
->reloc_count
;
859 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
861 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
863 /* Skip any relocations before the current offset. This should help
864 avoid confusion caused by unexpected relocations for the preceding
867 (irel
->r_offset
< off
868 || (irel
->r_offset
== off
869 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
876 if (irel
&& irel
->r_offset
== off
)
879 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
880 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
882 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
885 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
886 BFD_ASSERT (sym_off
== 0);
887 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
891 if (address
< section_addr
892 || address
>= section_addr
+ section_limit
)
896 blocks
[block_count
].address
= address
;
897 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
899 blocks
[block_count
].flags
= predef_flags
;
901 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
905 release_contents (table_section
, table_data
);
906 release_internal_relocs (table_section
, internal_relocs
);
910 /* Now sort them into address order for easy reference. */
911 qsort (blocks
, block_count
, sizeof (property_table_entry
),
912 property_table_compare
);
914 /* Check that the table contents are valid. Problems may occur,
915 for example, if an unrelocated object file is stripped. */
916 for (blk
= 1; blk
< block_count
; blk
++)
918 /* The only circumstance where two entries may legitimately
919 have the same address is when one of them is a zero-size
920 placeholder to mark a place where fill can be inserted.
921 The zero-size entry should come first. */
922 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
923 blocks
[blk
- 1].size
!= 0)
925 /* xgettext:c-format */
926 _bfd_error_handler (_("%pB(%pA): invalid property table"),
928 bfd_set_error (bfd_error_bad_value
);
940 static property_table_entry
*
941 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
942 int property_table_size
,
945 property_table_entry entry
;
946 property_table_entry
*rv
;
948 if (property_table_size
== 0)
951 entry
.address
= addr
;
955 rv
= bsearch (&entry
, property_table
, property_table_size
,
956 sizeof (property_table_entry
), property_table_matches
);
962 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
966 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
973 /* Look through the relocs for a section during the first phase, and
974 calculate needed space in the dynamic reloc sections. */
977 elf_xtensa_check_relocs (bfd
*abfd
,
978 struct bfd_link_info
*info
,
980 const Elf_Internal_Rela
*relocs
)
982 struct elf_xtensa_link_hash_table
*htab
;
983 Elf_Internal_Shdr
*symtab_hdr
;
984 struct elf_link_hash_entry
**sym_hashes
;
985 const Elf_Internal_Rela
*rel
;
986 const Elf_Internal_Rela
*rel_end
;
988 if (bfd_link_relocatable (info
) || (sec
->flags
& SEC_ALLOC
) == 0)
991 BFD_ASSERT (is_xtensa_elf (abfd
));
993 htab
= elf_xtensa_hash_table (info
);
997 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
998 sym_hashes
= elf_sym_hashes (abfd
);
1000 rel_end
= relocs
+ sec
->reloc_count
;
1001 for (rel
= relocs
; rel
< rel_end
; rel
++)
1003 unsigned int r_type
;
1005 struct elf_link_hash_entry
*h
= NULL
;
1006 struct elf_xtensa_link_hash_entry
*eh
;
1007 int tls_type
, old_tls_type
;
1008 bfd_boolean is_got
= FALSE
;
1009 bfd_boolean is_plt
= FALSE
;
1010 bfd_boolean is_tlsfunc
= FALSE
;
1012 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1013 r_type
= ELF32_R_TYPE (rel
->r_info
);
1015 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1017 /* xgettext:c-format */
1018 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1023 if (r_symndx
>= symtab_hdr
->sh_info
)
1025 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1026 while (h
->root
.type
== bfd_link_hash_indirect
1027 || h
->root
.type
== bfd_link_hash_warning
)
1028 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1030 eh
= elf_xtensa_hash_entry (h
);
1034 case R_XTENSA_TLSDESC_FN
:
1035 if (bfd_link_pic (info
))
1037 tls_type
= GOT_TLS_GD
;
1042 tls_type
= GOT_TLS_IE
;
1045 case R_XTENSA_TLSDESC_ARG
:
1046 if (bfd_link_pic (info
))
1048 tls_type
= GOT_TLS_GD
;
1053 tls_type
= GOT_TLS_IE
;
1054 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1059 case R_XTENSA_TLS_DTPOFF
:
1060 if (bfd_link_pic (info
))
1061 tls_type
= GOT_TLS_GD
;
1063 tls_type
= GOT_TLS_IE
;
1066 case R_XTENSA_TLS_TPOFF
:
1067 tls_type
= GOT_TLS_IE
;
1068 if (bfd_link_pic (info
))
1069 info
->flags
|= DF_STATIC_TLS
;
1070 if (bfd_link_pic (info
) || h
)
1075 tls_type
= GOT_NORMAL
;
1080 tls_type
= GOT_NORMAL
;
1084 case R_XTENSA_GNU_VTINHERIT
:
1085 /* This relocation describes the C++ object vtable hierarchy.
1086 Reconstruct it for later use during GC. */
1087 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1091 case R_XTENSA_GNU_VTENTRY
:
1092 /* This relocation describes which C++ vtable entries are actually
1093 used. Record for later use during GC. */
1094 BFD_ASSERT (h
!= NULL
);
1096 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1101 /* Nothing to do for any other relocations. */
1109 if (h
->plt
.refcount
<= 0)
1112 h
->plt
.refcount
= 1;
1115 h
->plt
.refcount
+= 1;
1117 /* Keep track of the total PLT relocation count even if we
1118 don't yet know whether the dynamic sections will be
1120 htab
->plt_reloc_count
+= 1;
1122 if (elf_hash_table (info
)->dynamic_sections_created
)
1124 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1130 if (h
->got
.refcount
<= 0)
1131 h
->got
.refcount
= 1;
1133 h
->got
.refcount
+= 1;
1137 eh
->tlsfunc_refcount
+= 1;
1139 old_tls_type
= eh
->tls_type
;
1143 /* Allocate storage the first time. */
1144 if (elf_local_got_refcounts (abfd
) == NULL
)
1146 bfd_size_type size
= symtab_hdr
->sh_info
;
1149 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1152 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1154 mem
= bfd_zalloc (abfd
, size
);
1157 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1159 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1162 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1163 = (bfd_signed_vma
*) mem
;
1166 /* This is a global offset table entry for a local symbol. */
1167 if (is_got
|| is_plt
)
1168 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1171 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1173 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1176 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1177 tls_type
|= old_tls_type
;
1178 /* If a TLS symbol is accessed using IE at least once,
1179 there is no point to use a dynamic model for it. */
1180 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1181 && ((old_tls_type
& GOT_TLS_GD
) == 0
1182 || (tls_type
& GOT_TLS_IE
) == 0))
1184 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1185 tls_type
= old_tls_type
;
1186 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1187 tls_type
|= old_tls_type
;
1191 /* xgettext:c-format */
1192 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1194 h
? h
->root
.root
.string
: "<local>");
1199 if (old_tls_type
!= tls_type
)
1202 eh
->tls_type
= tls_type
;
1204 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1213 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1214 struct elf_link_hash_entry
*h
)
1216 if (bfd_link_pic (info
))
1218 if (h
->plt
.refcount
> 0)
1220 /* For shared objects, there's no need for PLT entries for local
1221 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1222 if (h
->got
.refcount
< 0)
1223 h
->got
.refcount
= 0;
1224 h
->got
.refcount
+= h
->plt
.refcount
;
1225 h
->plt
.refcount
= 0;
1230 /* Don't need any dynamic relocations at all. */
1231 h
->plt
.refcount
= 0;
1232 h
->got
.refcount
= 0;
1238 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1239 struct elf_link_hash_entry
*h
,
1240 bfd_boolean force_local
)
1242 /* For a shared link, move the plt refcount to the got refcount to leave
1243 space for RELATIVE relocs. */
1244 elf_xtensa_make_sym_local (info
, h
);
1246 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1250 /* Return the section that should be marked against GC for a given
1254 elf_xtensa_gc_mark_hook (asection
*sec
,
1255 struct bfd_link_info
*info
,
1256 Elf_Internal_Rela
*rel
,
1257 struct elf_link_hash_entry
*h
,
1258 Elf_Internal_Sym
*sym
)
1260 /* Property sections are marked "KEEP" in the linker scripts, but they
1261 should not cause other sections to be marked. (This approach relies
1262 on elf_xtensa_discard_info to remove property table entries that
1263 describe discarded sections. Alternatively, it might be more
1264 efficient to avoid using "KEEP" in the linker scripts and instead use
1265 the gc_mark_extra_sections hook to mark only the property sections
1266 that describe marked sections. That alternative does not work well
1267 with the current property table sections, which do not correspond
1268 one-to-one with the sections they describe, but that should be fixed
1270 if (xtensa_is_property_section (sec
))
1274 switch (ELF32_R_TYPE (rel
->r_info
))
1276 case R_XTENSA_GNU_VTINHERIT
:
1277 case R_XTENSA_GNU_VTENTRY
:
1281 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1285 /* Create all the dynamic sections. */
1288 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1290 struct elf_xtensa_link_hash_table
*htab
;
1291 flagword flags
, noalloc_flags
;
1293 htab
= elf_xtensa_hash_table (info
);
1297 /* First do all the standard stuff. */
1298 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1301 /* Create any extra PLT sections in case check_relocs has already
1302 been called on all the non-dynamic input files. */
1303 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1306 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1307 | SEC_LINKER_CREATED
| SEC_READONLY
);
1308 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1310 /* Mark the ".got.plt" section READONLY. */
1311 if (htab
->elf
.sgotplt
== NULL
1312 || ! bfd_set_section_flags (dynobj
, htab
->elf
.sgotplt
, flags
))
1315 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1316 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1318 if (htab
->sgotloc
== NULL
1319 || ! bfd_set_section_alignment (dynobj
, htab
->sgotloc
, 2))
1322 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1323 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1325 if (htab
->spltlittbl
== NULL
1326 || ! bfd_set_section_alignment (dynobj
, htab
->spltlittbl
, 2))
1334 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1336 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1339 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1340 ".got.plt" sections. */
1341 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1347 /* Stop when we find a section has already been created. */
1348 if (elf_xtensa_get_plt_section (info
, chunk
))
1351 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1352 | SEC_LINKER_CREATED
| SEC_READONLY
);
1354 sname
= (char *) bfd_malloc (10);
1355 sprintf (sname
, ".plt.%u", chunk
);
1356 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1358 || ! bfd_set_section_alignment (dynobj
, s
, 2))
1361 sname
= (char *) bfd_malloc (14);
1362 sprintf (sname
, ".got.plt.%u", chunk
);
1363 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1365 || ! bfd_set_section_alignment (dynobj
, s
, 2))
1373 /* Adjust a symbol defined by a dynamic object and referenced by a
1374 regular object. The current definition is in some section of the
1375 dynamic object, but we're not including those sections. We have to
1376 change the definition to something the rest of the link can
1380 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1381 struct elf_link_hash_entry
*h
)
1383 /* If this is a weak symbol, and there is a real definition, the
1384 processor independent code will have arranged for us to see the
1385 real definition first, and we can just use the same value. */
1386 if (h
->is_weakalias
)
1388 struct elf_link_hash_entry
*def
= weakdef (h
);
1389 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1390 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1391 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1395 /* This is a reference to a symbol defined by a dynamic object. The
1396 reference must go through the GOT, so there's no need for COPY relocs,
1404 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1406 struct bfd_link_info
*info
;
1407 struct elf_xtensa_link_hash_table
*htab
;
1408 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1410 if (h
->root
.type
== bfd_link_hash_indirect
)
1413 info
= (struct bfd_link_info
*) arg
;
1414 htab
= elf_xtensa_hash_table (info
);
1418 /* If we saw any use of an IE model for this symbol, we can then optimize
1419 away GOT entries for any TLSDESC_FN relocs. */
1420 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1422 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1423 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1426 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1427 elf_xtensa_make_sym_local (info
, h
);
1429 if (h
->plt
.refcount
> 0)
1430 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1432 if (h
->got
.refcount
> 0)
1433 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1440 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1442 struct elf_xtensa_link_hash_table
*htab
;
1445 htab
= elf_xtensa_hash_table (info
);
1449 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1451 bfd_signed_vma
*local_got_refcounts
;
1452 bfd_size_type j
, cnt
;
1453 Elf_Internal_Shdr
*symtab_hdr
;
1455 local_got_refcounts
= elf_local_got_refcounts (i
);
1456 if (!local_got_refcounts
)
1459 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1460 cnt
= symtab_hdr
->sh_info
;
1462 for (j
= 0; j
< cnt
; ++j
)
1464 /* If we saw any use of an IE model for this symbol, we can
1465 then optimize away GOT entries for any TLSDESC_FN relocs. */
1466 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1468 bfd_signed_vma
*tlsfunc_refcount
1469 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1470 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1471 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1474 if (local_got_refcounts
[j
] > 0)
1475 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1476 * sizeof (Elf32_External_Rela
));
1482 /* Set the sizes of the dynamic sections. */
1485 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1486 struct bfd_link_info
*info
)
1488 struct elf_xtensa_link_hash_table
*htab
;
1490 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1491 bfd_boolean relplt
, relgot
;
1492 int plt_entries
, plt_chunks
, chunk
;
1497 htab
= elf_xtensa_hash_table (info
);
1501 dynobj
= elf_hash_table (info
)->dynobj
;
1504 srelgot
= htab
->elf
.srelgot
;
1505 srelplt
= htab
->elf
.srelplt
;
1507 if (elf_hash_table (info
)->dynamic_sections_created
)
1509 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1510 && htab
->elf
.srelplt
!= NULL
1511 && htab
->elf
.sgot
!= NULL
1512 && htab
->spltlittbl
!= NULL
1513 && htab
->sgotloc
!= NULL
);
1515 /* Set the contents of the .interp section to the interpreter. */
1516 if (bfd_link_executable (info
) && !info
->nointerp
)
1518 s
= bfd_get_linker_section (dynobj
, ".interp");
1521 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1522 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1525 /* Allocate room for one word in ".got". */
1526 htab
->elf
.sgot
->size
= 4;
1528 /* Allocate space in ".rela.got" for literals that reference global
1529 symbols and space in ".rela.plt" for literals that have PLT
1531 elf_link_hash_traverse (elf_hash_table (info
),
1532 elf_xtensa_allocate_dynrelocs
,
1535 /* If we are generating a shared object, we also need space in
1536 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1537 reference local symbols. */
1538 if (bfd_link_pic (info
))
1539 elf_xtensa_allocate_local_got_size (info
);
1541 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1542 each PLT entry, we need the PLT code plus a 4-byte literal.
1543 For each chunk of ".plt", we also need two more 4-byte
1544 literals, two corresponding entries in ".rela.got", and an
1545 8-byte entry in ".xt.lit.plt". */
1546 spltlittbl
= htab
->spltlittbl
;
1547 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1549 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1551 /* Iterate over all the PLT chunks, including any extra sections
1552 created earlier because the initial count of PLT relocations
1553 was an overestimate. */
1555 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1560 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1561 BFD_ASSERT (sgotplt
!= NULL
);
1563 if (chunk
< plt_chunks
- 1)
1564 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1565 else if (chunk
== plt_chunks
- 1)
1566 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1570 if (chunk_entries
!= 0)
1572 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1573 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1574 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1575 spltlittbl
->size
+= 8;
1584 /* Allocate space in ".got.loc" to match the total size of all the
1586 sgotloc
= htab
->sgotloc
;
1587 sgotloc
->size
= spltlittbl
->size
;
1588 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1590 if (abfd
->flags
& DYNAMIC
)
1592 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1594 if (! discarded_section (s
)
1595 && xtensa_is_littable_section (s
)
1597 sgotloc
->size
+= s
->size
;
1602 /* Allocate memory for dynamic sections. */
1605 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1609 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1612 /* It's OK to base decisions on the section name, because none
1613 of the dynobj section names depend upon the input files. */
1614 name
= bfd_get_section_name (dynobj
, s
);
1616 if (CONST_STRNEQ (name
, ".rela"))
1620 if (strcmp (name
, ".rela.plt") == 0)
1622 else if (strcmp (name
, ".rela.got") == 0)
1625 /* We use the reloc_count field as a counter if we need
1626 to copy relocs into the output file. */
1630 else if (! CONST_STRNEQ (name
, ".plt.")
1631 && ! CONST_STRNEQ (name
, ".got.plt.")
1632 && strcmp (name
, ".got") != 0
1633 && strcmp (name
, ".plt") != 0
1634 && strcmp (name
, ".got.plt") != 0
1635 && strcmp (name
, ".xt.lit.plt") != 0
1636 && strcmp (name
, ".got.loc") != 0)
1638 /* It's not one of our sections, so don't allocate space. */
1644 /* If we don't need this section, strip it from the output
1645 file. We must create the ".plt*" and ".got.plt*"
1646 sections in create_dynamic_sections and/or check_relocs
1647 based on a conservative estimate of the PLT relocation
1648 count, because the sections must be created before the
1649 linker maps input sections to output sections. The
1650 linker does that before size_dynamic_sections, where we
1651 compute the exact size of the PLT, so there may be more
1652 of these sections than are actually needed. */
1653 s
->flags
|= SEC_EXCLUDE
;
1655 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1657 /* Allocate memory for the section contents. */
1658 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1659 if (s
->contents
== NULL
)
1664 if (elf_hash_table (info
)->dynamic_sections_created
)
1666 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1667 known until finish_dynamic_sections, but we need to get the relocs
1668 in place before they are sorted. */
1669 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1671 Elf_Internal_Rela irela
;
1675 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1678 loc
= (srelgot
->contents
1679 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1680 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1681 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1682 loc
+ sizeof (Elf32_External_Rela
));
1683 srelgot
->reloc_count
+= 2;
1686 /* Add some entries to the .dynamic section. We fill in the
1687 values later, in elf_xtensa_finish_dynamic_sections, but we
1688 must add the entries now so that we get the correct size for
1689 the .dynamic section. The DT_DEBUG entry is filled in by the
1690 dynamic linker and used by the debugger. */
1691 #define add_dynamic_entry(TAG, VAL) \
1692 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1694 if (bfd_link_executable (info
))
1696 if (!add_dynamic_entry (DT_DEBUG
, 0))
1702 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1703 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1704 || !add_dynamic_entry (DT_JMPREL
, 0))
1710 if (!add_dynamic_entry (DT_RELA
, 0)
1711 || !add_dynamic_entry (DT_RELASZ
, 0)
1712 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1716 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1717 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1718 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1721 #undef add_dynamic_entry
1727 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1728 struct bfd_link_info
*info
)
1730 struct elf_xtensa_link_hash_table
*htab
;
1733 htab
= elf_xtensa_hash_table (info
);
1737 tls_sec
= htab
->elf
.tls_sec
;
1739 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1741 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1742 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1743 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1745 tlsbase
->type
= STT_TLS
;
1746 if (!(_bfd_generic_link_add_one_symbol
1747 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1748 tls_sec
, 0, NULL
, FALSE
,
1749 bed
->collect
, &bh
)))
1751 tlsbase
->def_regular
= 1;
1752 tlsbase
->other
= STV_HIDDEN
;
1753 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1760 /* Return the base VMA address which should be subtracted from real addresses
1761 when resolving @dtpoff relocation.
1762 This is PT_TLS segment p_vaddr. */
1765 dtpoff_base (struct bfd_link_info
*info
)
1767 /* If tls_sec is NULL, we should have signalled an error already. */
1768 if (elf_hash_table (info
)->tls_sec
== NULL
)
1770 return elf_hash_table (info
)->tls_sec
->vma
;
1773 /* Return the relocation value for @tpoff relocation
1774 if STT_TLS virtual address is ADDRESS. */
1777 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1779 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1782 /* If tls_sec is NULL, we should have signalled an error already. */
1783 if (htab
->tls_sec
== NULL
)
1785 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1786 return address
- htab
->tls_sec
->vma
+ base
;
1789 /* Perform the specified relocation. The instruction at (contents + address)
1790 is modified to set one operand to represent the value in "relocation". The
1791 operand position is determined by the relocation type recorded in the
1794 #define CALL_SEGMENT_BITS (30)
1795 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1797 static bfd_reloc_status_type
1798 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1800 asection
*input_section
,
1804 bfd_boolean is_weak_undef
,
1805 char **error_message
)
1808 xtensa_opcode opcode
;
1809 xtensa_isa isa
= xtensa_default_isa
;
1810 static xtensa_insnbuf ibuff
= NULL
;
1811 static xtensa_insnbuf sbuff
= NULL
;
1812 bfd_vma self_address
;
1813 bfd_size_type input_size
;
1819 ibuff
= xtensa_insnbuf_alloc (isa
);
1820 sbuff
= xtensa_insnbuf_alloc (isa
);
1823 input_size
= bfd_get_section_limit (abfd
, input_section
);
1825 /* Calculate the PC address for this instruction. */
1826 self_address
= (input_section
->output_section
->vma
1827 + input_section
->output_offset
1830 switch (howto
->type
)
1833 case R_XTENSA_DIFF8
:
1834 case R_XTENSA_DIFF16
:
1835 case R_XTENSA_DIFF32
:
1836 case R_XTENSA_TLS_FUNC
:
1837 case R_XTENSA_TLS_ARG
:
1838 case R_XTENSA_TLS_CALL
:
1839 return bfd_reloc_ok
;
1841 case R_XTENSA_ASM_EXPAND
:
1844 /* Check for windowed CALL across a 1GB boundary. */
1845 opcode
= get_expanded_call_opcode (contents
+ address
,
1846 input_size
- address
, 0);
1847 if (is_windowed_call_opcode (opcode
))
1849 if ((self_address
>> CALL_SEGMENT_BITS
)
1850 != (relocation
>> CALL_SEGMENT_BITS
))
1852 *error_message
= "windowed longcall crosses 1GB boundary; "
1854 return bfd_reloc_dangerous
;
1858 return bfd_reloc_ok
;
1860 case R_XTENSA_ASM_SIMPLIFY
:
1862 /* Convert the L32R/CALLX to CALL. */
1863 bfd_reloc_status_type retval
=
1864 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1866 if (retval
!= bfd_reloc_ok
)
1867 return bfd_reloc_dangerous
;
1869 /* The CALL needs to be relocated. Continue below for that part. */
1872 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1879 x
= bfd_get_32 (abfd
, contents
+ address
);
1881 bfd_put_32 (abfd
, x
, contents
+ address
);
1883 return bfd_reloc_ok
;
1885 case R_XTENSA_32_PCREL
:
1886 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1887 return bfd_reloc_ok
;
1890 case R_XTENSA_TLSDESC_FN
:
1891 case R_XTENSA_TLSDESC_ARG
:
1892 case R_XTENSA_TLS_DTPOFF
:
1893 case R_XTENSA_TLS_TPOFF
:
1894 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1895 return bfd_reloc_ok
;
1898 /* Only instruction slot-specific relocations handled below.... */
1899 slot
= get_relocation_slot (howto
->type
);
1900 if (slot
== XTENSA_UNDEFINED
)
1902 *error_message
= "unexpected relocation";
1903 return bfd_reloc_dangerous
;
1906 /* Read the instruction into a buffer and decode the opcode. */
1907 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1908 input_size
- address
);
1909 fmt
= xtensa_format_decode (isa
, ibuff
);
1910 if (fmt
== XTENSA_UNDEFINED
)
1912 *error_message
= "cannot decode instruction format";
1913 return bfd_reloc_dangerous
;
1916 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1918 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1919 if (opcode
== XTENSA_UNDEFINED
)
1921 *error_message
= "cannot decode instruction opcode";
1922 return bfd_reloc_dangerous
;
1925 /* Check for opcode-specific "alternate" relocations. */
1926 if (is_alt_relocation (howto
->type
))
1928 if (opcode
== get_l32r_opcode ())
1930 /* Handle the special-case of non-PC-relative L32R instructions. */
1931 bfd
*output_bfd
= input_section
->output_section
->owner
;
1932 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
1935 *error_message
= "relocation references missing .lit4 section";
1936 return bfd_reloc_dangerous
;
1938 self_address
= ((lit4_sec
->vma
& ~0xfff)
1939 + 0x40000 - 3); /* -3 to compensate for do_reloc */
1940 newval
= relocation
;
1943 else if (opcode
== get_const16_opcode ())
1945 /* ALT used for high 16 bits. */
1946 newval
= relocation
>> 16;
1951 /* No other "alternate" relocations currently defined. */
1952 *error_message
= "unexpected relocation";
1953 return bfd_reloc_dangerous
;
1956 else /* Not an "alternate" relocation.... */
1958 if (opcode
== get_const16_opcode ())
1960 newval
= relocation
& 0xffff;
1965 /* ...normal PC-relative relocation.... */
1967 /* Determine which operand is being relocated. */
1968 opnd
= get_relocation_opnd (opcode
, howto
->type
);
1969 if (opnd
== XTENSA_UNDEFINED
)
1971 *error_message
= "unexpected relocation";
1972 return bfd_reloc_dangerous
;
1975 if (!howto
->pc_relative
)
1977 *error_message
= "expected PC-relative relocation";
1978 return bfd_reloc_dangerous
;
1981 newval
= relocation
;
1985 /* Apply the relocation. */
1986 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
1987 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
1988 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
1991 const char *opname
= xtensa_opcode_name (isa
, opcode
);
1994 msg
= "cannot encode";
1995 if (is_direct_call_opcode (opcode
))
1997 if ((relocation
& 0x3) != 0)
1998 msg
= "misaligned call target";
2000 msg
= "call target out of range";
2002 else if (opcode
== get_l32r_opcode ())
2004 if ((relocation
& 0x3) != 0)
2005 msg
= "misaligned literal target";
2006 else if (is_alt_relocation (howto
->type
))
2007 msg
= "literal target out of range (too many literals)";
2008 else if (self_address
> relocation
)
2009 msg
= "literal target out of range (try using text-section-literals)";
2011 msg
= "literal placed after use";
2014 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2015 return bfd_reloc_dangerous
;
2018 /* Check for calls across 1GB boundaries. */
2019 if (is_direct_call_opcode (opcode
)
2020 && is_windowed_call_opcode (opcode
))
2022 if ((self_address
>> CALL_SEGMENT_BITS
)
2023 != (relocation
>> CALL_SEGMENT_BITS
))
2026 "windowed call crosses 1GB boundary; return may fail";
2027 return bfd_reloc_dangerous
;
2031 /* Write the modified instruction back out of the buffer. */
2032 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2033 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2034 input_size
- address
);
2035 return bfd_reloc_ok
;
2040 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2042 /* To reduce the size of the memory leak,
2043 we only use a single message buffer. */
2044 static bfd_size_type alloc_size
= 0;
2045 static char *message
= NULL
;
2046 bfd_size_type orig_len
, len
= 0;
2047 bfd_boolean is_append
;
2050 va_start (ap
, arglen
);
2052 is_append
= (origmsg
== message
);
2054 orig_len
= strlen (origmsg
);
2055 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2056 if (len
> alloc_size
)
2058 message
= (char *) bfd_realloc_or_free (message
, len
);
2061 if (message
!= NULL
)
2064 memcpy (message
, origmsg
, orig_len
);
2065 vsprintf (message
+ orig_len
, fmt
, ap
);
2072 /* This function is registered as the "special_function" in the
2073 Xtensa howto for handling simplify operations.
2074 bfd_perform_relocation / bfd_install_relocation use it to
2075 perform (install) the specified relocation. Since this replaces the code
2076 in bfd_perform_relocation, it is basically an Xtensa-specific,
2077 stripped-down version of bfd_perform_relocation. */
2079 static bfd_reloc_status_type
2080 bfd_elf_xtensa_reloc (bfd
*abfd
,
2081 arelent
*reloc_entry
,
2084 asection
*input_section
,
2086 char **error_message
)
2089 bfd_reloc_status_type flag
;
2090 bfd_size_type octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
2091 bfd_vma output_base
= 0;
2092 reloc_howto_type
*howto
= reloc_entry
->howto
;
2093 asection
*reloc_target_output_section
;
2094 bfd_boolean is_weak_undef
;
2096 if (!xtensa_default_isa
)
2097 xtensa_default_isa
= xtensa_isa_init (0, 0);
2099 /* ELF relocs are against symbols. If we are producing relocatable
2100 output, and the reloc is against an external symbol, the resulting
2101 reloc will also be against the same symbol. In such a case, we
2102 don't want to change anything about the way the reloc is handled,
2103 since it will all be done at final link time. This test is similar
2104 to what bfd_elf_generic_reloc does except that it lets relocs with
2105 howto->partial_inplace go through even if the addend is non-zero.
2106 (The real problem is that partial_inplace is set for XTENSA_32
2107 relocs to begin with, but that's a long story and there's little we
2108 can do about it now....) */
2110 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2112 reloc_entry
->address
+= input_section
->output_offset
;
2113 return bfd_reloc_ok
;
2116 /* Is the address of the relocation really within the section? */
2117 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2118 return bfd_reloc_outofrange
;
2120 /* Work out which section the relocation is targeted at and the
2121 initial relocation command value. */
2123 /* Get symbol value. (Common symbols are special.) */
2124 if (bfd_is_com_section (symbol
->section
))
2127 relocation
= symbol
->value
;
2129 reloc_target_output_section
= symbol
->section
->output_section
;
2131 /* Convert input-section-relative symbol value to absolute. */
2132 if ((output_bfd
&& !howto
->partial_inplace
)
2133 || reloc_target_output_section
== NULL
)
2136 output_base
= reloc_target_output_section
->vma
;
2138 relocation
+= output_base
+ symbol
->section
->output_offset
;
2140 /* Add in supplied addend. */
2141 relocation
+= reloc_entry
->addend
;
2143 /* Here the variable relocation holds the final address of the
2144 symbol we are relocating against, plus any addend. */
2147 if (!howto
->partial_inplace
)
2149 /* This is a partial relocation, and we want to apply the relocation
2150 to the reloc entry rather than the raw data. Everything except
2151 relocations against section symbols has already been handled
2154 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2155 reloc_entry
->addend
= relocation
;
2156 reloc_entry
->address
+= input_section
->output_offset
;
2157 return bfd_reloc_ok
;
2161 reloc_entry
->address
+= input_section
->output_offset
;
2162 reloc_entry
->addend
= 0;
2166 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2167 && (symbol
->flags
& BSF_WEAK
) != 0);
2168 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2169 (bfd_byte
*) data
, (bfd_vma
) octets
,
2170 is_weak_undef
, error_message
);
2172 if (flag
== bfd_reloc_dangerous
)
2174 /* Add the symbol name to the error message. */
2175 if (! *error_message
)
2176 *error_message
= "";
2177 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2178 strlen (symbol
->name
) + 17,
2180 (unsigned long) reloc_entry
->addend
);
2187 /* Set up an entry in the procedure linkage table. */
2190 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2192 unsigned reloc_index
)
2194 asection
*splt
, *sgotplt
;
2195 bfd_vma plt_base
, got_base
;
2196 bfd_vma code_offset
, lit_offset
, abi_offset
;
2199 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2200 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2201 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2202 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2204 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2205 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2207 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2208 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2210 /* Fill in the literal entry. This is the offset of the dynamic
2211 relocation entry. */
2212 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2213 sgotplt
->contents
+ lit_offset
);
2215 /* Fill in the entry in the procedure linkage table. */
2216 memcpy (splt
->contents
+ code_offset
,
2217 (bfd_big_endian (output_bfd
)
2218 ? elf_xtensa_be_plt_entry
[XSHAL_ABI
!= XTHAL_ABI_WINDOWED
]
2219 : elf_xtensa_le_plt_entry
[XSHAL_ABI
!= XTHAL_ABI_WINDOWED
]),
2221 abi_offset
= XSHAL_ABI
== XTHAL_ABI_WINDOWED
? 3 : 0;
2222 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2223 plt_base
+ code_offset
+ abi_offset
),
2224 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2225 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2226 plt_base
+ code_offset
+ abi_offset
+ 3),
2227 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2228 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2229 plt_base
+ code_offset
+ abi_offset
+ 6),
2230 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2232 return plt_base
+ code_offset
;
2236 static bfd_boolean
get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2239 replace_tls_insn (Elf_Internal_Rela
*rel
,
2241 asection
*input_section
,
2243 bfd_boolean is_ld_model
,
2244 char **error_message
)
2246 static xtensa_insnbuf ibuff
= NULL
;
2247 static xtensa_insnbuf sbuff
= NULL
;
2248 xtensa_isa isa
= xtensa_default_isa
;
2250 xtensa_opcode old_op
, new_op
;
2251 bfd_size_type input_size
;
2253 unsigned dest_reg
, src_reg
;
2257 ibuff
= xtensa_insnbuf_alloc (isa
);
2258 sbuff
= xtensa_insnbuf_alloc (isa
);
2261 input_size
= bfd_get_section_limit (abfd
, input_section
);
2263 /* Read the instruction into a buffer and decode the opcode. */
2264 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2265 input_size
- rel
->r_offset
);
2266 fmt
= xtensa_format_decode (isa
, ibuff
);
2267 if (fmt
== XTENSA_UNDEFINED
)
2269 *error_message
= "cannot decode instruction format";
2273 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2274 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2276 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2277 if (old_op
== XTENSA_UNDEFINED
)
2279 *error_message
= "cannot decode instruction opcode";
2283 r_type
= ELF32_R_TYPE (rel
->r_info
);
2286 case R_XTENSA_TLS_FUNC
:
2287 case R_XTENSA_TLS_ARG
:
2288 if (old_op
!= get_l32r_opcode ()
2289 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2290 sbuff
, &dest_reg
) != 0)
2292 *error_message
= "cannot extract L32R destination for TLS access";
2297 case R_XTENSA_TLS_CALL
:
2298 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2299 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2300 sbuff
, &src_reg
) != 0)
2302 *error_message
= "cannot extract CALLXn operands for TLS access";
2315 case R_XTENSA_TLS_FUNC
:
2316 case R_XTENSA_TLS_ARG
:
2317 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2318 versions of Xtensa). */
2319 new_op
= xtensa_opcode_lookup (isa
, "nop");
2320 if (new_op
== XTENSA_UNDEFINED
)
2322 new_op
= xtensa_opcode_lookup (isa
, "or");
2323 if (new_op
== XTENSA_UNDEFINED
2324 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2325 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2327 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2329 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2332 *error_message
= "cannot encode OR for TLS access";
2338 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2340 *error_message
= "cannot encode NOP for TLS access";
2346 case R_XTENSA_TLS_CALL
:
2347 /* Read THREADPTR into the CALLX's return value register. */
2348 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2349 if (new_op
== XTENSA_UNDEFINED
2350 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2351 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2352 sbuff
, dest_reg
+ 2) != 0)
2354 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2364 case R_XTENSA_TLS_FUNC
:
2365 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2366 if (new_op
== XTENSA_UNDEFINED
2367 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2368 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2369 sbuff
, dest_reg
) != 0)
2371 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2376 case R_XTENSA_TLS_ARG
:
2377 /* Nothing to do. Keep the original L32R instruction. */
2380 case R_XTENSA_TLS_CALL
:
2381 /* Add the CALLX's src register (holding the THREADPTR value)
2382 to the first argument register (holding the offset) and put
2383 the result in the CALLX's return value register. */
2384 new_op
= xtensa_opcode_lookup (isa
, "add");
2385 if (new_op
== XTENSA_UNDEFINED
2386 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2387 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2388 sbuff
, dest_reg
+ 2) != 0
2389 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2390 sbuff
, dest_reg
+ 2) != 0
2391 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2392 sbuff
, src_reg
) != 0)
2394 *error_message
= "cannot encode ADD for TLS access";
2401 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2402 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2403 input_size
- rel
->r_offset
);
2409 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2410 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2411 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2412 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2413 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2414 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2415 || (R_TYPE) == R_XTENSA_TLS_ARG \
2416 || (R_TYPE) == R_XTENSA_TLS_CALL)
2418 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2419 both relocatable and final links. */
2422 elf_xtensa_relocate_section (bfd
*output_bfd
,
2423 struct bfd_link_info
*info
,
2425 asection
*input_section
,
2427 Elf_Internal_Rela
*relocs
,
2428 Elf_Internal_Sym
*local_syms
,
2429 asection
**local_sections
)
2431 struct elf_xtensa_link_hash_table
*htab
;
2432 Elf_Internal_Shdr
*symtab_hdr
;
2433 Elf_Internal_Rela
*rel
;
2434 Elf_Internal_Rela
*relend
;
2435 struct elf_link_hash_entry
**sym_hashes
;
2436 property_table_entry
*lit_table
= 0;
2438 char *local_got_tls_types
;
2439 char *error_message
= NULL
;
2440 bfd_size_type input_size
;
2443 if (!xtensa_default_isa
)
2444 xtensa_default_isa
= xtensa_isa_init (0, 0);
2446 BFD_ASSERT (is_xtensa_elf (input_bfd
));
2448 htab
= elf_xtensa_hash_table (info
);
2452 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2453 sym_hashes
= elf_sym_hashes (input_bfd
);
2454 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2456 if (elf_hash_table (info
)->dynamic_sections_created
)
2458 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2459 &lit_table
, XTENSA_LIT_SEC_NAME
,
2465 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2468 relend
= relocs
+ input_section
->reloc_count
;
2469 for (; rel
< relend
; rel
++)
2472 reloc_howto_type
*howto
;
2473 unsigned long r_symndx
;
2474 struct elf_link_hash_entry
*h
;
2475 Elf_Internal_Sym
*sym
;
2480 bfd_reloc_status_type r
;
2481 bfd_boolean is_weak_undef
;
2482 bfd_boolean unresolved_reloc
;
2484 bfd_boolean dynamic_symbol
;
2486 r_type
= ELF32_R_TYPE (rel
->r_info
);
2487 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2488 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2491 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2493 bfd_set_error (bfd_error_bad_value
);
2496 howto
= &elf_howto_table
[r_type
];
2498 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2503 is_weak_undef
= FALSE
;
2504 unresolved_reloc
= FALSE
;
2507 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2509 /* Because R_XTENSA_32 was made partial_inplace to fix some
2510 problems with DWARF info in partial links, there may be
2511 an addend stored in the contents. Take it out of there
2512 and move it back into the addend field of the reloc. */
2513 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2514 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2517 if (r_symndx
< symtab_hdr
->sh_info
)
2519 sym
= local_syms
+ r_symndx
;
2520 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2521 sec
= local_sections
[r_symndx
];
2522 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2526 bfd_boolean ignored
;
2528 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2529 r_symndx
, symtab_hdr
, sym_hashes
,
2531 unresolved_reloc
, warned
, ignored
);
2534 && !unresolved_reloc
2535 && h
->root
.type
== bfd_link_hash_undefweak
)
2536 is_weak_undef
= TRUE
;
2541 if (sec
!= NULL
&& discarded_section (sec
))
2542 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2543 rel
, 1, relend
, howto
, 0, contents
);
2545 if (bfd_link_relocatable (info
))
2548 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2550 /* This is a relocatable link.
2551 1) If the reloc is against a section symbol, adjust
2552 according to the output section.
2553 2) If there is a new target for this relocation,
2554 the new target will be in the same output section.
2555 We adjust the relocation by the output section
2558 if (relaxing_section
)
2560 /* Check if this references a section in another input file. */
2561 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2566 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2567 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2569 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2571 error_message
= NULL
;
2572 /* Convert ASM_SIMPLIFY into the simpler relocation
2573 so that they never escape a relaxing link. */
2574 r
= contract_asm_expansion (contents
, input_size
, rel
,
2576 if (r
!= bfd_reloc_ok
)
2577 (*info
->callbacks
->reloc_dangerous
)
2578 (info
, error_message
,
2579 input_bfd
, input_section
, rel
->r_offset
);
2581 r_type
= ELF32_R_TYPE (rel
->r_info
);
2584 /* This is a relocatable link, so we don't have to change
2585 anything unless the reloc is against a section symbol,
2586 in which case we have to adjust according to where the
2587 section symbol winds up in the output section. */
2588 if (r_symndx
< symtab_hdr
->sh_info
)
2590 sym
= local_syms
+ r_symndx
;
2591 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2593 sec
= local_sections
[r_symndx
];
2594 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2598 /* If there is an addend with a partial_inplace howto,
2599 then move the addend to the contents. This is a hack
2600 to work around problems with DWARF in relocatable links
2601 with some previous version of BFD. Now we can't easily get
2602 rid of the hack without breaking backward compatibility.... */
2604 howto
= &elf_howto_table
[r_type
];
2605 if (howto
->partial_inplace
&& rel
->r_addend
)
2607 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2608 rel
->r_addend
, contents
,
2609 rel
->r_offset
, FALSE
,
2615 /* Put the correct bits in the target instruction, even
2616 though the relocation will still be present in the output
2617 file. This makes disassembly clearer, as well as
2618 allowing loadable kernel modules to work without needing
2619 relocations on anything other than calls and l32r's. */
2621 /* If it is not in the same section, there is nothing we can do. */
2622 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2623 sym_sec
->output_section
== input_section
->output_section
)
2625 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2626 dest_addr
, contents
,
2627 rel
->r_offset
, FALSE
,
2631 if (r
!= bfd_reloc_ok
)
2632 (*info
->callbacks
->reloc_dangerous
)
2633 (info
, error_message
,
2634 input_bfd
, input_section
, rel
->r_offset
);
2636 /* Done with work for relocatable link; continue with next reloc. */
2640 /* This is a final link. */
2642 if (relaxing_section
)
2644 /* Check if this references a section in another input file. */
2645 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2649 /* Sanity check the address. */
2650 if (rel
->r_offset
>= input_size
2651 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2654 /* xgettext:c-format */
2655 (_("%pB(%pA+%#" PRIx64
"): "
2656 "relocation offset out of range (size=%#" PRIx64
")"),
2657 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2658 (uint64_t) input_size
);
2659 bfd_set_error (bfd_error_bad_value
);
2664 name
= h
->root
.root
.string
;
2667 name
= (bfd_elf_string_from_elf_section
2668 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2669 if (name
== NULL
|| *name
== '\0')
2670 name
= bfd_section_name (input_bfd
, sec
);
2673 if (r_symndx
!= STN_UNDEF
2674 && r_type
!= R_XTENSA_NONE
2676 || h
->root
.type
== bfd_link_hash_defined
2677 || h
->root
.type
== bfd_link_hash_defweak
)
2678 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2681 ((sym_type
== STT_TLS
2682 /* xgettext:c-format */
2683 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2684 /* xgettext:c-format */
2685 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2688 (uint64_t) rel
->r_offset
,
2693 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2695 tls_type
= GOT_UNKNOWN
;
2697 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2698 else if (local_got_tls_types
)
2699 tls_type
= local_got_tls_types
[r_symndx
];
2705 if (elf_hash_table (info
)->dynamic_sections_created
2706 && (input_section
->flags
& SEC_ALLOC
) != 0
2707 && (dynamic_symbol
|| bfd_link_pic (info
)))
2709 Elf_Internal_Rela outrel
;
2713 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2714 srel
= htab
->elf
.srelplt
;
2716 srel
= htab
->elf
.srelgot
;
2718 BFD_ASSERT (srel
!= NULL
);
2721 _bfd_elf_section_offset (output_bfd
, info
,
2722 input_section
, rel
->r_offset
);
2724 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2725 memset (&outrel
, 0, sizeof outrel
);
2728 outrel
.r_offset
+= (input_section
->output_section
->vma
2729 + input_section
->output_offset
);
2731 /* Complain if the relocation is in a read-only section
2732 and not in a literal pool. */
2733 if ((input_section
->flags
& SEC_READONLY
) != 0
2734 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2738 _("dynamic relocation in read-only section");
2739 (*info
->callbacks
->reloc_dangerous
)
2740 (info
, error_message
,
2741 input_bfd
, input_section
, rel
->r_offset
);
2746 outrel
.r_addend
= rel
->r_addend
;
2749 if (r_type
== R_XTENSA_32
)
2752 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2755 else /* r_type == R_XTENSA_PLT */
2758 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2760 /* Create the PLT entry and set the initial
2761 contents of the literal entry to the address of
2764 elf_xtensa_create_plt_entry (info
, output_bfd
,
2767 unresolved_reloc
= FALSE
;
2771 /* Generate a RELATIVE relocation. */
2772 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2773 outrel
.r_addend
= 0;
2777 loc
= (srel
->contents
2778 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2779 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2780 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2783 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2785 /* This should only happen for non-PIC code, which is not
2786 supposed to be used on systems with dynamic linking.
2787 Just ignore these relocations. */
2792 case R_XTENSA_TLS_TPOFF
:
2793 /* Switch to LE model for local symbols in an executable. */
2794 if (! bfd_link_pic (info
) && ! dynamic_symbol
)
2796 relocation
= tpoff (info
, relocation
);
2801 case R_XTENSA_TLSDESC_FN
:
2802 case R_XTENSA_TLSDESC_ARG
:
2804 if (r_type
== R_XTENSA_TLSDESC_FN
)
2806 if (! bfd_link_pic (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2807 r_type
= R_XTENSA_NONE
;
2809 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2811 if (bfd_link_pic (info
))
2813 if ((tls_type
& GOT_TLS_IE
) != 0)
2814 r_type
= R_XTENSA_TLS_TPOFF
;
2818 r_type
= R_XTENSA_TLS_TPOFF
;
2819 if (! dynamic_symbol
)
2821 relocation
= tpoff (info
, relocation
);
2827 if (r_type
== R_XTENSA_NONE
)
2828 /* Nothing to do here; skip to the next reloc. */
2831 if (! elf_hash_table (info
)->dynamic_sections_created
)
2834 _("TLS relocation invalid without dynamic sections");
2835 (*info
->callbacks
->reloc_dangerous
)
2836 (info
, error_message
,
2837 input_bfd
, input_section
, rel
->r_offset
);
2841 Elf_Internal_Rela outrel
;
2843 asection
*srel
= htab
->elf
.srelgot
;
2846 outrel
.r_offset
= (input_section
->output_section
->vma
2847 + input_section
->output_offset
2850 /* Complain if the relocation is in a read-only section
2851 and not in a literal pool. */
2852 if ((input_section
->flags
& SEC_READONLY
) != 0
2853 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2857 _("dynamic relocation in read-only section");
2858 (*info
->callbacks
->reloc_dangerous
)
2859 (info
, error_message
,
2860 input_bfd
, input_section
, rel
->r_offset
);
2863 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2865 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2867 outrel
.r_addend
= 0;
2870 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2872 unresolved_reloc
= FALSE
;
2875 loc
= (srel
->contents
2876 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2877 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2878 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2884 case R_XTENSA_TLS_DTPOFF
:
2885 if (! bfd_link_pic (info
))
2886 /* Switch from LD model to LE model. */
2887 relocation
= tpoff (info
, relocation
);
2889 relocation
-= dtpoff_base (info
);
2892 case R_XTENSA_TLS_FUNC
:
2893 case R_XTENSA_TLS_ARG
:
2894 case R_XTENSA_TLS_CALL
:
2895 /* Check if optimizing to IE or LE model. */
2896 if ((tls_type
& GOT_TLS_IE
) != 0)
2898 bfd_boolean is_ld_model
=
2899 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
2900 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
2901 is_ld_model
, &error_message
))
2902 (*info
->callbacks
->reloc_dangerous
)
2903 (info
, error_message
,
2904 input_bfd
, input_section
, rel
->r_offset
);
2906 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
2908 /* Skip subsequent relocations on the same instruction. */
2909 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
2916 if (elf_hash_table (info
)->dynamic_sections_created
2917 && dynamic_symbol
&& (is_operand_relocation (r_type
)
2918 || r_type
== R_XTENSA_32_PCREL
))
2921 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
2922 strlen (name
) + 2, name
);
2923 (*info
->callbacks
->reloc_dangerous
)
2924 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
2930 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2931 because such sections are not SEC_ALLOC and thus ld.so will
2932 not process them. */
2933 if (unresolved_reloc
2934 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2936 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2937 rel
->r_offset
) != (bfd_vma
) -1)
2940 /* xgettext:c-format */
2941 (_("%pB(%pA+%#" PRIx64
"): "
2942 "unresolvable %s relocation against symbol `%s'"),
2945 (uint64_t) rel
->r_offset
,
2951 /* TLS optimizations may have changed r_type; update "howto". */
2952 howto
= &elf_howto_table
[r_type
];
2954 /* There's no point in calling bfd_perform_relocation here.
2955 Just go directly to our "special function". */
2956 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2957 relocation
+ rel
->r_addend
,
2958 contents
, rel
->r_offset
, is_weak_undef
,
2961 if (r
!= bfd_reloc_ok
&& !warned
)
2963 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
2964 BFD_ASSERT (error_message
!= NULL
);
2966 if (rel
->r_addend
== 0)
2967 error_message
= vsprint_msg (error_message
, ": %s",
2968 strlen (name
) + 2, name
);
2970 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
2972 name
, (int) rel
->r_addend
);
2974 (*info
->callbacks
->reloc_dangerous
)
2975 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
2982 input_section
->reloc_done
= TRUE
;
2988 /* Finish up dynamic symbol handling. There's not much to do here since
2989 the PLT and GOT entries are all set up by relocate_section. */
2992 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2993 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2994 struct elf_link_hash_entry
*h
,
2995 Elf_Internal_Sym
*sym
)
2997 if (h
->needs_plt
&& !h
->def_regular
)
2999 /* Mark the symbol as undefined, rather than as defined in
3000 the .plt section. Leave the value alone. */
3001 sym
->st_shndx
= SHN_UNDEF
;
3002 /* If the symbol is weak, we do need to clear the value.
3003 Otherwise, the PLT entry would provide a definition for
3004 the symbol even if the symbol wasn't defined anywhere,
3005 and so the symbol would never be NULL. */
3006 if (!h
->ref_regular_nonweak
)
3010 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3011 if (h
== elf_hash_table (info
)->hdynamic
3012 || h
== elf_hash_table (info
)->hgot
)
3013 sym
->st_shndx
= SHN_ABS
;
3019 /* Combine adjacent literal table entries in the output. Adjacent
3020 entries within each input section may have been removed during
3021 relaxation, but we repeat the process here, even though it's too late
3022 to shrink the output section, because it's important to minimize the
3023 number of literal table entries to reduce the start-up work for the
3024 runtime linker. Returns the number of remaining table entries or -1
3028 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3033 property_table_entry
*table
;
3034 bfd_size_type section_size
, sgotloc_size
;
3038 section_size
= sxtlit
->size
;
3039 BFD_ASSERT (section_size
% 8 == 0);
3040 num
= section_size
/ 8;
3042 sgotloc_size
= sgotloc
->size
;
3043 if (sgotloc_size
!= section_size
)
3046 (_("internal inconsistency in size of .got.loc section"));
3050 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3054 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3055 propagates to the output section, where it doesn't really apply and
3056 where it breaks the following call to bfd_malloc_and_get_section. */
3057 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3059 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3067 /* There should never be any relocations left at this point, so this
3068 is quite a bit easier than what is done during relaxation. */
3070 /* Copy the raw contents into a property table array and sort it. */
3072 for (n
= 0; n
< num
; n
++)
3074 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3075 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3078 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3080 for (n
= 0; n
< num
; n
++)
3082 bfd_boolean remove_entry
= FALSE
;
3084 if (table
[n
].size
== 0)
3085 remove_entry
= TRUE
;
3087 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3089 table
[n
-1].size
+= table
[n
].size
;
3090 remove_entry
= TRUE
;
3095 for (m
= n
; m
< num
- 1; m
++)
3097 table
[m
].address
= table
[m
+1].address
;
3098 table
[m
].size
= table
[m
+1].size
;
3106 /* Copy the data back to the raw contents. */
3108 for (n
= 0; n
< num
; n
++)
3110 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3111 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3115 /* Clear the removed bytes. */
3116 if ((bfd_size_type
) (num
* 8) < section_size
)
3117 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3119 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3123 /* Copy the contents to ".got.loc". */
3124 memcpy (sgotloc
->contents
, contents
, section_size
);
3132 /* Finish up the dynamic sections. */
3135 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3136 struct bfd_link_info
*info
)
3138 struct elf_xtensa_link_hash_table
*htab
;
3140 asection
*sdyn
, *srelplt
, *sgot
, *sxtlit
, *sgotloc
;
3141 Elf32_External_Dyn
*dyncon
, *dynconend
;
3142 int num_xtlit_entries
= 0;
3144 if (! elf_hash_table (info
)->dynamic_sections_created
)
3147 htab
= elf_xtensa_hash_table (info
);
3151 dynobj
= elf_hash_table (info
)->dynobj
;
3152 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3153 BFD_ASSERT (sdyn
!= NULL
);
3155 /* Set the first entry in the global offset table to the address of
3156 the dynamic section. */
3157 sgot
= htab
->elf
.sgot
;
3160 BFD_ASSERT (sgot
->size
== 4);
3162 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3164 bfd_put_32 (output_bfd
,
3165 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3169 srelplt
= htab
->elf
.srelplt
;
3170 if (srelplt
&& srelplt
->size
!= 0)
3172 asection
*sgotplt
, *srelgot
, *spltlittbl
;
3173 int chunk
, plt_chunks
, plt_entries
;
3174 Elf_Internal_Rela irela
;
3176 unsigned rtld_reloc
;
3178 srelgot
= htab
->elf
.srelgot
;
3179 spltlittbl
= htab
->spltlittbl
;
3180 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3182 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3183 of them follow immediately after.... */
3184 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3186 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3187 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3188 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3191 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3193 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3195 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3197 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3199 int chunk_entries
= 0;
3201 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3202 BFD_ASSERT (sgotplt
!= NULL
);
3204 /* Emit special RTLD relocations for the first two entries in
3205 each chunk of the .got.plt section. */
3207 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3208 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3209 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3210 irela
.r_offset
= (sgotplt
->output_section
->vma
3211 + sgotplt
->output_offset
);
3212 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3213 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3215 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3217 /* Next literal immediately follows the first. */
3218 loc
+= sizeof (Elf32_External_Rela
);
3219 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3220 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3221 irela
.r_offset
= (sgotplt
->output_section
->vma
3222 + sgotplt
->output_offset
+ 4);
3223 /* Tell rtld to set value to object's link map. */
3225 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3227 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3229 /* Fill in the literal table. */
3230 if (chunk
< plt_chunks
- 1)
3231 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3233 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3235 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3236 bfd_put_32 (output_bfd
,
3237 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3238 spltlittbl
->contents
+ (chunk
* 8) + 0);
3239 bfd_put_32 (output_bfd
,
3240 8 + (chunk_entries
* 4),
3241 spltlittbl
->contents
+ (chunk
* 8) + 4);
3244 /* All the dynamic relocations have been emitted at this point.
3245 Make sure the relocation sections are the correct size. */
3246 if (srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3247 * srelgot
->reloc_count
)
3248 || srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3249 * srelplt
->reloc_count
))
3252 /* The .xt.lit.plt section has just been modified. This must
3253 happen before the code below which combines adjacent literal
3254 table entries, and the .xt.lit.plt contents have to be forced to
3256 if (! bfd_set_section_contents (output_bfd
,
3257 spltlittbl
->output_section
,
3258 spltlittbl
->contents
,
3259 spltlittbl
->output_offset
,
3262 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3263 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3266 /* Combine adjacent literal table entries. */
3267 BFD_ASSERT (! bfd_link_relocatable (info
));
3268 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3269 sgotloc
= htab
->sgotloc
;
3270 BFD_ASSERT (sgotloc
);
3274 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3275 if (num_xtlit_entries
< 0)
3279 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3280 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3281 for (; dyncon
< dynconend
; dyncon
++)
3283 Elf_Internal_Dyn dyn
;
3285 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3292 case DT_XTENSA_GOT_LOC_SZ
:
3293 dyn
.d_un
.d_val
= num_xtlit_entries
;
3296 case DT_XTENSA_GOT_LOC_OFF
:
3297 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3298 + htab
->sgotloc
->output_offset
);
3302 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3303 + htab
->elf
.sgot
->output_offset
);
3307 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3308 + htab
->elf
.srelplt
->output_offset
);
3312 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3316 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3323 /* Functions for dealing with the e_flags field. */
3325 /* Merge backend specific data from an object file to the output
3326 object file when linking. */
3329 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3331 bfd
*obfd
= info
->output_bfd
;
3332 unsigned out_mach
, in_mach
;
3333 flagword out_flag
, in_flag
;
3335 /* Check if we have the same endianness. */
3336 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3339 /* Don't even pretend to support mixed-format linking. */
3340 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3341 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3344 out_flag
= elf_elfheader (obfd
)->e_flags
;
3345 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3347 out_mach
= out_flag
& EF_XTENSA_MACH
;
3348 in_mach
= in_flag
& EF_XTENSA_MACH
;
3349 if (out_mach
!= in_mach
)
3352 /* xgettext:c-format */
3353 (_("%pB: incompatible machine type. Output is 0x%x. Input is 0x%x"),
3354 ibfd
, out_mach
, in_mach
);
3355 bfd_set_error (bfd_error_wrong_format
);
3359 if (! elf_flags_init (obfd
))
3361 elf_flags_init (obfd
) = TRUE
;
3362 elf_elfheader (obfd
)->e_flags
= in_flag
;
3364 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3365 && bfd_get_arch_info (obfd
)->the_default
)
3366 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3367 bfd_get_mach (ibfd
));
3372 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3373 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3375 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3376 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3383 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3385 BFD_ASSERT (!elf_flags_init (abfd
)
3386 || elf_elfheader (abfd
)->e_flags
== flags
);
3388 elf_elfheader (abfd
)->e_flags
|= flags
;
3389 elf_flags_init (abfd
) = TRUE
;
3396 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3398 FILE *f
= (FILE *) farg
;
3399 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3401 fprintf (f
, "\nXtensa header:\n");
3402 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3403 fprintf (f
, "\nMachine = Base\n");
3405 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3407 fprintf (f
, "Insn tables = %s\n",
3408 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3410 fprintf (f
, "Literal tables = %s\n",
3411 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3413 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3417 /* Set the right machine number for an Xtensa ELF file. */
3420 elf_xtensa_object_p (bfd
*abfd
)
3423 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3428 mach
= bfd_mach_xtensa
;
3434 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3439 /* The final processing done just before writing out an Xtensa ELF object
3440 file. This gets the Xtensa architecture right based on the machine
3444 elf_xtensa_final_write_processing (bfd
*abfd
,
3445 bfd_boolean linker ATTRIBUTE_UNUSED
)
3450 switch (mach
= bfd_get_mach (abfd
))
3452 case bfd_mach_xtensa
:
3453 val
= E_XTENSA_MACH
;
3459 elf_elfheader (abfd
)->e_flags
&= (~ EF_XTENSA_MACH
);
3460 elf_elfheader (abfd
)->e_flags
|= val
;
3464 static enum elf_reloc_type_class
3465 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3466 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3467 const Elf_Internal_Rela
*rela
)
3469 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3471 case R_XTENSA_RELATIVE
:
3472 return reloc_class_relative
;
3473 case R_XTENSA_JMP_SLOT
:
3474 return reloc_class_plt
;
3476 return reloc_class_normal
;
3482 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3483 struct elf_reloc_cookie
*cookie
,
3484 struct bfd_link_info
*info
,
3488 bfd_vma offset
, actual_offset
;
3489 bfd_size_type removed_bytes
= 0;
3490 bfd_size_type entry_size
;
3492 if (sec
->output_section
3493 && bfd_is_abs_section (sec
->output_section
))
3496 if (xtensa_is_proptable_section (sec
))
3501 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3504 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3508 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3511 release_contents (sec
, contents
);
3515 /* Sort the relocations. They should already be in order when
3516 relaxation is enabled, but it might not be. */
3517 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3518 internal_reloc_compare
);
3520 cookie
->rel
= cookie
->rels
;
3521 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3523 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3525 actual_offset
= offset
- removed_bytes
;
3527 /* The ...symbol_deleted_p function will skip over relocs but it
3528 won't adjust their offsets, so do that here. */
3529 while (cookie
->rel
< cookie
->relend
3530 && cookie
->rel
->r_offset
< offset
)
3532 cookie
->rel
->r_offset
-= removed_bytes
;
3536 while (cookie
->rel
< cookie
->relend
3537 && cookie
->rel
->r_offset
== offset
)
3539 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3541 /* Remove the table entry. (If the reloc type is NONE, then
3542 the entry has already been merged with another and deleted
3543 during relaxation.) */
3544 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3546 /* Shift the contents up. */
3547 if (offset
+ entry_size
< sec
->size
)
3548 memmove (&contents
[actual_offset
],
3549 &contents
[actual_offset
+ entry_size
],
3550 sec
->size
- offset
- entry_size
);
3551 removed_bytes
+= entry_size
;
3554 /* Remove this relocation. */
3555 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3558 /* Adjust the relocation offset for previous removals. This
3559 should not be done before calling ...symbol_deleted_p
3560 because it might mess up the offset comparisons there.
3561 Make sure the offset doesn't underflow in the case where
3562 the first entry is removed. */
3563 if (cookie
->rel
->r_offset
>= removed_bytes
)
3564 cookie
->rel
->r_offset
-= removed_bytes
;
3566 cookie
->rel
->r_offset
= 0;
3572 if (removed_bytes
!= 0)
3574 /* Adjust any remaining relocs (shouldn't be any). */
3575 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3577 if (cookie
->rel
->r_offset
>= removed_bytes
)
3578 cookie
->rel
->r_offset
-= removed_bytes
;
3580 cookie
->rel
->r_offset
= 0;
3583 /* Clear the removed bytes. */
3584 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3586 pin_contents (sec
, contents
);
3587 pin_internal_relocs (sec
, cookie
->rels
);
3590 if (sec
->rawsize
== 0)
3591 sec
->rawsize
= sec
->size
;
3592 sec
->size
-= removed_bytes
;
3594 if (xtensa_is_littable_section (sec
))
3596 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3598 sgotloc
->size
-= removed_bytes
;
3603 release_contents (sec
, contents
);
3604 release_internal_relocs (sec
, cookie
->rels
);
3607 return (removed_bytes
!= 0);
3612 elf_xtensa_discard_info (bfd
*abfd
,
3613 struct elf_reloc_cookie
*cookie
,
3614 struct bfd_link_info
*info
)
3617 bfd_boolean changed
= FALSE
;
3619 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3621 if (xtensa_is_property_section (sec
))
3623 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3633 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3635 return xtensa_is_property_section (sec
);
3640 elf_xtensa_action_discarded (asection
*sec
)
3642 if (strcmp (".xt_except_table", sec
->name
) == 0)
3645 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3648 return _bfd_elf_default_action_discarded (sec
);
3652 /* Support for core dump NOTE sections. */
3655 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3660 /* The size for Xtensa is variable, so don't try to recognize the format
3661 based on the size. Just assume this is GNU/Linux. */
3664 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3667 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3671 size
= note
->descsz
- offset
- 4;
3673 /* Make a ".reg/999" section. */
3674 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3675 size
, note
->descpos
+ offset
);
3680 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3682 switch (note
->descsz
)
3687 case 128: /* GNU/Linux elf_prpsinfo */
3688 elf_tdata (abfd
)->core
->program
3689 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3690 elf_tdata (abfd
)->core
->command
3691 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3694 /* Note that for some reason, a spurious space is tacked
3695 onto the end of the args in some (at least one anyway)
3696 implementations, so strip it off if it exists. */
3699 char *command
= elf_tdata (abfd
)->core
->command
;
3700 int n
= strlen (command
);
3702 if (0 < n
&& command
[n
- 1] == ' ')
3703 command
[n
- 1] = '\0';
3710 /* Generic Xtensa configurability stuff. */
3712 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3713 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3714 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3715 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3716 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3717 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3718 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3719 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3722 init_call_opcodes (void)
3724 if (callx0_op
== XTENSA_UNDEFINED
)
3726 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3727 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3728 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3729 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3730 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3731 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3732 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3733 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3739 is_indirect_call_opcode (xtensa_opcode opcode
)
3741 init_call_opcodes ();
3742 return (opcode
== callx0_op
3743 || opcode
== callx4_op
3744 || opcode
== callx8_op
3745 || opcode
== callx12_op
);
3750 is_direct_call_opcode (xtensa_opcode opcode
)
3752 init_call_opcodes ();
3753 return (opcode
== call0_op
3754 || opcode
== call4_op
3755 || opcode
== call8_op
3756 || opcode
== call12_op
);
3761 is_windowed_call_opcode (xtensa_opcode opcode
)
3763 init_call_opcodes ();
3764 return (opcode
== call4_op
3765 || opcode
== call8_op
3766 || opcode
== call12_op
3767 || opcode
== callx4_op
3768 || opcode
== callx8_op
3769 || opcode
== callx12_op
);
3774 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3776 unsigned dst
= (unsigned) -1;
3778 init_call_opcodes ();
3779 if (opcode
== callx0_op
)
3781 else if (opcode
== callx4_op
)
3783 else if (opcode
== callx8_op
)
3785 else if (opcode
== callx12_op
)
3788 if (dst
== (unsigned) -1)
3796 static xtensa_opcode
3797 get_const16_opcode (void)
3799 static bfd_boolean done_lookup
= FALSE
;
3800 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3803 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3806 return const16_opcode
;
3810 static xtensa_opcode
3811 get_l32r_opcode (void)
3813 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3814 static bfd_boolean done_lookup
= FALSE
;
3818 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3826 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3830 offset
= addr
- ((pc
+3) & -4);
3831 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3832 offset
= (signed int) offset
>> 2;
3833 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3839 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3841 xtensa_isa isa
= xtensa_default_isa
;
3842 int last_immed
, last_opnd
, opi
;
3844 if (opcode
== XTENSA_UNDEFINED
)
3845 return XTENSA_UNDEFINED
;
3847 /* Find the last visible PC-relative immediate operand for the opcode.
3848 If there are no PC-relative immediates, then choose the last visible
3849 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3850 last_immed
= XTENSA_UNDEFINED
;
3851 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3852 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3854 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3856 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3861 if (last_immed
== XTENSA_UNDEFINED
3862 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3866 return XTENSA_UNDEFINED
;
3868 /* If the operand number was specified in an old-style relocation,
3869 check for consistency with the operand computed above. */
3870 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3872 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3873 if (reloc_opnd
!= last_immed
)
3874 return XTENSA_UNDEFINED
;
3882 get_relocation_slot (int r_type
)
3892 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
3893 return r_type
- R_XTENSA_SLOT0_OP
;
3894 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
3895 return r_type
- R_XTENSA_SLOT0_ALT
;
3899 return XTENSA_UNDEFINED
;
3903 /* Get the opcode for a relocation. */
3905 static xtensa_opcode
3906 get_relocation_opcode (bfd
*abfd
,
3909 Elf_Internal_Rela
*irel
)
3911 static xtensa_insnbuf ibuff
= NULL
;
3912 static xtensa_insnbuf sbuff
= NULL
;
3913 xtensa_isa isa
= xtensa_default_isa
;
3917 if (contents
== NULL
)
3918 return XTENSA_UNDEFINED
;
3920 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
3921 return XTENSA_UNDEFINED
;
3925 ibuff
= xtensa_insnbuf_alloc (isa
);
3926 sbuff
= xtensa_insnbuf_alloc (isa
);
3929 /* Decode the instruction. */
3930 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
3931 sec
->size
- irel
->r_offset
);
3932 fmt
= xtensa_format_decode (isa
, ibuff
);
3933 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
3934 if (slot
== XTENSA_UNDEFINED
)
3935 return XTENSA_UNDEFINED
;
3936 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
3937 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
3942 is_l32r_relocation (bfd
*abfd
,
3945 Elf_Internal_Rela
*irel
)
3947 xtensa_opcode opcode
;
3948 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
3950 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
3951 return (opcode
== get_l32r_opcode ());
3955 static bfd_size_type
3956 get_asm_simplify_size (bfd_byte
*contents
,
3957 bfd_size_type content_len
,
3958 bfd_size_type offset
)
3960 bfd_size_type insnlen
, size
= 0;
3962 /* Decode the size of the next two instructions. */
3963 insnlen
= insn_decode_len (contents
, content_len
, offset
);
3969 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
3979 is_alt_relocation (int r_type
)
3981 return (r_type
>= R_XTENSA_SLOT0_ALT
3982 && r_type
<= R_XTENSA_SLOT14_ALT
);
3987 is_operand_relocation (int r_type
)
3997 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
3999 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4008 #define MIN_INSN_LENGTH 2
4010 /* Return 0 if it fails to decode. */
4013 insn_decode_len (bfd_byte
*contents
,
4014 bfd_size_type content_len
,
4015 bfd_size_type offset
)
4018 xtensa_isa isa
= xtensa_default_isa
;
4020 static xtensa_insnbuf ibuff
= NULL
;
4022 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4026 ibuff
= xtensa_insnbuf_alloc (isa
);
4027 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4028 content_len
- offset
);
4029 fmt
= xtensa_format_decode (isa
, ibuff
);
4030 if (fmt
== XTENSA_UNDEFINED
)
4032 insn_len
= xtensa_format_length (isa
, fmt
);
4033 if (insn_len
== XTENSA_UNDEFINED
)
4039 /* Decode the opcode for a single slot instruction.
4040 Return 0 if it fails to decode or the instruction is multi-slot. */
4043 insn_decode_opcode (bfd_byte
*contents
,
4044 bfd_size_type content_len
,
4045 bfd_size_type offset
,
4048 xtensa_isa isa
= xtensa_default_isa
;
4050 static xtensa_insnbuf insnbuf
= NULL
;
4051 static xtensa_insnbuf slotbuf
= NULL
;
4053 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4054 return XTENSA_UNDEFINED
;
4056 if (insnbuf
== NULL
)
4058 insnbuf
= xtensa_insnbuf_alloc (isa
);
4059 slotbuf
= xtensa_insnbuf_alloc (isa
);
4062 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4063 content_len
- offset
);
4064 fmt
= xtensa_format_decode (isa
, insnbuf
);
4065 if (fmt
== XTENSA_UNDEFINED
)
4066 return XTENSA_UNDEFINED
;
4068 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4069 return XTENSA_UNDEFINED
;
4071 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4072 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4076 /* The offset is the offset in the contents.
4077 The address is the address of that offset. */
4080 check_branch_target_aligned (bfd_byte
*contents
,
4081 bfd_size_type content_length
,
4085 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4088 return check_branch_target_aligned_address (address
, insn_len
);
4093 check_loop_aligned (bfd_byte
*contents
,
4094 bfd_size_type content_length
,
4098 bfd_size_type loop_len
, insn_len
;
4099 xtensa_opcode opcode
;
4101 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4102 if (opcode
== XTENSA_UNDEFINED
4103 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4109 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4110 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4111 if (loop_len
== 0 || insn_len
== 0)
4117 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4122 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4125 return (addr
% 8 == 0);
4126 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4130 /* Instruction widening and narrowing. */
4132 /* When FLIX is available we need to access certain instructions only
4133 when they are 16-bit or 24-bit instructions. This table caches
4134 information about such instructions by walking through all the
4135 opcodes and finding the smallest single-slot format into which each
4138 static xtensa_format
*op_single_fmt_table
= NULL
;
4142 init_op_single_format_table (void)
4144 xtensa_isa isa
= xtensa_default_isa
;
4145 xtensa_insnbuf ibuf
;
4146 xtensa_opcode opcode
;
4150 if (op_single_fmt_table
)
4153 ibuf
= xtensa_insnbuf_alloc (isa
);
4154 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4156 op_single_fmt_table
= (xtensa_format
*)
4157 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4158 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4160 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4161 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4163 if (xtensa_format_num_slots (isa
, fmt
) == 1
4164 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4166 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4167 int fmt_length
= xtensa_format_length (isa
, fmt
);
4168 if (old_fmt
== XTENSA_UNDEFINED
4169 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4170 op_single_fmt_table
[opcode
] = fmt
;
4174 xtensa_insnbuf_free (isa
, ibuf
);
4178 static xtensa_format
4179 get_single_format (xtensa_opcode opcode
)
4181 init_op_single_format_table ();
4182 return op_single_fmt_table
[opcode
];
4186 /* For the set of narrowable instructions we do NOT include the
4187 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4188 involved during linker relaxation that may require these to
4189 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4190 requires special case code to ensure it only works when op1 == op2. */
4198 struct string_pair narrowable
[] =
4201 { "addi", "addi.n" },
4202 { "addmi", "addi.n" },
4203 { "l32i", "l32i.n" },
4204 { "movi", "movi.n" },
4206 { "retw", "retw.n" },
4207 { "s32i", "s32i.n" },
4208 { "or", "mov.n" } /* special case only when op1 == op2 */
4211 struct string_pair widenable
[] =
4214 { "addi", "addi.n" },
4215 { "addmi", "addi.n" },
4216 { "beqz", "beqz.n" },
4217 { "bnez", "bnez.n" },
4218 { "l32i", "l32i.n" },
4219 { "movi", "movi.n" },
4221 { "retw", "retw.n" },
4222 { "s32i", "s32i.n" },
4223 { "or", "mov.n" } /* special case only when op1 == op2 */
4227 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4228 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4229 return the instruction buffer holding the narrow instruction. Otherwise,
4230 return 0. The set of valid narrowing are specified by a string table
4231 but require some special case operand checks in some cases. */
4233 static xtensa_insnbuf
4234 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4236 xtensa_opcode opcode
)
4238 xtensa_isa isa
= xtensa_default_isa
;
4239 xtensa_format o_fmt
;
4242 static xtensa_insnbuf o_insnbuf
= NULL
;
4243 static xtensa_insnbuf o_slotbuf
= NULL
;
4245 if (o_insnbuf
== NULL
)
4247 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4248 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4251 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4253 bfd_boolean is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4255 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4257 uint32 value
, newval
;
4258 int i
, operand_count
, o_operand_count
;
4259 xtensa_opcode o_opcode
;
4261 /* Address does not matter in this case. We might need to
4262 fix it to handle branches/jumps. */
4263 bfd_vma self_address
= 0;
4265 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4266 if (o_opcode
== XTENSA_UNDEFINED
)
4268 o_fmt
= get_single_format (o_opcode
);
4269 if (o_fmt
== XTENSA_UNDEFINED
)
4272 if (xtensa_format_length (isa
, fmt
) != 3
4273 || xtensa_format_length (isa
, o_fmt
) != 2)
4276 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4277 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4278 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4280 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4285 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4290 uint32 rawval0
, rawval1
, rawval2
;
4292 if (o_operand_count
+ 1 != operand_count
4293 || xtensa_operand_get_field (isa
, opcode
, 0,
4294 fmt
, 0, slotbuf
, &rawval0
) != 0
4295 || xtensa_operand_get_field (isa
, opcode
, 1,
4296 fmt
, 0, slotbuf
, &rawval1
) != 0
4297 || xtensa_operand_get_field (isa
, opcode
, 2,
4298 fmt
, 0, slotbuf
, &rawval2
) != 0
4299 || rawval1
!= rawval2
4300 || rawval0
== rawval1
/* it is a nop */)
4304 for (i
= 0; i
< o_operand_count
; ++i
)
4306 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4308 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4311 /* PC-relative branches need adjustment, but
4312 the PC-rel operand will always have a relocation. */
4314 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4316 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4317 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4322 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4332 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4333 the action in-place directly into the contents and return TRUE. Otherwise,
4334 the return value is FALSE and the contents are not modified. */
4337 narrow_instruction (bfd_byte
*contents
,
4338 bfd_size_type content_length
,
4339 bfd_size_type offset
)
4341 xtensa_opcode opcode
;
4342 bfd_size_type insn_len
;
4343 xtensa_isa isa
= xtensa_default_isa
;
4345 xtensa_insnbuf o_insnbuf
;
4347 static xtensa_insnbuf insnbuf
= NULL
;
4348 static xtensa_insnbuf slotbuf
= NULL
;
4350 if (insnbuf
== NULL
)
4352 insnbuf
= xtensa_insnbuf_alloc (isa
);
4353 slotbuf
= xtensa_insnbuf_alloc (isa
);
4356 BFD_ASSERT (offset
< content_length
);
4358 if (content_length
< 2)
4361 /* We will hand-code a few of these for a little while.
4362 These have all been specified in the assembler aleady. */
4363 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4364 content_length
- offset
);
4365 fmt
= xtensa_format_decode (isa
, insnbuf
);
4366 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4369 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4372 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4373 if (opcode
== XTENSA_UNDEFINED
)
4375 insn_len
= xtensa_format_length (isa
, fmt
);
4376 if (insn_len
> content_length
)
4379 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4382 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4383 content_length
- offset
);
4391 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4392 "density" instruction to a standard 3-byte instruction. If it is valid,
4393 return the instruction buffer holding the wide instruction. Otherwise,
4394 return 0. The set of valid widenings are specified by a string table
4395 but require some special case operand checks in some cases. */
4397 static xtensa_insnbuf
4398 can_widen_instruction (xtensa_insnbuf slotbuf
,
4400 xtensa_opcode opcode
)
4402 xtensa_isa isa
= xtensa_default_isa
;
4403 xtensa_format o_fmt
;
4406 static xtensa_insnbuf o_insnbuf
= NULL
;
4407 static xtensa_insnbuf o_slotbuf
= NULL
;
4409 if (o_insnbuf
== NULL
)
4411 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4412 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4415 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4417 bfd_boolean is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4418 bfd_boolean is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4419 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4421 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4423 uint32 value
, newval
;
4424 int i
, operand_count
, o_operand_count
, check_operand_count
;
4425 xtensa_opcode o_opcode
;
4427 /* Address does not matter in this case. We might need to fix it
4428 to handle branches/jumps. */
4429 bfd_vma self_address
= 0;
4431 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4432 if (o_opcode
== XTENSA_UNDEFINED
)
4434 o_fmt
= get_single_format (o_opcode
);
4435 if (o_fmt
== XTENSA_UNDEFINED
)
4438 if (xtensa_format_length (isa
, fmt
) != 2
4439 || xtensa_format_length (isa
, o_fmt
) != 3)
4442 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4443 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4444 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4445 check_operand_count
= o_operand_count
;
4447 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4452 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4457 uint32 rawval0
, rawval1
;
4459 if (o_operand_count
!= operand_count
+ 1
4460 || xtensa_operand_get_field (isa
, opcode
, 0,
4461 fmt
, 0, slotbuf
, &rawval0
) != 0
4462 || xtensa_operand_get_field (isa
, opcode
, 1,
4463 fmt
, 0, slotbuf
, &rawval1
) != 0
4464 || rawval0
== rawval1
/* it is a nop */)
4468 check_operand_count
--;
4470 for (i
= 0; i
< check_operand_count
; i
++)
4473 if (is_or
&& i
== o_operand_count
- 1)
4475 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4477 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4480 /* PC-relative branches need adjustment, but
4481 the PC-rel operand will always have a relocation. */
4483 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4485 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4486 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4491 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4501 /* Attempt to widen an instruction. If the widening is valid, perform
4502 the action in-place directly into the contents and return TRUE. Otherwise,
4503 the return value is FALSE and the contents are not modified. */
4506 widen_instruction (bfd_byte
*contents
,
4507 bfd_size_type content_length
,
4508 bfd_size_type offset
)
4510 xtensa_opcode opcode
;
4511 bfd_size_type insn_len
;
4512 xtensa_isa isa
= xtensa_default_isa
;
4514 xtensa_insnbuf o_insnbuf
;
4516 static xtensa_insnbuf insnbuf
= NULL
;
4517 static xtensa_insnbuf slotbuf
= NULL
;
4519 if (insnbuf
== NULL
)
4521 insnbuf
= xtensa_insnbuf_alloc (isa
);
4522 slotbuf
= xtensa_insnbuf_alloc (isa
);
4525 BFD_ASSERT (offset
< content_length
);
4527 if (content_length
< 2)
4530 /* We will hand-code a few of these for a little while.
4531 These have all been specified in the assembler aleady. */
4532 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4533 content_length
- offset
);
4534 fmt
= xtensa_format_decode (isa
, insnbuf
);
4535 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4538 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4541 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4542 if (opcode
== XTENSA_UNDEFINED
)
4544 insn_len
= xtensa_format_length (isa
, fmt
);
4545 if (insn_len
> content_length
)
4548 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4551 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4552 content_length
- offset
);
4559 /* Code for transforming CALLs at link-time. */
4561 static bfd_reloc_status_type
4562 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4564 bfd_vma content_length
,
4565 char **error_message
)
4567 static xtensa_insnbuf insnbuf
= NULL
;
4568 static xtensa_insnbuf slotbuf
= NULL
;
4569 xtensa_format core_format
= XTENSA_UNDEFINED
;
4570 xtensa_opcode opcode
;
4571 xtensa_opcode direct_call_opcode
;
4572 xtensa_isa isa
= xtensa_default_isa
;
4573 bfd_byte
*chbuf
= contents
+ address
;
4576 if (insnbuf
== NULL
)
4578 insnbuf
= xtensa_insnbuf_alloc (isa
);
4579 slotbuf
= xtensa_insnbuf_alloc (isa
);
4582 if (content_length
< address
)
4584 *error_message
= _("Attempt to convert L32R/CALLX to CALL failed");
4585 return bfd_reloc_other
;
4588 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4589 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4590 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4592 *error_message
= _("Attempt to convert L32R/CALLX to CALL failed");
4593 return bfd_reloc_other
;
4596 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4597 core_format
= xtensa_format_lookup (isa
, "x24");
4598 opcode
= xtensa_opcode_lookup (isa
, "or");
4599 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4600 for (opn
= 0; opn
< 3; opn
++)
4603 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4604 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4607 xtensa_format_encode (isa
, core_format
, insnbuf
);
4608 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4609 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4611 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4612 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4613 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4615 xtensa_format_encode (isa
, core_format
, insnbuf
);
4616 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4617 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4618 content_length
- address
- 3);
4620 return bfd_reloc_ok
;
4624 static bfd_reloc_status_type
4625 contract_asm_expansion (bfd_byte
*contents
,
4626 bfd_vma content_length
,
4627 Elf_Internal_Rela
*irel
,
4628 char **error_message
)
4630 bfd_reloc_status_type retval
=
4631 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4634 if (retval
!= bfd_reloc_ok
)
4635 return bfd_reloc_dangerous
;
4637 /* Update the irel->r_offset field so that the right immediate and
4638 the right instruction are modified during the relocation. */
4639 irel
->r_offset
+= 3;
4640 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4641 return bfd_reloc_ok
;
4645 static xtensa_opcode
4646 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4648 init_call_opcodes ();
4650 if (opcode
== callx0_op
) return call0_op
;
4651 if (opcode
== callx4_op
) return call4_op
;
4652 if (opcode
== callx8_op
) return call8_op
;
4653 if (opcode
== callx12_op
) return call12_op
;
4655 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4656 return XTENSA_UNDEFINED
;
4660 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4661 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4662 If not, return XTENSA_UNDEFINED. */
4664 #define L32R_TARGET_REG_OPERAND 0
4665 #define CONST16_TARGET_REG_OPERAND 0
4666 #define CALLN_SOURCE_OPERAND 0
4668 static xtensa_opcode
4669 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bfd_boolean
*p_uses_l32r
)
4671 static xtensa_insnbuf insnbuf
= NULL
;
4672 static xtensa_insnbuf slotbuf
= NULL
;
4674 xtensa_opcode opcode
;
4675 xtensa_isa isa
= xtensa_default_isa
;
4676 uint32 regno
, const16_regno
, call_regno
;
4679 if (insnbuf
== NULL
)
4681 insnbuf
= xtensa_insnbuf_alloc (isa
);
4682 slotbuf
= xtensa_insnbuf_alloc (isa
);
4685 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4686 fmt
= xtensa_format_decode (isa
, insnbuf
);
4687 if (fmt
== XTENSA_UNDEFINED
4688 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4689 return XTENSA_UNDEFINED
;
4691 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4692 if (opcode
== XTENSA_UNDEFINED
)
4693 return XTENSA_UNDEFINED
;
4695 if (opcode
== get_l32r_opcode ())
4698 *p_uses_l32r
= TRUE
;
4699 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4700 fmt
, 0, slotbuf
, ®no
)
4701 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4703 return XTENSA_UNDEFINED
;
4705 else if (opcode
== get_const16_opcode ())
4708 *p_uses_l32r
= FALSE
;
4709 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4710 fmt
, 0, slotbuf
, ®no
)
4711 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4713 return XTENSA_UNDEFINED
;
4715 /* Check that the next instruction is also CONST16. */
4716 offset
+= xtensa_format_length (isa
, fmt
);
4717 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4718 fmt
= xtensa_format_decode (isa
, insnbuf
);
4719 if (fmt
== XTENSA_UNDEFINED
4720 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4721 return XTENSA_UNDEFINED
;
4722 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4723 if (opcode
!= get_const16_opcode ())
4724 return XTENSA_UNDEFINED
;
4726 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4727 fmt
, 0, slotbuf
, &const16_regno
)
4728 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4730 || const16_regno
!= regno
)
4731 return XTENSA_UNDEFINED
;
4734 return XTENSA_UNDEFINED
;
4736 /* Next instruction should be an CALLXn with operand 0 == regno. */
4737 offset
+= xtensa_format_length (isa
, fmt
);
4738 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4739 fmt
= xtensa_format_decode (isa
, insnbuf
);
4740 if (fmt
== XTENSA_UNDEFINED
4741 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4742 return XTENSA_UNDEFINED
;
4743 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4744 if (opcode
== XTENSA_UNDEFINED
4745 || !is_indirect_call_opcode (opcode
))
4746 return XTENSA_UNDEFINED
;
4748 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4749 fmt
, 0, slotbuf
, &call_regno
)
4750 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4752 return XTENSA_UNDEFINED
;
4754 if (call_regno
!= regno
)
4755 return XTENSA_UNDEFINED
;
4761 /* Data structures used during relaxation. */
4763 /* r_reloc: relocation values. */
4765 /* Through the relaxation process, we need to keep track of the values
4766 that will result from evaluating relocations. The standard ELF
4767 relocation structure is not sufficient for this purpose because we're
4768 operating on multiple input files at once, so we need to know which
4769 input file a relocation refers to. The r_reloc structure thus
4770 records both the input file (bfd) and ELF relocation.
4772 For efficiency, an r_reloc also contains a "target_offset" field to
4773 cache the target-section-relative offset value that is represented by
4776 The r_reloc also contains a virtual offset that allows multiple
4777 inserted literals to be placed at the same "address" with
4778 different offsets. */
4780 typedef struct r_reloc_struct r_reloc
;
4782 struct r_reloc_struct
4785 Elf_Internal_Rela rela
;
4786 bfd_vma target_offset
;
4787 bfd_vma virtual_offset
;
4791 /* The r_reloc structure is included by value in literal_value, but not
4792 every literal_value has an associated relocation -- some are simple
4793 constants. In such cases, we set all the fields in the r_reloc
4794 struct to zero. The r_reloc_is_const function should be used to
4795 detect this case. */
4798 r_reloc_is_const (const r_reloc
*r_rel
)
4800 return (r_rel
->abfd
== NULL
);
4805 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4807 bfd_vma target_offset
;
4808 unsigned long r_symndx
;
4810 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4811 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4812 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4813 return (target_offset
+ r_rel
->rela
.r_addend
);
4817 static struct elf_link_hash_entry
*
4818 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4820 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4821 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4826 r_reloc_get_section (const r_reloc
*r_rel
)
4828 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4829 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4834 r_reloc_is_defined (const r_reloc
*r_rel
)
4840 sec
= r_reloc_get_section (r_rel
);
4841 if (sec
== bfd_abs_section_ptr
4842 || sec
== bfd_com_section_ptr
4843 || sec
== bfd_und_section_ptr
)
4850 r_reloc_init (r_reloc
*r_rel
,
4852 Elf_Internal_Rela
*irel
,
4854 bfd_size_type content_length
)
4857 reloc_howto_type
*howto
;
4861 r_rel
->rela
= *irel
;
4863 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
4864 r_rel
->virtual_offset
= 0;
4865 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
4866 howto
= &elf_howto_table
[r_type
];
4867 if (howto
->partial_inplace
)
4869 bfd_vma inplace_val
;
4870 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
4872 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
4873 r_rel
->target_offset
+= inplace_val
;
4877 memset (r_rel
, 0, sizeof (r_reloc
));
4884 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
4886 if (r_reloc_is_defined (r_rel
))
4888 asection
*sec
= r_reloc_get_section (r_rel
);
4889 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
4891 else if (r_reloc_get_hash_entry (r_rel
))
4892 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
4894 fprintf (fp
, " ?? + ");
4896 fprintf_vma (fp
, r_rel
->target_offset
);
4897 if (r_rel
->virtual_offset
)
4899 fprintf (fp
, " + ");
4900 fprintf_vma (fp
, r_rel
->virtual_offset
);
4909 /* source_reloc: relocations that reference literals. */
4911 /* To determine whether literals can be coalesced, we need to first
4912 record all the relocations that reference the literals. The
4913 source_reloc structure below is used for this purpose. The
4914 source_reloc entries are kept in a per-literal-section array, sorted
4915 by offset within the literal section (i.e., target offset).
4917 The source_sec and r_rel.rela.r_offset fields identify the source of
4918 the relocation. The r_rel field records the relocation value, i.e.,
4919 the offset of the literal being referenced. The opnd field is needed
4920 to determine the range of the immediate field to which the relocation
4921 applies, so we can determine whether another literal with the same
4922 value is within range. The is_null field is true when the relocation
4923 is being removed (e.g., when an L32R is being removed due to a CALLX
4924 that is converted to a direct CALL). */
4926 typedef struct source_reloc_struct source_reloc
;
4928 struct source_reloc_struct
4930 asection
*source_sec
;
4932 xtensa_opcode opcode
;
4934 bfd_boolean is_null
;
4935 bfd_boolean is_abs_literal
;
4940 init_source_reloc (source_reloc
*reloc
,
4941 asection
*source_sec
,
4942 const r_reloc
*r_rel
,
4943 xtensa_opcode opcode
,
4945 bfd_boolean is_abs_literal
)
4947 reloc
->source_sec
= source_sec
;
4948 reloc
->r_rel
= *r_rel
;
4949 reloc
->opcode
= opcode
;
4951 reloc
->is_null
= FALSE
;
4952 reloc
->is_abs_literal
= is_abs_literal
;
4956 /* Find the source_reloc for a particular source offset and relocation
4957 type. Note that the array is sorted by _target_ offset, so this is
4958 just a linear search. */
4960 static source_reloc
*
4961 find_source_reloc (source_reloc
*src_relocs
,
4964 Elf_Internal_Rela
*irel
)
4968 for (i
= 0; i
< src_count
; i
++)
4970 if (src_relocs
[i
].source_sec
== sec
4971 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
4972 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
4973 == ELF32_R_TYPE (irel
->r_info
)))
4974 return &src_relocs
[i
];
4982 source_reloc_compare (const void *ap
, const void *bp
)
4984 const source_reloc
*a
= (const source_reloc
*) ap
;
4985 const source_reloc
*b
= (const source_reloc
*) bp
;
4987 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
4988 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
4990 /* We don't need to sort on these criteria for correctness,
4991 but enforcing a more strict ordering prevents unstable qsort
4992 from behaving differently with different implementations.
4993 Without the code below we get correct but different results
4994 on Solaris 2.7 and 2.8. We would like to always produce the
4995 same results no matter the host. */
4997 if ((!a
->is_null
) - (!b
->is_null
))
4998 return ((!a
->is_null
) - (!b
->is_null
));
4999 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5003 /* Literal values and value hash tables. */
5005 /* Literals with the same value can be coalesced. The literal_value
5006 structure records the value of a literal: the "r_rel" field holds the
5007 information from the relocation on the literal (if there is one) and
5008 the "value" field holds the contents of the literal word itself.
5010 The value_map structure records a literal value along with the
5011 location of a literal holding that value. The value_map hash table
5012 is indexed by the literal value, so that we can quickly check if a
5013 particular literal value has been seen before and is thus a candidate
5016 typedef struct literal_value_struct literal_value
;
5017 typedef struct value_map_struct value_map
;
5018 typedef struct value_map_hash_table_struct value_map_hash_table
;
5020 struct literal_value_struct
5023 unsigned long value
;
5024 bfd_boolean is_abs_literal
;
5027 struct value_map_struct
5029 literal_value val
; /* The literal value. */
5030 r_reloc loc
; /* Location of the literal. */
5034 struct value_map_hash_table_struct
5036 unsigned bucket_count
;
5037 value_map
**buckets
;
5039 bfd_boolean has_last_loc
;
5045 init_literal_value (literal_value
*lit
,
5046 const r_reloc
*r_rel
,
5047 unsigned long value
,
5048 bfd_boolean is_abs_literal
)
5050 lit
->r_rel
= *r_rel
;
5052 lit
->is_abs_literal
= is_abs_literal
;
5057 literal_value_equal (const literal_value
*src1
,
5058 const literal_value
*src2
,
5059 bfd_boolean final_static_link
)
5061 struct elf_link_hash_entry
*h1
, *h2
;
5063 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5066 if (r_reloc_is_const (&src1
->r_rel
))
5067 return (src1
->value
== src2
->value
);
5069 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5070 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5073 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5076 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5079 if (src1
->value
!= src2
->value
)
5082 /* Now check for the same section (if defined) or the same elf_hash
5083 (if undefined or weak). */
5084 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5085 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5086 if (r_reloc_is_defined (&src1
->r_rel
)
5087 && (final_static_link
5088 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5089 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5091 if (r_reloc_get_section (&src1
->r_rel
)
5092 != r_reloc_get_section (&src2
->r_rel
))
5097 /* Require that the hash entries (i.e., symbols) be identical. */
5098 if (h1
!= h2
|| h1
== 0)
5102 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5109 /* Must be power of 2. */
5110 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5112 static value_map_hash_table
*
5113 value_map_hash_table_init (void)
5115 value_map_hash_table
*values
;
5117 values
= (value_map_hash_table
*)
5118 bfd_zmalloc (sizeof (value_map_hash_table
));
5119 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5121 values
->buckets
= (value_map
**)
5122 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5123 if (values
->buckets
== NULL
)
5128 values
->has_last_loc
= FALSE
;
5135 value_map_hash_table_delete (value_map_hash_table
*table
)
5137 free (table
->buckets
);
5143 hash_bfd_vma (bfd_vma val
)
5145 return (val
>> 2) + (val
>> 10);
5150 literal_value_hash (const literal_value
*src
)
5154 hash_val
= hash_bfd_vma (src
->value
);
5155 if (!r_reloc_is_const (&src
->r_rel
))
5159 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5160 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5161 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5163 /* Now check for the same section and the same elf_hash. */
5164 if (r_reloc_is_defined (&src
->r_rel
))
5165 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5167 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5168 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5174 /* Check if the specified literal_value has been seen before. */
5177 value_map_get_cached_value (value_map_hash_table
*map
,
5178 const literal_value
*val
,
5179 bfd_boolean final_static_link
)
5185 idx
= literal_value_hash (val
);
5186 idx
= idx
& (map
->bucket_count
- 1);
5187 bucket
= map
->buckets
[idx
];
5188 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5190 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5197 /* Record a new literal value. It is illegal to call this if VALUE
5198 already has an entry here. */
5201 add_value_map (value_map_hash_table
*map
,
5202 const literal_value
*val
,
5204 bfd_boolean final_static_link
)
5206 value_map
**bucket_p
;
5209 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5212 bfd_set_error (bfd_error_no_memory
);
5216 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5220 idx
= literal_value_hash (val
);
5221 idx
= idx
& (map
->bucket_count
- 1);
5222 bucket_p
= &map
->buckets
[idx
];
5224 val_e
->next
= *bucket_p
;
5227 /* FIXME: Consider resizing the hash table if we get too many entries. */
5233 /* Lists of text actions (ta_) for narrowing, widening, longcall
5234 conversion, space fill, code & literal removal, etc. */
5236 /* The following text actions are generated:
5238 "ta_remove_insn" remove an instruction or instructions
5239 "ta_remove_longcall" convert longcall to call
5240 "ta_convert_longcall" convert longcall to nop/call
5241 "ta_narrow_insn" narrow a wide instruction
5242 "ta_widen" widen a narrow instruction
5243 "ta_fill" add fill or remove fill
5244 removed < 0 is a fill; branches to the fill address will be
5245 changed to address + fill size (e.g., address - removed)
5246 removed >= 0 branches to the fill address will stay unchanged
5247 "ta_remove_literal" remove a literal; this action is
5248 indicated when a literal is removed
5250 "ta_add_literal" insert a new literal; this action is
5251 indicated when a literal has been moved.
5252 It may use a virtual_offset because
5253 multiple literals can be placed at the
5256 For each of these text actions, we also record the number of bytes
5257 removed by performing the text action. In the case of a "ta_widen"
5258 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5260 typedef struct text_action_struct text_action
;
5261 typedef struct text_action_list_struct text_action_list
;
5262 typedef enum text_action_enum_t text_action_t
;
5264 enum text_action_enum_t
5267 ta_remove_insn
, /* removed = -size */
5268 ta_remove_longcall
, /* removed = -size */
5269 ta_convert_longcall
, /* removed = 0 */
5270 ta_narrow_insn
, /* removed = -1 */
5271 ta_widen_insn
, /* removed = +1 */
5272 ta_fill
, /* removed = +size */
5278 /* Structure for a text action record. */
5279 struct text_action_struct
5281 text_action_t action
;
5282 asection
*sec
; /* Optional */
5284 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5286 literal_value value
; /* Only valid when adding literals. */
5289 struct removal_by_action_entry_struct
5294 int eq_removed_before_fill
;
5296 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5298 struct removal_by_action_map_struct
5301 removal_by_action_entry
*entry
;
5303 typedef struct removal_by_action_map_struct removal_by_action_map
;
5306 /* List of all of the actions taken on a text section. */
5307 struct text_action_list_struct
5311 removal_by_action_map map
;
5315 static text_action
*
5316 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5320 /* It is not necessary to fill at the end of a section. */
5321 if (sec
->size
== offset
)
5327 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5329 return (text_action
*)node
->value
;
5335 compute_removed_action_diff (const text_action
*ta
,
5339 int removable_space
)
5342 int current_removed
= 0;
5345 current_removed
= ta
->removed_bytes
;
5347 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5348 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5350 /* It is not necessary to fill at the end of a section. Clean this up. */
5351 if (sec
->size
== offset
)
5352 new_removed
= removable_space
- 0;
5356 int added
= -removed
- current_removed
;
5357 /* Ignore multiples of the section alignment. */
5358 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5359 new_removed
= (-added
);
5361 /* Modify for removable. */
5362 space
= removable_space
- new_removed
;
5363 new_removed
= (removable_space
5364 - (((1 << sec
->alignment_power
) - 1) & space
));
5366 return (new_removed
- current_removed
);
5371 adjust_fill_action (text_action
*ta
, int fill_diff
)
5373 ta
->removed_bytes
+= fill_diff
;
5378 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5380 text_action
*pa
= (text_action
*)a
;
5381 text_action
*pb
= (text_action
*)b
;
5382 static const int action_priority
[] =
5386 [ta_convert_longcall
] = 2,
5387 [ta_narrow_insn
] = 3,
5388 [ta_remove_insn
] = 4,
5389 [ta_remove_longcall
] = 5,
5390 [ta_remove_literal
] = 6,
5391 [ta_widen_insn
] = 7,
5392 [ta_add_literal
] = 8,
5395 if (pa
->offset
== pb
->offset
)
5397 if (pa
->action
== pb
->action
)
5399 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5402 return pa
->offset
< pb
->offset
? -1 : 1;
5405 static text_action
*
5406 action_first (text_action_list
*action_list
)
5408 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5409 return node
? (text_action
*)node
->value
: NULL
;
5412 static text_action
*
5413 action_next (text_action_list
*action_list
, text_action
*action
)
5415 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5416 (splay_tree_key
)action
);
5417 return node
? (text_action
*)node
->value
: NULL
;
5420 /* Add a modification action to the text. For the case of adding or
5421 removing space, modify any current fill and assume that
5422 "unreachable_space" bytes can be freely contracted. Note that a
5423 negative removed value is a fill. */
5426 text_action_add (text_action_list
*l
,
5427 text_action_t action
,
5435 /* It is not necessary to fill at the end of a section. */
5436 if (action
== ta_fill
&& sec
->size
== offset
)
5439 /* It is not necessary to fill 0 bytes. */
5440 if (action
== ta_fill
&& removed
== 0)
5446 if (action
== ta_fill
)
5448 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5452 ta
= (text_action
*)node
->value
;
5453 ta
->removed_bytes
+= removed
;
5458 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5460 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5461 ta
->action
= action
;
5463 ta
->offset
= offset
;
5464 ta
->removed_bytes
= removed
;
5465 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5471 text_action_add_literal (text_action_list
*l
,
5472 text_action_t action
,
5474 const literal_value
*value
,
5478 asection
*sec
= r_reloc_get_section (loc
);
5479 bfd_vma offset
= loc
->target_offset
;
5480 bfd_vma virtual_offset
= loc
->virtual_offset
;
5482 BFD_ASSERT (action
== ta_add_literal
);
5484 /* Create a new record and fill it up. */
5485 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5486 ta
->action
= action
;
5488 ta
->offset
= offset
;
5489 ta
->virtual_offset
= virtual_offset
;
5491 ta
->removed_bytes
= removed
;
5493 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5494 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5499 /* Find the total offset adjustment for the relaxations specified by
5500 text_actions, beginning from a particular starting action. This is
5501 typically used from offset_with_removed_text to search an entire list of
5502 actions, but it may also be called directly when adjusting adjacent offsets
5503 so that each search may begin where the previous one left off. */
5506 removed_by_actions (text_action_list
*action_list
,
5507 text_action
**p_start_action
,
5509 bfd_boolean before_fill
)
5514 r
= *p_start_action
;
5517 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5519 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5524 if (r
->offset
> offset
)
5527 if (r
->offset
== offset
5528 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5531 removed
+= r
->removed_bytes
;
5533 r
= action_next (action_list
, r
);
5536 *p_start_action
= r
;
5542 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5544 text_action
*r
= action_first (action_list
);
5546 return offset
- removed_by_actions (action_list
, &r
, offset
, FALSE
);
5551 action_list_count (text_action_list
*action_list
)
5553 return action_list
->count
;
5556 typedef struct map_action_fn_context_struct map_action_fn_context
;
5557 struct map_action_fn_context_struct
5560 removal_by_action_map map
;
5561 bfd_boolean eq_complete
;
5565 map_action_fn (splay_tree_node node
, void *p
)
5567 map_action_fn_context
*ctx
= p
;
5568 text_action
*r
= (text_action
*)node
->value
;
5569 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5571 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5577 ++ctx
->map
.n_entries
;
5578 ctx
->eq_complete
= FALSE
;
5579 ientry
->offset
= r
->offset
;
5580 ientry
->eq_removed_before_fill
= ctx
->removed
;
5583 if (!ctx
->eq_complete
)
5585 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5587 ientry
->eq_removed
= ctx
->removed
;
5588 ctx
->eq_complete
= TRUE
;
5591 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5594 ctx
->removed
+= r
->removed_bytes
;
5595 ientry
->removed
= ctx
->removed
;
5600 map_removal_by_action (text_action_list
*action_list
)
5602 map_action_fn_context ctx
;
5605 ctx
.map
.n_entries
= 0;
5606 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5607 sizeof (removal_by_action_entry
));
5608 ctx
.eq_complete
= FALSE
;
5610 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5611 action_list
->map
= ctx
.map
;
5615 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5616 bfd_boolean before_fill
)
5620 if (!action_list
->map
.entry
)
5621 map_removal_by_action (action_list
);
5623 if (!action_list
->map
.n_entries
)
5627 b
= action_list
->map
.n_entries
;
5631 unsigned c
= (a
+ b
) / 2;
5633 if (action_list
->map
.entry
[c
].offset
<= offset
)
5639 if (action_list
->map
.entry
[a
].offset
< offset
)
5641 return action_list
->map
.entry
[a
].removed
;
5643 else if (action_list
->map
.entry
[a
].offset
== offset
)
5645 return before_fill
?
5646 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5647 action_list
->map
.entry
[a
].eq_removed
;
5656 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5658 int removed
= removed_by_actions_map (action_list
, offset
, FALSE
);
5659 return offset
- removed
;
5663 /* The find_insn_action routine will only find non-fill actions. */
5665 static text_action
*
5666 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5668 static const text_action_t action
[] =
5670 ta_convert_longcall
,
5680 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5682 splay_tree_node node
;
5684 a
.action
= action
[i
];
5685 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5687 return (text_action
*)node
->value
;
5696 print_action (FILE *fp
, text_action
*r
)
5698 const char *t
= "unknown";
5701 case ta_remove_insn
:
5702 t
= "remove_insn"; break;
5703 case ta_remove_longcall
:
5704 t
= "remove_longcall"; break;
5705 case ta_convert_longcall
:
5706 t
= "convert_longcall"; break;
5707 case ta_narrow_insn
:
5708 t
= "narrow_insn"; break;
5710 t
= "widen_insn"; break;
5715 case ta_remove_literal
:
5716 t
= "remove_literal"; break;
5717 case ta_add_literal
:
5718 t
= "add_literal"; break;
5721 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5722 r
->sec
->owner
->filename
,
5723 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5727 print_action_list_fn (splay_tree_node node
, void *p
)
5729 text_action
*r
= (text_action
*)node
->value
;
5731 print_action (p
, r
);
5736 print_action_list (FILE *fp
, text_action_list
*action_list
)
5738 fprintf (fp
, "Text Action\n");
5739 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5745 /* Lists of literals being coalesced or removed. */
5747 /* In the usual case, the literal identified by "from" is being
5748 coalesced with another literal identified by "to". If the literal is
5749 unused and is being removed altogether, "to.abfd" will be NULL.
5750 The removed_literal entries are kept on a per-section list, sorted
5751 by the "from" offset field. */
5753 typedef struct removed_literal_struct removed_literal
;
5754 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5755 typedef struct removed_literal_list_struct removed_literal_list
;
5757 struct removed_literal_struct
5761 removed_literal
*next
;
5764 struct removed_literal_map_entry_struct
5767 removed_literal
*literal
;
5770 struct removed_literal_list_struct
5772 removed_literal
*head
;
5773 removed_literal
*tail
;
5776 removed_literal_map_entry
*map
;
5780 /* Record that the literal at "from" is being removed. If "to" is not
5781 NULL, the "from" literal is being coalesced with the "to" literal. */
5784 add_removed_literal (removed_literal_list
*removed_list
,
5785 const r_reloc
*from
,
5788 removed_literal
*r
, *new_r
, *next_r
;
5790 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5792 new_r
->from
= *from
;
5796 new_r
->to
.abfd
= NULL
;
5799 r
= removed_list
->head
;
5802 removed_list
->head
= new_r
;
5803 removed_list
->tail
= new_r
;
5805 /* Special check for common case of append. */
5806 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5808 removed_list
->tail
->next
= new_r
;
5809 removed_list
->tail
= new_r
;
5813 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5819 new_r
->next
= next_r
;
5821 removed_list
->tail
= new_r
;
5826 map_removed_literal (removed_literal_list
*removed_list
)
5830 removed_literal_map_entry
*map
= NULL
;
5831 removed_literal
*r
= removed_list
->head
;
5833 for (i
= 0; r
; ++i
, r
= r
->next
)
5837 n_map
= (n_map
* 2) + 2;
5838 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5840 map
[i
].addr
= r
->from
.target_offset
;
5843 removed_list
->map
= map
;
5844 removed_list
->n_map
= i
;
5848 removed_literal_compare (const void *a
, const void *b
)
5850 const removed_literal_map_entry
*pa
= a
;
5851 const removed_literal_map_entry
*pb
= b
;
5853 if (pa
->addr
== pb
->addr
)
5856 return pa
->addr
< pb
->addr
? -1 : 1;
5859 /* Check if the list of removed literals contains an entry for the
5860 given address. Return the entry if found. */
5862 static removed_literal
*
5863 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
5865 removed_literal_map_entry
*p
;
5866 removed_literal
*r
= NULL
;
5868 if (removed_list
->map
== NULL
)
5869 map_removed_literal (removed_list
);
5871 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
5872 sizeof (*removed_list
->map
), removed_literal_compare
);
5875 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
5886 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
5889 r
= removed_list
->head
;
5891 fprintf (fp
, "Removed Literals\n");
5892 for (; r
!= NULL
; r
= r
->next
)
5894 print_r_reloc (fp
, &r
->from
);
5895 fprintf (fp
, " => ");
5896 if (r
->to
.abfd
== NULL
)
5897 fprintf (fp
, "REMOVED");
5899 print_r_reloc (fp
, &r
->to
);
5907 /* Per-section data for relaxation. */
5909 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
5911 struct xtensa_relax_info_struct
5913 bfd_boolean is_relaxable_literal_section
;
5914 bfd_boolean is_relaxable_asm_section
;
5915 int visited
; /* Number of times visited. */
5917 source_reloc
*src_relocs
; /* Array[src_count]. */
5919 int src_next
; /* Next src_relocs entry to assign. */
5921 removed_literal_list removed_list
;
5922 text_action_list action_list
;
5924 reloc_bfd_fix
*fix_list
;
5925 reloc_bfd_fix
*fix_array
;
5926 unsigned fix_array_count
;
5928 /* Support for expanding the reloc array that is stored
5929 in the section structure. If the relocations have been
5930 reallocated, the newly allocated relocations will be referenced
5931 here along with the actual size allocated. The relocation
5932 count will always be found in the section structure. */
5933 Elf_Internal_Rela
*allocated_relocs
;
5934 unsigned relocs_count
;
5935 unsigned allocated_relocs_count
;
5938 struct elf_xtensa_section_data
5940 struct bfd_elf_section_data elf
;
5941 xtensa_relax_info relax_info
;
5946 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
5948 if (!sec
->used_by_bfd
)
5950 struct elf_xtensa_section_data
*sdata
;
5951 bfd_size_type amt
= sizeof (*sdata
);
5953 sdata
= bfd_zalloc (abfd
, amt
);
5956 sec
->used_by_bfd
= sdata
;
5959 return _bfd_elf_new_section_hook (abfd
, sec
);
5963 static xtensa_relax_info
*
5964 get_xtensa_relax_info (asection
*sec
)
5966 struct elf_xtensa_section_data
*section_data
;
5968 /* No info available if no section or if it is an output section. */
5969 if (!sec
|| sec
== sec
->output_section
)
5972 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
5973 return §ion_data
->relax_info
;
5978 init_xtensa_relax_info (asection
*sec
)
5980 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
5982 relax_info
->is_relaxable_literal_section
= FALSE
;
5983 relax_info
->is_relaxable_asm_section
= FALSE
;
5984 relax_info
->visited
= 0;
5986 relax_info
->src_relocs
= NULL
;
5987 relax_info
->src_count
= 0;
5988 relax_info
->src_next
= 0;
5990 relax_info
->removed_list
.head
= NULL
;
5991 relax_info
->removed_list
.tail
= NULL
;
5993 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
5995 relax_info
->action_list
.map
.n_entries
= 0;
5996 relax_info
->action_list
.map
.entry
= NULL
;
5998 relax_info
->fix_list
= NULL
;
5999 relax_info
->fix_array
= NULL
;
6000 relax_info
->fix_array_count
= 0;
6002 relax_info
->allocated_relocs
= NULL
;
6003 relax_info
->relocs_count
= 0;
6004 relax_info
->allocated_relocs_count
= 0;
6008 /* Coalescing literals may require a relocation to refer to a section in
6009 a different input file, but the standard relocation information
6010 cannot express that. Instead, the reloc_bfd_fix structures are used
6011 to "fix" the relocations that refer to sections in other input files.
6012 These structures are kept on per-section lists. The "src_type" field
6013 records the relocation type in case there are multiple relocations on
6014 the same location. FIXME: This is ugly; an alternative might be to
6015 add new symbols with the "owner" field to some other input file. */
6017 struct reloc_bfd_fix_struct
6021 unsigned src_type
; /* Relocation type. */
6023 asection
*target_sec
;
6024 bfd_vma target_offset
;
6025 bfd_boolean translated
;
6027 reloc_bfd_fix
*next
;
6031 static reloc_bfd_fix
*
6032 reloc_bfd_fix_init (asection
*src_sec
,
6035 asection
*target_sec
,
6036 bfd_vma target_offset
,
6037 bfd_boolean translated
)
6041 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6042 fix
->src_sec
= src_sec
;
6043 fix
->src_offset
= src_offset
;
6044 fix
->src_type
= src_type
;
6045 fix
->target_sec
= target_sec
;
6046 fix
->target_offset
= target_offset
;
6047 fix
->translated
= translated
;
6054 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6056 xtensa_relax_info
*relax_info
;
6058 relax_info
= get_xtensa_relax_info (src_sec
);
6059 fix
->next
= relax_info
->fix_list
;
6060 relax_info
->fix_list
= fix
;
6065 fix_compare (const void *ap
, const void *bp
)
6067 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6068 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6070 if (a
->src_offset
!= b
->src_offset
)
6071 return (a
->src_offset
- b
->src_offset
);
6072 return (a
->src_type
- b
->src_type
);
6077 cache_fix_array (asection
*sec
)
6079 unsigned i
, count
= 0;
6081 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6083 if (relax_info
== NULL
)
6085 if (relax_info
->fix_list
== NULL
)
6088 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6091 relax_info
->fix_array
=
6092 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6093 relax_info
->fix_array_count
= count
;
6095 r
= relax_info
->fix_list
;
6096 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6098 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6099 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6102 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6103 sizeof (reloc_bfd_fix
), fix_compare
);
6107 static reloc_bfd_fix
*
6108 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6110 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6114 if (relax_info
== NULL
)
6116 if (relax_info
->fix_list
== NULL
)
6119 if (relax_info
->fix_array
== NULL
)
6120 cache_fix_array (sec
);
6122 key
.src_offset
= offset
;
6123 key
.src_type
= type
;
6124 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6125 sizeof (reloc_bfd_fix
), fix_compare
);
6130 /* Section caching. */
6132 typedef struct section_cache_struct section_cache_t
;
6134 struct section_cache_struct
6138 bfd_byte
*contents
; /* Cache of the section contents. */
6139 bfd_size_type content_length
;
6141 property_table_entry
*ptbl
; /* Cache of the section property table. */
6144 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6145 unsigned reloc_count
;
6150 init_section_cache (section_cache_t
*sec_cache
)
6152 memset (sec_cache
, 0, sizeof (*sec_cache
));
6157 free_section_cache (section_cache_t
*sec_cache
)
6161 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6162 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6163 if (sec_cache
->ptbl
)
6164 free (sec_cache
->ptbl
);
6170 section_cache_section (section_cache_t
*sec_cache
,
6172 struct bfd_link_info
*link_info
)
6175 property_table_entry
*prop_table
= NULL
;
6177 bfd_byte
*contents
= NULL
;
6178 Elf_Internal_Rela
*internal_relocs
= NULL
;
6179 bfd_size_type sec_size
;
6183 if (sec
== sec_cache
->sec
)
6187 sec_size
= bfd_get_section_limit (abfd
, sec
);
6189 /* Get the contents. */
6190 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6191 if (contents
== NULL
&& sec_size
!= 0)
6194 /* Get the relocations. */
6195 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6196 link_info
->keep_memory
);
6198 /* Get the entry table. */
6199 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6200 XTENSA_PROP_SEC_NAME
, FALSE
);
6204 /* Fill in the new section cache. */
6205 free_section_cache (sec_cache
);
6206 init_section_cache (sec_cache
);
6208 sec_cache
->sec
= sec
;
6209 sec_cache
->contents
= contents
;
6210 sec_cache
->content_length
= sec_size
;
6211 sec_cache
->relocs
= internal_relocs
;
6212 sec_cache
->reloc_count
= sec
->reloc_count
;
6213 sec_cache
->pte_count
= ptblsize
;
6214 sec_cache
->ptbl
= prop_table
;
6219 release_contents (sec
, contents
);
6220 release_internal_relocs (sec
, internal_relocs
);
6227 /* Extended basic blocks. */
6229 /* An ebb_struct represents an Extended Basic Block. Within this
6230 range, we guarantee that all instructions are decodable, the
6231 property table entries are contiguous, and no property table
6232 specifies a segment that cannot have instructions moved. This
6233 structure contains caches of the contents, property table and
6234 relocations for the specified section for easy use. The range is
6235 specified by ranges of indices for the byte offset, property table
6236 offsets and relocation offsets. These must be consistent. */
6238 typedef struct ebb_struct ebb_t
;
6244 bfd_byte
*contents
; /* Cache of the section contents. */
6245 bfd_size_type content_length
;
6247 property_table_entry
*ptbl
; /* Cache of the section property table. */
6250 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6251 unsigned reloc_count
;
6253 bfd_vma start_offset
; /* Offset in section. */
6254 unsigned start_ptbl_idx
; /* Offset in the property table. */
6255 unsigned start_reloc_idx
; /* Offset in the relocations. */
6258 unsigned end_ptbl_idx
;
6259 unsigned end_reloc_idx
;
6261 bfd_boolean ends_section
; /* Is this the last ebb in a section? */
6263 /* The unreachable property table at the end of this set of blocks;
6264 NULL if the end is not an unreachable block. */
6265 property_table_entry
*ends_unreachable
;
6269 enum ebb_target_enum
6272 EBB_DESIRE_TGT_ALIGN
,
6273 EBB_REQUIRE_TGT_ALIGN
,
6274 EBB_REQUIRE_LOOP_ALIGN
,
6279 /* proposed_action_struct is similar to the text_action_struct except
6280 that is represents a potential transformation, not one that will
6281 occur. We build a list of these for an extended basic block
6282 and use them to compute the actual actions desired. We must be
6283 careful that the entire set of actual actions we perform do not
6284 break any relocations that would fit if the actions were not
6287 typedef struct proposed_action_struct proposed_action
;
6289 struct proposed_action_struct
6291 enum ebb_target_enum align_type
; /* for the target alignment */
6292 bfd_vma alignment_pow
;
6293 text_action_t action
;
6296 bfd_boolean do_action
; /* If false, then we will not perform the action. */
6300 /* The ebb_constraint_struct keeps a set of proposed actions for an
6301 extended basic block. */
6303 typedef struct ebb_constraint_struct ebb_constraint
;
6305 struct ebb_constraint_struct
6308 bfd_boolean start_movable
;
6310 /* Bytes of extra space at the beginning if movable. */
6311 int start_extra_space
;
6313 enum ebb_target_enum start_align
;
6315 bfd_boolean end_movable
;
6317 /* Bytes of extra space at the end if movable. */
6318 int end_extra_space
;
6320 unsigned action_count
;
6321 unsigned action_allocated
;
6323 /* Array of proposed actions. */
6324 proposed_action
*actions
;
6326 /* Action alignments -- one for each proposed action. */
6327 enum ebb_target_enum
*action_aligns
;
6332 init_ebb_constraint (ebb_constraint
*c
)
6334 memset (c
, 0, sizeof (ebb_constraint
));
6339 free_ebb_constraint (ebb_constraint
*c
)
6347 init_ebb (ebb_t
*ebb
,
6350 bfd_size_type content_length
,
6351 property_table_entry
*prop_table
,
6353 Elf_Internal_Rela
*internal_relocs
,
6354 unsigned reloc_count
)
6356 memset (ebb
, 0, sizeof (ebb_t
));
6358 ebb
->contents
= contents
;
6359 ebb
->content_length
= content_length
;
6360 ebb
->ptbl
= prop_table
;
6361 ebb
->pte_count
= ptblsize
;
6362 ebb
->relocs
= internal_relocs
;
6363 ebb
->reloc_count
= reloc_count
;
6364 ebb
->start_offset
= 0;
6365 ebb
->end_offset
= ebb
->content_length
- 1;
6366 ebb
->start_ptbl_idx
= 0;
6367 ebb
->end_ptbl_idx
= ptblsize
;
6368 ebb
->start_reloc_idx
= 0;
6369 ebb
->end_reloc_idx
= reloc_count
;
6373 /* Extend the ebb to all decodable contiguous sections. The algorithm
6374 for building a basic block around an instruction is to push it
6375 forward until we hit the end of a section, an unreachable block or
6376 a block that cannot be transformed. Then we push it backwards
6377 searching for similar conditions. */
6379 static bfd_boolean
extend_ebb_bounds_forward (ebb_t
*);
6380 static bfd_boolean
extend_ebb_bounds_backward (ebb_t
*);
6381 static bfd_size_type insn_block_decodable_len
6382 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6385 extend_ebb_bounds (ebb_t
*ebb
)
6387 if (!extend_ebb_bounds_forward (ebb
))
6389 if (!extend_ebb_bounds_backward (ebb
))
6396 extend_ebb_bounds_forward (ebb_t
*ebb
)
6398 property_table_entry
*the_entry
, *new_entry
;
6400 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6402 /* Stop when (1) we cannot decode an instruction, (2) we are at
6403 the end of the property tables, (3) we hit a non-contiguous property
6404 table entry, (4) we hit a NO_TRANSFORM region. */
6409 bfd_size_type insn_block_len
;
6411 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6413 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6415 entry_end
- ebb
->end_offset
);
6416 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6419 /* xgettext:c-format */
6420 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6421 "possible configuration mismatch"),
6422 ebb
->sec
->owner
, ebb
->sec
,
6423 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6426 ebb
->end_offset
+= insn_block_len
;
6428 if (ebb
->end_offset
== ebb
->sec
->size
)
6429 ebb
->ends_section
= TRUE
;
6431 /* Update the reloc counter. */
6432 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6433 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6436 ebb
->end_reloc_idx
++;
6439 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6442 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6443 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6444 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6445 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6448 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6451 the_entry
= new_entry
;
6452 ebb
->end_ptbl_idx
++;
6455 /* Quick check for an unreachable or end of file just at the end. */
6456 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6458 if (ebb
->end_offset
== ebb
->content_length
)
6459 ebb
->ends_section
= TRUE
;
6463 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6464 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6465 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6466 ebb
->ends_unreachable
= new_entry
;
6469 /* Any other ending requires exact alignment. */
6475 extend_ebb_bounds_backward (ebb_t
*ebb
)
6477 property_table_entry
*the_entry
, *new_entry
;
6479 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6481 /* Stop when (1) we cannot decode the instructions in the current entry.
6482 (2) we are at the beginning of the property tables, (3) we hit a
6483 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6487 bfd_vma block_begin
;
6488 bfd_size_type insn_block_len
;
6490 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6492 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6494 ebb
->start_offset
- block_begin
);
6495 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6498 /* xgettext:c-format */
6499 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6500 "possible configuration mismatch"),
6501 ebb
->sec
->owner
, ebb
->sec
,
6502 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6505 ebb
->start_offset
-= insn_block_len
;
6507 /* Update the reloc counter. */
6508 while (ebb
->start_reloc_idx
> 0
6509 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6510 >= ebb
->start_offset
))
6512 ebb
->start_reloc_idx
--;
6515 if (ebb
->start_ptbl_idx
== 0)
6518 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6519 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6520 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6521 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6523 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6526 the_entry
= new_entry
;
6527 ebb
->start_ptbl_idx
--;
6533 static bfd_size_type
6534 insn_block_decodable_len (bfd_byte
*contents
,
6535 bfd_size_type content_len
,
6536 bfd_vma block_offset
,
6537 bfd_size_type block_len
)
6539 bfd_vma offset
= block_offset
;
6541 while (offset
< block_offset
+ block_len
)
6543 bfd_size_type insn_len
= 0;
6545 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6547 return (offset
- block_offset
);
6550 return (offset
- block_offset
);
6555 ebb_propose_action (ebb_constraint
*c
,
6556 enum ebb_target_enum align_type
,
6557 bfd_vma alignment_pow
,
6558 text_action_t action
,
6561 bfd_boolean do_action
)
6563 proposed_action
*act
;
6565 if (c
->action_allocated
<= c
->action_count
)
6567 unsigned new_allocated
, i
;
6568 proposed_action
*new_actions
;
6570 new_allocated
= (c
->action_count
+ 2) * 2;
6571 new_actions
= (proposed_action
*)
6572 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6574 for (i
= 0; i
< c
->action_count
; i
++)
6575 new_actions
[i
] = c
->actions
[i
];
6578 c
->actions
= new_actions
;
6579 c
->action_allocated
= new_allocated
;
6582 act
= &c
->actions
[c
->action_count
];
6583 act
->align_type
= align_type
;
6584 act
->alignment_pow
= alignment_pow
;
6585 act
->action
= action
;
6586 act
->offset
= offset
;
6587 act
->removed_bytes
= removed_bytes
;
6588 act
->do_action
= do_action
;
6594 /* Access to internal relocations, section contents and symbols. */
6596 /* During relaxation, we need to modify relocations, section contents,
6597 and symbol definitions, and we need to keep the original values from
6598 being reloaded from the input files, i.e., we need to "pin" the
6599 modified values in memory. We also want to continue to observe the
6600 setting of the "keep-memory" flag. The following functions wrap the
6601 standard BFD functions to take care of this for us. */
6603 static Elf_Internal_Rela
*
6604 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6606 Elf_Internal_Rela
*internal_relocs
;
6608 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6611 internal_relocs
= elf_section_data (sec
)->relocs
;
6612 if (internal_relocs
== NULL
)
6613 internal_relocs
= (_bfd_elf_link_read_relocs
6614 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6615 return internal_relocs
;
6620 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6622 elf_section_data (sec
)->relocs
= internal_relocs
;
6627 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6630 && elf_section_data (sec
)->relocs
!= internal_relocs
)
6631 free (internal_relocs
);
6636 retrieve_contents (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6639 bfd_size_type sec_size
;
6641 sec_size
= bfd_get_section_limit (abfd
, sec
);
6642 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6644 if (contents
== NULL
&& sec_size
!= 0)
6646 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6653 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6660 pin_contents (asection
*sec
, bfd_byte
*contents
)
6662 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6667 release_contents (asection
*sec
, bfd_byte
*contents
)
6669 if (contents
&& elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6674 static Elf_Internal_Sym
*
6675 retrieve_local_syms (bfd
*input_bfd
)
6677 Elf_Internal_Shdr
*symtab_hdr
;
6678 Elf_Internal_Sym
*isymbuf
;
6681 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6682 locsymcount
= symtab_hdr
->sh_info
;
6684 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6685 if (isymbuf
== NULL
&& locsymcount
!= 0)
6686 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6689 /* Save the symbols for this input file so they won't be read again. */
6690 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6691 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6697 /* Code for link-time relaxation. */
6699 /* Initialization for relaxation: */
6700 static bfd_boolean
analyze_relocations (struct bfd_link_info
*);
6701 static bfd_boolean find_relaxable_sections
6702 (bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*);
6703 static bfd_boolean collect_source_relocs
6704 (bfd
*, asection
*, struct bfd_link_info
*);
6705 static bfd_boolean is_resolvable_asm_expansion
6706 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6708 static Elf_Internal_Rela
*find_associated_l32r_irel
6709 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6710 static bfd_boolean compute_text_actions
6711 (bfd
*, asection
*, struct bfd_link_info
*);
6712 static bfd_boolean
compute_ebb_proposed_actions (ebb_constraint
*);
6713 static bfd_boolean
compute_ebb_actions (ebb_constraint
*);
6714 typedef struct reloc_range_list_struct reloc_range_list
;
6715 static bfd_boolean check_section_ebb_pcrels_fit
6716 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6717 reloc_range_list
*, const ebb_constraint
*,
6718 const xtensa_opcode
*);
6719 static bfd_boolean
check_section_ebb_reduces (const ebb_constraint
*);
6720 static void text_action_add_proposed
6721 (text_action_list
*, const ebb_constraint
*, asection
*);
6722 static int compute_fill_extra_space (property_table_entry
*);
6725 static bfd_boolean compute_removed_literals
6726 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6727 static Elf_Internal_Rela
*get_irel_at_offset
6728 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6729 static bfd_boolean is_removable_literal
6730 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6731 property_table_entry
*, int);
6732 static bfd_boolean remove_dead_literal
6733 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6734 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6735 static bfd_boolean identify_literal_placement
6736 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6737 value_map_hash_table
*, bfd_boolean
*, Elf_Internal_Rela
*, int,
6738 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6740 static bfd_boolean
relocations_reach (source_reloc
*, int, const r_reloc
*);
6741 static bfd_boolean coalesce_shared_literal
6742 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6743 static bfd_boolean move_shared_literal
6744 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6745 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6748 static bfd_boolean
relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6749 static bfd_boolean
translate_section_fixes (asection
*);
6750 static bfd_boolean
translate_reloc_bfd_fix (reloc_bfd_fix
*);
6751 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6752 static void shrink_dynamic_reloc_sections
6753 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6754 static bfd_boolean move_literal
6755 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6756 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6757 static bfd_boolean relax_property_section
6758 (bfd
*, asection
*, struct bfd_link_info
*);
6761 static bfd_boolean
relax_section_symbols (bfd
*, asection
*);
6765 elf_xtensa_relax_section (bfd
*abfd
,
6767 struct bfd_link_info
*link_info
,
6770 static value_map_hash_table
*values
= NULL
;
6771 static bfd_boolean relocations_analyzed
= FALSE
;
6772 xtensa_relax_info
*relax_info
;
6774 if (!relocations_analyzed
)
6776 /* Do some overall initialization for relaxation. */
6777 values
= value_map_hash_table_init ();
6780 relaxing_section
= TRUE
;
6781 if (!analyze_relocations (link_info
))
6783 relocations_analyzed
= TRUE
;
6787 /* Don't mess with linker-created sections. */
6788 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6791 relax_info
= get_xtensa_relax_info (sec
);
6792 BFD_ASSERT (relax_info
!= NULL
);
6794 switch (relax_info
->visited
)
6797 /* Note: It would be nice to fold this pass into
6798 analyze_relocations, but it is important for this step that the
6799 sections be examined in link order. */
6800 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6807 value_map_hash_table_delete (values
);
6809 if (!relax_section (abfd
, sec
, link_info
))
6815 if (!relax_section_symbols (abfd
, sec
))
6820 relax_info
->visited
++;
6825 /* Initialization for relaxation. */
6827 /* This function is called once at the start of relaxation. It scans
6828 all the input sections and marks the ones that are relaxable (i.e.,
6829 literal sections with L32R relocations against them), and then
6830 collects source_reloc information for all the relocations against
6831 those relaxable sections. During this process, it also detects
6832 longcalls, i.e., calls relaxed by the assembler into indirect
6833 calls, that can be optimized back into direct calls. Within each
6834 extended basic block (ebb) containing an optimized longcall, it
6835 computes a set of "text actions" that can be performed to remove
6836 the L32R associated with the longcall while optionally preserving
6837 branch target alignments. */
6840 analyze_relocations (struct bfd_link_info
*link_info
)
6844 bfd_boolean is_relaxable
= FALSE
;
6846 /* Initialize the per-section relaxation info. */
6847 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6848 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6850 init_xtensa_relax_info (sec
);
6853 /* Mark relaxable sections (and count relocations against each one). */
6854 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6855 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6857 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
6861 /* Bail out if there are no relaxable sections. */
6865 /* Allocate space for source_relocs. */
6866 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6867 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6869 xtensa_relax_info
*relax_info
;
6871 relax_info
= get_xtensa_relax_info (sec
);
6872 if (relax_info
->is_relaxable_literal_section
6873 || relax_info
->is_relaxable_asm_section
)
6875 relax_info
->src_relocs
= (source_reloc
*)
6876 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
6879 relax_info
->src_count
= 0;
6882 /* Collect info on relocations against each relaxable section. */
6883 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6884 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6886 if (!collect_source_relocs (abfd
, sec
, link_info
))
6890 /* Compute the text actions. */
6891 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6892 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6894 if (!compute_text_actions (abfd
, sec
, link_info
))
6902 /* Find all the sections that might be relaxed. The motivation for
6903 this pass is that collect_source_relocs() needs to record _all_ the
6904 relocations that target each relaxable section. That is expensive
6905 and unnecessary unless the target section is actually going to be
6906 relaxed. This pass identifies all such sections by checking if
6907 they have L32Rs pointing to them. In the process, the total number
6908 of relocations targeting each section is also counted so that we
6909 know how much space to allocate for source_relocs against each
6910 relaxable literal section. */
6913 find_relaxable_sections (bfd
*abfd
,
6915 struct bfd_link_info
*link_info
,
6916 bfd_boolean
*is_relaxable_p
)
6918 Elf_Internal_Rela
*internal_relocs
;
6920 bfd_boolean ok
= TRUE
;
6922 xtensa_relax_info
*source_relax_info
;
6923 bfd_boolean is_l32r_reloc
;
6925 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6926 link_info
->keep_memory
);
6927 if (internal_relocs
== NULL
)
6930 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6931 if (contents
== NULL
&& sec
->size
!= 0)
6937 source_relax_info
= get_xtensa_relax_info (sec
);
6938 for (i
= 0; i
< sec
->reloc_count
; i
++)
6940 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
6942 asection
*target_sec
;
6943 xtensa_relax_info
*target_relax_info
;
6945 /* If this section has not already been marked as "relaxable", and
6946 if it contains any ASM_EXPAND relocations (marking expanded
6947 longcalls) that can be optimized into direct calls, then mark
6948 the section as "relaxable". */
6949 if (source_relax_info
6950 && !source_relax_info
->is_relaxable_asm_section
6951 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
6953 bfd_boolean is_reachable
= FALSE
;
6954 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
6955 link_info
, &is_reachable
)
6958 source_relax_info
->is_relaxable_asm_section
= TRUE
;
6959 *is_relaxable_p
= TRUE
;
6963 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
6964 bfd_get_section_limit (abfd
, sec
));
6966 target_sec
= r_reloc_get_section (&r_rel
);
6967 target_relax_info
= get_xtensa_relax_info (target_sec
);
6968 if (!target_relax_info
)
6971 /* Count PC-relative operand relocations against the target section.
6972 Note: The conditions tested here must match the conditions under
6973 which init_source_reloc is called in collect_source_relocs(). */
6974 is_l32r_reloc
= FALSE
;
6975 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
6977 xtensa_opcode opcode
=
6978 get_relocation_opcode (abfd
, sec
, contents
, irel
);
6979 if (opcode
!= XTENSA_UNDEFINED
)
6981 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
6982 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
6984 target_relax_info
->src_count
++;
6988 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
6990 /* Mark the target section as relaxable. */
6991 target_relax_info
->is_relaxable_literal_section
= TRUE
;
6992 *is_relaxable_p
= TRUE
;
6997 release_contents (sec
, contents
);
6998 release_internal_relocs (sec
, internal_relocs
);
7003 /* Record _all_ the relocations that point to relaxable sections, and
7004 get rid of ASM_EXPAND relocs by either converting them to
7005 ASM_SIMPLIFY or by removing them. */
7008 collect_source_relocs (bfd
*abfd
,
7010 struct bfd_link_info
*link_info
)
7012 Elf_Internal_Rela
*internal_relocs
;
7014 bfd_boolean ok
= TRUE
;
7016 bfd_size_type sec_size
;
7018 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7019 link_info
->keep_memory
);
7020 if (internal_relocs
== NULL
)
7023 sec_size
= bfd_get_section_limit (abfd
, sec
);
7024 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7025 if (contents
== NULL
&& sec_size
!= 0)
7031 /* Record relocations against relaxable literal sections. */
7032 for (i
= 0; i
< sec
->reloc_count
; i
++)
7034 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7036 asection
*target_sec
;
7037 xtensa_relax_info
*target_relax_info
;
7039 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7041 target_sec
= r_reloc_get_section (&r_rel
);
7042 target_relax_info
= get_xtensa_relax_info (target_sec
);
7044 if (target_relax_info
7045 && (target_relax_info
->is_relaxable_literal_section
7046 || target_relax_info
->is_relaxable_asm_section
))
7048 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7050 bfd_boolean is_abs_literal
= FALSE
;
7052 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7054 /* None of the current alternate relocs are PC-relative,
7055 and only PC-relative relocs matter here. However, we
7056 still need to record the opcode for literal
7058 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7059 if (opcode
== get_l32r_opcode ())
7061 is_abs_literal
= TRUE
;
7065 opcode
= XTENSA_UNDEFINED
;
7067 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7069 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7070 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7073 if (opcode
!= XTENSA_UNDEFINED
)
7075 int src_next
= target_relax_info
->src_next
++;
7076 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7078 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7084 /* Now get rid of ASM_EXPAND relocations. At this point, the
7085 src_relocs array for the target literal section may still be
7086 incomplete, but it must at least contain the entries for the L32R
7087 relocations associated with ASM_EXPANDs because they were just
7088 added in the preceding loop over the relocations. */
7090 for (i
= 0; i
< sec
->reloc_count
; i
++)
7092 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7093 bfd_boolean is_reachable
;
7095 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7101 Elf_Internal_Rela
*l32r_irel
;
7103 asection
*target_sec
;
7104 xtensa_relax_info
*target_relax_info
;
7106 /* Mark the source_reloc for the L32R so that it will be
7107 removed in compute_removed_literals(), along with the
7108 associated literal. */
7109 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7110 irel
, internal_relocs
);
7111 if (l32r_irel
== NULL
)
7114 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7116 target_sec
= r_reloc_get_section (&r_rel
);
7117 target_relax_info
= get_xtensa_relax_info (target_sec
);
7119 if (target_relax_info
7120 && (target_relax_info
->is_relaxable_literal_section
7121 || target_relax_info
->is_relaxable_asm_section
))
7123 source_reloc
*s_reloc
;
7125 /* Search the source_relocs for the entry corresponding to
7126 the l32r_irel. Note: The src_relocs array is not yet
7127 sorted, but it wouldn't matter anyway because we're
7128 searching by source offset instead of target offset. */
7129 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7130 target_relax_info
->src_next
,
7132 BFD_ASSERT (s_reloc
);
7133 s_reloc
->is_null
= TRUE
;
7136 /* Convert this reloc to ASM_SIMPLIFY. */
7137 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7138 R_XTENSA_ASM_SIMPLIFY
);
7139 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7141 pin_internal_relocs (sec
, internal_relocs
);
7145 /* It is resolvable but doesn't reach. We resolve now
7146 by eliminating the relocation -- the call will remain
7147 expanded into L32R/CALLX. */
7148 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7149 pin_internal_relocs (sec
, internal_relocs
);
7154 release_contents (sec
, contents
);
7155 release_internal_relocs (sec
, internal_relocs
);
7160 /* Return TRUE if the asm expansion can be resolved. Generally it can
7161 be resolved on a final link or when a partial link locates it in the
7162 same section as the target. Set "is_reachable" flag if the target of
7163 the call is within the range of a direct call, given the current VMA
7164 for this section and the target section. */
7167 is_resolvable_asm_expansion (bfd
*abfd
,
7170 Elf_Internal_Rela
*irel
,
7171 struct bfd_link_info
*link_info
,
7172 bfd_boolean
*is_reachable_p
)
7174 asection
*target_sec
;
7175 bfd_vma target_offset
;
7177 xtensa_opcode opcode
, direct_call_opcode
;
7178 bfd_vma self_address
;
7179 bfd_vma dest_address
;
7180 bfd_boolean uses_l32r
;
7181 bfd_size_type sec_size
;
7183 *is_reachable_p
= FALSE
;
7185 if (contents
== NULL
)
7188 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7191 sec_size
= bfd_get_section_limit (abfd
, sec
);
7192 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7193 sec_size
- irel
->r_offset
, &uses_l32r
);
7194 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7198 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7199 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7202 /* Check and see that the target resolves. */
7203 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7204 if (!r_reloc_is_defined (&r_rel
))
7207 target_sec
= r_reloc_get_section (&r_rel
);
7208 target_offset
= r_rel
.target_offset
;
7210 /* If the target is in a shared library, then it doesn't reach. This
7211 isn't supposed to come up because the compiler should never generate
7212 non-PIC calls on systems that use shared libraries, but the linker
7213 shouldn't crash regardless. */
7214 if (!target_sec
->output_section
)
7217 /* For relocatable sections, we can only simplify when the output
7218 section of the target is the same as the output section of the
7220 if (bfd_link_relocatable (link_info
)
7221 && (target_sec
->output_section
!= sec
->output_section
7222 || is_reloc_sym_weak (abfd
, irel
)))
7225 if (target_sec
->output_section
!= sec
->output_section
)
7227 /* If the two sections are sufficiently far away that relaxation
7228 might take the call out of range, we can't simplify. For
7229 example, a positive displacement call into another memory
7230 could get moved to a lower address due to literal removal,
7231 but the destination won't move, and so the displacment might
7234 If the displacement is negative, assume the destination could
7235 move as far back as the start of the output section. The
7236 self_address will be at least as far into the output section
7237 as it is prior to relaxation.
7239 If the displacement is postive, assume the destination will be in
7240 it's pre-relaxed location (because relaxation only makes sections
7241 smaller). The self_address could go all the way to the beginning
7242 of the output section. */
7244 dest_address
= target_sec
->output_section
->vma
;
7245 self_address
= sec
->output_section
->vma
;
7247 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7248 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7250 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7251 /* Call targets should be four-byte aligned. */
7252 dest_address
= (dest_address
+ 3) & ~3;
7257 self_address
= (sec
->output_section
->vma
7258 + sec
->output_offset
+ irel
->r_offset
+ 3);
7259 dest_address
= (target_sec
->output_section
->vma
7260 + target_sec
->output_offset
+ target_offset
);
7263 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7264 self_address
, dest_address
);
7266 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7267 (dest_address
>> CALL_SEGMENT_BITS
))
7274 static Elf_Internal_Rela
*
7275 find_associated_l32r_irel (bfd
*abfd
,
7278 Elf_Internal_Rela
*other_irel
,
7279 Elf_Internal_Rela
*internal_relocs
)
7283 for (i
= 0; i
< sec
->reloc_count
; i
++)
7285 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7287 if (irel
== other_irel
)
7289 if (irel
->r_offset
!= other_irel
->r_offset
)
7291 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7299 static xtensa_opcode
*
7300 build_reloc_opcodes (bfd
*abfd
,
7303 Elf_Internal_Rela
*internal_relocs
)
7306 xtensa_opcode
*reloc_opcodes
=
7307 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7308 for (i
= 0; i
< sec
->reloc_count
; i
++)
7310 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7311 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7313 return reloc_opcodes
;
7316 struct reloc_range_struct
7319 bfd_boolean add
; /* TRUE if start of a range, FALSE otherwise. */
7320 /* Original irel index in the array of relocations for a section. */
7321 unsigned irel_index
;
7323 typedef struct reloc_range_struct reloc_range
;
7325 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7326 struct reloc_range_list_entry_struct
7328 reloc_range_list_entry
*next
;
7329 reloc_range_list_entry
*prev
;
7330 Elf_Internal_Rela
*irel
;
7331 xtensa_opcode opcode
;
7335 struct reloc_range_list_struct
7337 /* The rest of the structure is only meaningful when ok is TRUE. */
7340 unsigned n_range
; /* Number of range markers. */
7341 reloc_range
*range
; /* Sorted range markers. */
7343 unsigned first
; /* Index of a first range element in the list. */
7344 unsigned last
; /* One past index of a last range element in the list. */
7346 unsigned n_list
; /* Number of list elements. */
7347 reloc_range_list_entry
*reloc
; /* */
7348 reloc_range_list_entry list_root
;
7352 reloc_range_compare (const void *a
, const void *b
)
7354 const reloc_range
*ra
= a
;
7355 const reloc_range
*rb
= b
;
7357 if (ra
->addr
!= rb
->addr
)
7358 return ra
->addr
< rb
->addr
? -1 : 1;
7359 if (ra
->add
!= rb
->add
)
7360 return ra
->add
? -1 : 1;
7365 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7367 Elf_Internal_Rela
*internal_relocs
,
7368 xtensa_opcode
*reloc_opcodes
,
7369 reloc_range_list
*list
)
7374 reloc_range
*ranges
= NULL
;
7375 reloc_range_list_entry
*reloc
=
7376 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7378 memset (list
, 0, sizeof (*list
));
7381 for (i
= 0; i
< sec
->reloc_count
; i
++)
7383 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7384 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7385 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7388 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7389 || r_type
== R_XTENSA_32_PCREL
7390 || !howto
->pc_relative
)
7393 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7394 bfd_get_section_limit (abfd
, sec
));
7396 if (r_reloc_get_section (&r_rel
) != sec
)
7401 max_n
= (max_n
+ 2) * 2;
7402 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7405 ranges
[n
].addr
= irel
->r_offset
;
7406 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7408 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7409 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7411 ranges
[n
].irel_index
= i
;
7412 ranges
[n
+ 1].irel_index
= i
;
7416 reloc
[i
].irel
= irel
;
7418 /* Every relocation won't possibly be checked in the optimized version of
7419 check_section_ebb_pcrels_fit, so this needs to be done here. */
7420 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7422 /* None of the current alternate relocs are PC-relative,
7423 and only PC-relative relocs matter here. */
7427 xtensa_opcode opcode
;
7431 opcode
= reloc_opcodes
[i
];
7433 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7435 if (opcode
== XTENSA_UNDEFINED
)
7441 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7442 if (opnum
== XTENSA_UNDEFINED
)
7448 /* Record relocation opcode and opnum as we've calculated them
7449 anyway and they won't change. */
7450 reloc
[i
].opcode
= opcode
;
7451 reloc
[i
].opnum
= opnum
;
7457 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7458 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7461 list
->range
= ranges
;
7462 list
->reloc
= reloc
;
7463 list
->list_root
.prev
= &list
->list_root
;
7464 list
->list_root
.next
= &list
->list_root
;
7473 static void reloc_range_list_append (reloc_range_list
*list
,
7474 unsigned irel_index
)
7476 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7478 entry
->prev
= list
->list_root
.prev
;
7479 entry
->next
= &list
->list_root
;
7480 entry
->prev
->next
= entry
;
7481 entry
->next
->prev
= entry
;
7485 static void reloc_range_list_remove (reloc_range_list
*list
,
7486 unsigned irel_index
)
7488 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7490 entry
->next
->prev
= entry
->prev
;
7491 entry
->prev
->next
= entry
->next
;
7495 /* Update relocation list object so that it lists all relocations that cross
7496 [first; last] range. Range bounds should not decrease with successive
7498 static void reloc_range_list_update_range (reloc_range_list
*list
,
7499 bfd_vma first
, bfd_vma last
)
7501 /* This should not happen: EBBs are iterated from lower addresses to higher.
7502 But even if that happens there's no need to break: just flush current list
7503 and start from scratch. */
7504 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7505 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7510 list
->list_root
.next
= &list
->list_root
;
7511 list
->list_root
.prev
= &list
->list_root
;
7512 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7515 for (; list
->last
< list
->n_range
&&
7516 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7517 if (list
->range
[list
->last
].add
)
7518 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7520 for (; list
->first
< list
->n_range
&&
7521 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7522 if (!list
->range
[list
->first
].add
)
7523 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7526 static void free_reloc_range_list (reloc_range_list
*list
)
7532 /* The compute_text_actions function will build a list of potential
7533 transformation actions for code in the extended basic block of each
7534 longcall that is optimized to a direct call. From this list we
7535 generate a set of actions to actually perform that optimizes for
7536 space and, if not using size_opt, maintains branch target
7539 These actions to be performed are placed on a per-section list.
7540 The actual changes are performed by relax_section() in the second
7544 compute_text_actions (bfd
*abfd
,
7546 struct bfd_link_info
*link_info
)
7548 xtensa_opcode
*reloc_opcodes
= NULL
;
7549 xtensa_relax_info
*relax_info
;
7551 Elf_Internal_Rela
*internal_relocs
;
7552 bfd_boolean ok
= TRUE
;
7554 property_table_entry
*prop_table
= 0;
7556 bfd_size_type sec_size
;
7557 reloc_range_list relevant_relocs
;
7559 relax_info
= get_xtensa_relax_info (sec
);
7560 BFD_ASSERT (relax_info
);
7561 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7563 /* Do nothing if the section contains no optimized longcalls. */
7564 if (!relax_info
->is_relaxable_asm_section
)
7567 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7568 link_info
->keep_memory
);
7570 if (internal_relocs
)
7571 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7572 internal_reloc_compare
);
7574 sec_size
= bfd_get_section_limit (abfd
, sec
);
7575 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7576 if (contents
== NULL
&& sec_size
!= 0)
7582 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7583 XTENSA_PROP_SEC_NAME
, FALSE
);
7590 /* Precompute the opcode for each relocation. */
7591 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7593 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7596 for (i
= 0; i
< sec
->reloc_count
; i
++)
7598 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7600 property_table_entry
*the_entry
;
7603 ebb_constraint ebb_table
;
7604 bfd_size_type simplify_size
;
7606 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7608 r_offset
= irel
->r_offset
;
7610 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7611 if (simplify_size
== 0)
7614 /* xgettext:c-format */
7615 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7616 "XTENSA_ASM_SIMPLIFY relocation; "
7617 "possible configuration mismatch"),
7618 sec
->owner
, sec
, (uint64_t) r_offset
);
7622 /* If the instruction table is not around, then don't do this
7624 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7625 sec
->vma
+ irel
->r_offset
);
7626 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7628 text_action_add (&relax_info
->action_list
,
7629 ta_convert_longcall
, sec
, r_offset
,
7634 /* If the next longcall happens to be at the same address as an
7635 unreachable section of size 0, then skip forward. */
7636 ptbl_idx
= the_entry
- prop_table
;
7637 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7638 && the_entry
->size
== 0
7639 && ptbl_idx
+ 1 < ptblsize
7640 && (prop_table
[ptbl_idx
+ 1].address
7641 == prop_table
[ptbl_idx
].address
))
7647 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7648 /* NO_REORDER is OK */
7651 init_ebb_constraint (&ebb_table
);
7652 ebb
= &ebb_table
.ebb
;
7653 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7654 internal_relocs
, sec
->reloc_count
);
7655 ebb
->start_offset
= r_offset
+ simplify_size
;
7656 ebb
->end_offset
= r_offset
+ simplify_size
;
7657 ebb
->start_ptbl_idx
= ptbl_idx
;
7658 ebb
->end_ptbl_idx
= ptbl_idx
;
7659 ebb
->start_reloc_idx
= i
;
7660 ebb
->end_reloc_idx
= i
;
7662 if (!extend_ebb_bounds (ebb
)
7663 || !compute_ebb_proposed_actions (&ebb_table
)
7664 || !compute_ebb_actions (&ebb_table
)
7665 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7668 &ebb_table
, reloc_opcodes
)
7669 || !check_section_ebb_reduces (&ebb_table
))
7671 /* If anything goes wrong or we get unlucky and something does
7672 not fit, with our plan because of expansion between
7673 critical branches, just convert to a NOP. */
7675 text_action_add (&relax_info
->action_list
,
7676 ta_convert_longcall
, sec
, r_offset
, 0);
7677 i
= ebb_table
.ebb
.end_reloc_idx
;
7678 free_ebb_constraint (&ebb_table
);
7682 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7684 /* Update the index so we do not go looking at the relocations
7685 we have already processed. */
7686 i
= ebb_table
.ebb
.end_reloc_idx
;
7687 free_ebb_constraint (&ebb_table
);
7690 free_reloc_range_list (&relevant_relocs
);
7693 if (action_list_count (&relax_info
->action_list
))
7694 print_action_list (stderr
, &relax_info
->action_list
);
7698 release_contents (sec
, contents
);
7699 release_internal_relocs (sec
, internal_relocs
);
7703 free (reloc_opcodes
);
7709 /* Do not widen an instruction if it is preceeded by a
7710 loop opcode. It might cause misalignment. */
7713 prev_instr_is_a_loop (bfd_byte
*contents
,
7714 bfd_size_type content_length
,
7715 bfd_size_type offset
)
7717 xtensa_opcode prev_opcode
;
7721 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7722 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7726 /* Find all of the possible actions for an extended basic block. */
7729 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7731 const ebb_t
*ebb
= &ebb_table
->ebb
;
7732 unsigned rel_idx
= ebb
->start_reloc_idx
;
7733 property_table_entry
*entry
, *start_entry
, *end_entry
;
7735 xtensa_isa isa
= xtensa_default_isa
;
7737 static xtensa_insnbuf insnbuf
= NULL
;
7738 static xtensa_insnbuf slotbuf
= NULL
;
7740 if (insnbuf
== NULL
)
7742 insnbuf
= xtensa_insnbuf_alloc (isa
);
7743 slotbuf
= xtensa_insnbuf_alloc (isa
);
7746 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7747 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7749 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7751 bfd_vma start_offset
, end_offset
;
7752 bfd_size_type insn_len
;
7754 start_offset
= entry
->address
- ebb
->sec
->vma
;
7755 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7757 if (entry
== start_entry
)
7758 start_offset
= ebb
->start_offset
;
7759 if (entry
== end_entry
)
7760 end_offset
= ebb
->end_offset
;
7761 offset
= start_offset
;
7763 if (offset
== entry
->address
- ebb
->sec
->vma
7764 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7766 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7767 BFD_ASSERT (offset
!= end_offset
);
7768 if (offset
== end_offset
)
7771 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7776 if (check_branch_target_aligned_address (offset
, insn_len
))
7777 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7779 ebb_propose_action (ebb_table
, align_type
, 0,
7780 ta_none
, offset
, 0, TRUE
);
7783 while (offset
!= end_offset
)
7785 Elf_Internal_Rela
*irel
;
7786 xtensa_opcode opcode
;
7788 while (rel_idx
< ebb
->end_reloc_idx
7789 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7790 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7791 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
7792 != R_XTENSA_ASM_SIMPLIFY
))))
7795 /* Check for longcall. */
7796 irel
= &ebb
->relocs
[rel_idx
];
7797 if (irel
->r_offset
== offset
7798 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
7800 bfd_size_type simplify_size
;
7802 simplify_size
= get_asm_simplify_size (ebb
->contents
,
7803 ebb
->content_length
,
7805 if (simplify_size
== 0)
7808 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7809 ta_convert_longcall
, offset
, 0, TRUE
);
7811 offset
+= simplify_size
;
7815 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
7817 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
7818 ebb
->content_length
- offset
);
7819 fmt
= xtensa_format_decode (isa
, insnbuf
);
7820 if (fmt
== XTENSA_UNDEFINED
)
7822 insn_len
= xtensa_format_length (isa
, fmt
);
7823 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
7826 if (xtensa_format_num_slots (isa
, fmt
) != 1)
7832 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
7833 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
7834 if (opcode
== XTENSA_UNDEFINED
)
7837 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
7838 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
7839 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
7841 /* Add an instruction narrow action. */
7842 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7843 ta_narrow_insn
, offset
, 0, FALSE
);
7845 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
7846 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
7847 && ! prev_instr_is_a_loop (ebb
->contents
,
7848 ebb
->content_length
, offset
))
7850 /* Add an instruction widen action. */
7851 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7852 ta_widen_insn
, offset
, 0, FALSE
);
7854 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
7856 /* Check for branch targets. */
7857 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
7858 ta_none
, offset
, 0, TRUE
);
7865 if (ebb
->ends_unreachable
)
7867 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7868 ta_fill
, ebb
->end_offset
, 0, TRUE
);
7875 /* xgettext:c-format */
7876 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
7877 "possible configuration mismatch"),
7878 ebb
->sec
->owner
, ebb
->sec
, (uint64_t) offset
);
7883 /* After all of the information has collected about the
7884 transformations possible in an EBB, compute the appropriate actions
7885 here in compute_ebb_actions. We still must check later to make
7886 sure that the actions do not break any relocations. The algorithm
7887 used here is pretty greedy. Basically, it removes as many no-ops
7888 as possible so that the end of the EBB has the same alignment
7889 characteristics as the original. First, it uses narrowing, then
7890 fill space at the end of the EBB, and finally widenings. If that
7891 does not work, it tries again with one fewer no-op removed. The
7892 optimization will only be performed if all of the branch targets
7893 that were aligned before transformation are also aligned after the
7896 When the size_opt flag is set, ignore the branch target alignments,
7897 narrow all wide instructions, and remove all no-ops unless the end
7898 of the EBB prevents it. */
7901 compute_ebb_actions (ebb_constraint
*ebb_table
)
7905 int removed_bytes
= 0;
7906 ebb_t
*ebb
= &ebb_table
->ebb
;
7907 unsigned seg_idx_start
= 0;
7908 unsigned seg_idx_end
= 0;
7910 /* We perform this like the assembler relaxation algorithm: Start by
7911 assuming all instructions are narrow and all no-ops removed; then
7914 /* For each segment of this that has a solid constraint, check to
7915 see if there are any combinations that will keep the constraint.
7917 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
7919 bfd_boolean requires_text_end_align
= FALSE
;
7920 unsigned longcall_count
= 0;
7921 unsigned longcall_convert_count
= 0;
7922 unsigned narrowable_count
= 0;
7923 unsigned narrowable_convert_count
= 0;
7924 unsigned widenable_count
= 0;
7925 unsigned widenable_convert_count
= 0;
7927 proposed_action
*action
= NULL
;
7928 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
7930 seg_idx_start
= seg_idx_end
;
7932 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
7934 action
= &ebb_table
->actions
[i
];
7935 if (action
->action
== ta_convert_longcall
)
7937 if (action
->action
== ta_narrow_insn
)
7939 if (action
->action
== ta_widen_insn
)
7941 if (action
->action
== ta_fill
)
7943 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
7945 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
7946 && !elf32xtensa_size_opt
)
7951 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
7952 requires_text_end_align
= TRUE
;
7954 if (elf32xtensa_size_opt
&& !requires_text_end_align
7955 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
7956 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
7958 longcall_convert_count
= longcall_count
;
7959 narrowable_convert_count
= narrowable_count
;
7960 widenable_convert_count
= 0;
7964 /* There is a constraint. Convert the max number of longcalls. */
7965 narrowable_convert_count
= 0;
7966 longcall_convert_count
= 0;
7967 widenable_convert_count
= 0;
7969 for (j
= 0; j
< longcall_count
; j
++)
7971 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
7972 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
7973 unsigned desire_widen
= removed
;
7974 if (desire_narrow
<= narrowable_count
)
7976 narrowable_convert_count
= desire_narrow
;
7977 narrowable_convert_count
+=
7978 (align
* ((narrowable_count
- narrowable_convert_count
)
7980 longcall_convert_count
= (longcall_count
- j
);
7981 widenable_convert_count
= 0;
7984 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
7986 narrowable_convert_count
= 0;
7987 longcall_convert_count
= longcall_count
- j
;
7988 widenable_convert_count
= desire_widen
;
7994 /* Now the number of conversions are saved. Do them. */
7995 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
7997 action
= &ebb_table
->actions
[i
];
7998 switch (action
->action
)
8000 case ta_convert_longcall
:
8001 if (longcall_convert_count
!= 0)
8003 action
->action
= ta_remove_longcall
;
8004 action
->do_action
= TRUE
;
8005 action
->removed_bytes
+= 3;
8006 longcall_convert_count
--;
8009 case ta_narrow_insn
:
8010 if (narrowable_convert_count
!= 0)
8012 action
->do_action
= TRUE
;
8013 action
->removed_bytes
+= 1;
8014 narrowable_convert_count
--;
8018 if (widenable_convert_count
!= 0)
8020 action
->do_action
= TRUE
;
8021 action
->removed_bytes
-= 1;
8022 widenable_convert_count
--;
8031 /* Now we move on to some local opts. Try to remove each of the
8032 remaining longcalls. */
8034 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8037 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8039 int old_removed_bytes
= removed_bytes
;
8040 proposed_action
*action
= &ebb_table
->actions
[i
];
8042 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8044 bfd_boolean bad_alignment
= FALSE
;
8046 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8048 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8049 bfd_vma offset
= new_action
->offset
;
8050 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8052 if (!check_branch_target_aligned
8053 (ebb_table
->ebb
.contents
,
8054 ebb_table
->ebb
.content_length
,
8055 offset
, offset
- removed_bytes
))
8057 bad_alignment
= TRUE
;
8061 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8063 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8064 ebb_table
->ebb
.content_length
,
8066 offset
- removed_bytes
))
8068 bad_alignment
= TRUE
;
8072 if (new_action
->action
== ta_narrow_insn
8073 && !new_action
->do_action
8074 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8076 /* Narrow an instruction and we are done. */
8077 new_action
->do_action
= TRUE
;
8078 new_action
->removed_bytes
+= 1;
8079 bad_alignment
= FALSE
;
8082 if (new_action
->action
== ta_widen_insn
8083 && new_action
->do_action
8084 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8086 /* Narrow an instruction and we are done. */
8087 new_action
->do_action
= FALSE
;
8088 new_action
->removed_bytes
+= 1;
8089 bad_alignment
= FALSE
;
8092 if (new_action
->do_action
)
8093 removed_bytes
+= new_action
->removed_bytes
;
8097 action
->removed_bytes
+= 3;
8098 action
->action
= ta_remove_longcall
;
8099 action
->do_action
= TRUE
;
8102 removed_bytes
= old_removed_bytes
;
8103 if (action
->do_action
)
8104 removed_bytes
+= action
->removed_bytes
;
8109 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8111 proposed_action
*action
= &ebb_table
->actions
[i
];
8112 if (action
->do_action
)
8113 removed_bytes
+= action
->removed_bytes
;
8116 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8117 && ebb
->ends_unreachable
)
8119 proposed_action
*action
;
8123 BFD_ASSERT (ebb_table
->action_count
!= 0);
8124 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8125 BFD_ASSERT (action
->action
== ta_fill
);
8126 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8128 extra_space
= compute_fill_extra_space (ebb
->ends_unreachable
);
8129 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8130 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8132 action
->removed_bytes
= extra_space
- br
;
8138 /* The xlate_map is a sorted array of address mappings designed to
8139 answer the offset_with_removed_text() query with a binary search instead
8140 of a linear search through the section's action_list. */
8142 typedef struct xlate_map_entry xlate_map_entry_t
;
8143 typedef struct xlate_map xlate_map_t
;
8145 struct xlate_map_entry
8147 unsigned orig_address
;
8148 unsigned new_address
;
8154 unsigned entry_count
;
8155 xlate_map_entry_t
*entry
;
8160 xlate_compare (const void *a_v
, const void *b_v
)
8162 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8163 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8164 if (a
->orig_address
< b
->orig_address
)
8166 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8173 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8174 text_action_list
*action_list
,
8178 xlate_map_entry_t
*e
;
8181 return offset_with_removed_text (action_list
, offset
);
8183 if (map
->entry_count
== 0)
8186 r
= bsearch (&offset
, map
->entry
, map
->entry_count
,
8187 sizeof (xlate_map_entry_t
), &xlate_compare
);
8188 e
= (xlate_map_entry_t
*) r
;
8190 BFD_ASSERT (e
!= NULL
);
8193 return e
->new_address
- e
->orig_address
+ offset
;
8196 typedef struct xlate_map_context_struct xlate_map_context
;
8197 struct xlate_map_context_struct
8200 xlate_map_entry_t
*current_entry
;
8205 xlate_map_fn (splay_tree_node node
, void *p
)
8207 text_action
*r
= (text_action
*)node
->value
;
8208 xlate_map_context
*ctx
= p
;
8209 unsigned orig_size
= 0;
8214 case ta_remove_insn
:
8215 case ta_convert_longcall
:
8216 case ta_remove_literal
:
8217 case ta_add_literal
:
8219 case ta_remove_longcall
:
8222 case ta_narrow_insn
:
8231 ctx
->current_entry
->size
=
8232 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8233 if (ctx
->current_entry
->size
!= 0)
8235 ctx
->current_entry
++;
8236 ctx
->map
->entry_count
++;
8238 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8239 ctx
->removed
+= r
->removed_bytes
;
8240 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8241 ctx
->current_entry
->size
= 0;
8245 /* Build a binary searchable offset translation map from a section's
8248 static xlate_map_t
*
8249 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8251 text_action_list
*action_list
= &relax_info
->action_list
;
8252 unsigned num_actions
= 0;
8253 xlate_map_context ctx
;
8255 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8257 if (ctx
.map
== NULL
)
8260 num_actions
= action_list_count (action_list
);
8261 ctx
.map
->entry
= (xlate_map_entry_t
*)
8262 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8263 if (ctx
.map
->entry
== NULL
)
8268 ctx
.map
->entry_count
= 0;
8271 ctx
.current_entry
= &ctx
.map
->entry
[0];
8273 ctx
.current_entry
->orig_address
= 0;
8274 ctx
.current_entry
->new_address
= 0;
8275 ctx
.current_entry
->size
= 0;
8277 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8279 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8280 - ctx
.current_entry
->orig_address
);
8281 if (ctx
.current_entry
->size
!= 0)
8282 ctx
.map
->entry_count
++;
8288 /* Free an offset translation map. */
8291 free_xlate_map (xlate_map_t
*map
)
8293 if (map
&& map
->entry
)
8300 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8301 relocations in a section will fit if a proposed set of actions
8305 check_section_ebb_pcrels_fit (bfd
*abfd
,
8308 Elf_Internal_Rela
*internal_relocs
,
8309 reloc_range_list
*relevant_relocs
,
8310 const ebb_constraint
*constraint
,
8311 const xtensa_opcode
*reloc_opcodes
)
8314 unsigned n
= sec
->reloc_count
;
8315 Elf_Internal_Rela
*irel
;
8316 xlate_map_t
*xmap
= NULL
;
8317 bfd_boolean ok
= TRUE
;
8318 xtensa_relax_info
*relax_info
;
8319 reloc_range_list_entry
*entry
= NULL
;
8321 relax_info
= get_xtensa_relax_info (sec
);
8323 if (relax_info
&& sec
->reloc_count
> 100)
8325 xmap
= build_xlate_map (sec
, relax_info
);
8326 /* NULL indicates out of memory, but the slow version
8327 can still be used. */
8330 if (relevant_relocs
&& constraint
->action_count
)
8332 if (!relevant_relocs
->ok
)
8339 bfd_vma min_offset
, max_offset
;
8340 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8342 for (i
= 1; i
< constraint
->action_count
; ++i
)
8344 proposed_action
*action
= &constraint
->actions
[i
];
8345 bfd_vma offset
= action
->offset
;
8347 if (offset
< min_offset
)
8348 min_offset
= offset
;
8349 if (offset
> max_offset
)
8350 max_offset
= offset
;
8352 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8354 n
= relevant_relocs
->n_list
;
8355 entry
= &relevant_relocs
->list_root
;
8360 relevant_relocs
= NULL
;
8363 for (i
= 0; i
< n
; i
++)
8366 bfd_vma orig_self_offset
, orig_target_offset
;
8367 bfd_vma self_offset
, target_offset
;
8369 reloc_howto_type
*howto
;
8370 int self_removed_bytes
, target_removed_bytes
;
8372 if (relevant_relocs
)
8374 entry
= entry
->next
;
8379 irel
= internal_relocs
+ i
;
8381 r_type
= ELF32_R_TYPE (irel
->r_info
);
8383 howto
= &elf_howto_table
[r_type
];
8384 /* We maintain the required invariant: PC-relative relocations
8385 that fit before linking must fit after linking. Thus we only
8386 need to deal with relocations to the same section that are
8388 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8389 || r_type
== R_XTENSA_32_PCREL
8390 || !howto
->pc_relative
)
8393 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8394 bfd_get_section_limit (abfd
, sec
));
8396 if (r_reloc_get_section (&r_rel
) != sec
)
8399 orig_self_offset
= irel
->r_offset
;
8400 orig_target_offset
= r_rel
.target_offset
;
8402 self_offset
= orig_self_offset
;
8403 target_offset
= orig_target_offset
;
8408 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8411 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8412 orig_target_offset
);
8415 self_removed_bytes
= 0;
8416 target_removed_bytes
= 0;
8418 for (j
= 0; j
< constraint
->action_count
; ++j
)
8420 proposed_action
*action
= &constraint
->actions
[j
];
8421 bfd_vma offset
= action
->offset
;
8422 int removed_bytes
= action
->removed_bytes
;
8423 if (offset
< orig_self_offset
8424 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8425 && action
->removed_bytes
< 0))
8426 self_removed_bytes
+= removed_bytes
;
8427 if (offset
< orig_target_offset
8428 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8429 && action
->removed_bytes
< 0))
8430 target_removed_bytes
+= removed_bytes
;
8432 self_offset
-= self_removed_bytes
;
8433 target_offset
-= target_removed_bytes
;
8435 /* Try to encode it. Get the operand and check. */
8436 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8438 /* None of the current alternate relocs are PC-relative,
8439 and only PC-relative relocs matter here. */
8443 xtensa_opcode opcode
;
8446 if (relevant_relocs
)
8448 opcode
= entry
->opcode
;
8449 opnum
= entry
->opnum
;
8454 opcode
= reloc_opcodes
[relevant_relocs
?
8455 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8457 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8458 if (opcode
== XTENSA_UNDEFINED
)
8464 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8465 if (opnum
== XTENSA_UNDEFINED
)
8472 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8481 free_xlate_map (xmap
);
8488 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8493 for (i
= 0; i
< constraint
->action_count
; i
++)
8495 const proposed_action
*action
= &constraint
->actions
[i
];
8496 if (action
->do_action
)
8497 removed
+= action
->removed_bytes
;
8507 text_action_add_proposed (text_action_list
*l
,
8508 const ebb_constraint
*ebb_table
,
8513 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8515 proposed_action
*action
= &ebb_table
->actions
[i
];
8517 if (!action
->do_action
)
8519 switch (action
->action
)
8521 case ta_remove_insn
:
8522 case ta_remove_longcall
:
8523 case ta_convert_longcall
:
8524 case ta_narrow_insn
:
8527 case ta_remove_literal
:
8528 text_action_add (l
, action
->action
, sec
, action
->offset
,
8529 action
->removed_bytes
);
8542 compute_fill_extra_space (property_table_entry
*entry
)
8544 int fill_extra_space
;
8549 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8552 fill_extra_space
= entry
->size
;
8553 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8555 /* Fill bytes for alignment:
8556 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8557 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8558 int nsm
= (1 << pow
) - 1;
8559 bfd_vma addr
= entry
->address
+ entry
->size
;
8560 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8561 fill_extra_space
+= align_fill
;
8563 return fill_extra_space
;
8567 /* First relaxation pass. */
8569 /* If the section contains relaxable literals, check each literal to
8570 see if it has the same value as another literal that has already
8571 been seen, either in the current section or a previous one. If so,
8572 add an entry to the per-section list of removed literals. The
8573 actual changes are deferred until the next pass. */
8576 compute_removed_literals (bfd
*abfd
,
8578 struct bfd_link_info
*link_info
,
8579 value_map_hash_table
*values
)
8581 xtensa_relax_info
*relax_info
;
8583 Elf_Internal_Rela
*internal_relocs
;
8584 source_reloc
*src_relocs
, *rel
;
8585 bfd_boolean ok
= TRUE
;
8586 property_table_entry
*prop_table
= NULL
;
8589 bfd_boolean last_loc_is_prev
= FALSE
;
8590 bfd_vma last_target_offset
= 0;
8591 section_cache_t target_sec_cache
;
8592 bfd_size_type sec_size
;
8594 init_section_cache (&target_sec_cache
);
8596 /* Do nothing if it is not a relaxable literal section. */
8597 relax_info
= get_xtensa_relax_info (sec
);
8598 BFD_ASSERT (relax_info
);
8599 if (!relax_info
->is_relaxable_literal_section
)
8602 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8603 link_info
->keep_memory
);
8605 sec_size
= bfd_get_section_limit (abfd
, sec
);
8606 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8607 if (contents
== NULL
&& sec_size
!= 0)
8613 /* Sort the source_relocs by target offset. */
8614 src_relocs
= relax_info
->src_relocs
;
8615 qsort (src_relocs
, relax_info
->src_count
,
8616 sizeof (source_reloc
), source_reloc_compare
);
8617 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8618 internal_reloc_compare
);
8620 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8621 XTENSA_PROP_SEC_NAME
, FALSE
);
8629 for (i
= 0; i
< relax_info
->src_count
; i
++)
8631 Elf_Internal_Rela
*irel
= NULL
;
8633 rel
= &src_relocs
[i
];
8634 if (get_l32r_opcode () != rel
->opcode
)
8636 irel
= get_irel_at_offset (sec
, internal_relocs
,
8637 rel
->r_rel
.target_offset
);
8639 /* If the relocation on this is not a simple R_XTENSA_32 or
8640 R_XTENSA_PLT then do not consider it. This may happen when
8641 the difference of two symbols is used in a literal. */
8642 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8643 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8646 /* If the target_offset for this relocation is the same as the
8647 previous relocation, then we've already considered whether the
8648 literal can be coalesced. Skip to the next one.... */
8649 if (i
!= 0 && prev_i
!= -1
8650 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8654 if (last_loc_is_prev
&&
8655 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8656 last_loc_is_prev
= FALSE
;
8658 /* Check if the relocation was from an L32R that is being removed
8659 because a CALLX was converted to a direct CALL, and check if
8660 there are no other relocations to the literal. */
8661 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8662 sec
, prop_table
, ptblsize
))
8664 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8665 irel
, rel
, prop_table
, ptblsize
))
8670 last_target_offset
= rel
->r_rel
.target_offset
;
8674 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8676 &last_loc_is_prev
, irel
,
8677 relax_info
->src_count
- i
, rel
,
8678 prop_table
, ptblsize
,
8679 &target_sec_cache
, rel
->is_abs_literal
))
8684 last_target_offset
= rel
->r_rel
.target_offset
;
8688 print_removed_literals (stderr
, &relax_info
->removed_list
);
8689 print_action_list (stderr
, &relax_info
->action_list
);
8695 free_section_cache (&target_sec_cache
);
8697 release_contents (sec
, contents
);
8698 release_internal_relocs (sec
, internal_relocs
);
8703 static Elf_Internal_Rela
*
8704 get_irel_at_offset (asection
*sec
,
8705 Elf_Internal_Rela
*internal_relocs
,
8709 Elf_Internal_Rela
*irel
;
8711 Elf_Internal_Rela key
;
8713 if (!internal_relocs
)
8716 key
.r_offset
= offset
;
8717 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8718 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8722 /* bsearch does not guarantee which will be returned if there are
8723 multiple matches. We need the first that is not an alignment. */
8724 i
= irel
- internal_relocs
;
8727 if (internal_relocs
[i
-1].r_offset
!= offset
)
8731 for ( ; i
< sec
->reloc_count
; i
++)
8733 irel
= &internal_relocs
[i
];
8734 r_type
= ELF32_R_TYPE (irel
->r_info
);
8735 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8744 is_removable_literal (const source_reloc
*rel
,
8746 const source_reloc
*src_relocs
,
8749 property_table_entry
*prop_table
,
8752 const source_reloc
*curr_rel
;
8753 property_table_entry
*entry
;
8758 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8759 sec
->vma
+ rel
->r_rel
.target_offset
);
8760 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8763 for (++i
; i
< src_count
; ++i
)
8765 curr_rel
= &src_relocs
[i
];
8766 /* If all others have the same target offset.... */
8767 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8770 if (!curr_rel
->is_null
8771 && !xtensa_is_property_section (curr_rel
->source_sec
)
8772 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8780 remove_dead_literal (bfd
*abfd
,
8782 struct bfd_link_info
*link_info
,
8783 Elf_Internal_Rela
*internal_relocs
,
8784 Elf_Internal_Rela
*irel
,
8786 property_table_entry
*prop_table
,
8789 property_table_entry
*entry
;
8790 xtensa_relax_info
*relax_info
;
8792 relax_info
= get_xtensa_relax_info (sec
);
8796 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8797 sec
->vma
+ rel
->r_rel
.target_offset
);
8799 /* Mark the unused literal so that it will be removed. */
8800 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
8802 text_action_add (&relax_info
->action_list
,
8803 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
8805 /* If the section is 4-byte aligned, do not add fill. */
8806 if (sec
->alignment_power
> 2)
8808 int fill_extra_space
;
8809 bfd_vma entry_sec_offset
;
8811 property_table_entry
*the_add_entry
;
8815 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
8817 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
8819 /* If the literal range is at the end of the section,
8821 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8823 fill_extra_space
= compute_fill_extra_space (the_add_entry
);
8825 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
8826 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
8827 -4, fill_extra_space
);
8829 adjust_fill_action (fa
, removed_diff
);
8831 text_action_add (&relax_info
->action_list
,
8832 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
8835 /* Zero out the relocation on this literal location. */
8838 if (elf_hash_table (link_info
)->dynamic_sections_created
)
8839 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
8841 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
8842 pin_internal_relocs (sec
, internal_relocs
);
8845 /* Do not modify "last_loc_is_prev". */
8851 identify_literal_placement (bfd
*abfd
,
8854 struct bfd_link_info
*link_info
,
8855 value_map_hash_table
*values
,
8856 bfd_boolean
*last_loc_is_prev_p
,
8857 Elf_Internal_Rela
*irel
,
8858 int remaining_src_rels
,
8860 property_table_entry
*prop_table
,
8862 section_cache_t
*target_sec_cache
,
8863 bfd_boolean is_abs_literal
)
8867 xtensa_relax_info
*relax_info
;
8868 bfd_boolean literal_placed
= FALSE
;
8870 unsigned long value
;
8871 bfd_boolean final_static_link
;
8872 bfd_size_type sec_size
;
8874 relax_info
= get_xtensa_relax_info (sec
);
8878 sec_size
= bfd_get_section_limit (abfd
, sec
);
8881 (!bfd_link_relocatable (link_info
)
8882 && !elf_hash_table (link_info
)->dynamic_sections_created
);
8884 /* The placement algorithm first checks to see if the literal is
8885 already in the value map. If so and the value map is reachable
8886 from all uses, then the literal is moved to that location. If
8887 not, then we identify the last location where a fresh literal was
8888 placed. If the literal can be safely moved there, then we do so.
8889 If not, then we assume that the literal is not to move and leave
8890 the literal where it is, marking it as the last literal
8893 /* Find the literal value. */
8895 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
8898 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
8899 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
8901 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
8903 /* Check if we've seen another literal with the same value that
8904 is in the same output section. */
8905 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
8908 && (r_reloc_get_section (&val_map
->loc
)->output_section
8909 == sec
->output_section
)
8910 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
8911 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
8913 /* No change to last_loc_is_prev. */
8914 literal_placed
= TRUE
;
8917 /* For relocatable links, do not try to move literals. To do it
8918 correctly might increase the number of relocations in an input
8919 section making the default relocatable linking fail. */
8920 if (!bfd_link_relocatable (link_info
) && !literal_placed
8921 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
8923 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
8924 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
8926 /* Increment the virtual offset. */
8927 r_reloc try_loc
= values
->last_loc
;
8928 try_loc
.virtual_offset
+= 4;
8930 /* There is a last loc that was in the same output section. */
8931 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
8932 && move_shared_literal (sec
, link_info
, rel
,
8933 prop_table
, ptblsize
,
8934 &try_loc
, &val
, target_sec_cache
))
8936 values
->last_loc
.virtual_offset
+= 4;
8937 literal_placed
= TRUE
;
8939 val_map
= add_value_map (values
, &val
, &try_loc
,
8942 val_map
->loc
= try_loc
;
8947 if (!literal_placed
)
8949 /* Nothing worked, leave the literal alone but update the last loc. */
8950 values
->has_last_loc
= TRUE
;
8951 values
->last_loc
= rel
->r_rel
;
8953 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
8955 val_map
->loc
= rel
->r_rel
;
8956 *last_loc_is_prev_p
= TRUE
;
8963 /* Check if the original relocations (presumably on L32R instructions)
8964 identified by reloc[0..N] can be changed to reference the literal
8965 identified by r_rel. If r_rel is out of range for any of the
8966 original relocations, then we don't want to coalesce the original
8967 literal with the one at r_rel. We only check reloc[0..N], where the
8968 offsets are all the same as for reloc[0] (i.e., they're all
8969 referencing the same literal) and where N is also bounded by the
8970 number of remaining entries in the "reloc" array. The "reloc" array
8971 is sorted by target offset so we know all the entries for the same
8972 literal will be contiguous. */
8975 relocations_reach (source_reloc
*reloc
,
8976 int remaining_relocs
,
8977 const r_reloc
*r_rel
)
8979 bfd_vma from_offset
, source_address
, dest_address
;
8983 if (!r_reloc_is_defined (r_rel
))
8986 sec
= r_reloc_get_section (r_rel
);
8987 from_offset
= reloc
[0].r_rel
.target_offset
;
8989 for (i
= 0; i
< remaining_relocs
; i
++)
8991 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
8994 /* Ignore relocations that have been removed. */
8995 if (reloc
[i
].is_null
)
8998 /* The original and new output section for these must be the same
8999 in order to coalesce. */
9000 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9001 != sec
->output_section
)
9004 /* Absolute literals in the same output section can always be
9006 if (reloc
[i
].is_abs_literal
)
9009 /* A literal with no PC-relative relocations can be moved anywhere. */
9010 if (reloc
[i
].opnd
!= -1)
9012 /* Otherwise, check to see that it fits. */
9013 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9014 + reloc
[i
].source_sec
->output_offset
9015 + reloc
[i
].r_rel
.rela
.r_offset
);
9016 dest_address
= (sec
->output_section
->vma
9017 + sec
->output_offset
9018 + r_rel
->target_offset
);
9020 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9021 source_address
, dest_address
))
9030 /* Move a literal to another literal location because it is
9031 the same as the other literal value. */
9034 coalesce_shared_literal (asection
*sec
,
9036 property_table_entry
*prop_table
,
9040 property_table_entry
*entry
;
9042 property_table_entry
*the_add_entry
;
9044 xtensa_relax_info
*relax_info
;
9046 relax_info
= get_xtensa_relax_info (sec
);
9050 entry
= elf_xtensa_find_property_entry
9051 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9052 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9055 /* Mark that the literal will be coalesced. */
9056 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9058 text_action_add (&relax_info
->action_list
,
9059 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9061 /* If the section is 4-byte aligned, do not add fill. */
9062 if (sec
->alignment_power
> 2)
9064 int fill_extra_space
;
9065 bfd_vma entry_sec_offset
;
9068 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9070 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9072 /* If the literal range is at the end of the section,
9074 fill_extra_space
= 0;
9075 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9077 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9078 fill_extra_space
= the_add_entry
->size
;
9080 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9081 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9082 -4, fill_extra_space
);
9084 adjust_fill_action (fa
, removed_diff
);
9086 text_action_add (&relax_info
->action_list
,
9087 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9094 /* Move a literal to another location. This may actually increase the
9095 total amount of space used because of alignments so we need to do
9096 this carefully. Also, it may make a branch go out of range. */
9099 move_shared_literal (asection
*sec
,
9100 struct bfd_link_info
*link_info
,
9102 property_table_entry
*prop_table
,
9104 const r_reloc
*target_loc
,
9105 const literal_value
*lit_value
,
9106 section_cache_t
*target_sec_cache
)
9108 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9109 text_action
*fa
, *target_fa
;
9111 xtensa_relax_info
*relax_info
, *target_relax_info
;
9112 asection
*target_sec
;
9114 ebb_constraint ebb_table
;
9115 bfd_boolean relocs_fit
;
9117 /* If this routine always returns FALSE, the literals that cannot be
9118 coalesced will not be moved. */
9119 if (elf32xtensa_no_literal_movement
)
9122 relax_info
= get_xtensa_relax_info (sec
);
9126 target_sec
= r_reloc_get_section (target_loc
);
9127 target_relax_info
= get_xtensa_relax_info (target_sec
);
9129 /* Literals to undefined sections may not be moved because they
9130 must report an error. */
9131 if (bfd_is_und_section (target_sec
))
9134 src_entry
= elf_xtensa_find_property_entry
9135 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9137 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9140 target_entry
= elf_xtensa_find_property_entry
9141 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9142 target_sec
->vma
+ target_loc
->target_offset
);
9147 /* Make sure that we have not broken any branches. */
9150 init_ebb_constraint (&ebb_table
);
9151 ebb
= &ebb_table
.ebb
;
9152 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9153 target_sec_cache
->content_length
,
9154 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9155 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9157 /* Propose to add 4 bytes + worst-case alignment size increase to
9159 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9160 ta_fill
, target_loc
->target_offset
,
9161 -4 - (1 << target_sec
->alignment_power
), TRUE
);
9163 /* Check all of the PC-relative relocations to make sure they still fit. */
9164 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9165 target_sec_cache
->contents
,
9166 target_sec_cache
->relocs
, NULL
,
9172 text_action_add_literal (&target_relax_info
->action_list
,
9173 ta_add_literal
, target_loc
, lit_value
, -4);
9175 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9177 /* May need to add or remove some fill to maintain alignment. */
9178 int fill_extra_space
;
9179 bfd_vma entry_sec_offset
;
9182 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9184 /* If the literal range is at the end of the section,
9186 fill_extra_space
= 0;
9188 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9189 target_sec_cache
->pte_count
,
9191 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9192 fill_extra_space
= the_add_entry
->size
;
9194 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9195 target_sec
, entry_sec_offset
);
9196 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9197 entry_sec_offset
, 4,
9200 adjust_fill_action (target_fa
, removed_diff
);
9202 text_action_add (&target_relax_info
->action_list
,
9203 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9206 /* Mark that the literal will be moved to the new location. */
9207 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9209 /* Remove the literal. */
9210 text_action_add (&relax_info
->action_list
,
9211 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9213 /* If the section is 4-byte aligned, do not add fill. */
9214 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9216 int fill_extra_space
;
9217 bfd_vma entry_sec_offset
;
9220 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9222 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9224 /* If the literal range is at the end of the section,
9226 fill_extra_space
= 0;
9227 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9229 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9230 fill_extra_space
= the_add_entry
->size
;
9232 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9233 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9234 -4, fill_extra_space
);
9236 adjust_fill_action (fa
, removed_diff
);
9238 text_action_add (&relax_info
->action_list
,
9239 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9246 /* Second relaxation pass. */
9249 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9251 bfd_size_type
*final_size
= p
;
9252 text_action
*action
= (text_action
*)node
->value
;
9254 *final_size
-= action
->removed_bytes
;
9258 /* Modify all of the relocations to point to the right spot, and if this
9259 is a relaxable section, delete the unwanted literals and fix the
9263 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9265 Elf_Internal_Rela
*internal_relocs
;
9266 xtensa_relax_info
*relax_info
;
9268 bfd_boolean ok
= TRUE
;
9270 bfd_boolean rv
= FALSE
;
9271 bfd_boolean virtual_action
;
9272 bfd_size_type sec_size
;
9274 sec_size
= bfd_get_section_limit (abfd
, sec
);
9275 relax_info
= get_xtensa_relax_info (sec
);
9276 BFD_ASSERT (relax_info
);
9278 /* First translate any of the fixes that have been added already. */
9279 translate_section_fixes (sec
);
9281 /* Handle property sections (e.g., literal tables) specially. */
9282 if (xtensa_is_property_section (sec
))
9284 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9285 return relax_property_section (abfd
, sec
, link_info
);
9288 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9289 link_info
->keep_memory
);
9290 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9293 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9294 if (contents
== NULL
&& sec_size
!= 0)
9300 if (internal_relocs
)
9302 for (i
= 0; i
< sec
->reloc_count
; i
++)
9304 Elf_Internal_Rela
*irel
;
9305 xtensa_relax_info
*target_relax_info
;
9306 bfd_vma source_offset
, old_source_offset
;
9309 asection
*target_sec
;
9311 /* Locally change the source address.
9312 Translate the target to the new target address.
9313 If it points to this section and has been removed,
9317 irel
= &internal_relocs
[i
];
9318 source_offset
= irel
->r_offset
;
9319 old_source_offset
= source_offset
;
9321 r_type
= ELF32_R_TYPE (irel
->r_info
);
9322 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9323 bfd_get_section_limit (abfd
, sec
));
9325 /* If this section could have changed then we may need to
9326 change the relocation's offset. */
9328 if (relax_info
->is_relaxable_literal_section
9329 || relax_info
->is_relaxable_asm_section
)
9331 pin_internal_relocs (sec
, internal_relocs
);
9333 if (r_type
!= R_XTENSA_NONE
9334 && find_removed_literal (&relax_info
->removed_list
,
9337 /* Remove this relocation. */
9338 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9339 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9340 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9341 irel
->r_offset
= offset_with_removed_text_map
9342 (&relax_info
->action_list
, irel
->r_offset
);
9346 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9348 text_action
*action
=
9349 find_insn_action (&relax_info
->action_list
,
9351 if (action
&& (action
->action
== ta_convert_longcall
9352 || action
->action
== ta_remove_longcall
))
9354 bfd_reloc_status_type retval
;
9355 char *error_message
= NULL
;
9357 retval
= contract_asm_expansion (contents
, sec_size
,
9358 irel
, &error_message
);
9359 if (retval
!= bfd_reloc_ok
)
9361 (*link_info
->callbacks
->reloc_dangerous
)
9362 (link_info
, error_message
, abfd
, sec
,
9366 /* Update the action so that the code that moves
9367 the contents will do the right thing. */
9368 /* ta_remove_longcall and ta_remove_insn actions are
9369 grouped together in the tree as well as
9370 ta_convert_longcall and ta_none, so that changes below
9371 can be done w/o removing and reinserting action into
9374 if (action
->action
== ta_remove_longcall
)
9375 action
->action
= ta_remove_insn
;
9377 action
->action
= ta_none
;
9378 /* Refresh the info in the r_rel. */
9379 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9380 r_type
= ELF32_R_TYPE (irel
->r_info
);
9384 source_offset
= offset_with_removed_text_map
9385 (&relax_info
->action_list
, irel
->r_offset
);
9386 irel
->r_offset
= source_offset
;
9389 /* If the target section could have changed then
9390 we may need to change the relocation's target offset. */
9392 target_sec
= r_reloc_get_section (&r_rel
);
9394 /* For a reference to a discarded section from a DWARF section,
9395 i.e., where action_discarded is PRETEND, the symbol will
9396 eventually be modified to refer to the kept section (at least if
9397 the kept and discarded sections are the same size). Anticipate
9398 that here and adjust things accordingly. */
9399 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9400 && elf_xtensa_action_discarded (sec
) == PRETEND
9401 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9402 && target_sec
!= NULL
9403 && discarded_section (target_sec
))
9405 /* It would be natural to call _bfd_elf_check_kept_section
9406 here, but it's not exported from elflink.c. It's also a
9407 fairly expensive check. Adjusting the relocations to the
9408 discarded section is fairly harmless; it will only adjust
9409 some addends and difference values. If it turns out that
9410 _bfd_elf_check_kept_section fails later, it won't matter,
9411 so just compare the section names to find the right group
9413 asection
*kept
= target_sec
->kept_section
;
9416 if ((kept
->flags
& SEC_GROUP
) != 0)
9418 asection
*first
= elf_next_in_group (kept
);
9419 asection
*s
= first
;
9424 if (strcmp (s
->name
, target_sec
->name
) == 0)
9429 s
= elf_next_in_group (s
);
9436 && ((target_sec
->rawsize
!= 0
9437 ? target_sec
->rawsize
: target_sec
->size
)
9438 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9442 target_relax_info
= get_xtensa_relax_info (target_sec
);
9443 if (target_relax_info
9444 && (target_relax_info
->is_relaxable_literal_section
9445 || target_relax_info
->is_relaxable_asm_section
))
9448 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9450 if (r_type
== R_XTENSA_DIFF8
9451 || r_type
== R_XTENSA_DIFF16
9452 || r_type
== R_XTENSA_DIFF32
)
9454 bfd_signed_vma diff_value
= 0;
9455 bfd_vma new_end_offset
, diff_mask
= 0;
9457 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9459 (*link_info
->callbacks
->reloc_dangerous
)
9460 (link_info
, _("invalid relocation address"),
9461 abfd
, sec
, old_source_offset
);
9467 case R_XTENSA_DIFF8
:
9469 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9471 case R_XTENSA_DIFF16
:
9473 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9475 case R_XTENSA_DIFF32
:
9477 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9481 new_end_offset
= offset_with_removed_text_map
9482 (&target_relax_info
->action_list
,
9483 r_rel
.target_offset
+ diff_value
);
9484 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9488 case R_XTENSA_DIFF8
:
9490 bfd_put_signed_8 (abfd
, diff_value
,
9491 &contents
[old_source_offset
]);
9493 case R_XTENSA_DIFF16
:
9495 bfd_put_signed_16 (abfd
, diff_value
,
9496 &contents
[old_source_offset
]);
9498 case R_XTENSA_DIFF32
:
9499 diff_mask
= 0x7fffffff;
9500 bfd_put_signed_32 (abfd
, diff_value
,
9501 &contents
[old_source_offset
]);
9505 /* Check for overflow. Sign bits must be all zeroes or all ones */
9506 if ((diff_value
& ~diff_mask
) != 0 &&
9507 (diff_value
& ~diff_mask
) != (-1 & ~diff_mask
))
9509 (*link_info
->callbacks
->reloc_dangerous
)
9510 (link_info
, _("overflow after relaxation"),
9511 abfd
, sec
, old_source_offset
);
9515 pin_contents (sec
, contents
);
9518 /* If the relocation still references a section in the same
9519 input file, modify the relocation directly instead of
9520 adding a "fix" record. */
9521 if (target_sec
->owner
== abfd
)
9523 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9524 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9525 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9526 pin_internal_relocs (sec
, internal_relocs
);
9530 bfd_vma addend_displacement
;
9533 addend_displacement
=
9534 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9535 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9537 addend_displacement
, TRUE
);
9544 if ((relax_info
->is_relaxable_literal_section
9545 || relax_info
->is_relaxable_asm_section
)
9546 && action_list_count (&relax_info
->action_list
))
9548 /* Walk through the planned actions and build up a table
9549 of move, copy and fill records. Use the move, copy and
9550 fill records to perform the actions once. */
9552 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9553 bfd_byte
*scratch
= NULL
;
9554 bfd_byte
*dup_contents
= NULL
;
9555 bfd_size_type orig_size
= sec
->size
;
9556 bfd_vma orig_dot
= 0;
9557 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9558 orig dot in physical memory. */
9559 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9560 bfd_vma dup_dot
= 0;
9562 text_action
*action
;
9564 final_size
= sec
->size
;
9566 splay_tree_foreach (relax_info
->action_list
.tree
,
9567 action_remove_bytes_fn
, &final_size
);
9568 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9569 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9571 /* The dot is the current fill location. */
9573 print_action_list (stderr
, &relax_info
->action_list
);
9576 for (action
= action_first (&relax_info
->action_list
); action
;
9577 action
= action_next (&relax_info
->action_list
, action
))
9579 virtual_action
= FALSE
;
9580 if (action
->offset
> orig_dot
)
9582 orig_dot
+= orig_dot_copied
;
9583 orig_dot_copied
= 0;
9585 /* Out of the virtual world. */
9588 if (action
->offset
> orig_dot
)
9590 copy_size
= action
->offset
- orig_dot
;
9591 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9592 orig_dot
+= copy_size
;
9593 dup_dot
+= copy_size
;
9594 BFD_ASSERT (action
->offset
== orig_dot
);
9596 else if (action
->offset
< orig_dot
)
9598 if (action
->action
== ta_fill
9599 && action
->offset
- action
->removed_bytes
== orig_dot
)
9601 /* This is OK because the fill only effects the dup_dot. */
9603 else if (action
->action
== ta_add_literal
)
9605 /* TBD. Might need to handle this. */
9608 if (action
->offset
== orig_dot
)
9610 if (action
->virtual_offset
> orig_dot_vo
)
9612 if (orig_dot_vo
== 0)
9614 /* Need to copy virtual_offset bytes. Probably four. */
9615 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9616 memmove (&dup_contents
[dup_dot
],
9617 &contents
[orig_dot
], copy_size
);
9618 orig_dot_copied
= copy_size
;
9619 dup_dot
+= copy_size
;
9621 virtual_action
= TRUE
;
9624 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9626 switch (action
->action
)
9628 case ta_remove_literal
:
9629 case ta_remove_insn
:
9630 BFD_ASSERT (action
->removed_bytes
>= 0);
9631 orig_dot
+= action
->removed_bytes
;
9634 case ta_narrow_insn
:
9637 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9638 BFD_ASSERT (action
->removed_bytes
== 1);
9639 rv
= narrow_instruction (scratch
, final_size
, 0);
9641 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9642 orig_dot
+= orig_insn_size
;
9643 dup_dot
+= copy_size
;
9647 if (action
->removed_bytes
>= 0)
9648 orig_dot
+= action
->removed_bytes
;
9651 /* Already zeroed in dup_contents. Just bump the
9653 dup_dot
+= (-action
->removed_bytes
);
9658 BFD_ASSERT (action
->removed_bytes
== 0);
9661 case ta_convert_longcall
:
9662 case ta_remove_longcall
:
9663 /* These will be removed or converted before we get here. */
9670 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9671 BFD_ASSERT (action
->removed_bytes
== -1);
9672 rv
= widen_instruction (scratch
, final_size
, 0);
9674 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9675 orig_dot
+= orig_insn_size
;
9676 dup_dot
+= copy_size
;
9679 case ta_add_literal
:
9682 BFD_ASSERT (action
->removed_bytes
== -4);
9683 /* TBD -- place the literal value here and insert
9685 memset (&dup_contents
[dup_dot
], 0, 4);
9686 pin_internal_relocs (sec
, internal_relocs
);
9687 pin_contents (sec
, contents
);
9689 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9690 relax_info
, &internal_relocs
, &action
->value
))
9694 orig_dot_vo
+= copy_size
;
9696 orig_dot
+= orig_insn_size
;
9697 dup_dot
+= copy_size
;
9701 /* Not implemented yet. */
9706 BFD_ASSERT (dup_dot
<= final_size
);
9707 BFD_ASSERT (orig_dot
<= orig_size
);
9710 orig_dot
+= orig_dot_copied
;
9711 orig_dot_copied
= 0;
9713 if (orig_dot
!= orig_size
)
9715 copy_size
= orig_size
- orig_dot
;
9716 BFD_ASSERT (orig_size
> orig_dot
);
9717 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9718 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9719 orig_dot
+= copy_size
;
9720 dup_dot
+= copy_size
;
9722 BFD_ASSERT (orig_size
== orig_dot
);
9723 BFD_ASSERT (final_size
== dup_dot
);
9725 /* Move the dup_contents back. */
9726 if (final_size
> orig_size
)
9728 /* Contents need to be reallocated. Swap the dup_contents into
9730 sec
->contents
= dup_contents
;
9732 contents
= dup_contents
;
9733 pin_contents (sec
, contents
);
9737 BFD_ASSERT (final_size
<= orig_size
);
9738 memset (contents
, 0, orig_size
);
9739 memcpy (contents
, dup_contents
, final_size
);
9740 free (dup_contents
);
9743 pin_contents (sec
, contents
);
9745 if (sec
->rawsize
== 0)
9746 sec
->rawsize
= sec
->size
;
9747 sec
->size
= final_size
;
9751 release_internal_relocs (sec
, internal_relocs
);
9752 release_contents (sec
, contents
);
9758 translate_section_fixes (asection
*sec
)
9760 xtensa_relax_info
*relax_info
;
9763 relax_info
= get_xtensa_relax_info (sec
);
9767 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
9768 if (!translate_reloc_bfd_fix (r
))
9775 /* Translate a fix given the mapping in the relax info for the target
9776 section. If it has already been translated, no work is required. */
9779 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
9781 reloc_bfd_fix new_fix
;
9783 xtensa_relax_info
*relax_info
;
9784 removed_literal
*removed
;
9785 bfd_vma new_offset
, target_offset
;
9787 if (fix
->translated
)
9790 sec
= fix
->target_sec
;
9791 target_offset
= fix
->target_offset
;
9793 relax_info
= get_xtensa_relax_info (sec
);
9796 fix
->translated
= TRUE
;
9802 /* The fix does not need to be translated if the section cannot change. */
9803 if (!relax_info
->is_relaxable_literal_section
9804 && !relax_info
->is_relaxable_asm_section
)
9806 fix
->translated
= TRUE
;
9810 /* If the literal has been moved and this relocation was on an
9811 opcode, then the relocation should move to the new literal
9812 location. Otherwise, the relocation should move within the
9816 if (is_operand_relocation (fix
->src_type
))
9818 /* Check if the original relocation is against a literal being
9820 removed
= find_removed_literal (&relax_info
->removed_list
,
9828 /* The fact that there is still a relocation to this literal indicates
9829 that the literal is being coalesced, not simply removed. */
9830 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
9832 /* This was moved to some other address (possibly another section). */
9833 new_sec
= r_reloc_get_section (&removed
->to
);
9837 relax_info
= get_xtensa_relax_info (sec
);
9839 (!relax_info
->is_relaxable_literal_section
9840 && !relax_info
->is_relaxable_asm_section
))
9842 target_offset
= removed
->to
.target_offset
;
9843 new_fix
.target_sec
= new_sec
;
9844 new_fix
.target_offset
= target_offset
;
9845 new_fix
.translated
= TRUE
;
9850 target_offset
= removed
->to
.target_offset
;
9851 new_fix
.target_sec
= new_sec
;
9854 /* The target address may have been moved within its section. */
9855 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
9858 new_fix
.target_offset
= new_offset
;
9859 new_fix
.target_offset
= new_offset
;
9860 new_fix
.translated
= TRUE
;
9866 /* Fix up a relocation to take account of removed literals. */
9869 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
9871 xtensa_relax_info
*relax_info
;
9872 removed_literal
*removed
;
9873 bfd_vma target_offset
, base_offset
;
9875 *new_rel
= *orig_rel
;
9877 if (!r_reloc_is_defined (orig_rel
))
9880 relax_info
= get_xtensa_relax_info (sec
);
9881 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
9882 || relax_info
->is_relaxable_asm_section
));
9884 target_offset
= orig_rel
->target_offset
;
9887 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
9889 /* Check if the original relocation is against a literal being
9891 removed
= find_removed_literal (&relax_info
->removed_list
,
9894 if (removed
&& removed
->to
.abfd
)
9898 /* The fact that there is still a relocation to this literal indicates
9899 that the literal is being coalesced, not simply removed. */
9900 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
9902 /* This was moved to some other address
9903 (possibly in another section). */
9904 *new_rel
= removed
->to
;
9905 new_sec
= r_reloc_get_section (new_rel
);
9909 relax_info
= get_xtensa_relax_info (sec
);
9911 || (!relax_info
->is_relaxable_literal_section
9912 && !relax_info
->is_relaxable_asm_section
))
9915 target_offset
= new_rel
->target_offset
;
9918 /* Find the base offset of the reloc symbol, excluding any addend from the
9919 reloc or from the section contents (for a partial_inplace reloc). Then
9920 find the adjusted values of the offsets due to relaxation. The base
9921 offset is needed to determine the change to the reloc's addend; the reloc
9922 addend should not be adjusted due to relaxations located before the base
9925 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
9926 if (base_offset
<= target_offset
)
9928 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
9929 base_offset
, FALSE
);
9930 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
9931 target_offset
, FALSE
) -
9934 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
9935 new_rel
->rela
.r_addend
-= addend_removed
;
9939 /* Handle a negative addend. The base offset comes first. */
9940 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
9941 target_offset
, FALSE
);
9942 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
9943 base_offset
, FALSE
) -
9946 new_rel
->target_offset
= target_offset
- tgt_removed
;
9947 new_rel
->rela
.r_addend
+= addend_removed
;
9954 /* For dynamic links, there may be a dynamic relocation for each
9955 literal. The number of dynamic relocations must be computed in
9956 size_dynamic_sections, which occurs before relaxation. When a
9957 literal is removed, this function checks if there is a corresponding
9958 dynamic relocation and shrinks the size of the appropriate dynamic
9959 relocation section accordingly. At this point, the contents of the
9960 dynamic relocation sections have not yet been filled in, so there's
9961 nothing else that needs to be done. */
9964 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
9966 asection
*input_section
,
9967 Elf_Internal_Rela
*rel
)
9969 struct elf_xtensa_link_hash_table
*htab
;
9970 Elf_Internal_Shdr
*symtab_hdr
;
9971 struct elf_link_hash_entry
**sym_hashes
;
9972 unsigned long r_symndx
;
9974 struct elf_link_hash_entry
*h
;
9975 bfd_boolean dynamic_symbol
;
9977 htab
= elf_xtensa_hash_table (info
);
9981 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
9982 sym_hashes
= elf_sym_hashes (abfd
);
9984 r_type
= ELF32_R_TYPE (rel
->r_info
);
9985 r_symndx
= ELF32_R_SYM (rel
->r_info
);
9987 if (r_symndx
< symtab_hdr
->sh_info
)
9990 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
9992 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
9994 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
9995 && (input_section
->flags
& SEC_ALLOC
) != 0
9996 && (dynamic_symbol
|| bfd_link_pic (info
)))
9999 bfd_boolean is_plt
= FALSE
;
10001 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10003 srel
= htab
->elf
.srelplt
;
10007 srel
= htab
->elf
.srelgot
;
10009 /* Reduce size of the .rela.* section by one reloc. */
10010 BFD_ASSERT (srel
!= NULL
);
10011 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10012 srel
->size
-= sizeof (Elf32_External_Rela
);
10016 asection
*splt
, *sgotplt
, *srelgot
;
10017 int reloc_index
, chunk
;
10019 /* Find the PLT reloc index of the entry being removed. This
10020 is computed from the size of ".rela.plt". It is needed to
10021 figure out which PLT chunk to resize. Usually "last index
10022 = size - 1" since the index starts at zero, but in this
10023 context, the size has just been decremented so there's no
10024 need to subtract one. */
10025 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10027 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10028 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10029 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10030 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10032 /* Check if an entire PLT chunk has just been eliminated. */
10033 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10035 /* The two magic GOT entries for that chunk can go away. */
10036 srelgot
= htab
->elf
.srelgot
;
10037 BFD_ASSERT (srelgot
!= NULL
);
10038 srelgot
->reloc_count
-= 2;
10039 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10040 sgotplt
->size
-= 8;
10042 /* There should be only one entry left (and it will be
10044 BFD_ASSERT (sgotplt
->size
== 4);
10045 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10048 BFD_ASSERT (sgotplt
->size
>= 4);
10049 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10051 sgotplt
->size
-= 4;
10052 splt
->size
-= PLT_ENTRY_SIZE
;
10058 /* Take an r_rel and move it to another section. This usually
10059 requires extending the interal_relocation array and pinning it. If
10060 the original r_rel is from the same BFD, we can complete this here.
10061 Otherwise, we add a fix record to let the final link fix the
10062 appropriate address. Contents and internal relocations for the
10063 section must be pinned after calling this routine. */
10066 move_literal (bfd
*abfd
,
10067 struct bfd_link_info
*link_info
,
10070 bfd_byte
*contents
,
10071 xtensa_relax_info
*relax_info
,
10072 Elf_Internal_Rela
**internal_relocs_p
,
10073 const literal_value
*lit
)
10075 Elf_Internal_Rela
*new_relocs
= NULL
;
10076 size_t new_relocs_count
= 0;
10077 Elf_Internal_Rela this_rela
;
10078 const r_reloc
*r_rel
;
10080 r_rel
= &lit
->r_rel
;
10081 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10083 if (r_reloc_is_const (r_rel
))
10084 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10089 reloc_bfd_fix
*fix
;
10090 unsigned insert_at
;
10092 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10094 /* This is the difficult case. We have to create a fix up. */
10095 this_rela
.r_offset
= offset
;
10096 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10097 this_rela
.r_addend
=
10098 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10099 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10101 /* Currently, we cannot move relocations during a relocatable link. */
10102 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10103 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10104 r_reloc_get_section (r_rel
),
10105 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10107 /* We also need to mark that relocations are needed here. */
10108 sec
->flags
|= SEC_RELOC
;
10110 translate_reloc_bfd_fix (fix
);
10111 /* This fix has not yet been translated. */
10112 add_fix (sec
, fix
);
10114 /* Add the relocation. If we have already allocated our own
10115 space for the relocations and we have room for more, then use
10116 it. Otherwise, allocate new space and move the literals. */
10117 insert_at
= sec
->reloc_count
;
10118 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10120 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10127 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10128 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10130 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10131 || sec
->reloc_count
== relax_info
->relocs_count
);
10133 if (relax_info
->allocated_relocs_count
== 0)
10134 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10136 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10138 new_relocs
= (Elf_Internal_Rela
*)
10139 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10143 /* We could handle this more quickly by finding the split point. */
10144 if (insert_at
!= 0)
10145 memcpy (new_relocs
, *internal_relocs_p
,
10146 insert_at
* sizeof (Elf_Internal_Rela
));
10148 new_relocs
[insert_at
] = this_rela
;
10150 if (insert_at
!= sec
->reloc_count
)
10151 memcpy (new_relocs
+ insert_at
+ 1,
10152 (*internal_relocs_p
) + insert_at
,
10153 (sec
->reloc_count
- insert_at
)
10154 * sizeof (Elf_Internal_Rela
));
10156 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10158 /* The first time we re-allocate, we can only free the
10159 old relocs if they were allocated with bfd_malloc.
10160 This is not true when keep_memory is in effect. */
10161 if (!link_info
->keep_memory
)
10162 free (*internal_relocs_p
);
10165 free (*internal_relocs_p
);
10166 relax_info
->allocated_relocs
= new_relocs
;
10167 relax_info
->allocated_relocs_count
= new_relocs_count
;
10168 elf_section_data (sec
)->relocs
= new_relocs
;
10169 sec
->reloc_count
++;
10170 relax_info
->relocs_count
= sec
->reloc_count
;
10171 *internal_relocs_p
= new_relocs
;
10175 if (insert_at
!= sec
->reloc_count
)
10178 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10179 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10181 (*internal_relocs_p
)[insert_at
] = this_rela
;
10182 sec
->reloc_count
++;
10183 if (relax_info
->allocated_relocs
)
10184 relax_info
->relocs_count
= sec
->reloc_count
;
10191 /* This is similar to relax_section except that when a target is moved,
10192 we shift addresses up. We also need to modify the size. This
10193 algorithm does NOT allow for relocations into the middle of the
10194 property sections. */
10197 relax_property_section (bfd
*abfd
,
10199 struct bfd_link_info
*link_info
)
10201 Elf_Internal_Rela
*internal_relocs
;
10202 bfd_byte
*contents
;
10204 bfd_boolean ok
= TRUE
;
10205 bfd_boolean is_full_prop_section
;
10206 size_t last_zfill_target_offset
= 0;
10207 asection
*last_zfill_target_sec
= NULL
;
10208 bfd_size_type sec_size
;
10209 bfd_size_type entry_size
;
10211 sec_size
= bfd_get_section_limit (abfd
, sec
);
10212 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10213 link_info
->keep_memory
);
10214 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10215 if (contents
== NULL
&& sec_size
!= 0)
10221 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10222 if (is_full_prop_section
)
10227 if (internal_relocs
)
10229 for (i
= 0; i
< sec
->reloc_count
; i
++)
10231 Elf_Internal_Rela
*irel
;
10232 xtensa_relax_info
*target_relax_info
;
10234 asection
*target_sec
;
10236 bfd_byte
*size_p
, *flags_p
;
10238 /* Locally change the source address.
10239 Translate the target to the new target address.
10240 If it points to this section and has been removed, MOVE IT.
10241 Also, don't forget to modify the associated SIZE at
10244 irel
= &internal_relocs
[i
];
10245 r_type
= ELF32_R_TYPE (irel
->r_info
);
10246 if (r_type
== R_XTENSA_NONE
)
10249 /* Find the literal value. */
10250 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10251 size_p
= &contents
[irel
->r_offset
+ 4];
10253 if (is_full_prop_section
)
10254 flags_p
= &contents
[irel
->r_offset
+ 8];
10255 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10257 target_sec
= r_reloc_get_section (&val
.r_rel
);
10258 target_relax_info
= get_xtensa_relax_info (target_sec
);
10260 if (target_relax_info
10261 && (target_relax_info
->is_relaxable_literal_section
10262 || target_relax_info
->is_relaxable_asm_section
))
10264 /* Translate the relocation's destination. */
10265 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10266 bfd_vma new_offset
;
10267 long old_size
, new_size
;
10268 int removed_by_old_offset
=
10269 removed_by_actions_map (&target_relax_info
->action_list
,
10270 old_offset
, FALSE
);
10271 new_offset
= old_offset
- removed_by_old_offset
;
10273 /* Assert that we are not out of bounds. */
10274 old_size
= bfd_get_32 (abfd
, size_p
);
10275 new_size
= old_size
;
10279 /* Only the first zero-sized unreachable entry is
10280 allowed to expand. In this case the new offset
10281 should be the offset before the fill and the new
10282 size is the expansion size. For other zero-sized
10283 entries the resulting size should be zero with an
10284 offset before or after the fill address depending
10285 on whether the expanding unreachable entry
10287 if (last_zfill_target_sec
== 0
10288 || last_zfill_target_sec
!= target_sec
10289 || last_zfill_target_offset
!= old_offset
)
10291 bfd_vma new_end_offset
= new_offset
;
10293 /* Recompute the new_offset, but this time don't
10294 include any fill inserted by relaxation. */
10295 removed_by_old_offset
=
10296 removed_by_actions_map (&target_relax_info
->action_list
,
10298 new_offset
= old_offset
- removed_by_old_offset
;
10300 /* If it is not unreachable and we have not yet
10301 seen an unreachable at this address, place it
10302 before the fill address. */
10303 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10304 & XTENSA_PROP_UNREACHABLE
) != 0)
10306 new_size
= new_end_offset
- new_offset
;
10308 last_zfill_target_sec
= target_sec
;
10309 last_zfill_target_offset
= old_offset
;
10315 int removed_by_old_offset_size
=
10316 removed_by_actions_map (&target_relax_info
->action_list
,
10317 old_offset
+ old_size
, TRUE
);
10318 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10321 if (new_size
!= old_size
)
10323 bfd_put_32 (abfd
, new_size
, size_p
);
10324 pin_contents (sec
, contents
);
10327 if (new_offset
!= old_offset
)
10329 bfd_vma diff
= new_offset
- old_offset
;
10330 irel
->r_addend
+= diff
;
10331 pin_internal_relocs (sec
, internal_relocs
);
10337 /* Combine adjacent property table entries. This is also done in
10338 finish_dynamic_sections() but at that point it's too late to
10339 reclaim the space in the output section, so we do this twice. */
10341 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10342 || xtensa_is_littable_section (sec
)))
10344 Elf_Internal_Rela
*last_irel
= NULL
;
10345 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10346 int removed_bytes
= 0;
10348 flagword predef_flags
;
10350 predef_flags
= xtensa_get_property_predef_flags (sec
);
10352 /* Walk over memory and relocations at the same time.
10353 This REQUIRES that the internal_relocs be sorted by offset. */
10354 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10355 internal_reloc_compare
);
10357 pin_internal_relocs (sec
, internal_relocs
);
10358 pin_contents (sec
, contents
);
10360 next_rel
= internal_relocs
;
10361 rel_end
= internal_relocs
+ sec
->reloc_count
;
10363 BFD_ASSERT (sec
->size
% entry_size
== 0);
10365 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10367 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10368 bfd_vma bytes_to_remove
, size
, actual_offset
;
10369 bfd_boolean remove_this_rel
;
10372 /* Find the first relocation for the entry at the current offset.
10373 Adjust the offsets of any extra relocations for the previous
10378 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10380 if ((irel
->r_offset
== offset
10381 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10382 || irel
->r_offset
> offset
)
10387 irel
->r_offset
-= removed_bytes
;
10391 /* Find the next relocation (if there are any left). */
10395 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10397 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10405 /* Check if there are relocations on the current entry. There
10406 should usually be a relocation on the offset field. If there
10407 are relocations on the size or flags, then we can't optimize
10408 this entry. Also, find the next relocation to examine on the
10412 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10414 next_rel
= offset_rel
;
10415 /* There are no relocations on the current entry, but we
10416 might still be able to remove it if the size is zero. */
10419 else if (offset_rel
->r_offset
> offset
10421 && extra_rel
->r_offset
< offset
+ entry_size
))
10423 /* There is a relocation on the size or flags, so we can't
10424 do anything with this entry. Continue with the next. */
10425 next_rel
= offset_rel
;
10430 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10431 offset_rel
->r_offset
-= removed_bytes
;
10432 next_rel
= offset_rel
+ 1;
10438 remove_this_rel
= FALSE
;
10439 bytes_to_remove
= 0;
10440 actual_offset
= offset
- removed_bytes
;
10441 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10443 if (is_full_prop_section
)
10444 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10446 flags
= predef_flags
;
10449 && (flags
& XTENSA_PROP_ALIGN
) == 0
10450 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10452 /* Always remove entries with zero size and no alignment. */
10453 bytes_to_remove
= entry_size
;
10455 remove_this_rel
= TRUE
;
10457 else if (offset_rel
10458 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10462 flagword old_flags
;
10464 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10465 bfd_vma old_address
=
10466 (last_irel
->r_addend
10467 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10468 bfd_vma new_address
=
10469 (offset_rel
->r_addend
10470 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10471 if (is_full_prop_section
)
10472 old_flags
= bfd_get_32
10473 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10475 old_flags
= predef_flags
;
10477 if ((ELF32_R_SYM (offset_rel
->r_info
)
10478 == ELF32_R_SYM (last_irel
->r_info
))
10479 && old_address
+ old_size
== new_address
10480 && old_flags
== flags
10481 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10482 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10484 /* Fix the old size. */
10485 bfd_put_32 (abfd
, old_size
+ size
,
10486 &contents
[last_irel
->r_offset
+ 4]);
10487 bytes_to_remove
= entry_size
;
10488 remove_this_rel
= TRUE
;
10491 last_irel
= offset_rel
;
10494 last_irel
= offset_rel
;
10497 if (remove_this_rel
)
10499 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10500 offset_rel
->r_offset
= 0;
10503 if (bytes_to_remove
!= 0)
10505 removed_bytes
+= bytes_to_remove
;
10506 if (offset
+ bytes_to_remove
< sec
->size
)
10507 memmove (&contents
[actual_offset
],
10508 &contents
[actual_offset
+ bytes_to_remove
],
10509 sec
->size
- offset
- bytes_to_remove
);
10515 /* Fix up any extra relocations on the last entry. */
10516 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10517 irel
->r_offset
-= removed_bytes
;
10519 /* Clear the removed bytes. */
10520 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10522 if (sec
->rawsize
== 0)
10523 sec
->rawsize
= sec
->size
;
10524 sec
->size
-= removed_bytes
;
10526 if (xtensa_is_littable_section (sec
))
10528 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10530 sgotloc
->size
-= removed_bytes
;
10536 release_internal_relocs (sec
, internal_relocs
);
10537 release_contents (sec
, contents
);
10542 /* Third relaxation pass. */
10544 /* Change symbol values to account for removed literals. */
10547 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10549 xtensa_relax_info
*relax_info
;
10550 unsigned int sec_shndx
;
10551 Elf_Internal_Shdr
*symtab_hdr
;
10552 Elf_Internal_Sym
*isymbuf
;
10553 unsigned i
, num_syms
, num_locals
;
10555 relax_info
= get_xtensa_relax_info (sec
);
10556 BFD_ASSERT (relax_info
);
10558 if (!relax_info
->is_relaxable_literal_section
10559 && !relax_info
->is_relaxable_asm_section
)
10562 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10564 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10565 isymbuf
= retrieve_local_syms (abfd
);
10567 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10568 num_locals
= symtab_hdr
->sh_info
;
10570 /* Adjust the local symbols defined in this section. */
10571 for (i
= 0; i
< num_locals
; i
++)
10573 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10575 if (isym
->st_shndx
== sec_shndx
)
10577 bfd_vma orig_addr
= isym
->st_value
;
10578 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10581 isym
->st_value
-= removed
;
10582 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10584 removed_by_actions_map (&relax_info
->action_list
,
10585 orig_addr
+ isym
->st_size
, FALSE
) -
10590 /* Now adjust the global symbols defined in this section. */
10591 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10593 struct elf_link_hash_entry
*sym_hash
;
10595 sym_hash
= elf_sym_hashes (abfd
)[i
];
10597 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10598 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10600 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10601 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10602 && sym_hash
->root
.u
.def
.section
== sec
)
10604 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10605 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10608 sym_hash
->root
.u
.def
.value
-= removed
;
10610 if (sym_hash
->type
== STT_FUNC
)
10612 removed_by_actions_map (&relax_info
->action_list
,
10613 orig_addr
+ sym_hash
->size
, FALSE
) -
10622 /* "Fix" handling functions, called while performing relocations. */
10625 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10627 asection
*input_section
,
10628 bfd_byte
*contents
)
10631 asection
*sec
, *old_sec
;
10632 bfd_vma old_offset
;
10633 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10634 reloc_bfd_fix
*fix
;
10636 if (r_type
== R_XTENSA_NONE
)
10639 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10643 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10644 bfd_get_section_limit (input_bfd
, input_section
));
10645 old_sec
= r_reloc_get_section (&r_rel
);
10646 old_offset
= r_rel
.target_offset
;
10648 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10650 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10653 /* xgettext:c-format */
10654 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10655 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10656 elf_howto_table
[r_type
].name
);
10659 /* Leave it be. Resolution will happen in a later stage. */
10663 sec
= fix
->target_sec
;
10664 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10665 - (old_sec
->output_offset
+ old_offset
));
10672 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10674 asection
*input_section
,
10675 bfd_byte
*contents
,
10676 bfd_vma
*relocationp
)
10679 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10680 reloc_bfd_fix
*fix
;
10681 bfd_vma fixup_diff
;
10683 if (r_type
== R_XTENSA_NONE
)
10686 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10690 sec
= fix
->target_sec
;
10692 fixup_diff
= rel
->r_addend
;
10693 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10695 bfd_vma inplace_val
;
10696 BFD_ASSERT (fix
->src_offset
10697 < bfd_get_section_limit (input_bfd
, input_section
));
10698 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10699 fixup_diff
+= inplace_val
;
10702 *relocationp
= (sec
->output_section
->vma
10703 + sec
->output_offset
10704 + fix
->target_offset
- fixup_diff
);
10708 /* Miscellaneous utility functions.... */
10711 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10717 return elf_hash_table (info
)->splt
;
10719 dynobj
= elf_hash_table (info
)->dynobj
;
10720 sprintf (plt_name
, ".plt.%u", chunk
);
10721 return bfd_get_linker_section (dynobj
, plt_name
);
10726 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10732 return elf_hash_table (info
)->sgotplt
;
10734 dynobj
= elf_hash_table (info
)->dynobj
;
10735 sprintf (got_name
, ".got.plt.%u", chunk
);
10736 return bfd_get_linker_section (dynobj
, got_name
);
10740 /* Get the input section for a given symbol index.
10742 . a section symbol, return the section;
10743 . a common symbol, return the common section;
10744 . an undefined symbol, return the undefined section;
10745 . an indirect symbol, follow the links;
10746 . an absolute value, return the absolute section. */
10749 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
10751 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10752 asection
*target_sec
= NULL
;
10753 if (r_symndx
< symtab_hdr
->sh_info
)
10755 Elf_Internal_Sym
*isymbuf
;
10756 unsigned int section_index
;
10758 isymbuf
= retrieve_local_syms (abfd
);
10759 section_index
= isymbuf
[r_symndx
].st_shndx
;
10761 if (section_index
== SHN_UNDEF
)
10762 target_sec
= bfd_und_section_ptr
;
10763 else if (section_index
== SHN_ABS
)
10764 target_sec
= bfd_abs_section_ptr
;
10765 else if (section_index
== SHN_COMMON
)
10766 target_sec
= bfd_com_section_ptr
;
10768 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
10772 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
10773 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
10775 while (h
->root
.type
== bfd_link_hash_indirect
10776 || h
->root
.type
== bfd_link_hash_warning
)
10777 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10779 switch (h
->root
.type
)
10781 case bfd_link_hash_defined
:
10782 case bfd_link_hash_defweak
:
10783 target_sec
= h
->root
.u
.def
.section
;
10785 case bfd_link_hash_common
:
10786 target_sec
= bfd_com_section_ptr
;
10788 case bfd_link_hash_undefined
:
10789 case bfd_link_hash_undefweak
:
10790 target_sec
= bfd_und_section_ptr
;
10792 default: /* New indirect warning. */
10793 target_sec
= bfd_und_section_ptr
;
10801 static struct elf_link_hash_entry
*
10802 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
10804 unsigned long indx
;
10805 struct elf_link_hash_entry
*h
;
10806 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10808 if (r_symndx
< symtab_hdr
->sh_info
)
10811 indx
= r_symndx
- symtab_hdr
->sh_info
;
10812 h
= elf_sym_hashes (abfd
)[indx
];
10813 while (h
->root
.type
== bfd_link_hash_indirect
10814 || h
->root
.type
== bfd_link_hash_warning
)
10815 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10820 /* Get the section-relative offset for a symbol number. */
10823 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
10825 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10826 bfd_vma offset
= 0;
10828 if (r_symndx
< symtab_hdr
->sh_info
)
10830 Elf_Internal_Sym
*isymbuf
;
10831 isymbuf
= retrieve_local_syms (abfd
);
10832 offset
= isymbuf
[r_symndx
].st_value
;
10836 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
10837 struct elf_link_hash_entry
*h
=
10838 elf_sym_hashes (abfd
)[indx
];
10840 while (h
->root
.type
== bfd_link_hash_indirect
10841 || h
->root
.type
== bfd_link_hash_warning
)
10842 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10843 if (h
->root
.type
== bfd_link_hash_defined
10844 || h
->root
.type
== bfd_link_hash_defweak
)
10845 offset
= h
->root
.u
.def
.value
;
10852 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
10854 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
10855 struct elf_link_hash_entry
*h
;
10857 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
10858 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
10865 pcrel_reloc_fits (xtensa_opcode opc
,
10867 bfd_vma self_address
,
10868 bfd_vma dest_address
)
10870 xtensa_isa isa
= xtensa_default_isa
;
10871 uint32 valp
= dest_address
;
10872 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
10873 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
10880 xtensa_is_property_section (asection
*sec
)
10882 if (xtensa_is_insntable_section (sec
)
10883 || xtensa_is_littable_section (sec
)
10884 || xtensa_is_proptable_section (sec
))
10892 xtensa_is_insntable_section (asection
*sec
)
10894 if (CONST_STRNEQ (sec
->name
, XTENSA_INSN_SEC_NAME
)
10895 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.x."))
10903 xtensa_is_littable_section (asection
*sec
)
10905 if (CONST_STRNEQ (sec
->name
, XTENSA_LIT_SEC_NAME
)
10906 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.p."))
10914 xtensa_is_proptable_section (asection
*sec
)
10916 if (CONST_STRNEQ (sec
->name
, XTENSA_PROP_SEC_NAME
)
10917 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.prop."))
10925 internal_reloc_compare (const void *ap
, const void *bp
)
10927 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
10928 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
10930 if (a
->r_offset
!= b
->r_offset
)
10931 return (a
->r_offset
- b
->r_offset
);
10933 /* We don't need to sort on these criteria for correctness,
10934 but enforcing a more strict ordering prevents unstable qsort
10935 from behaving differently with different implementations.
10936 Without the code below we get correct but different results
10937 on Solaris 2.7 and 2.8. We would like to always produce the
10938 same results no matter the host. */
10940 if (a
->r_info
!= b
->r_info
)
10941 return (a
->r_info
- b
->r_info
);
10943 return (a
->r_addend
- b
->r_addend
);
10948 internal_reloc_matches (const void *ap
, const void *bp
)
10950 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
10951 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
10953 /* Check if one entry overlaps with the other; this shouldn't happen
10954 except when searching for a match. */
10955 return (a
->r_offset
- b
->r_offset
);
10959 /* Predicate function used to look up a section in a particular group. */
10962 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
10964 const char *gname
= inf
;
10965 const char *group_name
= elf_group_name (sec
);
10967 return (group_name
== gname
10968 || (group_name
!= NULL
10970 && strcmp (group_name
, gname
) == 0));
10974 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
10977 xtensa_property_section_name (asection
*sec
, const char *base_name
)
10979 const char *suffix
, *group_name
;
10980 char *prop_sec_name
;
10982 group_name
= elf_group_name (sec
);
10985 suffix
= strrchr (sec
->name
, '.');
10986 if (suffix
== sec
->name
)
10988 prop_sec_name
= (char *) bfd_malloc (strlen (base_name
) + 1
10989 + (suffix
? strlen (suffix
) : 0));
10990 strcpy (prop_sec_name
, base_name
);
10992 strcat (prop_sec_name
, suffix
);
10994 else if (strncmp (sec
->name
, ".gnu.linkonce.", linkonce_len
) == 0)
10996 char *linkonce_kind
= 0;
10998 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
10999 linkonce_kind
= "x.";
11000 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11001 linkonce_kind
= "p.";
11002 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11003 linkonce_kind
= "prop.";
11007 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11008 + strlen (linkonce_kind
) + 1);
11009 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11010 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11012 suffix
= sec
->name
+ linkonce_len
;
11013 /* For backward compatibility, replace "t." instead of inserting
11014 the new linkonce_kind (but not for "prop" sections). */
11015 if (CONST_STRNEQ (suffix
, "t.") && linkonce_kind
[1] == '.')
11017 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11020 prop_sec_name
= strdup (base_name
);
11022 return prop_sec_name
;
11027 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11029 char *prop_sec_name
;
11030 asection
*prop_sec
;
11032 prop_sec_name
= xtensa_property_section_name (sec
, base_name
);
11033 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11034 match_section_group
,
11035 (void *) elf_group_name (sec
));
11036 free (prop_sec_name
);
11042 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11044 char *prop_sec_name
;
11045 asection
*prop_sec
;
11047 /* Check if the section already exists. */
11048 prop_sec_name
= xtensa_property_section_name (sec
, base_name
);
11049 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11050 match_section_group
,
11051 (void *) elf_group_name (sec
));
11052 /* If not, create it. */
11055 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11056 flags
|= (bfd_get_section_flags (sec
->owner
, sec
)
11057 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11059 prop_sec
= bfd_make_section_anyway_with_flags
11060 (sec
->owner
, strdup (prop_sec_name
), flags
);
11064 elf_group_name (prop_sec
) = elf_group_name (sec
);
11067 free (prop_sec_name
);
11073 xtensa_get_property_predef_flags (asection
*sec
)
11075 if (xtensa_is_insntable_section (sec
))
11076 return (XTENSA_PROP_INSN
11077 | XTENSA_PROP_NO_TRANSFORM
11078 | XTENSA_PROP_INSN_NO_REORDER
);
11080 if (xtensa_is_littable_section (sec
))
11081 return (XTENSA_PROP_LITERAL
11082 | XTENSA_PROP_NO_TRANSFORM
11083 | XTENSA_PROP_INSN_NO_REORDER
);
11089 /* Other functions called directly by the linker. */
11092 xtensa_callback_required_dependence (bfd
*abfd
,
11094 struct bfd_link_info
*link_info
,
11095 deps_callback_t callback
,
11098 Elf_Internal_Rela
*internal_relocs
;
11099 bfd_byte
*contents
;
11101 bfd_boolean ok
= TRUE
;
11102 bfd_size_type sec_size
;
11104 sec_size
= bfd_get_section_limit (abfd
, sec
);
11106 /* ".plt*" sections have no explicit relocations but they contain L32R
11107 instructions that reference the corresponding ".got.plt*" sections. */
11108 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11109 && CONST_STRNEQ (sec
->name
, ".plt"))
11113 /* Find the corresponding ".got.plt*" section. */
11114 if (sec
->name
[4] == '\0')
11115 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11121 BFD_ASSERT (sec
->name
[4] == '.');
11122 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11124 sprintf (got_name
, ".got.plt.%u", chunk
);
11125 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11127 BFD_ASSERT (sgotplt
);
11129 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11130 section referencing a literal at the very beginning of
11131 ".got.plt". This is very close to the real dependence, anyway. */
11132 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11135 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11136 when building uclibc, which runs "ld -b binary /dev/null". */
11137 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11140 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11141 link_info
->keep_memory
);
11142 if (internal_relocs
== NULL
11143 || sec
->reloc_count
== 0)
11146 /* Cache the contents for the duration of this scan. */
11147 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11148 if (contents
== NULL
&& sec_size
!= 0)
11154 if (!xtensa_default_isa
)
11155 xtensa_default_isa
= xtensa_isa_init (0, 0);
11157 for (i
= 0; i
< sec
->reloc_count
; i
++)
11159 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11160 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11163 asection
*target_sec
;
11164 bfd_vma target_offset
;
11166 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11169 /* L32Rs must be local to the input file. */
11170 if (r_reloc_is_defined (&l32r_rel
))
11172 target_sec
= r_reloc_get_section (&l32r_rel
);
11173 target_offset
= l32r_rel
.target_offset
;
11175 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11181 release_internal_relocs (sec
, internal_relocs
);
11182 release_contents (sec
, contents
);
11186 /* The default literal sections should always be marked as "code" (i.e.,
11187 SHF_EXECINSTR). This is particularly important for the Linux kernel
11188 module loader so that the literals are not placed after the text. */
11189 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11191 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11192 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11193 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11194 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11195 { NULL
, 0, 0, 0, 0 }
11198 #define ELF_TARGET_ID XTENSA_ELF_DATA
11200 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11201 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11202 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11203 #define TARGET_BIG_NAME "elf32-xtensa-be"
11204 #define ELF_ARCH bfd_arch_xtensa
11206 #define ELF_MACHINE_CODE EM_XTENSA
11207 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11209 #define ELF_MAXPAGESIZE 0x1000
11210 #endif /* ELF_ARCH */
11212 #define elf_backend_can_gc_sections 1
11213 #define elf_backend_can_refcount 1
11214 #define elf_backend_plt_readonly 1
11215 #define elf_backend_got_header_size 4
11216 #define elf_backend_want_dynbss 0
11217 #define elf_backend_want_got_plt 1
11218 #define elf_backend_dtrel_excludes_plt 1
11220 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11222 #define bfd_elf32_mkobject elf_xtensa_mkobject
11224 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11225 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11226 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11227 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11228 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11229 #define bfd_elf32_bfd_reloc_name_lookup \
11230 elf_xtensa_reloc_name_lookup
11231 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11232 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11234 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11235 #define elf_backend_check_relocs elf_xtensa_check_relocs
11236 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11237 #define elf_backend_discard_info elf_xtensa_discard_info
11238 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11239 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11240 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11241 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11242 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11243 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11244 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11245 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11246 #define elf_backend_object_p elf_xtensa_object_p
11247 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11248 #define elf_backend_relocate_section elf_xtensa_relocate_section
11249 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11250 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11251 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11252 #define elf_backend_special_sections elf_xtensa_special_sections
11253 #define elf_backend_action_discarded elf_xtensa_action_discarded
11254 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11256 #include "elf32-target.h"