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 /* Place property records for a section into individual property section
158 with xt.prop. prefix. */
160 bfd_boolean elf32xtensa_separate_props
= FALSE
;
162 /* Rename one of the generic section flags to better document how it
164 /* Whether relocations have been processed. */
165 #define reloc_done sec_flg0
167 static reloc_howto_type elf_howto_table
[] =
169 HOWTO (R_XTENSA_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
170 bfd_elf_xtensa_reloc
, "R_XTENSA_NONE",
172 HOWTO (R_XTENSA_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
173 bfd_elf_xtensa_reloc
, "R_XTENSA_32",
174 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
176 /* Replace a 32-bit value with a value from the runtime linker (only
177 used by linker-generated stub functions). The r_addend value is
178 special: 1 means to substitute a pointer to the runtime linker's
179 dynamic resolver function; 2 means to substitute the link map for
180 the shared object. */
181 HOWTO (R_XTENSA_RTLD
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
182 NULL
, "R_XTENSA_RTLD", FALSE
, 0, 0, FALSE
),
184 HOWTO (R_XTENSA_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
185 bfd_elf_generic_reloc
, "R_XTENSA_GLOB_DAT",
186 FALSE
, 0, 0xffffffff, FALSE
),
187 HOWTO (R_XTENSA_JMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
188 bfd_elf_generic_reloc
, "R_XTENSA_JMP_SLOT",
189 FALSE
, 0, 0xffffffff, FALSE
),
190 HOWTO (R_XTENSA_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
191 bfd_elf_generic_reloc
, "R_XTENSA_RELATIVE",
192 FALSE
, 0, 0xffffffff, FALSE
),
193 HOWTO (R_XTENSA_PLT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
194 bfd_elf_xtensa_reloc
, "R_XTENSA_PLT",
195 FALSE
, 0, 0xffffffff, FALSE
),
199 /* Old relocations for backward compatibility. */
200 HOWTO (R_XTENSA_OP0
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
201 bfd_elf_xtensa_reloc
, "R_XTENSA_OP0", FALSE
, 0, 0, TRUE
),
202 HOWTO (R_XTENSA_OP1
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
203 bfd_elf_xtensa_reloc
, "R_XTENSA_OP1", FALSE
, 0, 0, TRUE
),
204 HOWTO (R_XTENSA_OP2
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
205 bfd_elf_xtensa_reloc
, "R_XTENSA_OP2", FALSE
, 0, 0, TRUE
),
207 /* Assembly auto-expansion. */
208 HOWTO (R_XTENSA_ASM_EXPAND
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
209 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_EXPAND", FALSE
, 0, 0, TRUE
),
210 /* Relax assembly auto-expansion. */
211 HOWTO (R_XTENSA_ASM_SIMPLIFY
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
212 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_SIMPLIFY", FALSE
, 0, 0, TRUE
),
216 HOWTO (R_XTENSA_32_PCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
217 bfd_elf_xtensa_reloc
, "R_XTENSA_32_PCREL",
218 FALSE
, 0, 0xffffffff, TRUE
),
220 /* GNU extension to record C++ vtable hierarchy. */
221 HOWTO (R_XTENSA_GNU_VTINHERIT
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
222 NULL
, "R_XTENSA_GNU_VTINHERIT",
224 /* GNU extension to record C++ vtable member usage. */
225 HOWTO (R_XTENSA_GNU_VTENTRY
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
226 _bfd_elf_rel_vtable_reloc_fn
, "R_XTENSA_GNU_VTENTRY",
229 /* Relocations for supporting difference of symbols. */
230 HOWTO (R_XTENSA_DIFF8
, 0, 0, 8, FALSE
, 0, complain_overflow_signed
,
231 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF8", FALSE
, 0, 0xff, FALSE
),
232 HOWTO (R_XTENSA_DIFF16
, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,
233 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF16", FALSE
, 0, 0xffff, FALSE
),
234 HOWTO (R_XTENSA_DIFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
235 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF32", FALSE
, 0, 0xffffffff, FALSE
),
237 /* General immediate operand relocations. */
238 HOWTO (R_XTENSA_SLOT0_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
239 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_OP", FALSE
, 0, 0, TRUE
),
240 HOWTO (R_XTENSA_SLOT1_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
241 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_OP", FALSE
, 0, 0, TRUE
),
242 HOWTO (R_XTENSA_SLOT2_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
243 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_OP", FALSE
, 0, 0, TRUE
),
244 HOWTO (R_XTENSA_SLOT3_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
245 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_OP", FALSE
, 0, 0, TRUE
),
246 HOWTO (R_XTENSA_SLOT4_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
247 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_OP", FALSE
, 0, 0, TRUE
),
248 HOWTO (R_XTENSA_SLOT5_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
249 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_OP", FALSE
, 0, 0, TRUE
),
250 HOWTO (R_XTENSA_SLOT6_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
251 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_OP", FALSE
, 0, 0, TRUE
),
252 HOWTO (R_XTENSA_SLOT7_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
253 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_OP", FALSE
, 0, 0, TRUE
),
254 HOWTO (R_XTENSA_SLOT8_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
255 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_OP", FALSE
, 0, 0, TRUE
),
256 HOWTO (R_XTENSA_SLOT9_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
257 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_OP", FALSE
, 0, 0, TRUE
),
258 HOWTO (R_XTENSA_SLOT10_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
259 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_OP", FALSE
, 0, 0, TRUE
),
260 HOWTO (R_XTENSA_SLOT11_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
261 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_OP", FALSE
, 0, 0, TRUE
),
262 HOWTO (R_XTENSA_SLOT12_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
263 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_OP", FALSE
, 0, 0, TRUE
),
264 HOWTO (R_XTENSA_SLOT13_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
265 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_OP", FALSE
, 0, 0, TRUE
),
266 HOWTO (R_XTENSA_SLOT14_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
267 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_OP", FALSE
, 0, 0, TRUE
),
269 /* "Alternate" relocations. The meaning of these is opcode-specific. */
270 HOWTO (R_XTENSA_SLOT0_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
271 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_ALT", FALSE
, 0, 0, TRUE
),
272 HOWTO (R_XTENSA_SLOT1_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
273 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_ALT", FALSE
, 0, 0, TRUE
),
274 HOWTO (R_XTENSA_SLOT2_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
275 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_ALT", FALSE
, 0, 0, TRUE
),
276 HOWTO (R_XTENSA_SLOT3_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
277 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_ALT", FALSE
, 0, 0, TRUE
),
278 HOWTO (R_XTENSA_SLOT4_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
279 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_ALT", FALSE
, 0, 0, TRUE
),
280 HOWTO (R_XTENSA_SLOT5_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
281 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_ALT", FALSE
, 0, 0, TRUE
),
282 HOWTO (R_XTENSA_SLOT6_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
283 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_ALT", FALSE
, 0, 0, TRUE
),
284 HOWTO (R_XTENSA_SLOT7_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
285 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_ALT", FALSE
, 0, 0, TRUE
),
286 HOWTO (R_XTENSA_SLOT8_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
287 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_ALT", FALSE
, 0, 0, TRUE
),
288 HOWTO (R_XTENSA_SLOT9_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
289 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_ALT", FALSE
, 0, 0, TRUE
),
290 HOWTO (R_XTENSA_SLOT10_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
291 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_ALT", FALSE
, 0, 0, TRUE
),
292 HOWTO (R_XTENSA_SLOT11_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
293 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_ALT", FALSE
, 0, 0, TRUE
),
294 HOWTO (R_XTENSA_SLOT12_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
295 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_ALT", FALSE
, 0, 0, TRUE
),
296 HOWTO (R_XTENSA_SLOT13_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
297 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_ALT", FALSE
, 0, 0, TRUE
),
298 HOWTO (R_XTENSA_SLOT14_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
299 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_ALT", FALSE
, 0, 0, TRUE
),
301 /* TLS relocations. */
302 HOWTO (R_XTENSA_TLSDESC_FN
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
303 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_FN",
304 FALSE
, 0, 0xffffffff, FALSE
),
305 HOWTO (R_XTENSA_TLSDESC_ARG
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
306 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_ARG",
307 FALSE
, 0, 0xffffffff, FALSE
),
308 HOWTO (R_XTENSA_TLS_DTPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
309 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_DTPOFF",
310 FALSE
, 0, 0xffffffff, FALSE
),
311 HOWTO (R_XTENSA_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
312 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_TPOFF",
313 FALSE
, 0, 0xffffffff, FALSE
),
314 HOWTO (R_XTENSA_TLS_FUNC
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
315 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_FUNC",
317 HOWTO (R_XTENSA_TLS_ARG
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
318 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_ARG",
320 HOWTO (R_XTENSA_TLS_CALL
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
321 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_CALL",
327 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
332 static reloc_howto_type
*
333 elf_xtensa_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
334 bfd_reloc_code_real_type code
)
339 TRACE ("BFD_RELOC_NONE");
340 return &elf_howto_table
[(unsigned) R_XTENSA_NONE
];
343 TRACE ("BFD_RELOC_32");
344 return &elf_howto_table
[(unsigned) R_XTENSA_32
];
346 case BFD_RELOC_32_PCREL
:
347 TRACE ("BFD_RELOC_32_PCREL");
348 return &elf_howto_table
[(unsigned) R_XTENSA_32_PCREL
];
350 case BFD_RELOC_XTENSA_DIFF8
:
351 TRACE ("BFD_RELOC_XTENSA_DIFF8");
352 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF8
];
354 case BFD_RELOC_XTENSA_DIFF16
:
355 TRACE ("BFD_RELOC_XTENSA_DIFF16");
356 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF16
];
358 case BFD_RELOC_XTENSA_DIFF32
:
359 TRACE ("BFD_RELOC_XTENSA_DIFF32");
360 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF32
];
362 case BFD_RELOC_XTENSA_RTLD
:
363 TRACE ("BFD_RELOC_XTENSA_RTLD");
364 return &elf_howto_table
[(unsigned) R_XTENSA_RTLD
];
366 case BFD_RELOC_XTENSA_GLOB_DAT
:
367 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
368 return &elf_howto_table
[(unsigned) R_XTENSA_GLOB_DAT
];
370 case BFD_RELOC_XTENSA_JMP_SLOT
:
371 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
372 return &elf_howto_table
[(unsigned) R_XTENSA_JMP_SLOT
];
374 case BFD_RELOC_XTENSA_RELATIVE
:
375 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
376 return &elf_howto_table
[(unsigned) R_XTENSA_RELATIVE
];
378 case BFD_RELOC_XTENSA_PLT
:
379 TRACE ("BFD_RELOC_XTENSA_PLT");
380 return &elf_howto_table
[(unsigned) R_XTENSA_PLT
];
382 case BFD_RELOC_XTENSA_OP0
:
383 TRACE ("BFD_RELOC_XTENSA_OP0");
384 return &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
386 case BFD_RELOC_XTENSA_OP1
:
387 TRACE ("BFD_RELOC_XTENSA_OP1");
388 return &elf_howto_table
[(unsigned) R_XTENSA_OP1
];
390 case BFD_RELOC_XTENSA_OP2
:
391 TRACE ("BFD_RELOC_XTENSA_OP2");
392 return &elf_howto_table
[(unsigned) R_XTENSA_OP2
];
394 case BFD_RELOC_XTENSA_ASM_EXPAND
:
395 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
396 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_EXPAND
];
398 case BFD_RELOC_XTENSA_ASM_SIMPLIFY
:
399 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
400 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_SIMPLIFY
];
402 case BFD_RELOC_VTABLE_INHERIT
:
403 TRACE ("BFD_RELOC_VTABLE_INHERIT");
404 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTINHERIT
];
406 case BFD_RELOC_VTABLE_ENTRY
:
407 TRACE ("BFD_RELOC_VTABLE_ENTRY");
408 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTENTRY
];
410 case BFD_RELOC_XTENSA_TLSDESC_FN
:
411 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
412 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_FN
];
414 case BFD_RELOC_XTENSA_TLSDESC_ARG
:
415 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
416 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_ARG
];
418 case BFD_RELOC_XTENSA_TLS_DTPOFF
:
419 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
420 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_DTPOFF
];
422 case BFD_RELOC_XTENSA_TLS_TPOFF
:
423 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
424 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_TPOFF
];
426 case BFD_RELOC_XTENSA_TLS_FUNC
:
427 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
428 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_FUNC
];
430 case BFD_RELOC_XTENSA_TLS_ARG
:
431 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
432 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_ARG
];
434 case BFD_RELOC_XTENSA_TLS_CALL
:
435 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
436 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_CALL
];
439 if (code
>= BFD_RELOC_XTENSA_SLOT0_OP
440 && code
<= BFD_RELOC_XTENSA_SLOT14_OP
)
442 unsigned n
= (R_XTENSA_SLOT0_OP
+
443 (code
- BFD_RELOC_XTENSA_SLOT0_OP
));
444 return &elf_howto_table
[n
];
447 if (code
>= BFD_RELOC_XTENSA_SLOT0_ALT
448 && code
<= BFD_RELOC_XTENSA_SLOT14_ALT
)
450 unsigned n
= (R_XTENSA_SLOT0_ALT
+
451 (code
- BFD_RELOC_XTENSA_SLOT0_ALT
));
452 return &elf_howto_table
[n
];
458 /* xgettext:c-format */
459 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
, (int) code
);
460 bfd_set_error (bfd_error_bad_value
);
465 static reloc_howto_type
*
466 elf_xtensa_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
471 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
472 if (elf_howto_table
[i
].name
!= NULL
473 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
474 return &elf_howto_table
[i
];
480 /* Given an ELF "rela" relocation, find the corresponding howto and record
481 it in the BFD internal arelent representation of the relocation. */
484 elf_xtensa_info_to_howto_rela (bfd
*abfd
,
486 Elf_Internal_Rela
*dst
)
488 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
490 if (r_type
>= (unsigned int) R_XTENSA_max
)
492 /* xgettext:c-format */
493 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
495 bfd_set_error (bfd_error_bad_value
);
498 cache_ptr
->howto
= &elf_howto_table
[r_type
];
503 /* Functions for the Xtensa ELF linker. */
505 /* The name of the dynamic interpreter. This is put in the .interp
508 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
510 /* The size in bytes of an entry in the procedure linkage table.
511 (This does _not_ include the space for the literals associated with
514 #define PLT_ENTRY_SIZE 16
516 /* For _really_ large PLTs, we may need to alternate between literals
517 and code to keep the literals within the 256K range of the L32R
518 instructions in the code. It's unlikely that anyone would ever need
519 such a big PLT, but an arbitrary limit on the PLT size would be bad.
520 Thus, we split the PLT into chunks. Since there's very little
521 overhead (2 extra literals) for each chunk, the chunk size is kept
522 small so that the code for handling multiple chunks get used and
523 tested regularly. With 254 entries, there are 1K of literals for
524 each chunk, and that seems like a nice round number. */
526 #define PLT_ENTRIES_PER_CHUNK 254
528 /* PLT entries are actually used as stub functions for lazy symbol
529 resolution. Once the symbol is resolved, the stub function is never
530 invoked. Note: the 32-byte frame size used here cannot be changed
531 without a corresponding change in the runtime linker. */
533 static const bfd_byte elf_xtensa_be_plt_entry
[][PLT_ENTRY_SIZE
] =
536 0x6c, 0x10, 0x04, /* entry sp, 32 */
537 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
538 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
539 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
540 0x0a, 0x80, 0x00, /* jx a8 */
544 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
545 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
546 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
547 0x0a, 0x80, 0x00, /* jx a8 */
552 static const bfd_byte elf_xtensa_le_plt_entry
[][PLT_ENTRY_SIZE
] =
555 0x36, 0x41, 0x00, /* entry sp, 32 */
556 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
557 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
558 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
559 0xa0, 0x08, 0x00, /* jx a8 */
563 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
564 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
565 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
566 0xa0, 0x08, 0x00, /* jx a8 */
571 /* The size of the thread control block. */
574 struct elf_xtensa_link_hash_entry
576 struct elf_link_hash_entry elf
;
578 bfd_signed_vma tlsfunc_refcount
;
580 #define GOT_UNKNOWN 0
582 #define GOT_TLS_GD 2 /* global or local dynamic */
583 #define GOT_TLS_IE 4 /* initial or local exec */
584 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
585 unsigned char tls_type
;
588 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
590 struct elf_xtensa_obj_tdata
592 struct elf_obj_tdata root
;
594 /* tls_type for each local got entry. */
595 char *local_got_tls_type
;
597 bfd_signed_vma
*local_tlsfunc_refcounts
;
600 #define elf_xtensa_tdata(abfd) \
601 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
603 #define elf_xtensa_local_got_tls_type(abfd) \
604 (elf_xtensa_tdata (abfd)->local_got_tls_type)
606 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
607 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
609 #define is_xtensa_elf(bfd) \
610 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
611 && elf_tdata (bfd) != NULL \
612 && elf_object_id (bfd) == XTENSA_ELF_DATA)
615 elf_xtensa_mkobject (bfd
*abfd
)
617 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_xtensa_obj_tdata
),
621 /* Xtensa ELF linker hash table. */
623 struct elf_xtensa_link_hash_table
625 struct elf_link_hash_table elf
;
627 /* Short-cuts to get to dynamic linker sections. */
629 asection
*spltlittbl
;
631 /* Total count of PLT relocations seen during check_relocs.
632 The actual PLT code must be split into multiple sections and all
633 the sections have to be created before size_dynamic_sections,
634 where we figure out the exact number of PLT entries that will be
635 needed. It is OK if this count is an overestimate, e.g., some
636 relocations may be removed by GC. */
639 struct elf_xtensa_link_hash_entry
*tlsbase
;
642 /* Get the Xtensa ELF linker hash table from a link_info structure. */
644 #define elf_xtensa_hash_table(p) \
645 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
646 == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
648 /* Create an entry in an Xtensa ELF linker hash table. */
650 static struct bfd_hash_entry
*
651 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
652 struct bfd_hash_table
*table
,
655 /* Allocate the structure if it has not already been allocated by a
659 entry
= bfd_hash_allocate (table
,
660 sizeof (struct elf_xtensa_link_hash_entry
));
665 /* Call the allocation method of the superclass. */
666 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
669 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (entry
);
670 eh
->tlsfunc_refcount
= 0;
671 eh
->tls_type
= GOT_UNKNOWN
;
677 /* Create an Xtensa ELF linker hash table. */
679 static struct bfd_link_hash_table
*
680 elf_xtensa_link_hash_table_create (bfd
*abfd
)
682 struct elf_link_hash_entry
*tlsbase
;
683 struct elf_xtensa_link_hash_table
*ret
;
684 bfd_size_type amt
= sizeof (struct elf_xtensa_link_hash_table
);
686 ret
= bfd_zmalloc (amt
);
690 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
691 elf_xtensa_link_hash_newfunc
,
692 sizeof (struct elf_xtensa_link_hash_entry
),
699 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
701 tlsbase
= elf_link_hash_lookup (&ret
->elf
, "_TLS_MODULE_BASE_",
703 tlsbase
->root
.type
= bfd_link_hash_new
;
704 tlsbase
->root
.u
.undef
.abfd
= NULL
;
705 tlsbase
->non_elf
= 0;
706 ret
->tlsbase
= elf_xtensa_hash_entry (tlsbase
);
707 ret
->tlsbase
->tls_type
= GOT_UNKNOWN
;
709 return &ret
->elf
.root
;
712 /* Copy the extra info we tack onto an elf_link_hash_entry. */
715 elf_xtensa_copy_indirect_symbol (struct bfd_link_info
*info
,
716 struct elf_link_hash_entry
*dir
,
717 struct elf_link_hash_entry
*ind
)
719 struct elf_xtensa_link_hash_entry
*edir
, *eind
;
721 edir
= elf_xtensa_hash_entry (dir
);
722 eind
= elf_xtensa_hash_entry (ind
);
724 if (ind
->root
.type
== bfd_link_hash_indirect
)
726 edir
->tlsfunc_refcount
+= eind
->tlsfunc_refcount
;
727 eind
->tlsfunc_refcount
= 0;
729 if (dir
->got
.refcount
<= 0)
731 edir
->tls_type
= eind
->tls_type
;
732 eind
->tls_type
= GOT_UNKNOWN
;
736 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
739 static inline bfd_boolean
740 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
741 struct bfd_link_info
*info
)
743 /* Check if we should do dynamic things to this symbol. The
744 "ignore_protected" argument need not be set, because Xtensa code
745 does not require special handling of STV_PROTECTED to make function
746 pointer comparisons work properly. The PLT addresses are never
747 used for function pointers. */
749 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
754 property_table_compare (const void *ap
, const void *bp
)
756 const property_table_entry
*a
= (const property_table_entry
*) ap
;
757 const property_table_entry
*b
= (const property_table_entry
*) bp
;
759 if (a
->address
== b
->address
)
761 if (a
->size
!= b
->size
)
762 return (a
->size
- b
->size
);
764 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
765 return ((b
->flags
& XTENSA_PROP_ALIGN
)
766 - (a
->flags
& XTENSA_PROP_ALIGN
));
768 if ((a
->flags
& XTENSA_PROP_ALIGN
)
769 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
770 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
771 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
772 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
774 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
775 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
776 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
777 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
779 return (a
->flags
- b
->flags
);
782 return (a
->address
- b
->address
);
787 property_table_matches (const void *ap
, const void *bp
)
789 const property_table_entry
*a
= (const property_table_entry
*) ap
;
790 const property_table_entry
*b
= (const property_table_entry
*) bp
;
792 /* Check if one entry overlaps with the other. */
793 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
794 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
797 return (a
->address
- b
->address
);
801 /* Get the literal table or property table entries for the given
802 section. Sets TABLE_P and returns the number of entries. On
803 error, returns a negative value. */
806 xtensa_read_table_entries (bfd
*abfd
,
808 property_table_entry
**table_p
,
809 const char *sec_name
,
810 bfd_boolean output_addr
)
812 asection
*table_section
;
813 bfd_size_type table_size
= 0;
814 bfd_byte
*table_data
;
815 property_table_entry
*blocks
;
816 int blk
, block_count
;
817 bfd_size_type num_records
;
818 Elf_Internal_Rela
*internal_relocs
, *irel
, *rel_end
;
819 bfd_vma section_addr
, off
;
820 flagword predef_flags
;
821 bfd_size_type table_entry_size
, section_limit
;
824 || !(section
->flags
& SEC_ALLOC
)
825 || (section
->flags
& SEC_DEBUGGING
))
831 table_section
= xtensa_get_property_section (section
, sec_name
);
833 table_size
= table_section
->size
;
841 predef_flags
= xtensa_get_property_predef_flags (table_section
);
842 table_entry_size
= 12;
844 table_entry_size
-= 4;
846 num_records
= table_size
/ table_entry_size
;
847 table_data
= retrieve_contents (abfd
, table_section
, TRUE
);
848 blocks
= (property_table_entry
*)
849 bfd_malloc (num_records
* sizeof (property_table_entry
));
853 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
855 section_addr
= section
->vma
;
857 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, TRUE
);
858 if (internal_relocs
&& !table_section
->reloc_done
)
860 qsort (internal_relocs
, table_section
->reloc_count
,
861 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
862 irel
= internal_relocs
;
867 section_limit
= bfd_get_section_limit (abfd
, section
);
868 rel_end
= internal_relocs
+ table_section
->reloc_count
;
870 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
872 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
874 /* Skip any relocations before the current offset. This should help
875 avoid confusion caused by unexpected relocations for the preceding
878 (irel
->r_offset
< off
879 || (irel
->r_offset
== off
880 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
887 if (irel
&& irel
->r_offset
== off
)
890 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
891 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
893 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
896 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
897 BFD_ASSERT (sym_off
== 0);
898 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
902 if (address
< section_addr
903 || address
>= section_addr
+ section_limit
)
907 blocks
[block_count
].address
= address
;
908 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
910 blocks
[block_count
].flags
= predef_flags
;
912 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
916 release_contents (table_section
, table_data
);
917 release_internal_relocs (table_section
, internal_relocs
);
921 /* Now sort them into address order for easy reference. */
922 qsort (blocks
, block_count
, sizeof (property_table_entry
),
923 property_table_compare
);
925 /* Check that the table contents are valid. Problems may occur,
926 for example, if an unrelocated object file is stripped. */
927 for (blk
= 1; blk
< block_count
; blk
++)
929 /* The only circumstance where two entries may legitimately
930 have the same address is when one of them is a zero-size
931 placeholder to mark a place where fill can be inserted.
932 The zero-size entry should come first. */
933 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
934 blocks
[blk
- 1].size
!= 0)
936 /* xgettext:c-format */
937 _bfd_error_handler (_("%pB(%pA): invalid property table"),
939 bfd_set_error (bfd_error_bad_value
);
951 static property_table_entry
*
952 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
953 int property_table_size
,
956 property_table_entry entry
;
957 property_table_entry
*rv
;
959 if (property_table_size
== 0)
962 entry
.address
= addr
;
966 rv
= bsearch (&entry
, property_table
, property_table_size
,
967 sizeof (property_table_entry
), property_table_matches
);
973 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
977 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
984 /* Look through the relocs for a section during the first phase, and
985 calculate needed space in the dynamic reloc sections. */
988 elf_xtensa_check_relocs (bfd
*abfd
,
989 struct bfd_link_info
*info
,
991 const Elf_Internal_Rela
*relocs
)
993 struct elf_xtensa_link_hash_table
*htab
;
994 Elf_Internal_Shdr
*symtab_hdr
;
995 struct elf_link_hash_entry
**sym_hashes
;
996 const Elf_Internal_Rela
*rel
;
997 const Elf_Internal_Rela
*rel_end
;
999 if (bfd_link_relocatable (info
) || (sec
->flags
& SEC_ALLOC
) == 0)
1002 BFD_ASSERT (is_xtensa_elf (abfd
));
1004 htab
= elf_xtensa_hash_table (info
);
1008 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1009 sym_hashes
= elf_sym_hashes (abfd
);
1011 rel_end
= relocs
+ sec
->reloc_count
;
1012 for (rel
= relocs
; rel
< rel_end
; rel
++)
1014 unsigned int r_type
;
1016 struct elf_link_hash_entry
*h
= NULL
;
1017 struct elf_xtensa_link_hash_entry
*eh
;
1018 int tls_type
, old_tls_type
;
1019 bfd_boolean is_got
= FALSE
;
1020 bfd_boolean is_plt
= FALSE
;
1021 bfd_boolean is_tlsfunc
= FALSE
;
1023 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1024 r_type
= ELF32_R_TYPE (rel
->r_info
);
1026 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1028 /* xgettext:c-format */
1029 _bfd_error_handler (_("%pB: bad symbol index: %d"),
1034 if (r_symndx
>= symtab_hdr
->sh_info
)
1036 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1037 while (h
->root
.type
== bfd_link_hash_indirect
1038 || h
->root
.type
== bfd_link_hash_warning
)
1039 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1041 eh
= elf_xtensa_hash_entry (h
);
1045 case R_XTENSA_TLSDESC_FN
:
1046 if (bfd_link_pic (info
))
1048 tls_type
= GOT_TLS_GD
;
1053 tls_type
= GOT_TLS_IE
;
1056 case R_XTENSA_TLSDESC_ARG
:
1057 if (bfd_link_pic (info
))
1059 tls_type
= GOT_TLS_GD
;
1064 tls_type
= GOT_TLS_IE
;
1065 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1070 case R_XTENSA_TLS_DTPOFF
:
1071 if (bfd_link_pic (info
))
1072 tls_type
= GOT_TLS_GD
;
1074 tls_type
= GOT_TLS_IE
;
1077 case R_XTENSA_TLS_TPOFF
:
1078 tls_type
= GOT_TLS_IE
;
1079 if (bfd_link_pic (info
))
1080 info
->flags
|= DF_STATIC_TLS
;
1081 if (bfd_link_pic (info
) || h
)
1086 tls_type
= GOT_NORMAL
;
1091 tls_type
= GOT_NORMAL
;
1095 case R_XTENSA_GNU_VTINHERIT
:
1096 /* This relocation describes the C++ object vtable hierarchy.
1097 Reconstruct it for later use during GC. */
1098 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1102 case R_XTENSA_GNU_VTENTRY
:
1103 /* This relocation describes which C++ vtable entries are actually
1104 used. Record for later use during GC. */
1105 BFD_ASSERT (h
!= NULL
);
1107 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1112 /* Nothing to do for any other relocations. */
1120 if (h
->plt
.refcount
<= 0)
1123 h
->plt
.refcount
= 1;
1126 h
->plt
.refcount
+= 1;
1128 /* Keep track of the total PLT relocation count even if we
1129 don't yet know whether the dynamic sections will be
1131 htab
->plt_reloc_count
+= 1;
1133 if (elf_hash_table (info
)->dynamic_sections_created
)
1135 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1141 if (h
->got
.refcount
<= 0)
1142 h
->got
.refcount
= 1;
1144 h
->got
.refcount
+= 1;
1148 eh
->tlsfunc_refcount
+= 1;
1150 old_tls_type
= eh
->tls_type
;
1154 /* Allocate storage the first time. */
1155 if (elf_local_got_refcounts (abfd
) == NULL
)
1157 bfd_size_type size
= symtab_hdr
->sh_info
;
1160 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1163 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1165 mem
= bfd_zalloc (abfd
, size
);
1168 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1170 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1173 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1174 = (bfd_signed_vma
*) mem
;
1177 /* This is a global offset table entry for a local symbol. */
1178 if (is_got
|| is_plt
)
1179 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1182 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1184 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1187 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1188 tls_type
|= old_tls_type
;
1189 /* If a TLS symbol is accessed using IE at least once,
1190 there is no point to use a dynamic model for it. */
1191 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1192 && ((old_tls_type
& GOT_TLS_GD
) == 0
1193 || (tls_type
& GOT_TLS_IE
) == 0))
1195 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1196 tls_type
= old_tls_type
;
1197 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1198 tls_type
|= old_tls_type
;
1202 /* xgettext:c-format */
1203 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1205 h
? h
->root
.root
.string
: "<local>");
1210 if (old_tls_type
!= tls_type
)
1213 eh
->tls_type
= tls_type
;
1215 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1224 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1225 struct elf_link_hash_entry
*h
)
1227 if (bfd_link_pic (info
))
1229 if (h
->plt
.refcount
> 0)
1231 /* For shared objects, there's no need for PLT entries for local
1232 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1233 if (h
->got
.refcount
< 0)
1234 h
->got
.refcount
= 0;
1235 h
->got
.refcount
+= h
->plt
.refcount
;
1236 h
->plt
.refcount
= 0;
1241 /* Don't need any dynamic relocations at all. */
1242 h
->plt
.refcount
= 0;
1243 h
->got
.refcount
= 0;
1249 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1250 struct elf_link_hash_entry
*h
,
1251 bfd_boolean force_local
)
1253 /* For a shared link, move the plt refcount to the got refcount to leave
1254 space for RELATIVE relocs. */
1255 elf_xtensa_make_sym_local (info
, h
);
1257 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1261 /* Return the section that should be marked against GC for a given
1265 elf_xtensa_gc_mark_hook (asection
*sec
,
1266 struct bfd_link_info
*info
,
1267 Elf_Internal_Rela
*rel
,
1268 struct elf_link_hash_entry
*h
,
1269 Elf_Internal_Sym
*sym
)
1271 /* Property sections are marked "KEEP" in the linker scripts, but they
1272 should not cause other sections to be marked. (This approach relies
1273 on elf_xtensa_discard_info to remove property table entries that
1274 describe discarded sections. Alternatively, it might be more
1275 efficient to avoid using "KEEP" in the linker scripts and instead use
1276 the gc_mark_extra_sections hook to mark only the property sections
1277 that describe marked sections. That alternative does not work well
1278 with the current property table sections, which do not correspond
1279 one-to-one with the sections they describe, but that should be fixed
1281 if (xtensa_is_property_section (sec
))
1285 switch (ELF32_R_TYPE (rel
->r_info
))
1287 case R_XTENSA_GNU_VTINHERIT
:
1288 case R_XTENSA_GNU_VTENTRY
:
1292 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1296 /* Create all the dynamic sections. */
1299 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1301 struct elf_xtensa_link_hash_table
*htab
;
1302 flagword flags
, noalloc_flags
;
1304 htab
= elf_xtensa_hash_table (info
);
1308 /* First do all the standard stuff. */
1309 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1312 /* Create any extra PLT sections in case check_relocs has already
1313 been called on all the non-dynamic input files. */
1314 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1317 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1318 | SEC_LINKER_CREATED
| SEC_READONLY
);
1319 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1321 /* Mark the ".got.plt" section READONLY. */
1322 if (htab
->elf
.sgotplt
== NULL
1323 || ! bfd_set_section_flags (dynobj
, htab
->elf
.sgotplt
, flags
))
1326 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1327 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1329 if (htab
->sgotloc
== NULL
1330 || ! bfd_set_section_alignment (dynobj
, htab
->sgotloc
, 2))
1333 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1334 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1336 if (htab
->spltlittbl
== NULL
1337 || ! bfd_set_section_alignment (dynobj
, htab
->spltlittbl
, 2))
1345 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1347 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1350 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1351 ".got.plt" sections. */
1352 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1358 /* Stop when we find a section has already been created. */
1359 if (elf_xtensa_get_plt_section (info
, chunk
))
1362 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1363 | SEC_LINKER_CREATED
| SEC_READONLY
);
1365 sname
= (char *) bfd_malloc (10);
1366 sprintf (sname
, ".plt.%u", chunk
);
1367 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1369 || ! bfd_set_section_alignment (dynobj
, s
, 2))
1372 sname
= (char *) bfd_malloc (14);
1373 sprintf (sname
, ".got.plt.%u", chunk
);
1374 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1376 || ! bfd_set_section_alignment (dynobj
, s
, 2))
1384 /* Adjust a symbol defined by a dynamic object and referenced by a
1385 regular object. The current definition is in some section of the
1386 dynamic object, but we're not including those sections. We have to
1387 change the definition to something the rest of the link can
1391 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1392 struct elf_link_hash_entry
*h
)
1394 /* If this is a weak symbol, and there is a real definition, the
1395 processor independent code will have arranged for us to see the
1396 real definition first, and we can just use the same value. */
1397 if (h
->is_weakalias
)
1399 struct elf_link_hash_entry
*def
= weakdef (h
);
1400 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1401 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1402 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1406 /* This is a reference to a symbol defined by a dynamic object. The
1407 reference must go through the GOT, so there's no need for COPY relocs,
1415 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1417 struct bfd_link_info
*info
;
1418 struct elf_xtensa_link_hash_table
*htab
;
1419 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1421 if (h
->root
.type
== bfd_link_hash_indirect
)
1424 info
= (struct bfd_link_info
*) arg
;
1425 htab
= elf_xtensa_hash_table (info
);
1429 /* If we saw any use of an IE model for this symbol, we can then optimize
1430 away GOT entries for any TLSDESC_FN relocs. */
1431 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1433 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1434 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1437 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1438 elf_xtensa_make_sym_local (info
, h
);
1440 if (h
->plt
.refcount
> 0)
1441 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1443 if (h
->got
.refcount
> 0)
1444 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1451 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1453 struct elf_xtensa_link_hash_table
*htab
;
1456 htab
= elf_xtensa_hash_table (info
);
1460 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1462 bfd_signed_vma
*local_got_refcounts
;
1463 bfd_size_type j
, cnt
;
1464 Elf_Internal_Shdr
*symtab_hdr
;
1466 local_got_refcounts
= elf_local_got_refcounts (i
);
1467 if (!local_got_refcounts
)
1470 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1471 cnt
= symtab_hdr
->sh_info
;
1473 for (j
= 0; j
< cnt
; ++j
)
1475 /* If we saw any use of an IE model for this symbol, we can
1476 then optimize away GOT entries for any TLSDESC_FN relocs. */
1477 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1479 bfd_signed_vma
*tlsfunc_refcount
1480 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1481 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1482 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1485 if (local_got_refcounts
[j
] > 0)
1486 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1487 * sizeof (Elf32_External_Rela
));
1493 /* Set the sizes of the dynamic sections. */
1496 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1497 struct bfd_link_info
*info
)
1499 struct elf_xtensa_link_hash_table
*htab
;
1501 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1502 bfd_boolean relplt
, relgot
;
1503 int plt_entries
, plt_chunks
, chunk
;
1508 htab
= elf_xtensa_hash_table (info
);
1512 dynobj
= elf_hash_table (info
)->dynobj
;
1515 srelgot
= htab
->elf
.srelgot
;
1516 srelplt
= htab
->elf
.srelplt
;
1518 if (elf_hash_table (info
)->dynamic_sections_created
)
1520 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1521 && htab
->elf
.srelplt
!= NULL
1522 && htab
->elf
.sgot
!= NULL
1523 && htab
->spltlittbl
!= NULL
1524 && htab
->sgotloc
!= NULL
);
1526 /* Set the contents of the .interp section to the interpreter. */
1527 if (bfd_link_executable (info
) && !info
->nointerp
)
1529 s
= bfd_get_linker_section (dynobj
, ".interp");
1532 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1533 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1536 /* Allocate room for one word in ".got". */
1537 htab
->elf
.sgot
->size
= 4;
1539 /* Allocate space in ".rela.got" for literals that reference global
1540 symbols and space in ".rela.plt" for literals that have PLT
1542 elf_link_hash_traverse (elf_hash_table (info
),
1543 elf_xtensa_allocate_dynrelocs
,
1546 /* If we are generating a shared object, we also need space in
1547 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1548 reference local symbols. */
1549 if (bfd_link_pic (info
))
1550 elf_xtensa_allocate_local_got_size (info
);
1552 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1553 each PLT entry, we need the PLT code plus a 4-byte literal.
1554 For each chunk of ".plt", we also need two more 4-byte
1555 literals, two corresponding entries in ".rela.got", and an
1556 8-byte entry in ".xt.lit.plt". */
1557 spltlittbl
= htab
->spltlittbl
;
1558 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1560 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1562 /* Iterate over all the PLT chunks, including any extra sections
1563 created earlier because the initial count of PLT relocations
1564 was an overestimate. */
1566 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1571 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1572 BFD_ASSERT (sgotplt
!= NULL
);
1574 if (chunk
< plt_chunks
- 1)
1575 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1576 else if (chunk
== plt_chunks
- 1)
1577 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1581 if (chunk_entries
!= 0)
1583 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1584 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1585 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1586 spltlittbl
->size
+= 8;
1595 /* Allocate space in ".got.loc" to match the total size of all the
1597 sgotloc
= htab
->sgotloc
;
1598 sgotloc
->size
= spltlittbl
->size
;
1599 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1601 if (abfd
->flags
& DYNAMIC
)
1603 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1605 if (! discarded_section (s
)
1606 && xtensa_is_littable_section (s
)
1608 sgotloc
->size
+= s
->size
;
1613 /* Allocate memory for dynamic sections. */
1616 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1620 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1623 /* It's OK to base decisions on the section name, because none
1624 of the dynobj section names depend upon the input files. */
1625 name
= bfd_get_section_name (dynobj
, s
);
1627 if (CONST_STRNEQ (name
, ".rela"))
1631 if (strcmp (name
, ".rela.plt") == 0)
1633 else if (strcmp (name
, ".rela.got") == 0)
1636 /* We use the reloc_count field as a counter if we need
1637 to copy relocs into the output file. */
1641 else if (! CONST_STRNEQ (name
, ".plt.")
1642 && ! CONST_STRNEQ (name
, ".got.plt.")
1643 && strcmp (name
, ".got") != 0
1644 && strcmp (name
, ".plt") != 0
1645 && strcmp (name
, ".got.plt") != 0
1646 && strcmp (name
, ".xt.lit.plt") != 0
1647 && strcmp (name
, ".got.loc") != 0)
1649 /* It's not one of our sections, so don't allocate space. */
1655 /* If we don't need this section, strip it from the output
1656 file. We must create the ".plt*" and ".got.plt*"
1657 sections in create_dynamic_sections and/or check_relocs
1658 based on a conservative estimate of the PLT relocation
1659 count, because the sections must be created before the
1660 linker maps input sections to output sections. The
1661 linker does that before size_dynamic_sections, where we
1662 compute the exact size of the PLT, so there may be more
1663 of these sections than are actually needed. */
1664 s
->flags
|= SEC_EXCLUDE
;
1666 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1668 /* Allocate memory for the section contents. */
1669 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1670 if (s
->contents
== NULL
)
1675 if (elf_hash_table (info
)->dynamic_sections_created
)
1677 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1678 known until finish_dynamic_sections, but we need to get the relocs
1679 in place before they are sorted. */
1680 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1682 Elf_Internal_Rela irela
;
1686 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1689 loc
= (srelgot
->contents
1690 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1691 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1692 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1693 loc
+ sizeof (Elf32_External_Rela
));
1694 srelgot
->reloc_count
+= 2;
1697 /* Add some entries to the .dynamic section. We fill in the
1698 values later, in elf_xtensa_finish_dynamic_sections, but we
1699 must add the entries now so that we get the correct size for
1700 the .dynamic section. The DT_DEBUG entry is filled in by the
1701 dynamic linker and used by the debugger. */
1702 #define add_dynamic_entry(TAG, VAL) \
1703 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1705 if (bfd_link_executable (info
))
1707 if (!add_dynamic_entry (DT_DEBUG
, 0))
1713 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1714 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1715 || !add_dynamic_entry (DT_JMPREL
, 0))
1721 if (!add_dynamic_entry (DT_RELA
, 0)
1722 || !add_dynamic_entry (DT_RELASZ
, 0)
1723 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1727 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1728 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1729 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1732 #undef add_dynamic_entry
1738 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1739 struct bfd_link_info
*info
)
1741 struct elf_xtensa_link_hash_table
*htab
;
1744 htab
= elf_xtensa_hash_table (info
);
1748 tls_sec
= htab
->elf
.tls_sec
;
1750 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1752 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1753 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1754 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1756 tlsbase
->type
= STT_TLS
;
1757 if (!(_bfd_generic_link_add_one_symbol
1758 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1759 tls_sec
, 0, NULL
, FALSE
,
1760 bed
->collect
, &bh
)))
1762 tlsbase
->def_regular
= 1;
1763 tlsbase
->other
= STV_HIDDEN
;
1764 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1771 /* Return the base VMA address which should be subtracted from real addresses
1772 when resolving @dtpoff relocation.
1773 This is PT_TLS segment p_vaddr. */
1776 dtpoff_base (struct bfd_link_info
*info
)
1778 /* If tls_sec is NULL, we should have signalled an error already. */
1779 if (elf_hash_table (info
)->tls_sec
== NULL
)
1781 return elf_hash_table (info
)->tls_sec
->vma
;
1784 /* Return the relocation value for @tpoff relocation
1785 if STT_TLS virtual address is ADDRESS. */
1788 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1790 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1793 /* If tls_sec is NULL, we should have signalled an error already. */
1794 if (htab
->tls_sec
== NULL
)
1796 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1797 return address
- htab
->tls_sec
->vma
+ base
;
1800 /* Perform the specified relocation. The instruction at (contents + address)
1801 is modified to set one operand to represent the value in "relocation". The
1802 operand position is determined by the relocation type recorded in the
1805 #define CALL_SEGMENT_BITS (30)
1806 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1808 static bfd_reloc_status_type
1809 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1811 asection
*input_section
,
1815 bfd_boolean is_weak_undef
,
1816 char **error_message
)
1819 xtensa_opcode opcode
;
1820 xtensa_isa isa
= xtensa_default_isa
;
1821 static xtensa_insnbuf ibuff
= NULL
;
1822 static xtensa_insnbuf sbuff
= NULL
;
1823 bfd_vma self_address
;
1824 bfd_size_type input_size
;
1830 ibuff
= xtensa_insnbuf_alloc (isa
);
1831 sbuff
= xtensa_insnbuf_alloc (isa
);
1834 input_size
= bfd_get_section_limit (abfd
, input_section
);
1836 /* Calculate the PC address for this instruction. */
1837 self_address
= (input_section
->output_section
->vma
1838 + input_section
->output_offset
1841 switch (howto
->type
)
1844 case R_XTENSA_DIFF8
:
1845 case R_XTENSA_DIFF16
:
1846 case R_XTENSA_DIFF32
:
1847 case R_XTENSA_TLS_FUNC
:
1848 case R_XTENSA_TLS_ARG
:
1849 case R_XTENSA_TLS_CALL
:
1850 return bfd_reloc_ok
;
1852 case R_XTENSA_ASM_EXPAND
:
1855 /* Check for windowed CALL across a 1GB boundary. */
1856 opcode
= get_expanded_call_opcode (contents
+ address
,
1857 input_size
- address
, 0);
1858 if (is_windowed_call_opcode (opcode
))
1860 if ((self_address
>> CALL_SEGMENT_BITS
)
1861 != (relocation
>> CALL_SEGMENT_BITS
))
1863 *error_message
= "windowed longcall crosses 1GB boundary; "
1865 return bfd_reloc_dangerous
;
1869 return bfd_reloc_ok
;
1871 case R_XTENSA_ASM_SIMPLIFY
:
1873 /* Convert the L32R/CALLX to CALL. */
1874 bfd_reloc_status_type retval
=
1875 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1877 if (retval
!= bfd_reloc_ok
)
1878 return bfd_reloc_dangerous
;
1880 /* The CALL needs to be relocated. Continue below for that part. */
1883 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1890 x
= bfd_get_32 (abfd
, contents
+ address
);
1892 bfd_put_32 (abfd
, x
, contents
+ address
);
1894 return bfd_reloc_ok
;
1896 case R_XTENSA_32_PCREL
:
1897 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1898 return bfd_reloc_ok
;
1901 case R_XTENSA_TLSDESC_FN
:
1902 case R_XTENSA_TLSDESC_ARG
:
1903 case R_XTENSA_TLS_DTPOFF
:
1904 case R_XTENSA_TLS_TPOFF
:
1905 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1906 return bfd_reloc_ok
;
1909 /* Only instruction slot-specific relocations handled below.... */
1910 slot
= get_relocation_slot (howto
->type
);
1911 if (slot
== XTENSA_UNDEFINED
)
1913 *error_message
= "unexpected relocation";
1914 return bfd_reloc_dangerous
;
1917 /* Read the instruction into a buffer and decode the opcode. */
1918 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1919 input_size
- address
);
1920 fmt
= xtensa_format_decode (isa
, ibuff
);
1921 if (fmt
== XTENSA_UNDEFINED
)
1923 *error_message
= "cannot decode instruction format";
1924 return bfd_reloc_dangerous
;
1927 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1929 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1930 if (opcode
== XTENSA_UNDEFINED
)
1932 *error_message
= "cannot decode instruction opcode";
1933 return bfd_reloc_dangerous
;
1936 /* Check for opcode-specific "alternate" relocations. */
1937 if (is_alt_relocation (howto
->type
))
1939 if (opcode
== get_l32r_opcode ())
1941 /* Handle the special-case of non-PC-relative L32R instructions. */
1942 bfd
*output_bfd
= input_section
->output_section
->owner
;
1943 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
1946 *error_message
= "relocation references missing .lit4 section";
1947 return bfd_reloc_dangerous
;
1949 self_address
= ((lit4_sec
->vma
& ~0xfff)
1950 + 0x40000 - 3); /* -3 to compensate for do_reloc */
1951 newval
= relocation
;
1954 else if (opcode
== get_const16_opcode ())
1956 /* ALT used for high 16 bits. */
1957 newval
= relocation
>> 16;
1962 /* No other "alternate" relocations currently defined. */
1963 *error_message
= "unexpected relocation";
1964 return bfd_reloc_dangerous
;
1967 else /* Not an "alternate" relocation.... */
1969 if (opcode
== get_const16_opcode ())
1971 newval
= relocation
& 0xffff;
1976 /* ...normal PC-relative relocation.... */
1978 /* Determine which operand is being relocated. */
1979 opnd
= get_relocation_opnd (opcode
, howto
->type
);
1980 if (opnd
== XTENSA_UNDEFINED
)
1982 *error_message
= "unexpected relocation";
1983 return bfd_reloc_dangerous
;
1986 if (!howto
->pc_relative
)
1988 *error_message
= "expected PC-relative relocation";
1989 return bfd_reloc_dangerous
;
1992 newval
= relocation
;
1996 /* Apply the relocation. */
1997 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
1998 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
1999 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2002 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2005 msg
= "cannot encode";
2006 if (is_direct_call_opcode (opcode
))
2008 if ((relocation
& 0x3) != 0)
2009 msg
= "misaligned call target";
2011 msg
= "call target out of range";
2013 else if (opcode
== get_l32r_opcode ())
2015 if ((relocation
& 0x3) != 0)
2016 msg
= "misaligned literal target";
2017 else if (is_alt_relocation (howto
->type
))
2018 msg
= "literal target out of range (too many literals)";
2019 else if (self_address
> relocation
)
2020 msg
= "literal target out of range (try using text-section-literals)";
2022 msg
= "literal placed after use";
2025 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2026 return bfd_reloc_dangerous
;
2029 /* Check for calls across 1GB boundaries. */
2030 if (is_direct_call_opcode (opcode
)
2031 && is_windowed_call_opcode (opcode
))
2033 if ((self_address
>> CALL_SEGMENT_BITS
)
2034 != (relocation
>> CALL_SEGMENT_BITS
))
2037 "windowed call crosses 1GB boundary; return may fail";
2038 return bfd_reloc_dangerous
;
2042 /* Write the modified instruction back out of the buffer. */
2043 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2044 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2045 input_size
- address
);
2046 return bfd_reloc_ok
;
2051 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2053 /* To reduce the size of the memory leak,
2054 we only use a single message buffer. */
2055 static bfd_size_type alloc_size
= 0;
2056 static char *message
= NULL
;
2057 bfd_size_type orig_len
, len
= 0;
2058 bfd_boolean is_append
;
2061 va_start (ap
, arglen
);
2063 is_append
= (origmsg
== message
);
2065 orig_len
= strlen (origmsg
);
2066 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2067 if (len
> alloc_size
)
2069 message
= (char *) bfd_realloc_or_free (message
, len
);
2072 if (message
!= NULL
)
2075 memcpy (message
, origmsg
, orig_len
);
2076 vsprintf (message
+ orig_len
, fmt
, ap
);
2083 /* This function is registered as the "special_function" in the
2084 Xtensa howto for handling simplify operations.
2085 bfd_perform_relocation / bfd_install_relocation use it to
2086 perform (install) the specified relocation. Since this replaces the code
2087 in bfd_perform_relocation, it is basically an Xtensa-specific,
2088 stripped-down version of bfd_perform_relocation. */
2090 static bfd_reloc_status_type
2091 bfd_elf_xtensa_reloc (bfd
*abfd
,
2092 arelent
*reloc_entry
,
2095 asection
*input_section
,
2097 char **error_message
)
2100 bfd_reloc_status_type flag
;
2101 bfd_size_type octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
2102 bfd_vma output_base
= 0;
2103 reloc_howto_type
*howto
= reloc_entry
->howto
;
2104 asection
*reloc_target_output_section
;
2105 bfd_boolean is_weak_undef
;
2107 if (!xtensa_default_isa
)
2108 xtensa_default_isa
= xtensa_isa_init (0, 0);
2110 /* ELF relocs are against symbols. If we are producing relocatable
2111 output, and the reloc is against an external symbol, the resulting
2112 reloc will also be against the same symbol. In such a case, we
2113 don't want to change anything about the way the reloc is handled,
2114 since it will all be done at final link time. This test is similar
2115 to what bfd_elf_generic_reloc does except that it lets relocs with
2116 howto->partial_inplace go through even if the addend is non-zero.
2117 (The real problem is that partial_inplace is set for XTENSA_32
2118 relocs to begin with, but that's a long story and there's little we
2119 can do about it now....) */
2121 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2123 reloc_entry
->address
+= input_section
->output_offset
;
2124 return bfd_reloc_ok
;
2127 /* Is the address of the relocation really within the section? */
2128 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2129 return bfd_reloc_outofrange
;
2131 /* Work out which section the relocation is targeted at and the
2132 initial relocation command value. */
2134 /* Get symbol value. (Common symbols are special.) */
2135 if (bfd_is_com_section (symbol
->section
))
2138 relocation
= symbol
->value
;
2140 reloc_target_output_section
= symbol
->section
->output_section
;
2142 /* Convert input-section-relative symbol value to absolute. */
2143 if ((output_bfd
&& !howto
->partial_inplace
)
2144 || reloc_target_output_section
== NULL
)
2147 output_base
= reloc_target_output_section
->vma
;
2149 relocation
+= output_base
+ symbol
->section
->output_offset
;
2151 /* Add in supplied addend. */
2152 relocation
+= reloc_entry
->addend
;
2154 /* Here the variable relocation holds the final address of the
2155 symbol we are relocating against, plus any addend. */
2158 if (!howto
->partial_inplace
)
2160 /* This is a partial relocation, and we want to apply the relocation
2161 to the reloc entry rather than the raw data. Everything except
2162 relocations against section symbols has already been handled
2165 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2166 reloc_entry
->addend
= relocation
;
2167 reloc_entry
->address
+= input_section
->output_offset
;
2168 return bfd_reloc_ok
;
2172 reloc_entry
->address
+= input_section
->output_offset
;
2173 reloc_entry
->addend
= 0;
2177 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2178 && (symbol
->flags
& BSF_WEAK
) != 0);
2179 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2180 (bfd_byte
*) data
, (bfd_vma
) octets
,
2181 is_weak_undef
, error_message
);
2183 if (flag
== bfd_reloc_dangerous
)
2185 /* Add the symbol name to the error message. */
2186 if (! *error_message
)
2187 *error_message
= "";
2188 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2189 strlen (symbol
->name
) + 17,
2191 (unsigned long) reloc_entry
->addend
);
2198 /* Set up an entry in the procedure linkage table. */
2201 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2203 unsigned reloc_index
)
2205 asection
*splt
, *sgotplt
;
2206 bfd_vma plt_base
, got_base
;
2207 bfd_vma code_offset
, lit_offset
, abi_offset
;
2210 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2211 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2212 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2213 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2215 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2216 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2218 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2219 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2221 /* Fill in the literal entry. This is the offset of the dynamic
2222 relocation entry. */
2223 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2224 sgotplt
->contents
+ lit_offset
);
2226 /* Fill in the entry in the procedure linkage table. */
2227 memcpy (splt
->contents
+ code_offset
,
2228 (bfd_big_endian (output_bfd
)
2229 ? elf_xtensa_be_plt_entry
[XSHAL_ABI
!= XTHAL_ABI_WINDOWED
]
2230 : elf_xtensa_le_plt_entry
[XSHAL_ABI
!= XTHAL_ABI_WINDOWED
]),
2232 abi_offset
= XSHAL_ABI
== XTHAL_ABI_WINDOWED
? 3 : 0;
2233 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2234 plt_base
+ code_offset
+ abi_offset
),
2235 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2236 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2237 plt_base
+ code_offset
+ abi_offset
+ 3),
2238 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2239 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2240 plt_base
+ code_offset
+ abi_offset
+ 6),
2241 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2243 return plt_base
+ code_offset
;
2247 static bfd_boolean
get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2250 replace_tls_insn (Elf_Internal_Rela
*rel
,
2252 asection
*input_section
,
2254 bfd_boolean is_ld_model
,
2255 char **error_message
)
2257 static xtensa_insnbuf ibuff
= NULL
;
2258 static xtensa_insnbuf sbuff
= NULL
;
2259 xtensa_isa isa
= xtensa_default_isa
;
2261 xtensa_opcode old_op
, new_op
;
2262 bfd_size_type input_size
;
2264 unsigned dest_reg
, src_reg
;
2268 ibuff
= xtensa_insnbuf_alloc (isa
);
2269 sbuff
= xtensa_insnbuf_alloc (isa
);
2272 input_size
= bfd_get_section_limit (abfd
, input_section
);
2274 /* Read the instruction into a buffer and decode the opcode. */
2275 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2276 input_size
- rel
->r_offset
);
2277 fmt
= xtensa_format_decode (isa
, ibuff
);
2278 if (fmt
== XTENSA_UNDEFINED
)
2280 *error_message
= "cannot decode instruction format";
2284 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2285 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2287 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2288 if (old_op
== XTENSA_UNDEFINED
)
2290 *error_message
= "cannot decode instruction opcode";
2294 r_type
= ELF32_R_TYPE (rel
->r_info
);
2297 case R_XTENSA_TLS_FUNC
:
2298 case R_XTENSA_TLS_ARG
:
2299 if (old_op
!= get_l32r_opcode ()
2300 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2301 sbuff
, &dest_reg
) != 0)
2303 *error_message
= "cannot extract L32R destination for TLS access";
2308 case R_XTENSA_TLS_CALL
:
2309 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2310 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2311 sbuff
, &src_reg
) != 0)
2313 *error_message
= "cannot extract CALLXn operands for TLS access";
2326 case R_XTENSA_TLS_FUNC
:
2327 case R_XTENSA_TLS_ARG
:
2328 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2329 versions of Xtensa). */
2330 new_op
= xtensa_opcode_lookup (isa
, "nop");
2331 if (new_op
== XTENSA_UNDEFINED
)
2333 new_op
= xtensa_opcode_lookup (isa
, "or");
2334 if (new_op
== XTENSA_UNDEFINED
2335 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2336 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2338 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2340 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2343 *error_message
= "cannot encode OR for TLS access";
2349 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2351 *error_message
= "cannot encode NOP for TLS access";
2357 case R_XTENSA_TLS_CALL
:
2358 /* Read THREADPTR into the CALLX's return value register. */
2359 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2360 if (new_op
== XTENSA_UNDEFINED
2361 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2362 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2363 sbuff
, dest_reg
+ 2) != 0)
2365 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2375 case R_XTENSA_TLS_FUNC
:
2376 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2377 if (new_op
== XTENSA_UNDEFINED
2378 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2379 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2380 sbuff
, dest_reg
) != 0)
2382 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2387 case R_XTENSA_TLS_ARG
:
2388 /* Nothing to do. Keep the original L32R instruction. */
2391 case R_XTENSA_TLS_CALL
:
2392 /* Add the CALLX's src register (holding the THREADPTR value)
2393 to the first argument register (holding the offset) and put
2394 the result in the CALLX's return value register. */
2395 new_op
= xtensa_opcode_lookup (isa
, "add");
2396 if (new_op
== XTENSA_UNDEFINED
2397 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2398 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2399 sbuff
, dest_reg
+ 2) != 0
2400 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2401 sbuff
, dest_reg
+ 2) != 0
2402 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2403 sbuff
, src_reg
) != 0)
2405 *error_message
= "cannot encode ADD for TLS access";
2412 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2413 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2414 input_size
- rel
->r_offset
);
2420 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2421 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2422 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2423 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2424 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2425 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2426 || (R_TYPE) == R_XTENSA_TLS_ARG \
2427 || (R_TYPE) == R_XTENSA_TLS_CALL)
2429 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2430 both relocatable and final links. */
2433 elf_xtensa_relocate_section (bfd
*output_bfd
,
2434 struct bfd_link_info
*info
,
2436 asection
*input_section
,
2438 Elf_Internal_Rela
*relocs
,
2439 Elf_Internal_Sym
*local_syms
,
2440 asection
**local_sections
)
2442 struct elf_xtensa_link_hash_table
*htab
;
2443 Elf_Internal_Shdr
*symtab_hdr
;
2444 Elf_Internal_Rela
*rel
;
2445 Elf_Internal_Rela
*relend
;
2446 struct elf_link_hash_entry
**sym_hashes
;
2447 property_table_entry
*lit_table
= 0;
2449 char *local_got_tls_types
;
2450 char *error_message
= NULL
;
2451 bfd_size_type input_size
;
2454 if (!xtensa_default_isa
)
2455 xtensa_default_isa
= xtensa_isa_init (0, 0);
2457 BFD_ASSERT (is_xtensa_elf (input_bfd
));
2459 htab
= elf_xtensa_hash_table (info
);
2463 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2464 sym_hashes
= elf_sym_hashes (input_bfd
);
2465 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2467 if (elf_hash_table (info
)->dynamic_sections_created
)
2469 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2470 &lit_table
, XTENSA_LIT_SEC_NAME
,
2476 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2479 relend
= relocs
+ input_section
->reloc_count
;
2480 for (; rel
< relend
; rel
++)
2483 reloc_howto_type
*howto
;
2484 unsigned long r_symndx
;
2485 struct elf_link_hash_entry
*h
;
2486 Elf_Internal_Sym
*sym
;
2491 bfd_reloc_status_type r
;
2492 bfd_boolean is_weak_undef
;
2493 bfd_boolean unresolved_reloc
;
2495 bfd_boolean dynamic_symbol
;
2497 r_type
= ELF32_R_TYPE (rel
->r_info
);
2498 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2499 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2502 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2504 bfd_set_error (bfd_error_bad_value
);
2507 howto
= &elf_howto_table
[r_type
];
2509 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2514 is_weak_undef
= FALSE
;
2515 unresolved_reloc
= FALSE
;
2518 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2520 /* Because R_XTENSA_32 was made partial_inplace to fix some
2521 problems with DWARF info in partial links, there may be
2522 an addend stored in the contents. Take it out of there
2523 and move it back into the addend field of the reloc. */
2524 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2525 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2528 if (r_symndx
< symtab_hdr
->sh_info
)
2530 sym
= local_syms
+ r_symndx
;
2531 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2532 sec
= local_sections
[r_symndx
];
2533 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2537 bfd_boolean ignored
;
2539 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2540 r_symndx
, symtab_hdr
, sym_hashes
,
2542 unresolved_reloc
, warned
, ignored
);
2545 && !unresolved_reloc
2546 && h
->root
.type
== bfd_link_hash_undefweak
)
2547 is_weak_undef
= TRUE
;
2552 if (sec
!= NULL
&& discarded_section (sec
))
2553 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2554 rel
, 1, relend
, howto
, 0, contents
);
2556 if (bfd_link_relocatable (info
))
2559 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2561 /* This is a relocatable link.
2562 1) If the reloc is against a section symbol, adjust
2563 according to the output section.
2564 2) If there is a new target for this relocation,
2565 the new target will be in the same output section.
2566 We adjust the relocation by the output section
2569 if (relaxing_section
)
2571 /* Check if this references a section in another input file. */
2572 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2577 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2578 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2580 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2582 error_message
= NULL
;
2583 /* Convert ASM_SIMPLIFY into the simpler relocation
2584 so that they never escape a relaxing link. */
2585 r
= contract_asm_expansion (contents
, input_size
, rel
,
2587 if (r
!= bfd_reloc_ok
)
2588 (*info
->callbacks
->reloc_dangerous
)
2589 (info
, error_message
,
2590 input_bfd
, input_section
, rel
->r_offset
);
2592 r_type
= ELF32_R_TYPE (rel
->r_info
);
2595 /* This is a relocatable link, so we don't have to change
2596 anything unless the reloc is against a section symbol,
2597 in which case we have to adjust according to where the
2598 section symbol winds up in the output section. */
2599 if (r_symndx
< symtab_hdr
->sh_info
)
2601 sym
= local_syms
+ r_symndx
;
2602 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2604 sec
= local_sections
[r_symndx
];
2605 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2609 /* If there is an addend with a partial_inplace howto,
2610 then move the addend to the contents. This is a hack
2611 to work around problems with DWARF in relocatable links
2612 with some previous version of BFD. Now we can't easily get
2613 rid of the hack without breaking backward compatibility.... */
2615 howto
= &elf_howto_table
[r_type
];
2616 if (howto
->partial_inplace
&& rel
->r_addend
)
2618 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2619 rel
->r_addend
, contents
,
2620 rel
->r_offset
, FALSE
,
2626 /* Put the correct bits in the target instruction, even
2627 though the relocation will still be present in the output
2628 file. This makes disassembly clearer, as well as
2629 allowing loadable kernel modules to work without needing
2630 relocations on anything other than calls and l32r's. */
2632 /* If it is not in the same section, there is nothing we can do. */
2633 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2634 sym_sec
->output_section
== input_section
->output_section
)
2636 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2637 dest_addr
, contents
,
2638 rel
->r_offset
, FALSE
,
2642 if (r
!= bfd_reloc_ok
)
2643 (*info
->callbacks
->reloc_dangerous
)
2644 (info
, error_message
,
2645 input_bfd
, input_section
, rel
->r_offset
);
2647 /* Done with work for relocatable link; continue with next reloc. */
2651 /* This is a final link. */
2653 if (relaxing_section
)
2655 /* Check if this references a section in another input file. */
2656 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2660 /* Sanity check the address. */
2661 if (rel
->r_offset
>= input_size
2662 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2665 /* xgettext:c-format */
2666 (_("%pB(%pA+%#" PRIx64
"): "
2667 "relocation offset out of range (size=%#" PRIx64
")"),
2668 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2669 (uint64_t) input_size
);
2670 bfd_set_error (bfd_error_bad_value
);
2675 name
= h
->root
.root
.string
;
2678 name
= (bfd_elf_string_from_elf_section
2679 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2680 if (name
== NULL
|| *name
== '\0')
2681 name
= bfd_section_name (input_bfd
, sec
);
2684 if (r_symndx
!= STN_UNDEF
2685 && r_type
!= R_XTENSA_NONE
2687 || h
->root
.type
== bfd_link_hash_defined
2688 || h
->root
.type
== bfd_link_hash_defweak
)
2689 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2692 ((sym_type
== STT_TLS
2693 /* xgettext:c-format */
2694 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2695 /* xgettext:c-format */
2696 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2699 (uint64_t) rel
->r_offset
,
2704 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2706 tls_type
= GOT_UNKNOWN
;
2708 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2709 else if (local_got_tls_types
)
2710 tls_type
= local_got_tls_types
[r_symndx
];
2716 if (elf_hash_table (info
)->dynamic_sections_created
2717 && (input_section
->flags
& SEC_ALLOC
) != 0
2718 && (dynamic_symbol
|| bfd_link_pic (info
)))
2720 Elf_Internal_Rela outrel
;
2724 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2725 srel
= htab
->elf
.srelplt
;
2727 srel
= htab
->elf
.srelgot
;
2729 BFD_ASSERT (srel
!= NULL
);
2732 _bfd_elf_section_offset (output_bfd
, info
,
2733 input_section
, rel
->r_offset
);
2735 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2736 memset (&outrel
, 0, sizeof outrel
);
2739 outrel
.r_offset
+= (input_section
->output_section
->vma
2740 + input_section
->output_offset
);
2742 /* Complain if the relocation is in a read-only section
2743 and not in a literal pool. */
2744 if ((input_section
->flags
& SEC_READONLY
) != 0
2745 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2749 _("dynamic relocation in read-only section");
2750 (*info
->callbacks
->reloc_dangerous
)
2751 (info
, error_message
,
2752 input_bfd
, input_section
, rel
->r_offset
);
2757 outrel
.r_addend
= rel
->r_addend
;
2760 if (r_type
== R_XTENSA_32
)
2763 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2766 else /* r_type == R_XTENSA_PLT */
2769 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2771 /* Create the PLT entry and set the initial
2772 contents of the literal entry to the address of
2775 elf_xtensa_create_plt_entry (info
, output_bfd
,
2778 unresolved_reloc
= FALSE
;
2782 /* Generate a RELATIVE relocation. */
2783 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2784 outrel
.r_addend
= 0;
2788 loc
= (srel
->contents
2789 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2790 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2791 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2794 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2796 /* This should only happen for non-PIC code, which is not
2797 supposed to be used on systems with dynamic linking.
2798 Just ignore these relocations. */
2803 case R_XTENSA_TLS_TPOFF
:
2804 /* Switch to LE model for local symbols in an executable. */
2805 if (! bfd_link_pic (info
) && ! dynamic_symbol
)
2807 relocation
= tpoff (info
, relocation
);
2812 case R_XTENSA_TLSDESC_FN
:
2813 case R_XTENSA_TLSDESC_ARG
:
2815 if (r_type
== R_XTENSA_TLSDESC_FN
)
2817 if (! bfd_link_pic (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2818 r_type
= R_XTENSA_NONE
;
2820 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2822 if (bfd_link_pic (info
))
2824 if ((tls_type
& GOT_TLS_IE
) != 0)
2825 r_type
= R_XTENSA_TLS_TPOFF
;
2829 r_type
= R_XTENSA_TLS_TPOFF
;
2830 if (! dynamic_symbol
)
2832 relocation
= tpoff (info
, relocation
);
2838 if (r_type
== R_XTENSA_NONE
)
2839 /* Nothing to do here; skip to the next reloc. */
2842 if (! elf_hash_table (info
)->dynamic_sections_created
)
2845 _("TLS relocation invalid without dynamic sections");
2846 (*info
->callbacks
->reloc_dangerous
)
2847 (info
, error_message
,
2848 input_bfd
, input_section
, rel
->r_offset
);
2852 Elf_Internal_Rela outrel
;
2854 asection
*srel
= htab
->elf
.srelgot
;
2857 outrel
.r_offset
= (input_section
->output_section
->vma
2858 + input_section
->output_offset
2861 /* Complain if the relocation is in a read-only section
2862 and not in a literal pool. */
2863 if ((input_section
->flags
& SEC_READONLY
) != 0
2864 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2868 _("dynamic relocation in read-only section");
2869 (*info
->callbacks
->reloc_dangerous
)
2870 (info
, error_message
,
2871 input_bfd
, input_section
, rel
->r_offset
);
2874 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2876 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2878 outrel
.r_addend
= 0;
2881 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2883 unresolved_reloc
= FALSE
;
2886 loc
= (srel
->contents
2887 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2888 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2889 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2895 case R_XTENSA_TLS_DTPOFF
:
2896 if (! bfd_link_pic (info
))
2897 /* Switch from LD model to LE model. */
2898 relocation
= tpoff (info
, relocation
);
2900 relocation
-= dtpoff_base (info
);
2903 case R_XTENSA_TLS_FUNC
:
2904 case R_XTENSA_TLS_ARG
:
2905 case R_XTENSA_TLS_CALL
:
2906 /* Check if optimizing to IE or LE model. */
2907 if ((tls_type
& GOT_TLS_IE
) != 0)
2909 bfd_boolean is_ld_model
=
2910 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
2911 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
2912 is_ld_model
, &error_message
))
2913 (*info
->callbacks
->reloc_dangerous
)
2914 (info
, error_message
,
2915 input_bfd
, input_section
, rel
->r_offset
);
2917 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
2919 /* Skip subsequent relocations on the same instruction. */
2920 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
2927 if (elf_hash_table (info
)->dynamic_sections_created
2928 && dynamic_symbol
&& (is_operand_relocation (r_type
)
2929 || r_type
== R_XTENSA_32_PCREL
))
2932 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
2933 strlen (name
) + 2, name
);
2934 (*info
->callbacks
->reloc_dangerous
)
2935 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
2941 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2942 because such sections are not SEC_ALLOC and thus ld.so will
2943 not process them. */
2944 if (unresolved_reloc
2945 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2947 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2948 rel
->r_offset
) != (bfd_vma
) -1)
2951 /* xgettext:c-format */
2952 (_("%pB(%pA+%#" PRIx64
"): "
2953 "unresolvable %s relocation against symbol `%s'"),
2956 (uint64_t) rel
->r_offset
,
2962 /* TLS optimizations may have changed r_type; update "howto". */
2963 howto
= &elf_howto_table
[r_type
];
2965 /* There's no point in calling bfd_perform_relocation here.
2966 Just go directly to our "special function". */
2967 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2968 relocation
+ rel
->r_addend
,
2969 contents
, rel
->r_offset
, is_weak_undef
,
2972 if (r
!= bfd_reloc_ok
&& !warned
)
2974 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
2975 BFD_ASSERT (error_message
!= NULL
);
2977 if (rel
->r_addend
== 0)
2978 error_message
= vsprint_msg (error_message
, ": %s",
2979 strlen (name
) + 2, name
);
2981 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
2983 name
, (int) rel
->r_addend
);
2985 (*info
->callbacks
->reloc_dangerous
)
2986 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
2993 input_section
->reloc_done
= TRUE
;
2999 /* Finish up dynamic symbol handling. There's not much to do here since
3000 the PLT and GOT entries are all set up by relocate_section. */
3003 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3004 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3005 struct elf_link_hash_entry
*h
,
3006 Elf_Internal_Sym
*sym
)
3008 if (h
->needs_plt
&& !h
->def_regular
)
3010 /* Mark the symbol as undefined, rather than as defined in
3011 the .plt section. Leave the value alone. */
3012 sym
->st_shndx
= SHN_UNDEF
;
3013 /* If the symbol is weak, we do need to clear the value.
3014 Otherwise, the PLT entry would provide a definition for
3015 the symbol even if the symbol wasn't defined anywhere,
3016 and so the symbol would never be NULL. */
3017 if (!h
->ref_regular_nonweak
)
3021 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3022 if (h
== elf_hash_table (info
)->hdynamic
3023 || h
== elf_hash_table (info
)->hgot
)
3024 sym
->st_shndx
= SHN_ABS
;
3030 /* Combine adjacent literal table entries in the output. Adjacent
3031 entries within each input section may have been removed during
3032 relaxation, but we repeat the process here, even though it's too late
3033 to shrink the output section, because it's important to minimize the
3034 number of literal table entries to reduce the start-up work for the
3035 runtime linker. Returns the number of remaining table entries or -1
3039 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3044 property_table_entry
*table
;
3045 bfd_size_type section_size
, sgotloc_size
;
3049 section_size
= sxtlit
->size
;
3050 BFD_ASSERT (section_size
% 8 == 0);
3051 num
= section_size
/ 8;
3053 sgotloc_size
= sgotloc
->size
;
3054 if (sgotloc_size
!= section_size
)
3057 (_("internal inconsistency in size of .got.loc section"));
3061 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3065 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3066 propagates to the output section, where it doesn't really apply and
3067 where it breaks the following call to bfd_malloc_and_get_section. */
3068 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3070 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3078 /* There should never be any relocations left at this point, so this
3079 is quite a bit easier than what is done during relaxation. */
3081 /* Copy the raw contents into a property table array and sort it. */
3083 for (n
= 0; n
< num
; n
++)
3085 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3086 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3089 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3091 for (n
= 0; n
< num
; n
++)
3093 bfd_boolean remove_entry
= FALSE
;
3095 if (table
[n
].size
== 0)
3096 remove_entry
= TRUE
;
3098 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3100 table
[n
-1].size
+= table
[n
].size
;
3101 remove_entry
= TRUE
;
3106 for (m
= n
; m
< num
- 1; m
++)
3108 table
[m
].address
= table
[m
+1].address
;
3109 table
[m
].size
= table
[m
+1].size
;
3117 /* Copy the data back to the raw contents. */
3119 for (n
= 0; n
< num
; n
++)
3121 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3122 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3126 /* Clear the removed bytes. */
3127 if ((bfd_size_type
) (num
* 8) < section_size
)
3128 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3130 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3134 /* Copy the contents to ".got.loc". */
3135 memcpy (sgotloc
->contents
, contents
, section_size
);
3143 /* Finish up the dynamic sections. */
3146 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3147 struct bfd_link_info
*info
)
3149 struct elf_xtensa_link_hash_table
*htab
;
3151 asection
*sdyn
, *srelplt
, *sgot
, *sxtlit
, *sgotloc
;
3152 Elf32_External_Dyn
*dyncon
, *dynconend
;
3153 int num_xtlit_entries
= 0;
3155 if (! elf_hash_table (info
)->dynamic_sections_created
)
3158 htab
= elf_xtensa_hash_table (info
);
3162 dynobj
= elf_hash_table (info
)->dynobj
;
3163 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3164 BFD_ASSERT (sdyn
!= NULL
);
3166 /* Set the first entry in the global offset table to the address of
3167 the dynamic section. */
3168 sgot
= htab
->elf
.sgot
;
3171 BFD_ASSERT (sgot
->size
== 4);
3173 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3175 bfd_put_32 (output_bfd
,
3176 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3180 srelplt
= htab
->elf
.srelplt
;
3181 if (srelplt
&& srelplt
->size
!= 0)
3183 asection
*sgotplt
, *srelgot
, *spltlittbl
;
3184 int chunk
, plt_chunks
, plt_entries
;
3185 Elf_Internal_Rela irela
;
3187 unsigned rtld_reloc
;
3189 srelgot
= htab
->elf
.srelgot
;
3190 spltlittbl
= htab
->spltlittbl
;
3191 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3193 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3194 of them follow immediately after.... */
3195 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3197 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3198 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3199 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3202 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3204 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3206 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3208 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3210 int chunk_entries
= 0;
3212 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3213 BFD_ASSERT (sgotplt
!= NULL
);
3215 /* Emit special RTLD relocations for the first two entries in
3216 each chunk of the .got.plt section. */
3218 loc
= srelgot
->contents
+ rtld_reloc
* 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
);
3223 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3224 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3226 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3228 /* Next literal immediately follows the first. */
3229 loc
+= sizeof (Elf32_External_Rela
);
3230 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3231 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3232 irela
.r_offset
= (sgotplt
->output_section
->vma
3233 + sgotplt
->output_offset
+ 4);
3234 /* Tell rtld to set value to object's link map. */
3236 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3238 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3240 /* Fill in the literal table. */
3241 if (chunk
< plt_chunks
- 1)
3242 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3244 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3246 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3247 bfd_put_32 (output_bfd
,
3248 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3249 spltlittbl
->contents
+ (chunk
* 8) + 0);
3250 bfd_put_32 (output_bfd
,
3251 8 + (chunk_entries
* 4),
3252 spltlittbl
->contents
+ (chunk
* 8) + 4);
3255 /* All the dynamic relocations have been emitted at this point.
3256 Make sure the relocation sections are the correct size. */
3257 if (srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3258 * srelgot
->reloc_count
)
3259 || srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3260 * srelplt
->reloc_count
))
3263 /* The .xt.lit.plt section has just been modified. This must
3264 happen before the code below which combines adjacent literal
3265 table entries, and the .xt.lit.plt contents have to be forced to
3267 if (! bfd_set_section_contents (output_bfd
,
3268 spltlittbl
->output_section
,
3269 spltlittbl
->contents
,
3270 spltlittbl
->output_offset
,
3273 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3274 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3277 /* Combine adjacent literal table entries. */
3278 BFD_ASSERT (! bfd_link_relocatable (info
));
3279 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3280 sgotloc
= htab
->sgotloc
;
3281 BFD_ASSERT (sgotloc
);
3285 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3286 if (num_xtlit_entries
< 0)
3290 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3291 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3292 for (; dyncon
< dynconend
; dyncon
++)
3294 Elf_Internal_Dyn dyn
;
3296 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3303 case DT_XTENSA_GOT_LOC_SZ
:
3304 dyn
.d_un
.d_val
= num_xtlit_entries
;
3307 case DT_XTENSA_GOT_LOC_OFF
:
3308 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3309 + htab
->sgotloc
->output_offset
);
3313 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3314 + htab
->elf
.sgot
->output_offset
);
3318 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3319 + htab
->elf
.srelplt
->output_offset
);
3323 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3327 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3334 /* Functions for dealing with the e_flags field. */
3336 /* Merge backend specific data from an object file to the output
3337 object file when linking. */
3340 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3342 bfd
*obfd
= info
->output_bfd
;
3343 unsigned out_mach
, in_mach
;
3344 flagword out_flag
, in_flag
;
3346 /* Check if we have the same endianness. */
3347 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3350 /* Don't even pretend to support mixed-format linking. */
3351 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3352 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3355 out_flag
= elf_elfheader (obfd
)->e_flags
;
3356 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3358 out_mach
= out_flag
& EF_XTENSA_MACH
;
3359 in_mach
= in_flag
& EF_XTENSA_MACH
;
3360 if (out_mach
!= in_mach
)
3363 /* xgettext:c-format */
3364 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3365 ibfd
, out_mach
, in_mach
);
3366 bfd_set_error (bfd_error_wrong_format
);
3370 if (! elf_flags_init (obfd
))
3372 elf_flags_init (obfd
) = TRUE
;
3373 elf_elfheader (obfd
)->e_flags
= in_flag
;
3375 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3376 && bfd_get_arch_info (obfd
)->the_default
)
3377 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3378 bfd_get_mach (ibfd
));
3383 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3384 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3386 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3387 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3394 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3396 BFD_ASSERT (!elf_flags_init (abfd
)
3397 || elf_elfheader (abfd
)->e_flags
== flags
);
3399 elf_elfheader (abfd
)->e_flags
|= flags
;
3400 elf_flags_init (abfd
) = TRUE
;
3407 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3409 FILE *f
= (FILE *) farg
;
3410 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3412 fprintf (f
, "\nXtensa header:\n");
3413 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3414 fprintf (f
, "\nMachine = Base\n");
3416 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3418 fprintf (f
, "Insn tables = %s\n",
3419 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3421 fprintf (f
, "Literal tables = %s\n",
3422 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3424 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3428 /* Set the right machine number for an Xtensa ELF file. */
3431 elf_xtensa_object_p (bfd
*abfd
)
3434 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3439 mach
= bfd_mach_xtensa
;
3445 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3450 /* The final processing done just before writing out an Xtensa ELF object
3451 file. This gets the Xtensa architecture right based on the machine
3455 elf_xtensa_final_write_processing (bfd
*abfd
,
3456 bfd_boolean linker ATTRIBUTE_UNUSED
)
3461 switch (mach
= bfd_get_mach (abfd
))
3463 case bfd_mach_xtensa
:
3464 val
= E_XTENSA_MACH
;
3470 elf_elfheader (abfd
)->e_flags
&= (~ EF_XTENSA_MACH
);
3471 elf_elfheader (abfd
)->e_flags
|= val
;
3475 static enum elf_reloc_type_class
3476 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3477 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3478 const Elf_Internal_Rela
*rela
)
3480 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3482 case R_XTENSA_RELATIVE
:
3483 return reloc_class_relative
;
3484 case R_XTENSA_JMP_SLOT
:
3485 return reloc_class_plt
;
3487 return reloc_class_normal
;
3493 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3494 struct elf_reloc_cookie
*cookie
,
3495 struct bfd_link_info
*info
,
3499 bfd_vma offset
, actual_offset
;
3500 bfd_size_type removed_bytes
= 0;
3501 bfd_size_type entry_size
;
3503 if (sec
->output_section
3504 && bfd_is_abs_section (sec
->output_section
))
3507 if (xtensa_is_proptable_section (sec
))
3512 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3515 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3519 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3522 release_contents (sec
, contents
);
3526 /* Sort the relocations. They should already be in order when
3527 relaxation is enabled, but it might not be. */
3528 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3529 internal_reloc_compare
);
3531 cookie
->rel
= cookie
->rels
;
3532 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3534 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3536 actual_offset
= offset
- removed_bytes
;
3538 /* The ...symbol_deleted_p function will skip over relocs but it
3539 won't adjust their offsets, so do that here. */
3540 while (cookie
->rel
< cookie
->relend
3541 && cookie
->rel
->r_offset
< offset
)
3543 cookie
->rel
->r_offset
-= removed_bytes
;
3547 while (cookie
->rel
< cookie
->relend
3548 && cookie
->rel
->r_offset
== offset
)
3550 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3552 /* Remove the table entry. (If the reloc type is NONE, then
3553 the entry has already been merged with another and deleted
3554 during relaxation.) */
3555 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3557 /* Shift the contents up. */
3558 if (offset
+ entry_size
< sec
->size
)
3559 memmove (&contents
[actual_offset
],
3560 &contents
[actual_offset
+ entry_size
],
3561 sec
->size
- offset
- entry_size
);
3562 removed_bytes
+= entry_size
;
3565 /* Remove this relocation. */
3566 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3569 /* Adjust the relocation offset for previous removals. This
3570 should not be done before calling ...symbol_deleted_p
3571 because it might mess up the offset comparisons there.
3572 Make sure the offset doesn't underflow in the case where
3573 the first entry is removed. */
3574 if (cookie
->rel
->r_offset
>= removed_bytes
)
3575 cookie
->rel
->r_offset
-= removed_bytes
;
3577 cookie
->rel
->r_offset
= 0;
3583 if (removed_bytes
!= 0)
3585 /* Adjust any remaining relocs (shouldn't be any). */
3586 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3588 if (cookie
->rel
->r_offset
>= removed_bytes
)
3589 cookie
->rel
->r_offset
-= removed_bytes
;
3591 cookie
->rel
->r_offset
= 0;
3594 /* Clear the removed bytes. */
3595 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3597 pin_contents (sec
, contents
);
3598 pin_internal_relocs (sec
, cookie
->rels
);
3601 if (sec
->rawsize
== 0)
3602 sec
->rawsize
= sec
->size
;
3603 sec
->size
-= removed_bytes
;
3605 if (xtensa_is_littable_section (sec
))
3607 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3609 sgotloc
->size
-= removed_bytes
;
3614 release_contents (sec
, contents
);
3615 release_internal_relocs (sec
, cookie
->rels
);
3618 return (removed_bytes
!= 0);
3623 elf_xtensa_discard_info (bfd
*abfd
,
3624 struct elf_reloc_cookie
*cookie
,
3625 struct bfd_link_info
*info
)
3628 bfd_boolean changed
= FALSE
;
3630 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3632 if (xtensa_is_property_section (sec
))
3634 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3644 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3646 return xtensa_is_property_section (sec
);
3651 elf_xtensa_action_discarded (asection
*sec
)
3653 if (strcmp (".xt_except_table", sec
->name
) == 0)
3656 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3659 return _bfd_elf_default_action_discarded (sec
);
3663 /* Support for core dump NOTE sections. */
3666 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3671 /* The size for Xtensa is variable, so don't try to recognize the format
3672 based on the size. Just assume this is GNU/Linux. */
3675 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3678 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3682 size
= note
->descsz
- offset
- 4;
3684 /* Make a ".reg/999" section. */
3685 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3686 size
, note
->descpos
+ offset
);
3691 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3693 switch (note
->descsz
)
3698 case 128: /* GNU/Linux elf_prpsinfo */
3699 elf_tdata (abfd
)->core
->program
3700 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3701 elf_tdata (abfd
)->core
->command
3702 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3705 /* Note that for some reason, a spurious space is tacked
3706 onto the end of the args in some (at least one anyway)
3707 implementations, so strip it off if it exists. */
3710 char *command
= elf_tdata (abfd
)->core
->command
;
3711 int n
= strlen (command
);
3713 if (0 < n
&& command
[n
- 1] == ' ')
3714 command
[n
- 1] = '\0';
3721 /* Generic Xtensa configurability stuff. */
3723 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3724 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3725 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3726 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3727 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3728 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3729 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3730 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3733 init_call_opcodes (void)
3735 if (callx0_op
== XTENSA_UNDEFINED
)
3737 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3738 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3739 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3740 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3741 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3742 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3743 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3744 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3750 is_indirect_call_opcode (xtensa_opcode opcode
)
3752 init_call_opcodes ();
3753 return (opcode
== callx0_op
3754 || opcode
== callx4_op
3755 || opcode
== callx8_op
3756 || opcode
== callx12_op
);
3761 is_direct_call_opcode (xtensa_opcode opcode
)
3763 init_call_opcodes ();
3764 return (opcode
== call0_op
3765 || opcode
== call4_op
3766 || opcode
== call8_op
3767 || opcode
== call12_op
);
3772 is_windowed_call_opcode (xtensa_opcode opcode
)
3774 init_call_opcodes ();
3775 return (opcode
== call4_op
3776 || opcode
== call8_op
3777 || opcode
== call12_op
3778 || opcode
== callx4_op
3779 || opcode
== callx8_op
3780 || opcode
== callx12_op
);
3785 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3787 unsigned dst
= (unsigned) -1;
3789 init_call_opcodes ();
3790 if (opcode
== callx0_op
)
3792 else if (opcode
== callx4_op
)
3794 else if (opcode
== callx8_op
)
3796 else if (opcode
== callx12_op
)
3799 if (dst
== (unsigned) -1)
3807 static xtensa_opcode
3808 get_const16_opcode (void)
3810 static bfd_boolean done_lookup
= FALSE
;
3811 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3814 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3817 return const16_opcode
;
3821 static xtensa_opcode
3822 get_l32r_opcode (void)
3824 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3825 static bfd_boolean done_lookup
= FALSE
;
3829 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3837 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3841 offset
= addr
- ((pc
+3) & -4);
3842 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3843 offset
= (signed int) offset
>> 2;
3844 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3850 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3852 xtensa_isa isa
= xtensa_default_isa
;
3853 int last_immed
, last_opnd
, opi
;
3855 if (opcode
== XTENSA_UNDEFINED
)
3856 return XTENSA_UNDEFINED
;
3858 /* Find the last visible PC-relative immediate operand for the opcode.
3859 If there are no PC-relative immediates, then choose the last visible
3860 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3861 last_immed
= XTENSA_UNDEFINED
;
3862 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3863 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3865 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3867 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3872 if (last_immed
== XTENSA_UNDEFINED
3873 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3877 return XTENSA_UNDEFINED
;
3879 /* If the operand number was specified in an old-style relocation,
3880 check for consistency with the operand computed above. */
3881 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3883 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3884 if (reloc_opnd
!= last_immed
)
3885 return XTENSA_UNDEFINED
;
3893 get_relocation_slot (int r_type
)
3903 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
3904 return r_type
- R_XTENSA_SLOT0_OP
;
3905 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
3906 return r_type
- R_XTENSA_SLOT0_ALT
;
3910 return XTENSA_UNDEFINED
;
3914 /* Get the opcode for a relocation. */
3916 static xtensa_opcode
3917 get_relocation_opcode (bfd
*abfd
,
3920 Elf_Internal_Rela
*irel
)
3922 static xtensa_insnbuf ibuff
= NULL
;
3923 static xtensa_insnbuf sbuff
= NULL
;
3924 xtensa_isa isa
= xtensa_default_isa
;
3928 if (contents
== NULL
)
3929 return XTENSA_UNDEFINED
;
3931 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
3932 return XTENSA_UNDEFINED
;
3936 ibuff
= xtensa_insnbuf_alloc (isa
);
3937 sbuff
= xtensa_insnbuf_alloc (isa
);
3940 /* Decode the instruction. */
3941 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
3942 sec
->size
- irel
->r_offset
);
3943 fmt
= xtensa_format_decode (isa
, ibuff
);
3944 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
3945 if (slot
== XTENSA_UNDEFINED
)
3946 return XTENSA_UNDEFINED
;
3947 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
3948 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
3953 is_l32r_relocation (bfd
*abfd
,
3956 Elf_Internal_Rela
*irel
)
3958 xtensa_opcode opcode
;
3959 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
3961 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
3962 return (opcode
== get_l32r_opcode ());
3966 static bfd_size_type
3967 get_asm_simplify_size (bfd_byte
*contents
,
3968 bfd_size_type content_len
,
3969 bfd_size_type offset
)
3971 bfd_size_type insnlen
, size
= 0;
3973 /* Decode the size of the next two instructions. */
3974 insnlen
= insn_decode_len (contents
, content_len
, offset
);
3980 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
3990 is_alt_relocation (int r_type
)
3992 return (r_type
>= R_XTENSA_SLOT0_ALT
3993 && r_type
<= R_XTENSA_SLOT14_ALT
);
3998 is_operand_relocation (int r_type
)
4008 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4010 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4019 #define MIN_INSN_LENGTH 2
4021 /* Return 0 if it fails to decode. */
4024 insn_decode_len (bfd_byte
*contents
,
4025 bfd_size_type content_len
,
4026 bfd_size_type offset
)
4029 xtensa_isa isa
= xtensa_default_isa
;
4031 static xtensa_insnbuf ibuff
= NULL
;
4033 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4037 ibuff
= xtensa_insnbuf_alloc (isa
);
4038 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4039 content_len
- offset
);
4040 fmt
= xtensa_format_decode (isa
, ibuff
);
4041 if (fmt
== XTENSA_UNDEFINED
)
4043 insn_len
= xtensa_format_length (isa
, fmt
);
4044 if (insn_len
== XTENSA_UNDEFINED
)
4050 /* Decode the opcode for a single slot instruction.
4051 Return 0 if it fails to decode or the instruction is multi-slot. */
4054 insn_decode_opcode (bfd_byte
*contents
,
4055 bfd_size_type content_len
,
4056 bfd_size_type offset
,
4059 xtensa_isa isa
= xtensa_default_isa
;
4061 static xtensa_insnbuf insnbuf
= NULL
;
4062 static xtensa_insnbuf slotbuf
= NULL
;
4064 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4065 return XTENSA_UNDEFINED
;
4067 if (insnbuf
== NULL
)
4069 insnbuf
= xtensa_insnbuf_alloc (isa
);
4070 slotbuf
= xtensa_insnbuf_alloc (isa
);
4073 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4074 content_len
- offset
);
4075 fmt
= xtensa_format_decode (isa
, insnbuf
);
4076 if (fmt
== XTENSA_UNDEFINED
)
4077 return XTENSA_UNDEFINED
;
4079 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4080 return XTENSA_UNDEFINED
;
4082 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4083 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4087 /* The offset is the offset in the contents.
4088 The address is the address of that offset. */
4091 check_branch_target_aligned (bfd_byte
*contents
,
4092 bfd_size_type content_length
,
4096 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4099 return check_branch_target_aligned_address (address
, insn_len
);
4104 check_loop_aligned (bfd_byte
*contents
,
4105 bfd_size_type content_length
,
4109 bfd_size_type loop_len
, insn_len
;
4110 xtensa_opcode opcode
;
4112 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4113 if (opcode
== XTENSA_UNDEFINED
4114 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4120 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4121 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4122 if (loop_len
== 0 || insn_len
== 0)
4128 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4133 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4136 return (addr
% 8 == 0);
4137 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4141 /* Instruction widening and narrowing. */
4143 /* When FLIX is available we need to access certain instructions only
4144 when they are 16-bit or 24-bit instructions. This table caches
4145 information about such instructions by walking through all the
4146 opcodes and finding the smallest single-slot format into which each
4149 static xtensa_format
*op_single_fmt_table
= NULL
;
4153 init_op_single_format_table (void)
4155 xtensa_isa isa
= xtensa_default_isa
;
4156 xtensa_insnbuf ibuf
;
4157 xtensa_opcode opcode
;
4161 if (op_single_fmt_table
)
4164 ibuf
= xtensa_insnbuf_alloc (isa
);
4165 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4167 op_single_fmt_table
= (xtensa_format
*)
4168 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4169 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4171 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4172 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4174 if (xtensa_format_num_slots (isa
, fmt
) == 1
4175 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4177 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4178 int fmt_length
= xtensa_format_length (isa
, fmt
);
4179 if (old_fmt
== XTENSA_UNDEFINED
4180 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4181 op_single_fmt_table
[opcode
] = fmt
;
4185 xtensa_insnbuf_free (isa
, ibuf
);
4189 static xtensa_format
4190 get_single_format (xtensa_opcode opcode
)
4192 init_op_single_format_table ();
4193 return op_single_fmt_table
[opcode
];
4197 /* For the set of narrowable instructions we do NOT include the
4198 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4199 involved during linker relaxation that may require these to
4200 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4201 requires special case code to ensure it only works when op1 == op2. */
4209 struct string_pair narrowable
[] =
4212 { "addi", "addi.n" },
4213 { "addmi", "addi.n" },
4214 { "l32i", "l32i.n" },
4215 { "movi", "movi.n" },
4217 { "retw", "retw.n" },
4218 { "s32i", "s32i.n" },
4219 { "or", "mov.n" } /* special case only when op1 == op2 */
4222 struct string_pair widenable
[] =
4225 { "addi", "addi.n" },
4226 { "addmi", "addi.n" },
4227 { "beqz", "beqz.n" },
4228 { "bnez", "bnez.n" },
4229 { "l32i", "l32i.n" },
4230 { "movi", "movi.n" },
4232 { "retw", "retw.n" },
4233 { "s32i", "s32i.n" },
4234 { "or", "mov.n" } /* special case only when op1 == op2 */
4238 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4239 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4240 return the instruction buffer holding the narrow instruction. Otherwise,
4241 return 0. The set of valid narrowing are specified by a string table
4242 but require some special case operand checks in some cases. */
4244 static xtensa_insnbuf
4245 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4247 xtensa_opcode opcode
)
4249 xtensa_isa isa
= xtensa_default_isa
;
4250 xtensa_format o_fmt
;
4253 static xtensa_insnbuf o_insnbuf
= NULL
;
4254 static xtensa_insnbuf o_slotbuf
= NULL
;
4256 if (o_insnbuf
== NULL
)
4258 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4259 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4262 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4264 bfd_boolean is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4266 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4268 uint32 value
, newval
;
4269 int i
, operand_count
, o_operand_count
;
4270 xtensa_opcode o_opcode
;
4272 /* Address does not matter in this case. We might need to
4273 fix it to handle branches/jumps. */
4274 bfd_vma self_address
= 0;
4276 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4277 if (o_opcode
== XTENSA_UNDEFINED
)
4279 o_fmt
= get_single_format (o_opcode
);
4280 if (o_fmt
== XTENSA_UNDEFINED
)
4283 if (xtensa_format_length (isa
, fmt
) != 3
4284 || xtensa_format_length (isa
, o_fmt
) != 2)
4287 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4288 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4289 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4291 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4296 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4301 uint32 rawval0
, rawval1
, rawval2
;
4303 if (o_operand_count
+ 1 != operand_count
4304 || xtensa_operand_get_field (isa
, opcode
, 0,
4305 fmt
, 0, slotbuf
, &rawval0
) != 0
4306 || xtensa_operand_get_field (isa
, opcode
, 1,
4307 fmt
, 0, slotbuf
, &rawval1
) != 0
4308 || xtensa_operand_get_field (isa
, opcode
, 2,
4309 fmt
, 0, slotbuf
, &rawval2
) != 0
4310 || rawval1
!= rawval2
4311 || rawval0
== rawval1
/* it is a nop */)
4315 for (i
= 0; i
< o_operand_count
; ++i
)
4317 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4319 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4322 /* PC-relative branches need adjustment, but
4323 the PC-rel operand will always have a relocation. */
4325 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4327 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4328 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4333 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4343 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4344 the action in-place directly into the contents and return TRUE. Otherwise,
4345 the return value is FALSE and the contents are not modified. */
4348 narrow_instruction (bfd_byte
*contents
,
4349 bfd_size_type content_length
,
4350 bfd_size_type offset
)
4352 xtensa_opcode opcode
;
4353 bfd_size_type insn_len
;
4354 xtensa_isa isa
= xtensa_default_isa
;
4356 xtensa_insnbuf o_insnbuf
;
4358 static xtensa_insnbuf insnbuf
= NULL
;
4359 static xtensa_insnbuf slotbuf
= NULL
;
4361 if (insnbuf
== NULL
)
4363 insnbuf
= xtensa_insnbuf_alloc (isa
);
4364 slotbuf
= xtensa_insnbuf_alloc (isa
);
4367 BFD_ASSERT (offset
< content_length
);
4369 if (content_length
< 2)
4372 /* We will hand-code a few of these for a little while.
4373 These have all been specified in the assembler aleady. */
4374 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4375 content_length
- offset
);
4376 fmt
= xtensa_format_decode (isa
, insnbuf
);
4377 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4380 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4383 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4384 if (opcode
== XTENSA_UNDEFINED
)
4386 insn_len
= xtensa_format_length (isa
, fmt
);
4387 if (insn_len
> content_length
)
4390 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4393 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4394 content_length
- offset
);
4402 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4403 "density" instruction to a standard 3-byte instruction. If it is valid,
4404 return the instruction buffer holding the wide instruction. Otherwise,
4405 return 0. The set of valid widenings are specified by a string table
4406 but require some special case operand checks in some cases. */
4408 static xtensa_insnbuf
4409 can_widen_instruction (xtensa_insnbuf slotbuf
,
4411 xtensa_opcode opcode
)
4413 xtensa_isa isa
= xtensa_default_isa
;
4414 xtensa_format o_fmt
;
4417 static xtensa_insnbuf o_insnbuf
= NULL
;
4418 static xtensa_insnbuf o_slotbuf
= NULL
;
4420 if (o_insnbuf
== NULL
)
4422 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4423 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4426 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4428 bfd_boolean is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4429 bfd_boolean is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4430 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4432 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4434 uint32 value
, newval
;
4435 int i
, operand_count
, o_operand_count
, check_operand_count
;
4436 xtensa_opcode o_opcode
;
4438 /* Address does not matter in this case. We might need to fix it
4439 to handle branches/jumps. */
4440 bfd_vma self_address
= 0;
4442 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4443 if (o_opcode
== XTENSA_UNDEFINED
)
4445 o_fmt
= get_single_format (o_opcode
);
4446 if (o_fmt
== XTENSA_UNDEFINED
)
4449 if (xtensa_format_length (isa
, fmt
) != 2
4450 || xtensa_format_length (isa
, o_fmt
) != 3)
4453 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4454 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4455 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4456 check_operand_count
= o_operand_count
;
4458 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4463 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4468 uint32 rawval0
, rawval1
;
4470 if (o_operand_count
!= operand_count
+ 1
4471 || xtensa_operand_get_field (isa
, opcode
, 0,
4472 fmt
, 0, slotbuf
, &rawval0
) != 0
4473 || xtensa_operand_get_field (isa
, opcode
, 1,
4474 fmt
, 0, slotbuf
, &rawval1
) != 0
4475 || rawval0
== rawval1
/* it is a nop */)
4479 check_operand_count
--;
4481 for (i
= 0; i
< check_operand_count
; i
++)
4484 if (is_or
&& i
== o_operand_count
- 1)
4486 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4488 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4491 /* PC-relative branches need adjustment, but
4492 the PC-rel operand will always have a relocation. */
4494 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4496 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4497 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4502 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4512 /* Attempt to widen an instruction. If the widening is valid, perform
4513 the action in-place directly into the contents and return TRUE. Otherwise,
4514 the return value is FALSE and the contents are not modified. */
4517 widen_instruction (bfd_byte
*contents
,
4518 bfd_size_type content_length
,
4519 bfd_size_type offset
)
4521 xtensa_opcode opcode
;
4522 bfd_size_type insn_len
;
4523 xtensa_isa isa
= xtensa_default_isa
;
4525 xtensa_insnbuf o_insnbuf
;
4527 static xtensa_insnbuf insnbuf
= NULL
;
4528 static xtensa_insnbuf slotbuf
= NULL
;
4530 if (insnbuf
== NULL
)
4532 insnbuf
= xtensa_insnbuf_alloc (isa
);
4533 slotbuf
= xtensa_insnbuf_alloc (isa
);
4536 BFD_ASSERT (offset
< content_length
);
4538 if (content_length
< 2)
4541 /* We will hand-code a few of these for a little while.
4542 These have all been specified in the assembler aleady. */
4543 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4544 content_length
- offset
);
4545 fmt
= xtensa_format_decode (isa
, insnbuf
);
4546 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4549 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4552 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4553 if (opcode
== XTENSA_UNDEFINED
)
4555 insn_len
= xtensa_format_length (isa
, fmt
);
4556 if (insn_len
> content_length
)
4559 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4562 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4563 content_length
- offset
);
4570 /* Code for transforming CALLs at link-time. */
4572 static bfd_reloc_status_type
4573 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4575 bfd_vma content_length
,
4576 char **error_message
)
4578 static xtensa_insnbuf insnbuf
= NULL
;
4579 static xtensa_insnbuf slotbuf
= NULL
;
4580 xtensa_format core_format
= XTENSA_UNDEFINED
;
4581 xtensa_opcode opcode
;
4582 xtensa_opcode direct_call_opcode
;
4583 xtensa_isa isa
= xtensa_default_isa
;
4584 bfd_byte
*chbuf
= contents
+ address
;
4587 if (insnbuf
== NULL
)
4589 insnbuf
= xtensa_insnbuf_alloc (isa
);
4590 slotbuf
= xtensa_insnbuf_alloc (isa
);
4593 if (content_length
< address
)
4595 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4596 return bfd_reloc_other
;
4599 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4600 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4601 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4603 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4604 return bfd_reloc_other
;
4607 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4608 core_format
= xtensa_format_lookup (isa
, "x24");
4609 opcode
= xtensa_opcode_lookup (isa
, "or");
4610 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4611 for (opn
= 0; opn
< 3; opn
++)
4614 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4615 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4618 xtensa_format_encode (isa
, core_format
, insnbuf
);
4619 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4620 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4622 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4623 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4624 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4626 xtensa_format_encode (isa
, core_format
, insnbuf
);
4627 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4628 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4629 content_length
- address
- 3);
4631 return bfd_reloc_ok
;
4635 static bfd_reloc_status_type
4636 contract_asm_expansion (bfd_byte
*contents
,
4637 bfd_vma content_length
,
4638 Elf_Internal_Rela
*irel
,
4639 char **error_message
)
4641 bfd_reloc_status_type retval
=
4642 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4645 if (retval
!= bfd_reloc_ok
)
4646 return bfd_reloc_dangerous
;
4648 /* Update the irel->r_offset field so that the right immediate and
4649 the right instruction are modified during the relocation. */
4650 irel
->r_offset
+= 3;
4651 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4652 return bfd_reloc_ok
;
4656 static xtensa_opcode
4657 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4659 init_call_opcodes ();
4661 if (opcode
== callx0_op
) return call0_op
;
4662 if (opcode
== callx4_op
) return call4_op
;
4663 if (opcode
== callx8_op
) return call8_op
;
4664 if (opcode
== callx12_op
) return call12_op
;
4666 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4667 return XTENSA_UNDEFINED
;
4671 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4672 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4673 If not, return XTENSA_UNDEFINED. */
4675 #define L32R_TARGET_REG_OPERAND 0
4676 #define CONST16_TARGET_REG_OPERAND 0
4677 #define CALLN_SOURCE_OPERAND 0
4679 static xtensa_opcode
4680 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bfd_boolean
*p_uses_l32r
)
4682 static xtensa_insnbuf insnbuf
= NULL
;
4683 static xtensa_insnbuf slotbuf
= NULL
;
4685 xtensa_opcode opcode
;
4686 xtensa_isa isa
= xtensa_default_isa
;
4687 uint32 regno
, const16_regno
, call_regno
;
4690 if (insnbuf
== NULL
)
4692 insnbuf
= xtensa_insnbuf_alloc (isa
);
4693 slotbuf
= xtensa_insnbuf_alloc (isa
);
4696 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4697 fmt
= xtensa_format_decode (isa
, insnbuf
);
4698 if (fmt
== XTENSA_UNDEFINED
4699 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4700 return XTENSA_UNDEFINED
;
4702 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4703 if (opcode
== XTENSA_UNDEFINED
)
4704 return XTENSA_UNDEFINED
;
4706 if (opcode
== get_l32r_opcode ())
4709 *p_uses_l32r
= TRUE
;
4710 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4711 fmt
, 0, slotbuf
, ®no
)
4712 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4714 return XTENSA_UNDEFINED
;
4716 else if (opcode
== get_const16_opcode ())
4719 *p_uses_l32r
= FALSE
;
4720 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4721 fmt
, 0, slotbuf
, ®no
)
4722 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4724 return XTENSA_UNDEFINED
;
4726 /* Check that the next instruction is also CONST16. */
4727 offset
+= xtensa_format_length (isa
, fmt
);
4728 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4729 fmt
= xtensa_format_decode (isa
, insnbuf
);
4730 if (fmt
== XTENSA_UNDEFINED
4731 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4732 return XTENSA_UNDEFINED
;
4733 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4734 if (opcode
!= get_const16_opcode ())
4735 return XTENSA_UNDEFINED
;
4737 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4738 fmt
, 0, slotbuf
, &const16_regno
)
4739 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4741 || const16_regno
!= regno
)
4742 return XTENSA_UNDEFINED
;
4745 return XTENSA_UNDEFINED
;
4747 /* Next instruction should be an CALLXn with operand 0 == regno. */
4748 offset
+= xtensa_format_length (isa
, fmt
);
4749 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4750 fmt
= xtensa_format_decode (isa
, insnbuf
);
4751 if (fmt
== XTENSA_UNDEFINED
4752 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4753 return XTENSA_UNDEFINED
;
4754 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4755 if (opcode
== XTENSA_UNDEFINED
4756 || !is_indirect_call_opcode (opcode
))
4757 return XTENSA_UNDEFINED
;
4759 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4760 fmt
, 0, slotbuf
, &call_regno
)
4761 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4763 return XTENSA_UNDEFINED
;
4765 if (call_regno
!= regno
)
4766 return XTENSA_UNDEFINED
;
4772 /* Data structures used during relaxation. */
4774 /* r_reloc: relocation values. */
4776 /* Through the relaxation process, we need to keep track of the values
4777 that will result from evaluating relocations. The standard ELF
4778 relocation structure is not sufficient for this purpose because we're
4779 operating on multiple input files at once, so we need to know which
4780 input file a relocation refers to. The r_reloc structure thus
4781 records both the input file (bfd) and ELF relocation.
4783 For efficiency, an r_reloc also contains a "target_offset" field to
4784 cache the target-section-relative offset value that is represented by
4787 The r_reloc also contains a virtual offset that allows multiple
4788 inserted literals to be placed at the same "address" with
4789 different offsets. */
4791 typedef struct r_reloc_struct r_reloc
;
4793 struct r_reloc_struct
4796 Elf_Internal_Rela rela
;
4797 bfd_vma target_offset
;
4798 bfd_vma virtual_offset
;
4802 /* The r_reloc structure is included by value in literal_value, but not
4803 every literal_value has an associated relocation -- some are simple
4804 constants. In such cases, we set all the fields in the r_reloc
4805 struct to zero. The r_reloc_is_const function should be used to
4806 detect this case. */
4809 r_reloc_is_const (const r_reloc
*r_rel
)
4811 return (r_rel
->abfd
== NULL
);
4816 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4818 bfd_vma target_offset
;
4819 unsigned long r_symndx
;
4821 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4822 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4823 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4824 return (target_offset
+ r_rel
->rela
.r_addend
);
4828 static struct elf_link_hash_entry
*
4829 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4831 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4832 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4837 r_reloc_get_section (const r_reloc
*r_rel
)
4839 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4840 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4845 r_reloc_is_defined (const r_reloc
*r_rel
)
4851 sec
= r_reloc_get_section (r_rel
);
4852 if (sec
== bfd_abs_section_ptr
4853 || sec
== bfd_com_section_ptr
4854 || sec
== bfd_und_section_ptr
)
4861 r_reloc_init (r_reloc
*r_rel
,
4863 Elf_Internal_Rela
*irel
,
4865 bfd_size_type content_length
)
4868 reloc_howto_type
*howto
;
4872 r_rel
->rela
= *irel
;
4874 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
4875 r_rel
->virtual_offset
= 0;
4876 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
4877 howto
= &elf_howto_table
[r_type
];
4878 if (howto
->partial_inplace
)
4880 bfd_vma inplace_val
;
4881 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
4883 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
4884 r_rel
->target_offset
+= inplace_val
;
4888 memset (r_rel
, 0, sizeof (r_reloc
));
4895 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
4897 if (r_reloc_is_defined (r_rel
))
4899 asection
*sec
= r_reloc_get_section (r_rel
);
4900 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
4902 else if (r_reloc_get_hash_entry (r_rel
))
4903 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
4905 fprintf (fp
, " ?? + ");
4907 fprintf_vma (fp
, r_rel
->target_offset
);
4908 if (r_rel
->virtual_offset
)
4910 fprintf (fp
, " + ");
4911 fprintf_vma (fp
, r_rel
->virtual_offset
);
4920 /* source_reloc: relocations that reference literals. */
4922 /* To determine whether literals can be coalesced, we need to first
4923 record all the relocations that reference the literals. The
4924 source_reloc structure below is used for this purpose. The
4925 source_reloc entries are kept in a per-literal-section array, sorted
4926 by offset within the literal section (i.e., target offset).
4928 The source_sec and r_rel.rela.r_offset fields identify the source of
4929 the relocation. The r_rel field records the relocation value, i.e.,
4930 the offset of the literal being referenced. The opnd field is needed
4931 to determine the range of the immediate field to which the relocation
4932 applies, so we can determine whether another literal with the same
4933 value is within range. The is_null field is true when the relocation
4934 is being removed (e.g., when an L32R is being removed due to a CALLX
4935 that is converted to a direct CALL). */
4937 typedef struct source_reloc_struct source_reloc
;
4939 struct source_reloc_struct
4941 asection
*source_sec
;
4943 xtensa_opcode opcode
;
4945 bfd_boolean is_null
;
4946 bfd_boolean is_abs_literal
;
4951 init_source_reloc (source_reloc
*reloc
,
4952 asection
*source_sec
,
4953 const r_reloc
*r_rel
,
4954 xtensa_opcode opcode
,
4956 bfd_boolean is_abs_literal
)
4958 reloc
->source_sec
= source_sec
;
4959 reloc
->r_rel
= *r_rel
;
4960 reloc
->opcode
= opcode
;
4962 reloc
->is_null
= FALSE
;
4963 reloc
->is_abs_literal
= is_abs_literal
;
4967 /* Find the source_reloc for a particular source offset and relocation
4968 type. Note that the array is sorted by _target_ offset, so this is
4969 just a linear search. */
4971 static source_reloc
*
4972 find_source_reloc (source_reloc
*src_relocs
,
4975 Elf_Internal_Rela
*irel
)
4979 for (i
= 0; i
< src_count
; i
++)
4981 if (src_relocs
[i
].source_sec
== sec
4982 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
4983 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
4984 == ELF32_R_TYPE (irel
->r_info
)))
4985 return &src_relocs
[i
];
4993 source_reloc_compare (const void *ap
, const void *bp
)
4995 const source_reloc
*a
= (const source_reloc
*) ap
;
4996 const source_reloc
*b
= (const source_reloc
*) bp
;
4998 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
4999 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5001 /* We don't need to sort on these criteria for correctness,
5002 but enforcing a more strict ordering prevents unstable qsort
5003 from behaving differently with different implementations.
5004 Without the code below we get correct but different results
5005 on Solaris 2.7 and 2.8. We would like to always produce the
5006 same results no matter the host. */
5008 if ((!a
->is_null
) - (!b
->is_null
))
5009 return ((!a
->is_null
) - (!b
->is_null
));
5010 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5014 /* Literal values and value hash tables. */
5016 /* Literals with the same value can be coalesced. The literal_value
5017 structure records the value of a literal: the "r_rel" field holds the
5018 information from the relocation on the literal (if there is one) and
5019 the "value" field holds the contents of the literal word itself.
5021 The value_map structure records a literal value along with the
5022 location of a literal holding that value. The value_map hash table
5023 is indexed by the literal value, so that we can quickly check if a
5024 particular literal value has been seen before and is thus a candidate
5027 typedef struct literal_value_struct literal_value
;
5028 typedef struct value_map_struct value_map
;
5029 typedef struct value_map_hash_table_struct value_map_hash_table
;
5031 struct literal_value_struct
5034 unsigned long value
;
5035 bfd_boolean is_abs_literal
;
5038 struct value_map_struct
5040 literal_value val
; /* The literal value. */
5041 r_reloc loc
; /* Location of the literal. */
5045 struct value_map_hash_table_struct
5047 unsigned bucket_count
;
5048 value_map
**buckets
;
5050 bfd_boolean has_last_loc
;
5056 init_literal_value (literal_value
*lit
,
5057 const r_reloc
*r_rel
,
5058 unsigned long value
,
5059 bfd_boolean is_abs_literal
)
5061 lit
->r_rel
= *r_rel
;
5063 lit
->is_abs_literal
= is_abs_literal
;
5068 literal_value_equal (const literal_value
*src1
,
5069 const literal_value
*src2
,
5070 bfd_boolean final_static_link
)
5072 struct elf_link_hash_entry
*h1
, *h2
;
5074 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5077 if (r_reloc_is_const (&src1
->r_rel
))
5078 return (src1
->value
== src2
->value
);
5080 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5081 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5084 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5087 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5090 if (src1
->value
!= src2
->value
)
5093 /* Now check for the same section (if defined) or the same elf_hash
5094 (if undefined or weak). */
5095 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5096 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5097 if (r_reloc_is_defined (&src1
->r_rel
)
5098 && (final_static_link
5099 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5100 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5102 if (r_reloc_get_section (&src1
->r_rel
)
5103 != r_reloc_get_section (&src2
->r_rel
))
5108 /* Require that the hash entries (i.e., symbols) be identical. */
5109 if (h1
!= h2
|| h1
== 0)
5113 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5120 /* Must be power of 2. */
5121 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5123 static value_map_hash_table
*
5124 value_map_hash_table_init (void)
5126 value_map_hash_table
*values
;
5128 values
= (value_map_hash_table
*)
5129 bfd_zmalloc (sizeof (value_map_hash_table
));
5130 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5132 values
->buckets
= (value_map
**)
5133 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5134 if (values
->buckets
== NULL
)
5139 values
->has_last_loc
= FALSE
;
5146 value_map_hash_table_delete (value_map_hash_table
*table
)
5148 free (table
->buckets
);
5154 hash_bfd_vma (bfd_vma val
)
5156 return (val
>> 2) + (val
>> 10);
5161 literal_value_hash (const literal_value
*src
)
5165 hash_val
= hash_bfd_vma (src
->value
);
5166 if (!r_reloc_is_const (&src
->r_rel
))
5170 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5171 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5172 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5174 /* Now check for the same section and the same elf_hash. */
5175 if (r_reloc_is_defined (&src
->r_rel
))
5176 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5178 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5179 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5185 /* Check if the specified literal_value has been seen before. */
5188 value_map_get_cached_value (value_map_hash_table
*map
,
5189 const literal_value
*val
,
5190 bfd_boolean final_static_link
)
5196 idx
= literal_value_hash (val
);
5197 idx
= idx
& (map
->bucket_count
- 1);
5198 bucket
= map
->buckets
[idx
];
5199 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5201 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5208 /* Record a new literal value. It is illegal to call this if VALUE
5209 already has an entry here. */
5212 add_value_map (value_map_hash_table
*map
,
5213 const literal_value
*val
,
5215 bfd_boolean final_static_link
)
5217 value_map
**bucket_p
;
5220 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5223 bfd_set_error (bfd_error_no_memory
);
5227 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5231 idx
= literal_value_hash (val
);
5232 idx
= idx
& (map
->bucket_count
- 1);
5233 bucket_p
= &map
->buckets
[idx
];
5235 val_e
->next
= *bucket_p
;
5238 /* FIXME: Consider resizing the hash table if we get too many entries. */
5244 /* Lists of text actions (ta_) for narrowing, widening, longcall
5245 conversion, space fill, code & literal removal, etc. */
5247 /* The following text actions are generated:
5249 "ta_remove_insn" remove an instruction or instructions
5250 "ta_remove_longcall" convert longcall to call
5251 "ta_convert_longcall" convert longcall to nop/call
5252 "ta_narrow_insn" narrow a wide instruction
5253 "ta_widen" widen a narrow instruction
5254 "ta_fill" add fill or remove fill
5255 removed < 0 is a fill; branches to the fill address will be
5256 changed to address + fill size (e.g., address - removed)
5257 removed >= 0 branches to the fill address will stay unchanged
5258 "ta_remove_literal" remove a literal; this action is
5259 indicated when a literal is removed
5261 "ta_add_literal" insert a new literal; this action is
5262 indicated when a literal has been moved.
5263 It may use a virtual_offset because
5264 multiple literals can be placed at the
5267 For each of these text actions, we also record the number of bytes
5268 removed by performing the text action. In the case of a "ta_widen"
5269 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5271 typedef struct text_action_struct text_action
;
5272 typedef struct text_action_list_struct text_action_list
;
5273 typedef enum text_action_enum_t text_action_t
;
5275 enum text_action_enum_t
5278 ta_remove_insn
, /* removed = -size */
5279 ta_remove_longcall
, /* removed = -size */
5280 ta_convert_longcall
, /* removed = 0 */
5281 ta_narrow_insn
, /* removed = -1 */
5282 ta_widen_insn
, /* removed = +1 */
5283 ta_fill
, /* removed = +size */
5289 /* Structure for a text action record. */
5290 struct text_action_struct
5292 text_action_t action
;
5293 asection
*sec
; /* Optional */
5295 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5297 literal_value value
; /* Only valid when adding literals. */
5300 struct removal_by_action_entry_struct
5305 int eq_removed_before_fill
;
5307 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5309 struct removal_by_action_map_struct
5312 removal_by_action_entry
*entry
;
5314 typedef struct removal_by_action_map_struct removal_by_action_map
;
5317 /* List of all of the actions taken on a text section. */
5318 struct text_action_list_struct
5322 removal_by_action_map map
;
5326 static text_action
*
5327 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5331 /* It is not necessary to fill at the end of a section. */
5332 if (sec
->size
== offset
)
5338 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5340 return (text_action
*)node
->value
;
5346 compute_removed_action_diff (const text_action
*ta
,
5350 int removable_space
)
5353 int current_removed
= 0;
5356 current_removed
= ta
->removed_bytes
;
5358 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5359 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5361 /* It is not necessary to fill at the end of a section. Clean this up. */
5362 if (sec
->size
== offset
)
5363 new_removed
= removable_space
- 0;
5367 int added
= -removed
- current_removed
;
5368 /* Ignore multiples of the section alignment. */
5369 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5370 new_removed
= (-added
);
5372 /* Modify for removable. */
5373 space
= removable_space
- new_removed
;
5374 new_removed
= (removable_space
5375 - (((1 << sec
->alignment_power
) - 1) & space
));
5377 return (new_removed
- current_removed
);
5382 adjust_fill_action (text_action
*ta
, int fill_diff
)
5384 ta
->removed_bytes
+= fill_diff
;
5389 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5391 text_action
*pa
= (text_action
*)a
;
5392 text_action
*pb
= (text_action
*)b
;
5393 static const int action_priority
[] =
5397 [ta_convert_longcall
] = 2,
5398 [ta_narrow_insn
] = 3,
5399 [ta_remove_insn
] = 4,
5400 [ta_remove_longcall
] = 5,
5401 [ta_remove_literal
] = 6,
5402 [ta_widen_insn
] = 7,
5403 [ta_add_literal
] = 8,
5406 if (pa
->offset
== pb
->offset
)
5408 if (pa
->action
== pb
->action
)
5410 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5413 return pa
->offset
< pb
->offset
? -1 : 1;
5416 static text_action
*
5417 action_first (text_action_list
*action_list
)
5419 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5420 return node
? (text_action
*)node
->value
: NULL
;
5423 static text_action
*
5424 action_next (text_action_list
*action_list
, text_action
*action
)
5426 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5427 (splay_tree_key
)action
);
5428 return node
? (text_action
*)node
->value
: NULL
;
5431 /* Add a modification action to the text. For the case of adding or
5432 removing space, modify any current fill and assume that
5433 "unreachable_space" bytes can be freely contracted. Note that a
5434 negative removed value is a fill. */
5437 text_action_add (text_action_list
*l
,
5438 text_action_t action
,
5446 /* It is not necessary to fill at the end of a section. */
5447 if (action
== ta_fill
&& sec
->size
== offset
)
5450 /* It is not necessary to fill 0 bytes. */
5451 if (action
== ta_fill
&& removed
== 0)
5457 if (action
== ta_fill
)
5459 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5463 ta
= (text_action
*)node
->value
;
5464 ta
->removed_bytes
+= removed
;
5469 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5471 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5472 ta
->action
= action
;
5474 ta
->offset
= offset
;
5475 ta
->removed_bytes
= removed
;
5476 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5482 text_action_add_literal (text_action_list
*l
,
5483 text_action_t action
,
5485 const literal_value
*value
,
5489 asection
*sec
= r_reloc_get_section (loc
);
5490 bfd_vma offset
= loc
->target_offset
;
5491 bfd_vma virtual_offset
= loc
->virtual_offset
;
5493 BFD_ASSERT (action
== ta_add_literal
);
5495 /* Create a new record and fill it up. */
5496 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5497 ta
->action
= action
;
5499 ta
->offset
= offset
;
5500 ta
->virtual_offset
= virtual_offset
;
5502 ta
->removed_bytes
= removed
;
5504 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5505 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5510 /* Find the total offset adjustment for the relaxations specified by
5511 text_actions, beginning from a particular starting action. This is
5512 typically used from offset_with_removed_text to search an entire list of
5513 actions, but it may also be called directly when adjusting adjacent offsets
5514 so that each search may begin where the previous one left off. */
5517 removed_by_actions (text_action_list
*action_list
,
5518 text_action
**p_start_action
,
5520 bfd_boolean before_fill
)
5525 r
= *p_start_action
;
5528 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5530 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5535 if (r
->offset
> offset
)
5538 if (r
->offset
== offset
5539 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5542 removed
+= r
->removed_bytes
;
5544 r
= action_next (action_list
, r
);
5547 *p_start_action
= r
;
5553 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5555 text_action
*r
= action_first (action_list
);
5557 return offset
- removed_by_actions (action_list
, &r
, offset
, FALSE
);
5562 action_list_count (text_action_list
*action_list
)
5564 return action_list
->count
;
5567 typedef struct map_action_fn_context_struct map_action_fn_context
;
5568 struct map_action_fn_context_struct
5571 removal_by_action_map map
;
5572 bfd_boolean eq_complete
;
5576 map_action_fn (splay_tree_node node
, void *p
)
5578 map_action_fn_context
*ctx
= p
;
5579 text_action
*r
= (text_action
*)node
->value
;
5580 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5582 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5588 ++ctx
->map
.n_entries
;
5589 ctx
->eq_complete
= FALSE
;
5590 ientry
->offset
= r
->offset
;
5591 ientry
->eq_removed_before_fill
= ctx
->removed
;
5594 if (!ctx
->eq_complete
)
5596 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5598 ientry
->eq_removed
= ctx
->removed
;
5599 ctx
->eq_complete
= TRUE
;
5602 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5605 ctx
->removed
+= r
->removed_bytes
;
5606 ientry
->removed
= ctx
->removed
;
5611 map_removal_by_action (text_action_list
*action_list
)
5613 map_action_fn_context ctx
;
5616 ctx
.map
.n_entries
= 0;
5617 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5618 sizeof (removal_by_action_entry
));
5619 ctx
.eq_complete
= FALSE
;
5621 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5622 action_list
->map
= ctx
.map
;
5626 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5627 bfd_boolean before_fill
)
5631 if (!action_list
->map
.entry
)
5632 map_removal_by_action (action_list
);
5634 if (!action_list
->map
.n_entries
)
5638 b
= action_list
->map
.n_entries
;
5642 unsigned c
= (a
+ b
) / 2;
5644 if (action_list
->map
.entry
[c
].offset
<= offset
)
5650 if (action_list
->map
.entry
[a
].offset
< offset
)
5652 return action_list
->map
.entry
[a
].removed
;
5654 else if (action_list
->map
.entry
[a
].offset
== offset
)
5656 return before_fill
?
5657 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5658 action_list
->map
.entry
[a
].eq_removed
;
5667 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5669 int removed
= removed_by_actions_map (action_list
, offset
, FALSE
);
5670 return offset
- removed
;
5674 /* The find_insn_action routine will only find non-fill actions. */
5676 static text_action
*
5677 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5679 static const text_action_t action
[] =
5681 ta_convert_longcall
,
5691 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5693 splay_tree_node node
;
5695 a
.action
= action
[i
];
5696 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5698 return (text_action
*)node
->value
;
5707 print_action (FILE *fp
, text_action
*r
)
5709 const char *t
= "unknown";
5712 case ta_remove_insn
:
5713 t
= "remove_insn"; break;
5714 case ta_remove_longcall
:
5715 t
= "remove_longcall"; break;
5716 case ta_convert_longcall
:
5717 t
= "convert_longcall"; break;
5718 case ta_narrow_insn
:
5719 t
= "narrow_insn"; break;
5721 t
= "widen_insn"; break;
5726 case ta_remove_literal
:
5727 t
= "remove_literal"; break;
5728 case ta_add_literal
:
5729 t
= "add_literal"; break;
5732 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5733 r
->sec
->owner
->filename
,
5734 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5738 print_action_list_fn (splay_tree_node node
, void *p
)
5740 text_action
*r
= (text_action
*)node
->value
;
5742 print_action (p
, r
);
5747 print_action_list (FILE *fp
, text_action_list
*action_list
)
5749 fprintf (fp
, "Text Action\n");
5750 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5756 /* Lists of literals being coalesced or removed. */
5758 /* In the usual case, the literal identified by "from" is being
5759 coalesced with another literal identified by "to". If the literal is
5760 unused and is being removed altogether, "to.abfd" will be NULL.
5761 The removed_literal entries are kept on a per-section list, sorted
5762 by the "from" offset field. */
5764 typedef struct removed_literal_struct removed_literal
;
5765 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5766 typedef struct removed_literal_list_struct removed_literal_list
;
5768 struct removed_literal_struct
5772 removed_literal
*next
;
5775 struct removed_literal_map_entry_struct
5778 removed_literal
*literal
;
5781 struct removed_literal_list_struct
5783 removed_literal
*head
;
5784 removed_literal
*tail
;
5787 removed_literal_map_entry
*map
;
5791 /* Record that the literal at "from" is being removed. If "to" is not
5792 NULL, the "from" literal is being coalesced with the "to" literal. */
5795 add_removed_literal (removed_literal_list
*removed_list
,
5796 const r_reloc
*from
,
5799 removed_literal
*r
, *new_r
, *next_r
;
5801 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5803 new_r
->from
= *from
;
5807 new_r
->to
.abfd
= NULL
;
5810 r
= removed_list
->head
;
5813 removed_list
->head
= new_r
;
5814 removed_list
->tail
= new_r
;
5816 /* Special check for common case of append. */
5817 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5819 removed_list
->tail
->next
= new_r
;
5820 removed_list
->tail
= new_r
;
5824 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5830 new_r
->next
= next_r
;
5832 removed_list
->tail
= new_r
;
5837 map_removed_literal (removed_literal_list
*removed_list
)
5841 removed_literal_map_entry
*map
= NULL
;
5842 removed_literal
*r
= removed_list
->head
;
5844 for (i
= 0; r
; ++i
, r
= r
->next
)
5848 n_map
= (n_map
* 2) + 2;
5849 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5851 map
[i
].addr
= r
->from
.target_offset
;
5854 removed_list
->map
= map
;
5855 removed_list
->n_map
= i
;
5859 removed_literal_compare (const void *a
, const void *b
)
5861 const removed_literal_map_entry
*pa
= a
;
5862 const removed_literal_map_entry
*pb
= b
;
5864 if (pa
->addr
== pb
->addr
)
5867 return pa
->addr
< pb
->addr
? -1 : 1;
5870 /* Check if the list of removed literals contains an entry for the
5871 given address. Return the entry if found. */
5873 static removed_literal
*
5874 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
5876 removed_literal_map_entry
*p
;
5877 removed_literal
*r
= NULL
;
5879 if (removed_list
->map
== NULL
)
5880 map_removed_literal (removed_list
);
5882 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
5883 sizeof (*removed_list
->map
), removed_literal_compare
);
5886 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
5897 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
5900 r
= removed_list
->head
;
5902 fprintf (fp
, "Removed Literals\n");
5903 for (; r
!= NULL
; r
= r
->next
)
5905 print_r_reloc (fp
, &r
->from
);
5906 fprintf (fp
, " => ");
5907 if (r
->to
.abfd
== NULL
)
5908 fprintf (fp
, "REMOVED");
5910 print_r_reloc (fp
, &r
->to
);
5918 /* Per-section data for relaxation. */
5920 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
5922 struct xtensa_relax_info_struct
5924 bfd_boolean is_relaxable_literal_section
;
5925 bfd_boolean is_relaxable_asm_section
;
5926 int visited
; /* Number of times visited. */
5928 source_reloc
*src_relocs
; /* Array[src_count]. */
5930 int src_next
; /* Next src_relocs entry to assign. */
5932 removed_literal_list removed_list
;
5933 text_action_list action_list
;
5935 reloc_bfd_fix
*fix_list
;
5936 reloc_bfd_fix
*fix_array
;
5937 unsigned fix_array_count
;
5939 /* Support for expanding the reloc array that is stored
5940 in the section structure. If the relocations have been
5941 reallocated, the newly allocated relocations will be referenced
5942 here along with the actual size allocated. The relocation
5943 count will always be found in the section structure. */
5944 Elf_Internal_Rela
*allocated_relocs
;
5945 unsigned relocs_count
;
5946 unsigned allocated_relocs_count
;
5949 struct elf_xtensa_section_data
5951 struct bfd_elf_section_data elf
;
5952 xtensa_relax_info relax_info
;
5957 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
5959 if (!sec
->used_by_bfd
)
5961 struct elf_xtensa_section_data
*sdata
;
5962 bfd_size_type amt
= sizeof (*sdata
);
5964 sdata
= bfd_zalloc (abfd
, amt
);
5967 sec
->used_by_bfd
= sdata
;
5970 return _bfd_elf_new_section_hook (abfd
, sec
);
5974 static xtensa_relax_info
*
5975 get_xtensa_relax_info (asection
*sec
)
5977 struct elf_xtensa_section_data
*section_data
;
5979 /* No info available if no section or if it is an output section. */
5980 if (!sec
|| sec
== sec
->output_section
)
5983 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
5984 return §ion_data
->relax_info
;
5989 init_xtensa_relax_info (asection
*sec
)
5991 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
5993 relax_info
->is_relaxable_literal_section
= FALSE
;
5994 relax_info
->is_relaxable_asm_section
= FALSE
;
5995 relax_info
->visited
= 0;
5997 relax_info
->src_relocs
= NULL
;
5998 relax_info
->src_count
= 0;
5999 relax_info
->src_next
= 0;
6001 relax_info
->removed_list
.head
= NULL
;
6002 relax_info
->removed_list
.tail
= NULL
;
6004 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6006 relax_info
->action_list
.map
.n_entries
= 0;
6007 relax_info
->action_list
.map
.entry
= NULL
;
6009 relax_info
->fix_list
= NULL
;
6010 relax_info
->fix_array
= NULL
;
6011 relax_info
->fix_array_count
= 0;
6013 relax_info
->allocated_relocs
= NULL
;
6014 relax_info
->relocs_count
= 0;
6015 relax_info
->allocated_relocs_count
= 0;
6019 /* Coalescing literals may require a relocation to refer to a section in
6020 a different input file, but the standard relocation information
6021 cannot express that. Instead, the reloc_bfd_fix structures are used
6022 to "fix" the relocations that refer to sections in other input files.
6023 These structures are kept on per-section lists. The "src_type" field
6024 records the relocation type in case there are multiple relocations on
6025 the same location. FIXME: This is ugly; an alternative might be to
6026 add new symbols with the "owner" field to some other input file. */
6028 struct reloc_bfd_fix_struct
6032 unsigned src_type
; /* Relocation type. */
6034 asection
*target_sec
;
6035 bfd_vma target_offset
;
6036 bfd_boolean translated
;
6038 reloc_bfd_fix
*next
;
6042 static reloc_bfd_fix
*
6043 reloc_bfd_fix_init (asection
*src_sec
,
6046 asection
*target_sec
,
6047 bfd_vma target_offset
,
6048 bfd_boolean translated
)
6052 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6053 fix
->src_sec
= src_sec
;
6054 fix
->src_offset
= src_offset
;
6055 fix
->src_type
= src_type
;
6056 fix
->target_sec
= target_sec
;
6057 fix
->target_offset
= target_offset
;
6058 fix
->translated
= translated
;
6065 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6067 xtensa_relax_info
*relax_info
;
6069 relax_info
= get_xtensa_relax_info (src_sec
);
6070 fix
->next
= relax_info
->fix_list
;
6071 relax_info
->fix_list
= fix
;
6076 fix_compare (const void *ap
, const void *bp
)
6078 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6079 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6081 if (a
->src_offset
!= b
->src_offset
)
6082 return (a
->src_offset
- b
->src_offset
);
6083 return (a
->src_type
- b
->src_type
);
6088 cache_fix_array (asection
*sec
)
6090 unsigned i
, count
= 0;
6092 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6094 if (relax_info
== NULL
)
6096 if (relax_info
->fix_list
== NULL
)
6099 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6102 relax_info
->fix_array
=
6103 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6104 relax_info
->fix_array_count
= count
;
6106 r
= relax_info
->fix_list
;
6107 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6109 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6110 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6113 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6114 sizeof (reloc_bfd_fix
), fix_compare
);
6118 static reloc_bfd_fix
*
6119 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6121 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6125 if (relax_info
== NULL
)
6127 if (relax_info
->fix_list
== NULL
)
6130 if (relax_info
->fix_array
== NULL
)
6131 cache_fix_array (sec
);
6133 key
.src_offset
= offset
;
6134 key
.src_type
= type
;
6135 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6136 sizeof (reloc_bfd_fix
), fix_compare
);
6141 /* Section caching. */
6143 typedef struct section_cache_struct section_cache_t
;
6145 struct section_cache_struct
6149 bfd_byte
*contents
; /* Cache of the section contents. */
6150 bfd_size_type content_length
;
6152 property_table_entry
*ptbl
; /* Cache of the section property table. */
6155 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6156 unsigned reloc_count
;
6161 init_section_cache (section_cache_t
*sec_cache
)
6163 memset (sec_cache
, 0, sizeof (*sec_cache
));
6168 free_section_cache (section_cache_t
*sec_cache
)
6172 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6173 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6174 if (sec_cache
->ptbl
)
6175 free (sec_cache
->ptbl
);
6181 section_cache_section (section_cache_t
*sec_cache
,
6183 struct bfd_link_info
*link_info
)
6186 property_table_entry
*prop_table
= NULL
;
6188 bfd_byte
*contents
= NULL
;
6189 Elf_Internal_Rela
*internal_relocs
= NULL
;
6190 bfd_size_type sec_size
;
6194 if (sec
== sec_cache
->sec
)
6198 sec_size
= bfd_get_section_limit (abfd
, sec
);
6200 /* Get the contents. */
6201 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6202 if (contents
== NULL
&& sec_size
!= 0)
6205 /* Get the relocations. */
6206 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6207 link_info
->keep_memory
);
6209 /* Get the entry table. */
6210 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6211 XTENSA_PROP_SEC_NAME
, FALSE
);
6215 /* Fill in the new section cache. */
6216 free_section_cache (sec_cache
);
6217 init_section_cache (sec_cache
);
6219 sec_cache
->sec
= sec
;
6220 sec_cache
->contents
= contents
;
6221 sec_cache
->content_length
= sec_size
;
6222 sec_cache
->relocs
= internal_relocs
;
6223 sec_cache
->reloc_count
= sec
->reloc_count
;
6224 sec_cache
->pte_count
= ptblsize
;
6225 sec_cache
->ptbl
= prop_table
;
6230 release_contents (sec
, contents
);
6231 release_internal_relocs (sec
, internal_relocs
);
6238 /* Extended basic blocks. */
6240 /* An ebb_struct represents an Extended Basic Block. Within this
6241 range, we guarantee that all instructions are decodable, the
6242 property table entries are contiguous, and no property table
6243 specifies a segment that cannot have instructions moved. This
6244 structure contains caches of the contents, property table and
6245 relocations for the specified section for easy use. The range is
6246 specified by ranges of indices for the byte offset, property table
6247 offsets and relocation offsets. These must be consistent. */
6249 typedef struct ebb_struct ebb_t
;
6255 bfd_byte
*contents
; /* Cache of the section contents. */
6256 bfd_size_type content_length
;
6258 property_table_entry
*ptbl
; /* Cache of the section property table. */
6261 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6262 unsigned reloc_count
;
6264 bfd_vma start_offset
; /* Offset in section. */
6265 unsigned start_ptbl_idx
; /* Offset in the property table. */
6266 unsigned start_reloc_idx
; /* Offset in the relocations. */
6269 unsigned end_ptbl_idx
;
6270 unsigned end_reloc_idx
;
6272 bfd_boolean ends_section
; /* Is this the last ebb in a section? */
6274 /* The unreachable property table at the end of this set of blocks;
6275 NULL if the end is not an unreachable block. */
6276 property_table_entry
*ends_unreachable
;
6280 enum ebb_target_enum
6283 EBB_DESIRE_TGT_ALIGN
,
6284 EBB_REQUIRE_TGT_ALIGN
,
6285 EBB_REQUIRE_LOOP_ALIGN
,
6290 /* proposed_action_struct is similar to the text_action_struct except
6291 that is represents a potential transformation, not one that will
6292 occur. We build a list of these for an extended basic block
6293 and use them to compute the actual actions desired. We must be
6294 careful that the entire set of actual actions we perform do not
6295 break any relocations that would fit if the actions were not
6298 typedef struct proposed_action_struct proposed_action
;
6300 struct proposed_action_struct
6302 enum ebb_target_enum align_type
; /* for the target alignment */
6303 bfd_vma alignment_pow
;
6304 text_action_t action
;
6307 bfd_boolean do_action
; /* If false, then we will not perform the action. */
6311 /* The ebb_constraint_struct keeps a set of proposed actions for an
6312 extended basic block. */
6314 typedef struct ebb_constraint_struct ebb_constraint
;
6316 struct ebb_constraint_struct
6319 bfd_boolean start_movable
;
6321 /* Bytes of extra space at the beginning if movable. */
6322 int start_extra_space
;
6324 enum ebb_target_enum start_align
;
6326 bfd_boolean end_movable
;
6328 /* Bytes of extra space at the end if movable. */
6329 int end_extra_space
;
6331 unsigned action_count
;
6332 unsigned action_allocated
;
6334 /* Array of proposed actions. */
6335 proposed_action
*actions
;
6337 /* Action alignments -- one for each proposed action. */
6338 enum ebb_target_enum
*action_aligns
;
6343 init_ebb_constraint (ebb_constraint
*c
)
6345 memset (c
, 0, sizeof (ebb_constraint
));
6350 free_ebb_constraint (ebb_constraint
*c
)
6358 init_ebb (ebb_t
*ebb
,
6361 bfd_size_type content_length
,
6362 property_table_entry
*prop_table
,
6364 Elf_Internal_Rela
*internal_relocs
,
6365 unsigned reloc_count
)
6367 memset (ebb
, 0, sizeof (ebb_t
));
6369 ebb
->contents
= contents
;
6370 ebb
->content_length
= content_length
;
6371 ebb
->ptbl
= prop_table
;
6372 ebb
->pte_count
= ptblsize
;
6373 ebb
->relocs
= internal_relocs
;
6374 ebb
->reloc_count
= reloc_count
;
6375 ebb
->start_offset
= 0;
6376 ebb
->end_offset
= ebb
->content_length
- 1;
6377 ebb
->start_ptbl_idx
= 0;
6378 ebb
->end_ptbl_idx
= ptblsize
;
6379 ebb
->start_reloc_idx
= 0;
6380 ebb
->end_reloc_idx
= reloc_count
;
6384 /* Extend the ebb to all decodable contiguous sections. The algorithm
6385 for building a basic block around an instruction is to push it
6386 forward until we hit the end of a section, an unreachable block or
6387 a block that cannot be transformed. Then we push it backwards
6388 searching for similar conditions. */
6390 static bfd_boolean
extend_ebb_bounds_forward (ebb_t
*);
6391 static bfd_boolean
extend_ebb_bounds_backward (ebb_t
*);
6392 static bfd_size_type insn_block_decodable_len
6393 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6396 extend_ebb_bounds (ebb_t
*ebb
)
6398 if (!extend_ebb_bounds_forward (ebb
))
6400 if (!extend_ebb_bounds_backward (ebb
))
6407 extend_ebb_bounds_forward (ebb_t
*ebb
)
6409 property_table_entry
*the_entry
, *new_entry
;
6411 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6413 /* Stop when (1) we cannot decode an instruction, (2) we are at
6414 the end of the property tables, (3) we hit a non-contiguous property
6415 table entry, (4) we hit a NO_TRANSFORM region. */
6420 bfd_size_type insn_block_len
;
6422 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6424 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6426 entry_end
- ebb
->end_offset
);
6427 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6430 /* xgettext:c-format */
6431 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6432 "possible configuration mismatch"),
6433 ebb
->sec
->owner
, ebb
->sec
,
6434 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6437 ebb
->end_offset
+= insn_block_len
;
6439 if (ebb
->end_offset
== ebb
->sec
->size
)
6440 ebb
->ends_section
= TRUE
;
6442 /* Update the reloc counter. */
6443 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6444 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6447 ebb
->end_reloc_idx
++;
6450 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6453 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6454 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6455 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6456 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6459 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6462 the_entry
= new_entry
;
6463 ebb
->end_ptbl_idx
++;
6466 /* Quick check for an unreachable or end of file just at the end. */
6467 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6469 if (ebb
->end_offset
== ebb
->content_length
)
6470 ebb
->ends_section
= TRUE
;
6474 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6475 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6476 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6477 ebb
->ends_unreachable
= new_entry
;
6480 /* Any other ending requires exact alignment. */
6486 extend_ebb_bounds_backward (ebb_t
*ebb
)
6488 property_table_entry
*the_entry
, *new_entry
;
6490 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6492 /* Stop when (1) we cannot decode the instructions in the current entry.
6493 (2) we are at the beginning of the property tables, (3) we hit a
6494 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6498 bfd_vma block_begin
;
6499 bfd_size_type insn_block_len
;
6501 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6503 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6505 ebb
->start_offset
- block_begin
);
6506 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6509 /* xgettext:c-format */
6510 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6511 "possible configuration mismatch"),
6512 ebb
->sec
->owner
, ebb
->sec
,
6513 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6516 ebb
->start_offset
-= insn_block_len
;
6518 /* Update the reloc counter. */
6519 while (ebb
->start_reloc_idx
> 0
6520 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6521 >= ebb
->start_offset
))
6523 ebb
->start_reloc_idx
--;
6526 if (ebb
->start_ptbl_idx
== 0)
6529 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6530 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6531 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6532 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6534 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6537 the_entry
= new_entry
;
6538 ebb
->start_ptbl_idx
--;
6544 static bfd_size_type
6545 insn_block_decodable_len (bfd_byte
*contents
,
6546 bfd_size_type content_len
,
6547 bfd_vma block_offset
,
6548 bfd_size_type block_len
)
6550 bfd_vma offset
= block_offset
;
6552 while (offset
< block_offset
+ block_len
)
6554 bfd_size_type insn_len
= 0;
6556 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6558 return (offset
- block_offset
);
6561 return (offset
- block_offset
);
6566 ebb_propose_action (ebb_constraint
*c
,
6567 enum ebb_target_enum align_type
,
6568 bfd_vma alignment_pow
,
6569 text_action_t action
,
6572 bfd_boolean do_action
)
6574 proposed_action
*act
;
6576 if (c
->action_allocated
<= c
->action_count
)
6578 unsigned new_allocated
, i
;
6579 proposed_action
*new_actions
;
6581 new_allocated
= (c
->action_count
+ 2) * 2;
6582 new_actions
= (proposed_action
*)
6583 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6585 for (i
= 0; i
< c
->action_count
; i
++)
6586 new_actions
[i
] = c
->actions
[i
];
6589 c
->actions
= new_actions
;
6590 c
->action_allocated
= new_allocated
;
6593 act
= &c
->actions
[c
->action_count
];
6594 act
->align_type
= align_type
;
6595 act
->alignment_pow
= alignment_pow
;
6596 act
->action
= action
;
6597 act
->offset
= offset
;
6598 act
->removed_bytes
= removed_bytes
;
6599 act
->do_action
= do_action
;
6605 /* Access to internal relocations, section contents and symbols. */
6607 /* During relaxation, we need to modify relocations, section contents,
6608 and symbol definitions, and we need to keep the original values from
6609 being reloaded from the input files, i.e., we need to "pin" the
6610 modified values in memory. We also want to continue to observe the
6611 setting of the "keep-memory" flag. The following functions wrap the
6612 standard BFD functions to take care of this for us. */
6614 static Elf_Internal_Rela
*
6615 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6617 Elf_Internal_Rela
*internal_relocs
;
6619 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6622 internal_relocs
= elf_section_data (sec
)->relocs
;
6623 if (internal_relocs
== NULL
)
6624 internal_relocs
= (_bfd_elf_link_read_relocs
6625 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6626 return internal_relocs
;
6631 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6633 elf_section_data (sec
)->relocs
= internal_relocs
;
6638 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6641 && elf_section_data (sec
)->relocs
!= internal_relocs
)
6642 free (internal_relocs
);
6647 retrieve_contents (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6650 bfd_size_type sec_size
;
6652 sec_size
= bfd_get_section_limit (abfd
, sec
);
6653 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6655 if (contents
== NULL
&& sec_size
!= 0)
6657 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6664 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6671 pin_contents (asection
*sec
, bfd_byte
*contents
)
6673 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6678 release_contents (asection
*sec
, bfd_byte
*contents
)
6680 if (contents
&& elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6685 static Elf_Internal_Sym
*
6686 retrieve_local_syms (bfd
*input_bfd
)
6688 Elf_Internal_Shdr
*symtab_hdr
;
6689 Elf_Internal_Sym
*isymbuf
;
6692 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6693 locsymcount
= symtab_hdr
->sh_info
;
6695 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6696 if (isymbuf
== NULL
&& locsymcount
!= 0)
6697 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6700 /* Save the symbols for this input file so they won't be read again. */
6701 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6702 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6708 /* Code for link-time relaxation. */
6710 /* Initialization for relaxation: */
6711 static bfd_boolean
analyze_relocations (struct bfd_link_info
*);
6712 static bfd_boolean find_relaxable_sections
6713 (bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*);
6714 static bfd_boolean collect_source_relocs
6715 (bfd
*, asection
*, struct bfd_link_info
*);
6716 static bfd_boolean is_resolvable_asm_expansion
6717 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6719 static Elf_Internal_Rela
*find_associated_l32r_irel
6720 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6721 static bfd_boolean compute_text_actions
6722 (bfd
*, asection
*, struct bfd_link_info
*);
6723 static bfd_boolean
compute_ebb_proposed_actions (ebb_constraint
*);
6724 static bfd_boolean
compute_ebb_actions (ebb_constraint
*);
6725 typedef struct reloc_range_list_struct reloc_range_list
;
6726 static bfd_boolean check_section_ebb_pcrels_fit
6727 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6728 reloc_range_list
*, const ebb_constraint
*,
6729 const xtensa_opcode
*);
6730 static bfd_boolean
check_section_ebb_reduces (const ebb_constraint
*);
6731 static void text_action_add_proposed
6732 (text_action_list
*, const ebb_constraint
*, asection
*);
6735 static bfd_boolean compute_removed_literals
6736 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6737 static Elf_Internal_Rela
*get_irel_at_offset
6738 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6739 static bfd_boolean is_removable_literal
6740 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6741 property_table_entry
*, int);
6742 static bfd_boolean remove_dead_literal
6743 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6744 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6745 static bfd_boolean identify_literal_placement
6746 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6747 value_map_hash_table
*, bfd_boolean
*, Elf_Internal_Rela
*, int,
6748 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6750 static bfd_boolean
relocations_reach (source_reloc
*, int, const r_reloc
*);
6751 static bfd_boolean coalesce_shared_literal
6752 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6753 static bfd_boolean move_shared_literal
6754 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6755 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6758 static bfd_boolean
relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6759 static bfd_boolean
translate_section_fixes (asection
*);
6760 static bfd_boolean
translate_reloc_bfd_fix (reloc_bfd_fix
*);
6761 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6762 static void shrink_dynamic_reloc_sections
6763 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6764 static bfd_boolean move_literal
6765 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6766 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6767 static bfd_boolean relax_property_section
6768 (bfd
*, asection
*, struct bfd_link_info
*);
6771 static bfd_boolean
relax_section_symbols (bfd
*, asection
*);
6775 elf_xtensa_relax_section (bfd
*abfd
,
6777 struct bfd_link_info
*link_info
,
6780 static value_map_hash_table
*values
= NULL
;
6781 static bfd_boolean relocations_analyzed
= FALSE
;
6782 xtensa_relax_info
*relax_info
;
6784 if (!relocations_analyzed
)
6786 /* Do some overall initialization for relaxation. */
6787 values
= value_map_hash_table_init ();
6790 relaxing_section
= TRUE
;
6791 if (!analyze_relocations (link_info
))
6793 relocations_analyzed
= TRUE
;
6797 /* Don't mess with linker-created sections. */
6798 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6801 relax_info
= get_xtensa_relax_info (sec
);
6802 BFD_ASSERT (relax_info
!= NULL
);
6804 switch (relax_info
->visited
)
6807 /* Note: It would be nice to fold this pass into
6808 analyze_relocations, but it is important for this step that the
6809 sections be examined in link order. */
6810 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6817 value_map_hash_table_delete (values
);
6819 if (!relax_section (abfd
, sec
, link_info
))
6825 if (!relax_section_symbols (abfd
, sec
))
6830 relax_info
->visited
++;
6835 /* Initialization for relaxation. */
6837 /* This function is called once at the start of relaxation. It scans
6838 all the input sections and marks the ones that are relaxable (i.e.,
6839 literal sections with L32R relocations against them), and then
6840 collects source_reloc information for all the relocations against
6841 those relaxable sections. During this process, it also detects
6842 longcalls, i.e., calls relaxed by the assembler into indirect
6843 calls, that can be optimized back into direct calls. Within each
6844 extended basic block (ebb) containing an optimized longcall, it
6845 computes a set of "text actions" that can be performed to remove
6846 the L32R associated with the longcall while optionally preserving
6847 branch target alignments. */
6850 analyze_relocations (struct bfd_link_info
*link_info
)
6854 bfd_boolean is_relaxable
= FALSE
;
6856 /* Initialize the per-section relaxation info. */
6857 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6858 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6860 init_xtensa_relax_info (sec
);
6863 /* Mark relaxable sections (and count relocations against each one). */
6864 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6865 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6867 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
6871 /* Bail out if there are no relaxable sections. */
6875 /* Allocate space for source_relocs. */
6876 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6877 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6879 xtensa_relax_info
*relax_info
;
6881 relax_info
= get_xtensa_relax_info (sec
);
6882 if (relax_info
->is_relaxable_literal_section
6883 || relax_info
->is_relaxable_asm_section
)
6885 relax_info
->src_relocs
= (source_reloc
*)
6886 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
6889 relax_info
->src_count
= 0;
6892 /* Collect info on relocations against each relaxable section. */
6893 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6894 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6896 if (!collect_source_relocs (abfd
, sec
, link_info
))
6900 /* Compute the text actions. */
6901 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6902 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6904 if (!compute_text_actions (abfd
, sec
, link_info
))
6912 /* Find all the sections that might be relaxed. The motivation for
6913 this pass is that collect_source_relocs() needs to record _all_ the
6914 relocations that target each relaxable section. That is expensive
6915 and unnecessary unless the target section is actually going to be
6916 relaxed. This pass identifies all such sections by checking if
6917 they have L32Rs pointing to them. In the process, the total number
6918 of relocations targeting each section is also counted so that we
6919 know how much space to allocate for source_relocs against each
6920 relaxable literal section. */
6923 find_relaxable_sections (bfd
*abfd
,
6925 struct bfd_link_info
*link_info
,
6926 bfd_boolean
*is_relaxable_p
)
6928 Elf_Internal_Rela
*internal_relocs
;
6930 bfd_boolean ok
= TRUE
;
6932 xtensa_relax_info
*source_relax_info
;
6933 bfd_boolean is_l32r_reloc
;
6935 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6936 link_info
->keep_memory
);
6937 if (internal_relocs
== NULL
)
6940 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6941 if (contents
== NULL
&& sec
->size
!= 0)
6947 source_relax_info
= get_xtensa_relax_info (sec
);
6948 for (i
= 0; i
< sec
->reloc_count
; i
++)
6950 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
6952 asection
*target_sec
;
6953 xtensa_relax_info
*target_relax_info
;
6955 /* If this section has not already been marked as "relaxable", and
6956 if it contains any ASM_EXPAND relocations (marking expanded
6957 longcalls) that can be optimized into direct calls, then mark
6958 the section as "relaxable". */
6959 if (source_relax_info
6960 && !source_relax_info
->is_relaxable_asm_section
6961 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
6963 bfd_boolean is_reachable
= FALSE
;
6964 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
6965 link_info
, &is_reachable
)
6968 source_relax_info
->is_relaxable_asm_section
= TRUE
;
6969 *is_relaxable_p
= TRUE
;
6973 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
6974 bfd_get_section_limit (abfd
, sec
));
6976 target_sec
= r_reloc_get_section (&r_rel
);
6977 target_relax_info
= get_xtensa_relax_info (target_sec
);
6978 if (!target_relax_info
)
6981 /* Count PC-relative operand relocations against the target section.
6982 Note: The conditions tested here must match the conditions under
6983 which init_source_reloc is called in collect_source_relocs(). */
6984 is_l32r_reloc
= FALSE
;
6985 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
6987 xtensa_opcode opcode
=
6988 get_relocation_opcode (abfd
, sec
, contents
, irel
);
6989 if (opcode
!= XTENSA_UNDEFINED
)
6991 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
6992 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
6994 target_relax_info
->src_count
++;
6998 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7000 /* Mark the target section as relaxable. */
7001 target_relax_info
->is_relaxable_literal_section
= TRUE
;
7002 *is_relaxable_p
= TRUE
;
7007 release_contents (sec
, contents
);
7008 release_internal_relocs (sec
, internal_relocs
);
7013 /* Record _all_ the relocations that point to relaxable sections, and
7014 get rid of ASM_EXPAND relocs by either converting them to
7015 ASM_SIMPLIFY or by removing them. */
7018 collect_source_relocs (bfd
*abfd
,
7020 struct bfd_link_info
*link_info
)
7022 Elf_Internal_Rela
*internal_relocs
;
7024 bfd_boolean ok
= TRUE
;
7026 bfd_size_type sec_size
;
7028 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7029 link_info
->keep_memory
);
7030 if (internal_relocs
== NULL
)
7033 sec_size
= bfd_get_section_limit (abfd
, sec
);
7034 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7035 if (contents
== NULL
&& sec_size
!= 0)
7041 /* Record relocations against relaxable literal sections. */
7042 for (i
= 0; i
< sec
->reloc_count
; i
++)
7044 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7046 asection
*target_sec
;
7047 xtensa_relax_info
*target_relax_info
;
7049 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7051 target_sec
= r_reloc_get_section (&r_rel
);
7052 target_relax_info
= get_xtensa_relax_info (target_sec
);
7054 if (target_relax_info
7055 && (target_relax_info
->is_relaxable_literal_section
7056 || target_relax_info
->is_relaxable_asm_section
))
7058 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7060 bfd_boolean is_abs_literal
= FALSE
;
7062 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7064 /* None of the current alternate relocs are PC-relative,
7065 and only PC-relative relocs matter here. However, we
7066 still need to record the opcode for literal
7068 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7069 if (opcode
== get_l32r_opcode ())
7071 is_abs_literal
= TRUE
;
7075 opcode
= XTENSA_UNDEFINED
;
7077 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7079 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7080 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7083 if (opcode
!= XTENSA_UNDEFINED
)
7085 int src_next
= target_relax_info
->src_next
++;
7086 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7088 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7094 /* Now get rid of ASM_EXPAND relocations. At this point, the
7095 src_relocs array for the target literal section may still be
7096 incomplete, but it must at least contain the entries for the L32R
7097 relocations associated with ASM_EXPANDs because they were just
7098 added in the preceding loop over the relocations. */
7100 for (i
= 0; i
< sec
->reloc_count
; i
++)
7102 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7103 bfd_boolean is_reachable
;
7105 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7111 Elf_Internal_Rela
*l32r_irel
;
7113 asection
*target_sec
;
7114 xtensa_relax_info
*target_relax_info
;
7116 /* Mark the source_reloc for the L32R so that it will be
7117 removed in compute_removed_literals(), along with the
7118 associated literal. */
7119 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7120 irel
, internal_relocs
);
7121 if (l32r_irel
== NULL
)
7124 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7126 target_sec
= r_reloc_get_section (&r_rel
);
7127 target_relax_info
= get_xtensa_relax_info (target_sec
);
7129 if (target_relax_info
7130 && (target_relax_info
->is_relaxable_literal_section
7131 || target_relax_info
->is_relaxable_asm_section
))
7133 source_reloc
*s_reloc
;
7135 /* Search the source_relocs for the entry corresponding to
7136 the l32r_irel. Note: The src_relocs array is not yet
7137 sorted, but it wouldn't matter anyway because we're
7138 searching by source offset instead of target offset. */
7139 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7140 target_relax_info
->src_next
,
7142 BFD_ASSERT (s_reloc
);
7143 s_reloc
->is_null
= TRUE
;
7146 /* Convert this reloc to ASM_SIMPLIFY. */
7147 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7148 R_XTENSA_ASM_SIMPLIFY
);
7149 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7151 pin_internal_relocs (sec
, internal_relocs
);
7155 /* It is resolvable but doesn't reach. We resolve now
7156 by eliminating the relocation -- the call will remain
7157 expanded into L32R/CALLX. */
7158 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7159 pin_internal_relocs (sec
, internal_relocs
);
7164 release_contents (sec
, contents
);
7165 release_internal_relocs (sec
, internal_relocs
);
7170 /* Return TRUE if the asm expansion can be resolved. Generally it can
7171 be resolved on a final link or when a partial link locates it in the
7172 same section as the target. Set "is_reachable" flag if the target of
7173 the call is within the range of a direct call, given the current VMA
7174 for this section and the target section. */
7177 is_resolvable_asm_expansion (bfd
*abfd
,
7180 Elf_Internal_Rela
*irel
,
7181 struct bfd_link_info
*link_info
,
7182 bfd_boolean
*is_reachable_p
)
7184 asection
*target_sec
;
7185 bfd_vma target_offset
;
7187 xtensa_opcode opcode
, direct_call_opcode
;
7188 bfd_vma self_address
;
7189 bfd_vma dest_address
;
7190 bfd_boolean uses_l32r
;
7191 bfd_size_type sec_size
;
7193 *is_reachable_p
= FALSE
;
7195 if (contents
== NULL
)
7198 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7201 sec_size
= bfd_get_section_limit (abfd
, sec
);
7202 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7203 sec_size
- irel
->r_offset
, &uses_l32r
);
7204 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7208 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7209 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7212 /* Check and see that the target resolves. */
7213 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7214 if (!r_reloc_is_defined (&r_rel
))
7217 target_sec
= r_reloc_get_section (&r_rel
);
7218 target_offset
= r_rel
.target_offset
;
7220 /* If the target is in a shared library, then it doesn't reach. This
7221 isn't supposed to come up because the compiler should never generate
7222 non-PIC calls on systems that use shared libraries, but the linker
7223 shouldn't crash regardless. */
7224 if (!target_sec
->output_section
)
7227 /* For relocatable sections, we can only simplify when the output
7228 section of the target is the same as the output section of the
7230 if (bfd_link_relocatable (link_info
)
7231 && (target_sec
->output_section
!= sec
->output_section
7232 || is_reloc_sym_weak (abfd
, irel
)))
7235 if (target_sec
->output_section
!= sec
->output_section
)
7237 /* If the two sections are sufficiently far away that relaxation
7238 might take the call out of range, we can't simplify. For
7239 example, a positive displacement call into another memory
7240 could get moved to a lower address due to literal removal,
7241 but the destination won't move, and so the displacment might
7244 If the displacement is negative, assume the destination could
7245 move as far back as the start of the output section. The
7246 self_address will be at least as far into the output section
7247 as it is prior to relaxation.
7249 If the displacement is postive, assume the destination will be in
7250 it's pre-relaxed location (because relaxation only makes sections
7251 smaller). The self_address could go all the way to the beginning
7252 of the output section. */
7254 dest_address
= target_sec
->output_section
->vma
;
7255 self_address
= sec
->output_section
->vma
;
7257 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7258 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7260 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7261 /* Call targets should be four-byte aligned. */
7262 dest_address
= (dest_address
+ 3) & ~3;
7267 self_address
= (sec
->output_section
->vma
7268 + sec
->output_offset
+ irel
->r_offset
+ 3);
7269 dest_address
= (target_sec
->output_section
->vma
7270 + target_sec
->output_offset
+ target_offset
);
7273 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7274 self_address
, dest_address
);
7276 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7277 (dest_address
>> CALL_SEGMENT_BITS
))
7284 static Elf_Internal_Rela
*
7285 find_associated_l32r_irel (bfd
*abfd
,
7288 Elf_Internal_Rela
*other_irel
,
7289 Elf_Internal_Rela
*internal_relocs
)
7293 for (i
= 0; i
< sec
->reloc_count
; i
++)
7295 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7297 if (irel
== other_irel
)
7299 if (irel
->r_offset
!= other_irel
->r_offset
)
7301 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7309 static xtensa_opcode
*
7310 build_reloc_opcodes (bfd
*abfd
,
7313 Elf_Internal_Rela
*internal_relocs
)
7316 xtensa_opcode
*reloc_opcodes
=
7317 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7318 for (i
= 0; i
< sec
->reloc_count
; i
++)
7320 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7321 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7323 return reloc_opcodes
;
7326 struct reloc_range_struct
7329 bfd_boolean add
; /* TRUE if start of a range, FALSE otherwise. */
7330 /* Original irel index in the array of relocations for a section. */
7331 unsigned irel_index
;
7333 typedef struct reloc_range_struct reloc_range
;
7335 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7336 struct reloc_range_list_entry_struct
7338 reloc_range_list_entry
*next
;
7339 reloc_range_list_entry
*prev
;
7340 Elf_Internal_Rela
*irel
;
7341 xtensa_opcode opcode
;
7345 struct reloc_range_list_struct
7347 /* The rest of the structure is only meaningful when ok is TRUE. */
7350 unsigned n_range
; /* Number of range markers. */
7351 reloc_range
*range
; /* Sorted range markers. */
7353 unsigned first
; /* Index of a first range element in the list. */
7354 unsigned last
; /* One past index of a last range element in the list. */
7356 unsigned n_list
; /* Number of list elements. */
7357 reloc_range_list_entry
*reloc
; /* */
7358 reloc_range_list_entry list_root
;
7362 reloc_range_compare (const void *a
, const void *b
)
7364 const reloc_range
*ra
= a
;
7365 const reloc_range
*rb
= b
;
7367 if (ra
->addr
!= rb
->addr
)
7368 return ra
->addr
< rb
->addr
? -1 : 1;
7369 if (ra
->add
!= rb
->add
)
7370 return ra
->add
? -1 : 1;
7375 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7377 Elf_Internal_Rela
*internal_relocs
,
7378 xtensa_opcode
*reloc_opcodes
,
7379 reloc_range_list
*list
)
7384 reloc_range
*ranges
= NULL
;
7385 reloc_range_list_entry
*reloc
=
7386 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7388 memset (list
, 0, sizeof (*list
));
7391 for (i
= 0; i
< sec
->reloc_count
; i
++)
7393 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7394 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7395 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7398 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7399 || r_type
== R_XTENSA_32_PCREL
7400 || !howto
->pc_relative
)
7403 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7404 bfd_get_section_limit (abfd
, sec
));
7406 if (r_reloc_get_section (&r_rel
) != sec
)
7411 max_n
= (max_n
+ 2) * 2;
7412 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7415 ranges
[n
].addr
= irel
->r_offset
;
7416 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7418 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7419 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7421 ranges
[n
].irel_index
= i
;
7422 ranges
[n
+ 1].irel_index
= i
;
7426 reloc
[i
].irel
= irel
;
7428 /* Every relocation won't possibly be checked in the optimized version of
7429 check_section_ebb_pcrels_fit, so this needs to be done here. */
7430 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7432 /* None of the current alternate relocs are PC-relative,
7433 and only PC-relative relocs matter here. */
7437 xtensa_opcode opcode
;
7441 opcode
= reloc_opcodes
[i
];
7443 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7445 if (opcode
== XTENSA_UNDEFINED
)
7451 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7452 if (opnum
== XTENSA_UNDEFINED
)
7458 /* Record relocation opcode and opnum as we've calculated them
7459 anyway and they won't change. */
7460 reloc
[i
].opcode
= opcode
;
7461 reloc
[i
].opnum
= opnum
;
7467 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7468 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7471 list
->range
= ranges
;
7472 list
->reloc
= reloc
;
7473 list
->list_root
.prev
= &list
->list_root
;
7474 list
->list_root
.next
= &list
->list_root
;
7483 static void reloc_range_list_append (reloc_range_list
*list
,
7484 unsigned irel_index
)
7486 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7488 entry
->prev
= list
->list_root
.prev
;
7489 entry
->next
= &list
->list_root
;
7490 entry
->prev
->next
= entry
;
7491 entry
->next
->prev
= entry
;
7495 static void reloc_range_list_remove (reloc_range_list
*list
,
7496 unsigned irel_index
)
7498 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7500 entry
->next
->prev
= entry
->prev
;
7501 entry
->prev
->next
= entry
->next
;
7505 /* Update relocation list object so that it lists all relocations that cross
7506 [first; last] range. Range bounds should not decrease with successive
7508 static void reloc_range_list_update_range (reloc_range_list
*list
,
7509 bfd_vma first
, bfd_vma last
)
7511 /* This should not happen: EBBs are iterated from lower addresses to higher.
7512 But even if that happens there's no need to break: just flush current list
7513 and start from scratch. */
7514 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7515 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7520 list
->list_root
.next
= &list
->list_root
;
7521 list
->list_root
.prev
= &list
->list_root
;
7522 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7525 for (; list
->last
< list
->n_range
&&
7526 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7527 if (list
->range
[list
->last
].add
)
7528 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7530 for (; list
->first
< list
->n_range
&&
7531 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7532 if (!list
->range
[list
->first
].add
)
7533 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7536 static void free_reloc_range_list (reloc_range_list
*list
)
7542 /* The compute_text_actions function will build a list of potential
7543 transformation actions for code in the extended basic block of each
7544 longcall that is optimized to a direct call. From this list we
7545 generate a set of actions to actually perform that optimizes for
7546 space and, if not using size_opt, maintains branch target
7549 These actions to be performed are placed on a per-section list.
7550 The actual changes are performed by relax_section() in the second
7554 compute_text_actions (bfd
*abfd
,
7556 struct bfd_link_info
*link_info
)
7558 xtensa_opcode
*reloc_opcodes
= NULL
;
7559 xtensa_relax_info
*relax_info
;
7561 Elf_Internal_Rela
*internal_relocs
;
7562 bfd_boolean ok
= TRUE
;
7564 property_table_entry
*prop_table
= 0;
7566 bfd_size_type sec_size
;
7567 reloc_range_list relevant_relocs
;
7569 relax_info
= get_xtensa_relax_info (sec
);
7570 BFD_ASSERT (relax_info
);
7571 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7573 /* Do nothing if the section contains no optimized longcalls. */
7574 if (!relax_info
->is_relaxable_asm_section
)
7577 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7578 link_info
->keep_memory
);
7580 if (internal_relocs
)
7581 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7582 internal_reloc_compare
);
7584 sec_size
= bfd_get_section_limit (abfd
, sec
);
7585 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7586 if (contents
== NULL
&& sec_size
!= 0)
7592 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7593 XTENSA_PROP_SEC_NAME
, FALSE
);
7600 /* Precompute the opcode for each relocation. */
7601 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7603 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7606 for (i
= 0; i
< sec
->reloc_count
; i
++)
7608 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7610 property_table_entry
*the_entry
;
7613 ebb_constraint ebb_table
;
7614 bfd_size_type simplify_size
;
7616 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7618 r_offset
= irel
->r_offset
;
7620 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7621 if (simplify_size
== 0)
7624 /* xgettext:c-format */
7625 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7626 "XTENSA_ASM_SIMPLIFY relocation; "
7627 "possible configuration mismatch"),
7628 sec
->owner
, sec
, (uint64_t) r_offset
);
7632 /* If the instruction table is not around, then don't do this
7634 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7635 sec
->vma
+ irel
->r_offset
);
7636 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7638 text_action_add (&relax_info
->action_list
,
7639 ta_convert_longcall
, sec
, r_offset
,
7644 /* If the next longcall happens to be at the same address as an
7645 unreachable section of size 0, then skip forward. */
7646 ptbl_idx
= the_entry
- prop_table
;
7647 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7648 && the_entry
->size
== 0
7649 && ptbl_idx
+ 1 < ptblsize
7650 && (prop_table
[ptbl_idx
+ 1].address
7651 == prop_table
[ptbl_idx
].address
))
7657 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7658 /* NO_REORDER is OK */
7661 init_ebb_constraint (&ebb_table
);
7662 ebb
= &ebb_table
.ebb
;
7663 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7664 internal_relocs
, sec
->reloc_count
);
7665 ebb
->start_offset
= r_offset
+ simplify_size
;
7666 ebb
->end_offset
= r_offset
+ simplify_size
;
7667 ebb
->start_ptbl_idx
= ptbl_idx
;
7668 ebb
->end_ptbl_idx
= ptbl_idx
;
7669 ebb
->start_reloc_idx
= i
;
7670 ebb
->end_reloc_idx
= i
;
7672 if (!extend_ebb_bounds (ebb
)
7673 || !compute_ebb_proposed_actions (&ebb_table
)
7674 || !compute_ebb_actions (&ebb_table
)
7675 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7678 &ebb_table
, reloc_opcodes
)
7679 || !check_section_ebb_reduces (&ebb_table
))
7681 /* If anything goes wrong or we get unlucky and something does
7682 not fit, with our plan because of expansion between
7683 critical branches, just convert to a NOP. */
7685 text_action_add (&relax_info
->action_list
,
7686 ta_convert_longcall
, sec
, r_offset
, 0);
7687 i
= ebb_table
.ebb
.end_reloc_idx
;
7688 free_ebb_constraint (&ebb_table
);
7692 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7694 /* Update the index so we do not go looking at the relocations
7695 we have already processed. */
7696 i
= ebb_table
.ebb
.end_reloc_idx
;
7697 free_ebb_constraint (&ebb_table
);
7700 free_reloc_range_list (&relevant_relocs
);
7703 if (action_list_count (&relax_info
->action_list
))
7704 print_action_list (stderr
, &relax_info
->action_list
);
7708 release_contents (sec
, contents
);
7709 release_internal_relocs (sec
, internal_relocs
);
7713 free (reloc_opcodes
);
7719 /* Do not widen an instruction if it is preceeded by a
7720 loop opcode. It might cause misalignment. */
7723 prev_instr_is_a_loop (bfd_byte
*contents
,
7724 bfd_size_type content_length
,
7725 bfd_size_type offset
)
7727 xtensa_opcode prev_opcode
;
7731 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7732 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7736 /* Find all of the possible actions for an extended basic block. */
7739 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7741 const ebb_t
*ebb
= &ebb_table
->ebb
;
7742 unsigned rel_idx
= ebb
->start_reloc_idx
;
7743 property_table_entry
*entry
, *start_entry
, *end_entry
;
7745 xtensa_isa isa
= xtensa_default_isa
;
7747 static xtensa_insnbuf insnbuf
= NULL
;
7748 static xtensa_insnbuf slotbuf
= NULL
;
7750 if (insnbuf
== NULL
)
7752 insnbuf
= xtensa_insnbuf_alloc (isa
);
7753 slotbuf
= xtensa_insnbuf_alloc (isa
);
7756 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7757 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7759 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7761 bfd_vma start_offset
, end_offset
;
7762 bfd_size_type insn_len
;
7764 start_offset
= entry
->address
- ebb
->sec
->vma
;
7765 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7767 if (entry
== start_entry
)
7768 start_offset
= ebb
->start_offset
;
7769 if (entry
== end_entry
)
7770 end_offset
= ebb
->end_offset
;
7771 offset
= start_offset
;
7773 if (offset
== entry
->address
- ebb
->sec
->vma
7774 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7776 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7777 BFD_ASSERT (offset
!= end_offset
);
7778 if (offset
== end_offset
)
7781 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7786 if (check_branch_target_aligned_address (offset
, insn_len
))
7787 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7789 ebb_propose_action (ebb_table
, align_type
, 0,
7790 ta_none
, offset
, 0, TRUE
);
7793 while (offset
!= end_offset
)
7795 Elf_Internal_Rela
*irel
;
7796 xtensa_opcode opcode
;
7798 while (rel_idx
< ebb
->end_reloc_idx
7799 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7800 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7801 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
7802 != R_XTENSA_ASM_SIMPLIFY
))))
7805 /* Check for longcall. */
7806 irel
= &ebb
->relocs
[rel_idx
];
7807 if (irel
->r_offset
== offset
7808 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
7810 bfd_size_type simplify_size
;
7812 simplify_size
= get_asm_simplify_size (ebb
->contents
,
7813 ebb
->content_length
,
7815 if (simplify_size
== 0)
7818 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7819 ta_convert_longcall
, offset
, 0, TRUE
);
7821 offset
+= simplify_size
;
7825 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
7827 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
7828 ebb
->content_length
- offset
);
7829 fmt
= xtensa_format_decode (isa
, insnbuf
);
7830 if (fmt
== XTENSA_UNDEFINED
)
7832 insn_len
= xtensa_format_length (isa
, fmt
);
7833 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
7836 if (xtensa_format_num_slots (isa
, fmt
) != 1)
7842 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
7843 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
7844 if (opcode
== XTENSA_UNDEFINED
)
7847 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
7848 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
7849 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
7851 /* Add an instruction narrow action. */
7852 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7853 ta_narrow_insn
, offset
, 0, FALSE
);
7855 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
7856 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
7857 && ! prev_instr_is_a_loop (ebb
->contents
,
7858 ebb
->content_length
, offset
))
7860 /* Add an instruction widen action. */
7861 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7862 ta_widen_insn
, offset
, 0, FALSE
);
7864 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
7866 /* Check for branch targets. */
7867 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
7868 ta_none
, offset
, 0, TRUE
);
7875 if (ebb
->ends_unreachable
)
7877 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7878 ta_fill
, ebb
->end_offset
, 0, TRUE
);
7885 /* xgettext:c-format */
7886 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
7887 "possible configuration mismatch"),
7888 ebb
->sec
->owner
, ebb
->sec
, (uint64_t) offset
);
7893 /* After all of the information has collected about the
7894 transformations possible in an EBB, compute the appropriate actions
7895 here in compute_ebb_actions. We still must check later to make
7896 sure that the actions do not break any relocations. The algorithm
7897 used here is pretty greedy. Basically, it removes as many no-ops
7898 as possible so that the end of the EBB has the same alignment
7899 characteristics as the original. First, it uses narrowing, then
7900 fill space at the end of the EBB, and finally widenings. If that
7901 does not work, it tries again with one fewer no-op removed. The
7902 optimization will only be performed if all of the branch targets
7903 that were aligned before transformation are also aligned after the
7906 When the size_opt flag is set, ignore the branch target alignments,
7907 narrow all wide instructions, and remove all no-ops unless the end
7908 of the EBB prevents it. */
7911 compute_ebb_actions (ebb_constraint
*ebb_table
)
7915 int removed_bytes
= 0;
7916 ebb_t
*ebb
= &ebb_table
->ebb
;
7917 unsigned seg_idx_start
= 0;
7918 unsigned seg_idx_end
= 0;
7920 /* We perform this like the assembler relaxation algorithm: Start by
7921 assuming all instructions are narrow and all no-ops removed; then
7924 /* For each segment of this that has a solid constraint, check to
7925 see if there are any combinations that will keep the constraint.
7927 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
7929 bfd_boolean requires_text_end_align
= FALSE
;
7930 unsigned longcall_count
= 0;
7931 unsigned longcall_convert_count
= 0;
7932 unsigned narrowable_count
= 0;
7933 unsigned narrowable_convert_count
= 0;
7934 unsigned widenable_count
= 0;
7935 unsigned widenable_convert_count
= 0;
7937 proposed_action
*action
= NULL
;
7938 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
7940 seg_idx_start
= seg_idx_end
;
7942 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
7944 action
= &ebb_table
->actions
[i
];
7945 if (action
->action
== ta_convert_longcall
)
7947 if (action
->action
== ta_narrow_insn
)
7949 if (action
->action
== ta_widen_insn
)
7951 if (action
->action
== ta_fill
)
7953 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
7955 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
7956 && !elf32xtensa_size_opt
)
7961 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
7962 requires_text_end_align
= TRUE
;
7964 if (elf32xtensa_size_opt
&& !requires_text_end_align
7965 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
7966 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
7968 longcall_convert_count
= longcall_count
;
7969 narrowable_convert_count
= narrowable_count
;
7970 widenable_convert_count
= 0;
7974 /* There is a constraint. Convert the max number of longcalls. */
7975 narrowable_convert_count
= 0;
7976 longcall_convert_count
= 0;
7977 widenable_convert_count
= 0;
7979 for (j
= 0; j
< longcall_count
; j
++)
7981 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
7982 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
7983 unsigned desire_widen
= removed
;
7984 if (desire_narrow
<= narrowable_count
)
7986 narrowable_convert_count
= desire_narrow
;
7987 narrowable_convert_count
+=
7988 (align
* ((narrowable_count
- narrowable_convert_count
)
7990 longcall_convert_count
= (longcall_count
- j
);
7991 widenable_convert_count
= 0;
7994 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
7996 narrowable_convert_count
= 0;
7997 longcall_convert_count
= longcall_count
- j
;
7998 widenable_convert_count
= desire_widen
;
8004 /* Now the number of conversions are saved. Do them. */
8005 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
8007 action
= &ebb_table
->actions
[i
];
8008 switch (action
->action
)
8010 case ta_convert_longcall
:
8011 if (longcall_convert_count
!= 0)
8013 action
->action
= ta_remove_longcall
;
8014 action
->do_action
= TRUE
;
8015 action
->removed_bytes
+= 3;
8016 longcall_convert_count
--;
8019 case ta_narrow_insn
:
8020 if (narrowable_convert_count
!= 0)
8022 action
->do_action
= TRUE
;
8023 action
->removed_bytes
+= 1;
8024 narrowable_convert_count
--;
8028 if (widenable_convert_count
!= 0)
8030 action
->do_action
= TRUE
;
8031 action
->removed_bytes
-= 1;
8032 widenable_convert_count
--;
8041 /* Now we move on to some local opts. Try to remove each of the
8042 remaining longcalls. */
8044 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8047 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8049 int old_removed_bytes
= removed_bytes
;
8050 proposed_action
*action
= &ebb_table
->actions
[i
];
8052 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8054 bfd_boolean bad_alignment
= FALSE
;
8056 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8058 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8059 bfd_vma offset
= new_action
->offset
;
8060 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8062 if (!check_branch_target_aligned
8063 (ebb_table
->ebb
.contents
,
8064 ebb_table
->ebb
.content_length
,
8065 offset
, offset
- removed_bytes
))
8067 bad_alignment
= TRUE
;
8071 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8073 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8074 ebb_table
->ebb
.content_length
,
8076 offset
- removed_bytes
))
8078 bad_alignment
= TRUE
;
8082 if (new_action
->action
== ta_narrow_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
= TRUE
;
8088 new_action
->removed_bytes
+= 1;
8089 bad_alignment
= FALSE
;
8092 if (new_action
->action
== ta_widen_insn
8093 && new_action
->do_action
8094 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8096 /* Narrow an instruction and we are done. */
8097 new_action
->do_action
= FALSE
;
8098 new_action
->removed_bytes
+= 1;
8099 bad_alignment
= FALSE
;
8102 if (new_action
->do_action
)
8103 removed_bytes
+= new_action
->removed_bytes
;
8107 action
->removed_bytes
+= 3;
8108 action
->action
= ta_remove_longcall
;
8109 action
->do_action
= TRUE
;
8112 removed_bytes
= old_removed_bytes
;
8113 if (action
->do_action
)
8114 removed_bytes
+= action
->removed_bytes
;
8119 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8121 proposed_action
*action
= &ebb_table
->actions
[i
];
8122 if (action
->do_action
)
8123 removed_bytes
+= action
->removed_bytes
;
8126 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8127 && ebb
->ends_unreachable
)
8129 proposed_action
*action
;
8133 BFD_ASSERT (ebb_table
->action_count
!= 0);
8134 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8135 BFD_ASSERT (action
->action
== ta_fill
);
8136 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8138 extra_space
= xtensa_compute_fill_extra_space (ebb
->ends_unreachable
);
8139 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8140 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8142 action
->removed_bytes
= extra_space
- br
;
8148 /* The xlate_map is a sorted array of address mappings designed to
8149 answer the offset_with_removed_text() query with a binary search instead
8150 of a linear search through the section's action_list. */
8152 typedef struct xlate_map_entry xlate_map_entry_t
;
8153 typedef struct xlate_map xlate_map_t
;
8155 struct xlate_map_entry
8157 bfd_vma orig_address
;
8158 bfd_vma new_address
;
8164 unsigned entry_count
;
8165 xlate_map_entry_t
*entry
;
8170 xlate_compare (const void *a_v
, const void *b_v
)
8172 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8173 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8174 if (a
->orig_address
< b
->orig_address
)
8176 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8183 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8184 text_action_list
*action_list
,
8188 xlate_map_entry_t
*e
;
8189 struct xlate_map_entry se
;
8192 return offset_with_removed_text (action_list
, offset
);
8194 if (map
->entry_count
== 0)
8197 se
.orig_address
= offset
;
8198 r
= bsearch (&se
, map
->entry
, map
->entry_count
,
8199 sizeof (xlate_map_entry_t
), &xlate_compare
);
8200 e
= (xlate_map_entry_t
*) r
;
8202 /* There could be a jump past the end of the section,
8203 allow it using the last xlate map entry to translate its address. */
8206 e
= map
->entry
+ map
->entry_count
- 1;
8207 if (xlate_compare (&se
, e
) <= 0)
8210 BFD_ASSERT (e
!= NULL
);
8213 return e
->new_address
- e
->orig_address
+ offset
;
8216 typedef struct xlate_map_context_struct xlate_map_context
;
8217 struct xlate_map_context_struct
8220 xlate_map_entry_t
*current_entry
;
8225 xlate_map_fn (splay_tree_node node
, void *p
)
8227 text_action
*r
= (text_action
*)node
->value
;
8228 xlate_map_context
*ctx
= p
;
8229 unsigned orig_size
= 0;
8234 case ta_remove_insn
:
8235 case ta_convert_longcall
:
8236 case ta_remove_literal
:
8237 case ta_add_literal
:
8239 case ta_remove_longcall
:
8242 case ta_narrow_insn
:
8251 ctx
->current_entry
->size
=
8252 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8253 if (ctx
->current_entry
->size
!= 0)
8255 ctx
->current_entry
++;
8256 ctx
->map
->entry_count
++;
8258 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8259 ctx
->removed
+= r
->removed_bytes
;
8260 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8261 ctx
->current_entry
->size
= 0;
8265 /* Build a binary searchable offset translation map from a section's
8268 static xlate_map_t
*
8269 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8271 text_action_list
*action_list
= &relax_info
->action_list
;
8272 unsigned num_actions
= 0;
8273 xlate_map_context ctx
;
8275 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8277 if (ctx
.map
== NULL
)
8280 num_actions
= action_list_count (action_list
);
8281 ctx
.map
->entry
= (xlate_map_entry_t
*)
8282 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8283 if (ctx
.map
->entry
== NULL
)
8288 ctx
.map
->entry_count
= 0;
8291 ctx
.current_entry
= &ctx
.map
->entry
[0];
8293 ctx
.current_entry
->orig_address
= 0;
8294 ctx
.current_entry
->new_address
= 0;
8295 ctx
.current_entry
->size
= 0;
8297 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8299 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8300 - ctx
.current_entry
->orig_address
);
8301 if (ctx
.current_entry
->size
!= 0)
8302 ctx
.map
->entry_count
++;
8308 /* Free an offset translation map. */
8311 free_xlate_map (xlate_map_t
*map
)
8313 if (map
&& map
->entry
)
8320 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8321 relocations in a section will fit if a proposed set of actions
8325 check_section_ebb_pcrels_fit (bfd
*abfd
,
8328 Elf_Internal_Rela
*internal_relocs
,
8329 reloc_range_list
*relevant_relocs
,
8330 const ebb_constraint
*constraint
,
8331 const xtensa_opcode
*reloc_opcodes
)
8334 unsigned n
= sec
->reloc_count
;
8335 Elf_Internal_Rela
*irel
;
8336 xlate_map_t
*xmap
= NULL
;
8337 bfd_boolean ok
= TRUE
;
8338 xtensa_relax_info
*relax_info
;
8339 reloc_range_list_entry
*entry
= NULL
;
8341 relax_info
= get_xtensa_relax_info (sec
);
8343 if (relax_info
&& sec
->reloc_count
> 100)
8345 xmap
= build_xlate_map (sec
, relax_info
);
8346 /* NULL indicates out of memory, but the slow version
8347 can still be used. */
8350 if (relevant_relocs
&& constraint
->action_count
)
8352 if (!relevant_relocs
->ok
)
8359 bfd_vma min_offset
, max_offset
;
8360 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8362 for (i
= 1; i
< constraint
->action_count
; ++i
)
8364 proposed_action
*action
= &constraint
->actions
[i
];
8365 bfd_vma offset
= action
->offset
;
8367 if (offset
< min_offset
)
8368 min_offset
= offset
;
8369 if (offset
> max_offset
)
8370 max_offset
= offset
;
8372 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8374 n
= relevant_relocs
->n_list
;
8375 entry
= &relevant_relocs
->list_root
;
8380 relevant_relocs
= NULL
;
8383 for (i
= 0; i
< n
; i
++)
8386 bfd_vma orig_self_offset
, orig_target_offset
;
8387 bfd_vma self_offset
, target_offset
;
8389 reloc_howto_type
*howto
;
8390 int self_removed_bytes
, target_removed_bytes
;
8392 if (relevant_relocs
)
8394 entry
= entry
->next
;
8399 irel
= internal_relocs
+ i
;
8401 r_type
= ELF32_R_TYPE (irel
->r_info
);
8403 howto
= &elf_howto_table
[r_type
];
8404 /* We maintain the required invariant: PC-relative relocations
8405 that fit before linking must fit after linking. Thus we only
8406 need to deal with relocations to the same section that are
8408 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8409 || r_type
== R_XTENSA_32_PCREL
8410 || !howto
->pc_relative
)
8413 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8414 bfd_get_section_limit (abfd
, sec
));
8416 if (r_reloc_get_section (&r_rel
) != sec
)
8419 orig_self_offset
= irel
->r_offset
;
8420 orig_target_offset
= r_rel
.target_offset
;
8422 self_offset
= orig_self_offset
;
8423 target_offset
= orig_target_offset
;
8428 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8431 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8432 orig_target_offset
);
8435 self_removed_bytes
= 0;
8436 target_removed_bytes
= 0;
8438 for (j
= 0; j
< constraint
->action_count
; ++j
)
8440 proposed_action
*action
= &constraint
->actions
[j
];
8441 bfd_vma offset
= action
->offset
;
8442 int removed_bytes
= action
->removed_bytes
;
8443 if (offset
< orig_self_offset
8444 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8445 && action
->removed_bytes
< 0))
8446 self_removed_bytes
+= removed_bytes
;
8447 if (offset
< orig_target_offset
8448 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8449 && action
->removed_bytes
< 0))
8450 target_removed_bytes
+= removed_bytes
;
8452 self_offset
-= self_removed_bytes
;
8453 target_offset
-= target_removed_bytes
;
8455 /* Try to encode it. Get the operand and check. */
8456 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8458 /* None of the current alternate relocs are PC-relative,
8459 and only PC-relative relocs matter here. */
8463 xtensa_opcode opcode
;
8466 if (relevant_relocs
)
8468 opcode
= entry
->opcode
;
8469 opnum
= entry
->opnum
;
8474 opcode
= reloc_opcodes
[relevant_relocs
?
8475 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8477 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8478 if (opcode
== XTENSA_UNDEFINED
)
8484 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8485 if (opnum
== XTENSA_UNDEFINED
)
8492 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8501 free_xlate_map (xmap
);
8508 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8513 for (i
= 0; i
< constraint
->action_count
; i
++)
8515 const proposed_action
*action
= &constraint
->actions
[i
];
8516 if (action
->do_action
)
8517 removed
+= action
->removed_bytes
;
8527 text_action_add_proposed (text_action_list
*l
,
8528 const ebb_constraint
*ebb_table
,
8533 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8535 proposed_action
*action
= &ebb_table
->actions
[i
];
8537 if (!action
->do_action
)
8539 switch (action
->action
)
8541 case ta_remove_insn
:
8542 case ta_remove_longcall
:
8543 case ta_convert_longcall
:
8544 case ta_narrow_insn
:
8547 case ta_remove_literal
:
8548 text_action_add (l
, action
->action
, sec
, action
->offset
,
8549 action
->removed_bytes
);
8562 xtensa_compute_fill_extra_space (property_table_entry
*entry
)
8564 int fill_extra_space
;
8569 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8572 fill_extra_space
= entry
->size
;
8573 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8575 /* Fill bytes for alignment:
8576 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8577 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8578 int nsm
= (1 << pow
) - 1;
8579 bfd_vma addr
= entry
->address
+ entry
->size
;
8580 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8581 fill_extra_space
+= align_fill
;
8583 return fill_extra_space
;
8587 /* First relaxation pass. */
8589 /* If the section contains relaxable literals, check each literal to
8590 see if it has the same value as another literal that has already
8591 been seen, either in the current section or a previous one. If so,
8592 add an entry to the per-section list of removed literals. The
8593 actual changes are deferred until the next pass. */
8596 compute_removed_literals (bfd
*abfd
,
8598 struct bfd_link_info
*link_info
,
8599 value_map_hash_table
*values
)
8601 xtensa_relax_info
*relax_info
;
8603 Elf_Internal_Rela
*internal_relocs
;
8604 source_reloc
*src_relocs
, *rel
;
8605 bfd_boolean ok
= TRUE
;
8606 property_table_entry
*prop_table
= NULL
;
8609 bfd_boolean last_loc_is_prev
= FALSE
;
8610 bfd_vma last_target_offset
= 0;
8611 section_cache_t target_sec_cache
;
8612 bfd_size_type sec_size
;
8614 init_section_cache (&target_sec_cache
);
8616 /* Do nothing if it is not a relaxable literal section. */
8617 relax_info
= get_xtensa_relax_info (sec
);
8618 BFD_ASSERT (relax_info
);
8619 if (!relax_info
->is_relaxable_literal_section
)
8622 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8623 link_info
->keep_memory
);
8625 sec_size
= bfd_get_section_limit (abfd
, sec
);
8626 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8627 if (contents
== NULL
&& sec_size
!= 0)
8633 /* Sort the source_relocs by target offset. */
8634 src_relocs
= relax_info
->src_relocs
;
8635 qsort (src_relocs
, relax_info
->src_count
,
8636 sizeof (source_reloc
), source_reloc_compare
);
8637 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8638 internal_reloc_compare
);
8640 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8641 XTENSA_PROP_SEC_NAME
, FALSE
);
8649 for (i
= 0; i
< relax_info
->src_count
; i
++)
8651 Elf_Internal_Rela
*irel
= NULL
;
8653 rel
= &src_relocs
[i
];
8654 if (get_l32r_opcode () != rel
->opcode
)
8656 irel
= get_irel_at_offset (sec
, internal_relocs
,
8657 rel
->r_rel
.target_offset
);
8659 /* If the relocation on this is not a simple R_XTENSA_32 or
8660 R_XTENSA_PLT then do not consider it. This may happen when
8661 the difference of two symbols is used in a literal. */
8662 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8663 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8666 /* If the target_offset for this relocation is the same as the
8667 previous relocation, then we've already considered whether the
8668 literal can be coalesced. Skip to the next one.... */
8669 if (i
!= 0 && prev_i
!= -1
8670 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8674 if (last_loc_is_prev
&&
8675 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8676 last_loc_is_prev
= FALSE
;
8678 /* Check if the relocation was from an L32R that is being removed
8679 because a CALLX was converted to a direct CALL, and check if
8680 there are no other relocations to the literal. */
8681 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8682 sec
, prop_table
, ptblsize
))
8684 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8685 irel
, rel
, prop_table
, ptblsize
))
8690 last_target_offset
= rel
->r_rel
.target_offset
;
8694 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8696 &last_loc_is_prev
, irel
,
8697 relax_info
->src_count
- i
, rel
,
8698 prop_table
, ptblsize
,
8699 &target_sec_cache
, rel
->is_abs_literal
))
8704 last_target_offset
= rel
->r_rel
.target_offset
;
8708 print_removed_literals (stderr
, &relax_info
->removed_list
);
8709 print_action_list (stderr
, &relax_info
->action_list
);
8715 free_section_cache (&target_sec_cache
);
8717 release_contents (sec
, contents
);
8718 release_internal_relocs (sec
, internal_relocs
);
8723 static Elf_Internal_Rela
*
8724 get_irel_at_offset (asection
*sec
,
8725 Elf_Internal_Rela
*internal_relocs
,
8729 Elf_Internal_Rela
*irel
;
8731 Elf_Internal_Rela key
;
8733 if (!internal_relocs
)
8736 key
.r_offset
= offset
;
8737 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8738 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8742 /* bsearch does not guarantee which will be returned if there are
8743 multiple matches. We need the first that is not an alignment. */
8744 i
= irel
- internal_relocs
;
8747 if (internal_relocs
[i
-1].r_offset
!= offset
)
8751 for ( ; i
< sec
->reloc_count
; i
++)
8753 irel
= &internal_relocs
[i
];
8754 r_type
= ELF32_R_TYPE (irel
->r_info
);
8755 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8764 is_removable_literal (const source_reloc
*rel
,
8766 const source_reloc
*src_relocs
,
8769 property_table_entry
*prop_table
,
8772 const source_reloc
*curr_rel
;
8773 property_table_entry
*entry
;
8778 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8779 sec
->vma
+ rel
->r_rel
.target_offset
);
8780 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8783 for (++i
; i
< src_count
; ++i
)
8785 curr_rel
= &src_relocs
[i
];
8786 /* If all others have the same target offset.... */
8787 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8790 if (!curr_rel
->is_null
8791 && !xtensa_is_property_section (curr_rel
->source_sec
)
8792 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8800 remove_dead_literal (bfd
*abfd
,
8802 struct bfd_link_info
*link_info
,
8803 Elf_Internal_Rela
*internal_relocs
,
8804 Elf_Internal_Rela
*irel
,
8806 property_table_entry
*prop_table
,
8809 property_table_entry
*entry
;
8810 xtensa_relax_info
*relax_info
;
8812 relax_info
= get_xtensa_relax_info (sec
);
8816 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8817 sec
->vma
+ rel
->r_rel
.target_offset
);
8819 /* Mark the unused literal so that it will be removed. */
8820 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
8822 text_action_add (&relax_info
->action_list
,
8823 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
8825 /* If the section is 4-byte aligned, do not add fill. */
8826 if (sec
->alignment_power
> 2)
8828 int fill_extra_space
;
8829 bfd_vma entry_sec_offset
;
8831 property_table_entry
*the_add_entry
;
8835 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
8837 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
8839 /* If the literal range is at the end of the section,
8841 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8843 fill_extra_space
= xtensa_compute_fill_extra_space (the_add_entry
);
8845 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
8846 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
8847 -4, fill_extra_space
);
8849 adjust_fill_action (fa
, removed_diff
);
8851 text_action_add (&relax_info
->action_list
,
8852 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
8855 /* Zero out the relocation on this literal location. */
8858 if (elf_hash_table (link_info
)->dynamic_sections_created
)
8859 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
8861 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
8862 pin_internal_relocs (sec
, internal_relocs
);
8865 /* Do not modify "last_loc_is_prev". */
8871 identify_literal_placement (bfd
*abfd
,
8874 struct bfd_link_info
*link_info
,
8875 value_map_hash_table
*values
,
8876 bfd_boolean
*last_loc_is_prev_p
,
8877 Elf_Internal_Rela
*irel
,
8878 int remaining_src_rels
,
8880 property_table_entry
*prop_table
,
8882 section_cache_t
*target_sec_cache
,
8883 bfd_boolean is_abs_literal
)
8887 xtensa_relax_info
*relax_info
;
8888 bfd_boolean literal_placed
= FALSE
;
8890 unsigned long value
;
8891 bfd_boolean final_static_link
;
8892 bfd_size_type sec_size
;
8894 relax_info
= get_xtensa_relax_info (sec
);
8898 sec_size
= bfd_get_section_limit (abfd
, sec
);
8901 (!bfd_link_relocatable (link_info
)
8902 && !elf_hash_table (link_info
)->dynamic_sections_created
);
8904 /* The placement algorithm first checks to see if the literal is
8905 already in the value map. If so and the value map is reachable
8906 from all uses, then the literal is moved to that location. If
8907 not, then we identify the last location where a fresh literal was
8908 placed. If the literal can be safely moved there, then we do so.
8909 If not, then we assume that the literal is not to move and leave
8910 the literal where it is, marking it as the last literal
8913 /* Find the literal value. */
8915 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
8918 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
8919 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
8921 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
8923 /* Check if we've seen another literal with the same value that
8924 is in the same output section. */
8925 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
8928 && (r_reloc_get_section (&val_map
->loc
)->output_section
8929 == sec
->output_section
)
8930 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
8931 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
8933 /* No change to last_loc_is_prev. */
8934 literal_placed
= TRUE
;
8937 /* For relocatable links, do not try to move literals. To do it
8938 correctly might increase the number of relocations in an input
8939 section making the default relocatable linking fail. */
8940 if (!bfd_link_relocatable (link_info
) && !literal_placed
8941 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
8943 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
8944 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
8946 /* Increment the virtual offset. */
8947 r_reloc try_loc
= values
->last_loc
;
8948 try_loc
.virtual_offset
+= 4;
8950 /* There is a last loc that was in the same output section. */
8951 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
8952 && move_shared_literal (sec
, link_info
, rel
,
8953 prop_table
, ptblsize
,
8954 &try_loc
, &val
, target_sec_cache
))
8956 values
->last_loc
.virtual_offset
+= 4;
8957 literal_placed
= TRUE
;
8959 val_map
= add_value_map (values
, &val
, &try_loc
,
8962 val_map
->loc
= try_loc
;
8967 if (!literal_placed
)
8969 /* Nothing worked, leave the literal alone but update the last loc. */
8970 values
->has_last_loc
= TRUE
;
8971 values
->last_loc
= rel
->r_rel
;
8973 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
8975 val_map
->loc
= rel
->r_rel
;
8976 *last_loc_is_prev_p
= TRUE
;
8983 /* Check if the original relocations (presumably on L32R instructions)
8984 identified by reloc[0..N] can be changed to reference the literal
8985 identified by r_rel. If r_rel is out of range for any of the
8986 original relocations, then we don't want to coalesce the original
8987 literal with the one at r_rel. We only check reloc[0..N], where the
8988 offsets are all the same as for reloc[0] (i.e., they're all
8989 referencing the same literal) and where N is also bounded by the
8990 number of remaining entries in the "reloc" array. The "reloc" array
8991 is sorted by target offset so we know all the entries for the same
8992 literal will be contiguous. */
8995 relocations_reach (source_reloc
*reloc
,
8996 int remaining_relocs
,
8997 const r_reloc
*r_rel
)
8999 bfd_vma from_offset
, source_address
, dest_address
;
9003 if (!r_reloc_is_defined (r_rel
))
9006 sec
= r_reloc_get_section (r_rel
);
9007 from_offset
= reloc
[0].r_rel
.target_offset
;
9009 for (i
= 0; i
< remaining_relocs
; i
++)
9011 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9014 /* Ignore relocations that have been removed. */
9015 if (reloc
[i
].is_null
)
9018 /* The original and new output section for these must be the same
9019 in order to coalesce. */
9020 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9021 != sec
->output_section
)
9024 /* Absolute literals in the same output section can always be
9026 if (reloc
[i
].is_abs_literal
)
9029 /* A literal with no PC-relative relocations can be moved anywhere. */
9030 if (reloc
[i
].opnd
!= -1)
9032 /* Otherwise, check to see that it fits. */
9033 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9034 + reloc
[i
].source_sec
->output_offset
9035 + reloc
[i
].r_rel
.rela
.r_offset
);
9036 dest_address
= (sec
->output_section
->vma
9037 + sec
->output_offset
9038 + r_rel
->target_offset
);
9040 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9041 source_address
, dest_address
))
9050 /* Move a literal to another literal location because it is
9051 the same as the other literal value. */
9054 coalesce_shared_literal (asection
*sec
,
9056 property_table_entry
*prop_table
,
9060 property_table_entry
*entry
;
9062 property_table_entry
*the_add_entry
;
9064 xtensa_relax_info
*relax_info
;
9066 relax_info
= get_xtensa_relax_info (sec
);
9070 entry
= elf_xtensa_find_property_entry
9071 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9072 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9075 /* Mark that the literal will be coalesced. */
9076 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9078 text_action_add (&relax_info
->action_list
,
9079 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9081 /* If the section is 4-byte aligned, do not add fill. */
9082 if (sec
->alignment_power
> 2)
9084 int fill_extra_space
;
9085 bfd_vma entry_sec_offset
;
9088 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9090 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9092 /* If the literal range is at the end of the section,
9094 fill_extra_space
= 0;
9095 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9097 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9098 fill_extra_space
= the_add_entry
->size
;
9100 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9101 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9102 -4, fill_extra_space
);
9104 adjust_fill_action (fa
, removed_diff
);
9106 text_action_add (&relax_info
->action_list
,
9107 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9114 /* Move a literal to another location. This may actually increase the
9115 total amount of space used because of alignments so we need to do
9116 this carefully. Also, it may make a branch go out of range. */
9119 move_shared_literal (asection
*sec
,
9120 struct bfd_link_info
*link_info
,
9122 property_table_entry
*prop_table
,
9124 const r_reloc
*target_loc
,
9125 const literal_value
*lit_value
,
9126 section_cache_t
*target_sec_cache
)
9128 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9129 text_action
*fa
, *target_fa
;
9131 xtensa_relax_info
*relax_info
, *target_relax_info
;
9132 asection
*target_sec
;
9134 ebb_constraint ebb_table
;
9135 bfd_boolean relocs_fit
;
9137 /* If this routine always returns FALSE, the literals that cannot be
9138 coalesced will not be moved. */
9139 if (elf32xtensa_no_literal_movement
)
9142 relax_info
= get_xtensa_relax_info (sec
);
9146 target_sec
= r_reloc_get_section (target_loc
);
9147 target_relax_info
= get_xtensa_relax_info (target_sec
);
9149 /* Literals to undefined sections may not be moved because they
9150 must report an error. */
9151 if (bfd_is_und_section (target_sec
))
9154 src_entry
= elf_xtensa_find_property_entry
9155 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9157 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9160 target_entry
= elf_xtensa_find_property_entry
9161 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9162 target_sec
->vma
+ target_loc
->target_offset
);
9167 /* Make sure that we have not broken any branches. */
9170 init_ebb_constraint (&ebb_table
);
9171 ebb
= &ebb_table
.ebb
;
9172 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9173 target_sec_cache
->content_length
,
9174 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9175 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9177 /* Propose to add 4 bytes + worst-case alignment size increase to
9179 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9180 ta_fill
, target_loc
->target_offset
,
9181 -4 - (1 << target_sec
->alignment_power
), TRUE
);
9183 /* Check all of the PC-relative relocations to make sure they still fit. */
9184 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9185 target_sec_cache
->contents
,
9186 target_sec_cache
->relocs
, NULL
,
9192 text_action_add_literal (&target_relax_info
->action_list
,
9193 ta_add_literal
, target_loc
, lit_value
, -4);
9195 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9197 /* May need to add or remove some fill to maintain alignment. */
9198 int fill_extra_space
;
9199 bfd_vma entry_sec_offset
;
9202 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9204 /* If the literal range is at the end of the section,
9206 fill_extra_space
= 0;
9208 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9209 target_sec_cache
->pte_count
,
9211 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9212 fill_extra_space
= the_add_entry
->size
;
9214 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9215 target_sec
, entry_sec_offset
);
9216 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9217 entry_sec_offset
, 4,
9220 adjust_fill_action (target_fa
, removed_diff
);
9222 text_action_add (&target_relax_info
->action_list
,
9223 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9226 /* Mark that the literal will be moved to the new location. */
9227 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9229 /* Remove the literal. */
9230 text_action_add (&relax_info
->action_list
,
9231 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9233 /* If the section is 4-byte aligned, do not add fill. */
9234 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9236 int fill_extra_space
;
9237 bfd_vma entry_sec_offset
;
9240 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9242 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9244 /* If the literal range is at the end of the section,
9246 fill_extra_space
= 0;
9247 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9249 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9250 fill_extra_space
= the_add_entry
->size
;
9252 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9253 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9254 -4, fill_extra_space
);
9256 adjust_fill_action (fa
, removed_diff
);
9258 text_action_add (&relax_info
->action_list
,
9259 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9266 /* Second relaxation pass. */
9269 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9271 bfd_size_type
*final_size
= p
;
9272 text_action
*action
= (text_action
*)node
->value
;
9274 *final_size
-= action
->removed_bytes
;
9278 /* Modify all of the relocations to point to the right spot, and if this
9279 is a relaxable section, delete the unwanted literals and fix the
9283 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9285 Elf_Internal_Rela
*internal_relocs
;
9286 xtensa_relax_info
*relax_info
;
9288 bfd_boolean ok
= TRUE
;
9290 bfd_boolean rv
= FALSE
;
9291 bfd_boolean virtual_action
;
9292 bfd_size_type sec_size
;
9294 sec_size
= bfd_get_section_limit (abfd
, sec
);
9295 relax_info
= get_xtensa_relax_info (sec
);
9296 BFD_ASSERT (relax_info
);
9298 /* First translate any of the fixes that have been added already. */
9299 translate_section_fixes (sec
);
9301 /* Handle property sections (e.g., literal tables) specially. */
9302 if (xtensa_is_property_section (sec
))
9304 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9305 return relax_property_section (abfd
, sec
, link_info
);
9308 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9309 link_info
->keep_memory
);
9310 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9313 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9314 if (contents
== NULL
&& sec_size
!= 0)
9320 if (internal_relocs
)
9322 for (i
= 0; i
< sec
->reloc_count
; i
++)
9324 Elf_Internal_Rela
*irel
;
9325 xtensa_relax_info
*target_relax_info
;
9326 bfd_vma source_offset
, old_source_offset
;
9329 asection
*target_sec
;
9331 /* Locally change the source address.
9332 Translate the target to the new target address.
9333 If it points to this section and has been removed,
9337 irel
= &internal_relocs
[i
];
9338 source_offset
= irel
->r_offset
;
9339 old_source_offset
= source_offset
;
9341 r_type
= ELF32_R_TYPE (irel
->r_info
);
9342 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9343 bfd_get_section_limit (abfd
, sec
));
9345 /* If this section could have changed then we may need to
9346 change the relocation's offset. */
9348 if (relax_info
->is_relaxable_literal_section
9349 || relax_info
->is_relaxable_asm_section
)
9351 pin_internal_relocs (sec
, internal_relocs
);
9353 if (r_type
!= R_XTENSA_NONE
9354 && find_removed_literal (&relax_info
->removed_list
,
9357 /* Remove this relocation. */
9358 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9359 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9360 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9361 irel
->r_offset
= offset_with_removed_text_map
9362 (&relax_info
->action_list
, irel
->r_offset
);
9366 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9368 text_action
*action
=
9369 find_insn_action (&relax_info
->action_list
,
9371 if (action
&& (action
->action
== ta_convert_longcall
9372 || action
->action
== ta_remove_longcall
))
9374 bfd_reloc_status_type retval
;
9375 char *error_message
= NULL
;
9377 retval
= contract_asm_expansion (contents
, sec_size
,
9378 irel
, &error_message
);
9379 if (retval
!= bfd_reloc_ok
)
9381 (*link_info
->callbacks
->reloc_dangerous
)
9382 (link_info
, error_message
, abfd
, sec
,
9386 /* Update the action so that the code that moves
9387 the contents will do the right thing. */
9388 /* ta_remove_longcall and ta_remove_insn actions are
9389 grouped together in the tree as well as
9390 ta_convert_longcall and ta_none, so that changes below
9391 can be done w/o removing and reinserting action into
9394 if (action
->action
== ta_remove_longcall
)
9395 action
->action
= ta_remove_insn
;
9397 action
->action
= ta_none
;
9398 /* Refresh the info in the r_rel. */
9399 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9400 r_type
= ELF32_R_TYPE (irel
->r_info
);
9404 source_offset
= offset_with_removed_text_map
9405 (&relax_info
->action_list
, irel
->r_offset
);
9406 irel
->r_offset
= source_offset
;
9409 /* If the target section could have changed then
9410 we may need to change the relocation's target offset. */
9412 target_sec
= r_reloc_get_section (&r_rel
);
9414 /* For a reference to a discarded section from a DWARF section,
9415 i.e., where action_discarded is PRETEND, the symbol will
9416 eventually be modified to refer to the kept section (at least if
9417 the kept and discarded sections are the same size). Anticipate
9418 that here and adjust things accordingly. */
9419 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9420 && elf_xtensa_action_discarded (sec
) == PRETEND
9421 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9422 && target_sec
!= NULL
9423 && discarded_section (target_sec
))
9425 /* It would be natural to call _bfd_elf_check_kept_section
9426 here, but it's not exported from elflink.c. It's also a
9427 fairly expensive check. Adjusting the relocations to the
9428 discarded section is fairly harmless; it will only adjust
9429 some addends and difference values. If it turns out that
9430 _bfd_elf_check_kept_section fails later, it won't matter,
9431 so just compare the section names to find the right group
9433 asection
*kept
= target_sec
->kept_section
;
9436 if ((kept
->flags
& SEC_GROUP
) != 0)
9438 asection
*first
= elf_next_in_group (kept
);
9439 asection
*s
= first
;
9444 if (strcmp (s
->name
, target_sec
->name
) == 0)
9449 s
= elf_next_in_group (s
);
9456 && ((target_sec
->rawsize
!= 0
9457 ? target_sec
->rawsize
: target_sec
->size
)
9458 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9462 target_relax_info
= get_xtensa_relax_info (target_sec
);
9463 if (target_relax_info
9464 && (target_relax_info
->is_relaxable_literal_section
9465 || target_relax_info
->is_relaxable_asm_section
))
9468 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9470 if (r_type
== R_XTENSA_DIFF8
9471 || r_type
== R_XTENSA_DIFF16
9472 || r_type
== R_XTENSA_DIFF32
)
9474 bfd_signed_vma diff_value
= 0;
9475 bfd_vma new_end_offset
, diff_mask
= 0;
9477 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9479 (*link_info
->callbacks
->reloc_dangerous
)
9480 (link_info
, _("invalid relocation address"),
9481 abfd
, sec
, old_source_offset
);
9487 case R_XTENSA_DIFF8
:
9489 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9491 case R_XTENSA_DIFF16
:
9493 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9495 case R_XTENSA_DIFF32
:
9497 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9501 new_end_offset
= offset_with_removed_text_map
9502 (&target_relax_info
->action_list
,
9503 r_rel
.target_offset
+ diff_value
);
9504 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9508 case R_XTENSA_DIFF8
:
9510 bfd_put_signed_8 (abfd
, diff_value
,
9511 &contents
[old_source_offset
]);
9513 case R_XTENSA_DIFF16
:
9515 bfd_put_signed_16 (abfd
, diff_value
,
9516 &contents
[old_source_offset
]);
9518 case R_XTENSA_DIFF32
:
9519 diff_mask
= 0x7fffffff;
9520 bfd_put_signed_32 (abfd
, diff_value
,
9521 &contents
[old_source_offset
]);
9525 /* Check for overflow. Sign bits must be all zeroes or all ones */
9526 if ((diff_value
& ~diff_mask
) != 0 &&
9527 (diff_value
& ~diff_mask
) != (-1 & ~diff_mask
))
9529 (*link_info
->callbacks
->reloc_dangerous
)
9530 (link_info
, _("overflow after relaxation"),
9531 abfd
, sec
, old_source_offset
);
9535 pin_contents (sec
, contents
);
9538 /* If the relocation still references a section in the same
9539 input file, modify the relocation directly instead of
9540 adding a "fix" record. */
9541 if (target_sec
->owner
== abfd
)
9543 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9544 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9545 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9546 pin_internal_relocs (sec
, internal_relocs
);
9550 bfd_vma addend_displacement
;
9553 addend_displacement
=
9554 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9555 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9557 addend_displacement
, TRUE
);
9564 if ((relax_info
->is_relaxable_literal_section
9565 || relax_info
->is_relaxable_asm_section
)
9566 && action_list_count (&relax_info
->action_list
))
9568 /* Walk through the planned actions and build up a table
9569 of move, copy and fill records. Use the move, copy and
9570 fill records to perform the actions once. */
9572 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9573 bfd_byte
*scratch
= NULL
;
9574 bfd_byte
*dup_contents
= NULL
;
9575 bfd_size_type orig_size
= sec
->size
;
9576 bfd_vma orig_dot
= 0;
9577 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9578 orig dot in physical memory. */
9579 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9580 bfd_vma dup_dot
= 0;
9582 text_action
*action
;
9584 final_size
= sec
->size
;
9586 splay_tree_foreach (relax_info
->action_list
.tree
,
9587 action_remove_bytes_fn
, &final_size
);
9588 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9589 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9591 /* The dot is the current fill location. */
9593 print_action_list (stderr
, &relax_info
->action_list
);
9596 for (action
= action_first (&relax_info
->action_list
); action
;
9597 action
= action_next (&relax_info
->action_list
, action
))
9599 virtual_action
= FALSE
;
9600 if (action
->offset
> orig_dot
)
9602 orig_dot
+= orig_dot_copied
;
9603 orig_dot_copied
= 0;
9605 /* Out of the virtual world. */
9608 if (action
->offset
> orig_dot
)
9610 copy_size
= action
->offset
- orig_dot
;
9611 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9612 orig_dot
+= copy_size
;
9613 dup_dot
+= copy_size
;
9614 BFD_ASSERT (action
->offset
== orig_dot
);
9616 else if (action
->offset
< orig_dot
)
9618 if (action
->action
== ta_fill
9619 && action
->offset
- action
->removed_bytes
== orig_dot
)
9621 /* This is OK because the fill only effects the dup_dot. */
9623 else if (action
->action
== ta_add_literal
)
9625 /* TBD. Might need to handle this. */
9628 if (action
->offset
== orig_dot
)
9630 if (action
->virtual_offset
> orig_dot_vo
)
9632 if (orig_dot_vo
== 0)
9634 /* Need to copy virtual_offset bytes. Probably four. */
9635 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9636 memmove (&dup_contents
[dup_dot
],
9637 &contents
[orig_dot
], copy_size
);
9638 orig_dot_copied
= copy_size
;
9639 dup_dot
+= copy_size
;
9641 virtual_action
= TRUE
;
9644 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9646 switch (action
->action
)
9648 case ta_remove_literal
:
9649 case ta_remove_insn
:
9650 BFD_ASSERT (action
->removed_bytes
>= 0);
9651 orig_dot
+= action
->removed_bytes
;
9654 case ta_narrow_insn
:
9657 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9658 BFD_ASSERT (action
->removed_bytes
== 1);
9659 rv
= narrow_instruction (scratch
, final_size
, 0);
9661 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9662 orig_dot
+= orig_insn_size
;
9663 dup_dot
+= copy_size
;
9667 if (action
->removed_bytes
>= 0)
9668 orig_dot
+= action
->removed_bytes
;
9671 /* Already zeroed in dup_contents. Just bump the
9673 dup_dot
+= (-action
->removed_bytes
);
9678 BFD_ASSERT (action
->removed_bytes
== 0);
9681 case ta_convert_longcall
:
9682 case ta_remove_longcall
:
9683 /* These will be removed or converted before we get here. */
9690 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9691 BFD_ASSERT (action
->removed_bytes
== -1);
9692 rv
= widen_instruction (scratch
, final_size
, 0);
9694 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9695 orig_dot
+= orig_insn_size
;
9696 dup_dot
+= copy_size
;
9699 case ta_add_literal
:
9702 BFD_ASSERT (action
->removed_bytes
== -4);
9703 /* TBD -- place the literal value here and insert
9705 memset (&dup_contents
[dup_dot
], 0, 4);
9706 pin_internal_relocs (sec
, internal_relocs
);
9707 pin_contents (sec
, contents
);
9709 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9710 relax_info
, &internal_relocs
, &action
->value
))
9714 orig_dot_vo
+= copy_size
;
9716 orig_dot
+= orig_insn_size
;
9717 dup_dot
+= copy_size
;
9721 /* Not implemented yet. */
9726 BFD_ASSERT (dup_dot
<= final_size
);
9727 BFD_ASSERT (orig_dot
<= orig_size
);
9730 orig_dot
+= orig_dot_copied
;
9731 orig_dot_copied
= 0;
9733 if (orig_dot
!= orig_size
)
9735 copy_size
= orig_size
- orig_dot
;
9736 BFD_ASSERT (orig_size
> orig_dot
);
9737 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9738 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9739 orig_dot
+= copy_size
;
9740 dup_dot
+= copy_size
;
9742 BFD_ASSERT (orig_size
== orig_dot
);
9743 BFD_ASSERT (final_size
== dup_dot
);
9745 /* Move the dup_contents back. */
9746 if (final_size
> orig_size
)
9748 /* Contents need to be reallocated. Swap the dup_contents into
9750 sec
->contents
= dup_contents
;
9752 contents
= dup_contents
;
9753 pin_contents (sec
, contents
);
9757 BFD_ASSERT (final_size
<= orig_size
);
9758 memset (contents
, 0, orig_size
);
9759 memcpy (contents
, dup_contents
, final_size
);
9760 free (dup_contents
);
9763 pin_contents (sec
, contents
);
9765 if (sec
->rawsize
== 0)
9766 sec
->rawsize
= sec
->size
;
9767 sec
->size
= final_size
;
9771 release_internal_relocs (sec
, internal_relocs
);
9772 release_contents (sec
, contents
);
9778 translate_section_fixes (asection
*sec
)
9780 xtensa_relax_info
*relax_info
;
9783 relax_info
= get_xtensa_relax_info (sec
);
9787 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
9788 if (!translate_reloc_bfd_fix (r
))
9795 /* Translate a fix given the mapping in the relax info for the target
9796 section. If it has already been translated, no work is required. */
9799 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
9801 reloc_bfd_fix new_fix
;
9803 xtensa_relax_info
*relax_info
;
9804 removed_literal
*removed
;
9805 bfd_vma new_offset
, target_offset
;
9807 if (fix
->translated
)
9810 sec
= fix
->target_sec
;
9811 target_offset
= fix
->target_offset
;
9813 relax_info
= get_xtensa_relax_info (sec
);
9816 fix
->translated
= TRUE
;
9822 /* The fix does not need to be translated if the section cannot change. */
9823 if (!relax_info
->is_relaxable_literal_section
9824 && !relax_info
->is_relaxable_asm_section
)
9826 fix
->translated
= TRUE
;
9830 /* If the literal has been moved and this relocation was on an
9831 opcode, then the relocation should move to the new literal
9832 location. Otherwise, the relocation should move within the
9836 if (is_operand_relocation (fix
->src_type
))
9838 /* Check if the original relocation is against a literal being
9840 removed
= find_removed_literal (&relax_info
->removed_list
,
9848 /* The fact that there is still a relocation to this literal indicates
9849 that the literal is being coalesced, not simply removed. */
9850 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
9852 /* This was moved to some other address (possibly another section). */
9853 new_sec
= r_reloc_get_section (&removed
->to
);
9857 relax_info
= get_xtensa_relax_info (sec
);
9859 (!relax_info
->is_relaxable_literal_section
9860 && !relax_info
->is_relaxable_asm_section
))
9862 target_offset
= removed
->to
.target_offset
;
9863 new_fix
.target_sec
= new_sec
;
9864 new_fix
.target_offset
= target_offset
;
9865 new_fix
.translated
= TRUE
;
9870 target_offset
= removed
->to
.target_offset
;
9871 new_fix
.target_sec
= new_sec
;
9874 /* The target address may have been moved within its section. */
9875 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
9878 new_fix
.target_offset
= new_offset
;
9879 new_fix
.target_offset
= new_offset
;
9880 new_fix
.translated
= TRUE
;
9886 /* Fix up a relocation to take account of removed literals. */
9889 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
9891 xtensa_relax_info
*relax_info
;
9892 removed_literal
*removed
;
9893 bfd_vma target_offset
, base_offset
;
9895 *new_rel
= *orig_rel
;
9897 if (!r_reloc_is_defined (orig_rel
))
9900 relax_info
= get_xtensa_relax_info (sec
);
9901 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
9902 || relax_info
->is_relaxable_asm_section
));
9904 target_offset
= orig_rel
->target_offset
;
9907 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
9909 /* Check if the original relocation is against a literal being
9911 removed
= find_removed_literal (&relax_info
->removed_list
,
9914 if (removed
&& removed
->to
.abfd
)
9918 /* The fact that there is still a relocation to this literal indicates
9919 that the literal is being coalesced, not simply removed. */
9920 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
9922 /* This was moved to some other address
9923 (possibly in another section). */
9924 *new_rel
= removed
->to
;
9925 new_sec
= r_reloc_get_section (new_rel
);
9929 relax_info
= get_xtensa_relax_info (sec
);
9931 || (!relax_info
->is_relaxable_literal_section
9932 && !relax_info
->is_relaxable_asm_section
))
9935 target_offset
= new_rel
->target_offset
;
9938 /* Find the base offset of the reloc symbol, excluding any addend from the
9939 reloc or from the section contents (for a partial_inplace reloc). Then
9940 find the adjusted values of the offsets due to relaxation. The base
9941 offset is needed to determine the change to the reloc's addend; the reloc
9942 addend should not be adjusted due to relaxations located before the base
9945 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
9946 if (base_offset
<= target_offset
)
9948 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
9949 base_offset
, FALSE
);
9950 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
9951 target_offset
, FALSE
) -
9954 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
9955 new_rel
->rela
.r_addend
-= addend_removed
;
9959 /* Handle a negative addend. The base offset comes first. */
9960 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
9961 target_offset
, FALSE
);
9962 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
9963 base_offset
, FALSE
) -
9966 new_rel
->target_offset
= target_offset
- tgt_removed
;
9967 new_rel
->rela
.r_addend
+= addend_removed
;
9974 /* For dynamic links, there may be a dynamic relocation for each
9975 literal. The number of dynamic relocations must be computed in
9976 size_dynamic_sections, which occurs before relaxation. When a
9977 literal is removed, this function checks if there is a corresponding
9978 dynamic relocation and shrinks the size of the appropriate dynamic
9979 relocation section accordingly. At this point, the contents of the
9980 dynamic relocation sections have not yet been filled in, so there's
9981 nothing else that needs to be done. */
9984 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
9986 asection
*input_section
,
9987 Elf_Internal_Rela
*rel
)
9989 struct elf_xtensa_link_hash_table
*htab
;
9990 Elf_Internal_Shdr
*symtab_hdr
;
9991 struct elf_link_hash_entry
**sym_hashes
;
9992 unsigned long r_symndx
;
9994 struct elf_link_hash_entry
*h
;
9995 bfd_boolean dynamic_symbol
;
9997 htab
= elf_xtensa_hash_table (info
);
10001 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10002 sym_hashes
= elf_sym_hashes (abfd
);
10004 r_type
= ELF32_R_TYPE (rel
->r_info
);
10005 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10007 if (r_symndx
< symtab_hdr
->sh_info
)
10010 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10012 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10014 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10015 && (input_section
->flags
& SEC_ALLOC
) != 0
10016 && (dynamic_symbol
|| bfd_link_pic (info
)))
10019 bfd_boolean is_plt
= FALSE
;
10021 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10023 srel
= htab
->elf
.srelplt
;
10027 srel
= htab
->elf
.srelgot
;
10029 /* Reduce size of the .rela.* section by one reloc. */
10030 BFD_ASSERT (srel
!= NULL
);
10031 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10032 srel
->size
-= sizeof (Elf32_External_Rela
);
10036 asection
*splt
, *sgotplt
, *srelgot
;
10037 int reloc_index
, chunk
;
10039 /* Find the PLT reloc index of the entry being removed. This
10040 is computed from the size of ".rela.plt". It is needed to
10041 figure out which PLT chunk to resize. Usually "last index
10042 = size - 1" since the index starts at zero, but in this
10043 context, the size has just been decremented so there's no
10044 need to subtract one. */
10045 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10047 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10048 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10049 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10050 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10052 /* Check if an entire PLT chunk has just been eliminated. */
10053 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10055 /* The two magic GOT entries for that chunk can go away. */
10056 srelgot
= htab
->elf
.srelgot
;
10057 BFD_ASSERT (srelgot
!= NULL
);
10058 srelgot
->reloc_count
-= 2;
10059 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10060 sgotplt
->size
-= 8;
10062 /* There should be only one entry left (and it will be
10064 BFD_ASSERT (sgotplt
->size
== 4);
10065 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10068 BFD_ASSERT (sgotplt
->size
>= 4);
10069 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10071 sgotplt
->size
-= 4;
10072 splt
->size
-= PLT_ENTRY_SIZE
;
10078 /* Take an r_rel and move it to another section. This usually
10079 requires extending the interal_relocation array and pinning it. If
10080 the original r_rel is from the same BFD, we can complete this here.
10081 Otherwise, we add a fix record to let the final link fix the
10082 appropriate address. Contents and internal relocations for the
10083 section must be pinned after calling this routine. */
10086 move_literal (bfd
*abfd
,
10087 struct bfd_link_info
*link_info
,
10090 bfd_byte
*contents
,
10091 xtensa_relax_info
*relax_info
,
10092 Elf_Internal_Rela
**internal_relocs_p
,
10093 const literal_value
*lit
)
10095 Elf_Internal_Rela
*new_relocs
= NULL
;
10096 size_t new_relocs_count
= 0;
10097 Elf_Internal_Rela this_rela
;
10098 const r_reloc
*r_rel
;
10100 r_rel
= &lit
->r_rel
;
10101 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10103 if (r_reloc_is_const (r_rel
))
10104 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10109 reloc_bfd_fix
*fix
;
10110 unsigned insert_at
;
10112 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10114 /* This is the difficult case. We have to create a fix up. */
10115 this_rela
.r_offset
= offset
;
10116 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10117 this_rela
.r_addend
=
10118 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10119 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10121 /* Currently, we cannot move relocations during a relocatable link. */
10122 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10123 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10124 r_reloc_get_section (r_rel
),
10125 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10127 /* We also need to mark that relocations are needed here. */
10128 sec
->flags
|= SEC_RELOC
;
10130 translate_reloc_bfd_fix (fix
);
10131 /* This fix has not yet been translated. */
10132 add_fix (sec
, fix
);
10134 /* Add the relocation. If we have already allocated our own
10135 space for the relocations and we have room for more, then use
10136 it. Otherwise, allocate new space and move the literals. */
10137 insert_at
= sec
->reloc_count
;
10138 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10140 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10147 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10148 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10150 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10151 || sec
->reloc_count
== relax_info
->relocs_count
);
10153 if (relax_info
->allocated_relocs_count
== 0)
10154 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10156 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10158 new_relocs
= (Elf_Internal_Rela
*)
10159 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10163 /* We could handle this more quickly by finding the split point. */
10164 if (insert_at
!= 0)
10165 memcpy (new_relocs
, *internal_relocs_p
,
10166 insert_at
* sizeof (Elf_Internal_Rela
));
10168 new_relocs
[insert_at
] = this_rela
;
10170 if (insert_at
!= sec
->reloc_count
)
10171 memcpy (new_relocs
+ insert_at
+ 1,
10172 (*internal_relocs_p
) + insert_at
,
10173 (sec
->reloc_count
- insert_at
)
10174 * sizeof (Elf_Internal_Rela
));
10176 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10178 /* The first time we re-allocate, we can only free the
10179 old relocs if they were allocated with bfd_malloc.
10180 This is not true when keep_memory is in effect. */
10181 if (!link_info
->keep_memory
)
10182 free (*internal_relocs_p
);
10185 free (*internal_relocs_p
);
10186 relax_info
->allocated_relocs
= new_relocs
;
10187 relax_info
->allocated_relocs_count
= new_relocs_count
;
10188 elf_section_data (sec
)->relocs
= new_relocs
;
10189 sec
->reloc_count
++;
10190 relax_info
->relocs_count
= sec
->reloc_count
;
10191 *internal_relocs_p
= new_relocs
;
10195 if (insert_at
!= sec
->reloc_count
)
10198 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10199 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10201 (*internal_relocs_p
)[insert_at
] = this_rela
;
10202 sec
->reloc_count
++;
10203 if (relax_info
->allocated_relocs
)
10204 relax_info
->relocs_count
= sec
->reloc_count
;
10211 /* This is similar to relax_section except that when a target is moved,
10212 we shift addresses up. We also need to modify the size. This
10213 algorithm does NOT allow for relocations into the middle of the
10214 property sections. */
10217 relax_property_section (bfd
*abfd
,
10219 struct bfd_link_info
*link_info
)
10221 Elf_Internal_Rela
*internal_relocs
;
10222 bfd_byte
*contents
;
10224 bfd_boolean ok
= TRUE
;
10225 bfd_boolean is_full_prop_section
;
10226 size_t last_zfill_target_offset
= 0;
10227 asection
*last_zfill_target_sec
= NULL
;
10228 bfd_size_type sec_size
;
10229 bfd_size_type entry_size
;
10231 sec_size
= bfd_get_section_limit (abfd
, sec
);
10232 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10233 link_info
->keep_memory
);
10234 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10235 if (contents
== NULL
&& sec_size
!= 0)
10241 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10242 if (is_full_prop_section
)
10247 if (internal_relocs
)
10249 for (i
= 0; i
< sec
->reloc_count
; i
++)
10251 Elf_Internal_Rela
*irel
;
10252 xtensa_relax_info
*target_relax_info
;
10254 asection
*target_sec
;
10256 bfd_byte
*size_p
, *flags_p
;
10258 /* Locally change the source address.
10259 Translate the target to the new target address.
10260 If it points to this section and has been removed, MOVE IT.
10261 Also, don't forget to modify the associated SIZE at
10264 irel
= &internal_relocs
[i
];
10265 r_type
= ELF32_R_TYPE (irel
->r_info
);
10266 if (r_type
== R_XTENSA_NONE
)
10269 /* Find the literal value. */
10270 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10271 size_p
= &contents
[irel
->r_offset
+ 4];
10273 if (is_full_prop_section
)
10274 flags_p
= &contents
[irel
->r_offset
+ 8];
10275 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10277 target_sec
= r_reloc_get_section (&val
.r_rel
);
10278 target_relax_info
= get_xtensa_relax_info (target_sec
);
10280 if (target_relax_info
10281 && (target_relax_info
->is_relaxable_literal_section
10282 || target_relax_info
->is_relaxable_asm_section
))
10284 /* Translate the relocation's destination. */
10285 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10286 bfd_vma new_offset
;
10287 long old_size
, new_size
;
10288 int removed_by_old_offset
=
10289 removed_by_actions_map (&target_relax_info
->action_list
,
10290 old_offset
, FALSE
);
10291 new_offset
= old_offset
- removed_by_old_offset
;
10293 /* Assert that we are not out of bounds. */
10294 old_size
= bfd_get_32 (abfd
, size_p
);
10295 new_size
= old_size
;
10299 /* Only the first zero-sized unreachable entry is
10300 allowed to expand. In this case the new offset
10301 should be the offset before the fill and the new
10302 size is the expansion size. For other zero-sized
10303 entries the resulting size should be zero with an
10304 offset before or after the fill address depending
10305 on whether the expanding unreachable entry
10307 if (last_zfill_target_sec
== 0
10308 || last_zfill_target_sec
!= target_sec
10309 || last_zfill_target_offset
!= old_offset
)
10311 bfd_vma new_end_offset
= new_offset
;
10313 /* Recompute the new_offset, but this time don't
10314 include any fill inserted by relaxation. */
10315 removed_by_old_offset
=
10316 removed_by_actions_map (&target_relax_info
->action_list
,
10318 new_offset
= old_offset
- removed_by_old_offset
;
10320 /* If it is not unreachable and we have not yet
10321 seen an unreachable at this address, place it
10322 before the fill address. */
10323 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10324 & XTENSA_PROP_UNREACHABLE
) != 0)
10326 new_size
= new_end_offset
- new_offset
;
10328 last_zfill_target_sec
= target_sec
;
10329 last_zfill_target_offset
= old_offset
;
10335 int removed_by_old_offset_size
=
10336 removed_by_actions_map (&target_relax_info
->action_list
,
10337 old_offset
+ old_size
, TRUE
);
10338 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10341 if (new_size
!= old_size
)
10343 bfd_put_32 (abfd
, new_size
, size_p
);
10344 pin_contents (sec
, contents
);
10347 if (new_offset
!= old_offset
)
10349 bfd_vma diff
= new_offset
- old_offset
;
10350 irel
->r_addend
+= diff
;
10351 pin_internal_relocs (sec
, internal_relocs
);
10357 /* Combine adjacent property table entries. This is also done in
10358 finish_dynamic_sections() but at that point it's too late to
10359 reclaim the space in the output section, so we do this twice. */
10361 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10362 || xtensa_is_littable_section (sec
)))
10364 Elf_Internal_Rela
*last_irel
= NULL
;
10365 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10366 int removed_bytes
= 0;
10368 flagword predef_flags
;
10370 predef_flags
= xtensa_get_property_predef_flags (sec
);
10372 /* Walk over memory and relocations at the same time.
10373 This REQUIRES that the internal_relocs be sorted by offset. */
10374 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10375 internal_reloc_compare
);
10377 pin_internal_relocs (sec
, internal_relocs
);
10378 pin_contents (sec
, contents
);
10380 next_rel
= internal_relocs
;
10381 rel_end
= internal_relocs
+ sec
->reloc_count
;
10383 BFD_ASSERT (sec
->size
% entry_size
== 0);
10385 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10387 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10388 bfd_vma bytes_to_remove
, size
, actual_offset
;
10389 bfd_boolean remove_this_rel
;
10392 /* Find the first relocation for the entry at the current offset.
10393 Adjust the offsets of any extra relocations for the previous
10398 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10400 if ((irel
->r_offset
== offset
10401 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10402 || irel
->r_offset
> offset
)
10407 irel
->r_offset
-= removed_bytes
;
10411 /* Find the next relocation (if there are any left). */
10415 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10417 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10425 /* Check if there are relocations on the current entry. There
10426 should usually be a relocation on the offset field. If there
10427 are relocations on the size or flags, then we can't optimize
10428 this entry. Also, find the next relocation to examine on the
10432 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10434 next_rel
= offset_rel
;
10435 /* There are no relocations on the current entry, but we
10436 might still be able to remove it if the size is zero. */
10439 else if (offset_rel
->r_offset
> offset
10441 && extra_rel
->r_offset
< offset
+ entry_size
))
10443 /* There is a relocation on the size or flags, so we can't
10444 do anything with this entry. Continue with the next. */
10445 next_rel
= offset_rel
;
10450 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10451 offset_rel
->r_offset
-= removed_bytes
;
10452 next_rel
= offset_rel
+ 1;
10458 remove_this_rel
= FALSE
;
10459 bytes_to_remove
= 0;
10460 actual_offset
= offset
- removed_bytes
;
10461 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10463 if (is_full_prop_section
)
10464 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10466 flags
= predef_flags
;
10469 && (flags
& XTENSA_PROP_ALIGN
) == 0
10470 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10472 /* Always remove entries with zero size and no alignment. */
10473 bytes_to_remove
= entry_size
;
10475 remove_this_rel
= TRUE
;
10477 else if (offset_rel
10478 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10482 flagword old_flags
;
10484 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10485 bfd_vma old_address
=
10486 (last_irel
->r_addend
10487 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10488 bfd_vma new_address
=
10489 (offset_rel
->r_addend
10490 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10491 if (is_full_prop_section
)
10492 old_flags
= bfd_get_32
10493 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10495 old_flags
= predef_flags
;
10497 if ((ELF32_R_SYM (offset_rel
->r_info
)
10498 == ELF32_R_SYM (last_irel
->r_info
))
10499 && old_address
+ old_size
== new_address
10500 && old_flags
== flags
10501 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10502 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10504 /* Fix the old size. */
10505 bfd_put_32 (abfd
, old_size
+ size
,
10506 &contents
[last_irel
->r_offset
+ 4]);
10507 bytes_to_remove
= entry_size
;
10508 remove_this_rel
= TRUE
;
10511 last_irel
= offset_rel
;
10514 last_irel
= offset_rel
;
10517 if (remove_this_rel
)
10519 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10520 offset_rel
->r_offset
= 0;
10523 if (bytes_to_remove
!= 0)
10525 removed_bytes
+= bytes_to_remove
;
10526 if (offset
+ bytes_to_remove
< sec
->size
)
10527 memmove (&contents
[actual_offset
],
10528 &contents
[actual_offset
+ bytes_to_remove
],
10529 sec
->size
- offset
- bytes_to_remove
);
10535 /* Fix up any extra relocations on the last entry. */
10536 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10537 irel
->r_offset
-= removed_bytes
;
10539 /* Clear the removed bytes. */
10540 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10542 if (sec
->rawsize
== 0)
10543 sec
->rawsize
= sec
->size
;
10544 sec
->size
-= removed_bytes
;
10546 if (xtensa_is_littable_section (sec
))
10548 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10550 sgotloc
->size
-= removed_bytes
;
10556 release_internal_relocs (sec
, internal_relocs
);
10557 release_contents (sec
, contents
);
10562 /* Third relaxation pass. */
10564 /* Change symbol values to account for removed literals. */
10567 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10569 xtensa_relax_info
*relax_info
;
10570 unsigned int sec_shndx
;
10571 Elf_Internal_Shdr
*symtab_hdr
;
10572 Elf_Internal_Sym
*isymbuf
;
10573 unsigned i
, num_syms
, num_locals
;
10575 relax_info
= get_xtensa_relax_info (sec
);
10576 BFD_ASSERT (relax_info
);
10578 if (!relax_info
->is_relaxable_literal_section
10579 && !relax_info
->is_relaxable_asm_section
)
10582 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10584 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10585 isymbuf
= retrieve_local_syms (abfd
);
10587 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10588 num_locals
= symtab_hdr
->sh_info
;
10590 /* Adjust the local symbols defined in this section. */
10591 for (i
= 0; i
< num_locals
; i
++)
10593 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10595 if (isym
->st_shndx
== sec_shndx
)
10597 bfd_vma orig_addr
= isym
->st_value
;
10598 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10601 isym
->st_value
-= removed
;
10602 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10604 removed_by_actions_map (&relax_info
->action_list
,
10605 orig_addr
+ isym
->st_size
, FALSE
) -
10610 /* Now adjust the global symbols defined in this section. */
10611 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10613 struct elf_link_hash_entry
*sym_hash
;
10615 sym_hash
= elf_sym_hashes (abfd
)[i
];
10617 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10618 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10620 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10621 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10622 && sym_hash
->root
.u
.def
.section
== sec
)
10624 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10625 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10628 sym_hash
->root
.u
.def
.value
-= removed
;
10630 if (sym_hash
->type
== STT_FUNC
)
10632 removed_by_actions_map (&relax_info
->action_list
,
10633 orig_addr
+ sym_hash
->size
, FALSE
) -
10642 /* "Fix" handling functions, called while performing relocations. */
10645 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10647 asection
*input_section
,
10648 bfd_byte
*contents
)
10651 asection
*sec
, *old_sec
;
10652 bfd_vma old_offset
;
10653 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10654 reloc_bfd_fix
*fix
;
10656 if (r_type
== R_XTENSA_NONE
)
10659 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10663 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10664 bfd_get_section_limit (input_bfd
, input_section
));
10665 old_sec
= r_reloc_get_section (&r_rel
);
10666 old_offset
= r_rel
.target_offset
;
10668 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10670 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10673 /* xgettext:c-format */
10674 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10675 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10676 elf_howto_table
[r_type
].name
);
10679 /* Leave it be. Resolution will happen in a later stage. */
10683 sec
= fix
->target_sec
;
10684 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10685 - (old_sec
->output_offset
+ old_offset
));
10692 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10694 asection
*input_section
,
10695 bfd_byte
*contents
,
10696 bfd_vma
*relocationp
)
10699 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10700 reloc_bfd_fix
*fix
;
10701 bfd_vma fixup_diff
;
10703 if (r_type
== R_XTENSA_NONE
)
10706 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10710 sec
= fix
->target_sec
;
10712 fixup_diff
= rel
->r_addend
;
10713 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10715 bfd_vma inplace_val
;
10716 BFD_ASSERT (fix
->src_offset
10717 < bfd_get_section_limit (input_bfd
, input_section
));
10718 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10719 fixup_diff
+= inplace_val
;
10722 *relocationp
= (sec
->output_section
->vma
10723 + sec
->output_offset
10724 + fix
->target_offset
- fixup_diff
);
10728 /* Miscellaneous utility functions.... */
10731 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10737 return elf_hash_table (info
)->splt
;
10739 dynobj
= elf_hash_table (info
)->dynobj
;
10740 sprintf (plt_name
, ".plt.%u", chunk
);
10741 return bfd_get_linker_section (dynobj
, plt_name
);
10746 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10752 return elf_hash_table (info
)->sgotplt
;
10754 dynobj
= elf_hash_table (info
)->dynobj
;
10755 sprintf (got_name
, ".got.plt.%u", chunk
);
10756 return bfd_get_linker_section (dynobj
, got_name
);
10760 /* Get the input section for a given symbol index.
10762 . a section symbol, return the section;
10763 . a common symbol, return the common section;
10764 . an undefined symbol, return the undefined section;
10765 . an indirect symbol, follow the links;
10766 . an absolute value, return the absolute section. */
10769 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
10771 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10772 asection
*target_sec
= NULL
;
10773 if (r_symndx
< symtab_hdr
->sh_info
)
10775 Elf_Internal_Sym
*isymbuf
;
10776 unsigned int section_index
;
10778 isymbuf
= retrieve_local_syms (abfd
);
10779 section_index
= isymbuf
[r_symndx
].st_shndx
;
10781 if (section_index
== SHN_UNDEF
)
10782 target_sec
= bfd_und_section_ptr
;
10783 else if (section_index
== SHN_ABS
)
10784 target_sec
= bfd_abs_section_ptr
;
10785 else if (section_index
== SHN_COMMON
)
10786 target_sec
= bfd_com_section_ptr
;
10788 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
10792 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
10793 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
10795 while (h
->root
.type
== bfd_link_hash_indirect
10796 || h
->root
.type
== bfd_link_hash_warning
)
10797 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10799 switch (h
->root
.type
)
10801 case bfd_link_hash_defined
:
10802 case bfd_link_hash_defweak
:
10803 target_sec
= h
->root
.u
.def
.section
;
10805 case bfd_link_hash_common
:
10806 target_sec
= bfd_com_section_ptr
;
10808 case bfd_link_hash_undefined
:
10809 case bfd_link_hash_undefweak
:
10810 target_sec
= bfd_und_section_ptr
;
10812 default: /* New indirect warning. */
10813 target_sec
= bfd_und_section_ptr
;
10821 static struct elf_link_hash_entry
*
10822 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
10824 unsigned long indx
;
10825 struct elf_link_hash_entry
*h
;
10826 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10828 if (r_symndx
< symtab_hdr
->sh_info
)
10831 indx
= r_symndx
- symtab_hdr
->sh_info
;
10832 h
= elf_sym_hashes (abfd
)[indx
];
10833 while (h
->root
.type
== bfd_link_hash_indirect
10834 || h
->root
.type
== bfd_link_hash_warning
)
10835 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10840 /* Get the section-relative offset for a symbol number. */
10843 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
10845 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10846 bfd_vma offset
= 0;
10848 if (r_symndx
< symtab_hdr
->sh_info
)
10850 Elf_Internal_Sym
*isymbuf
;
10851 isymbuf
= retrieve_local_syms (abfd
);
10852 offset
= isymbuf
[r_symndx
].st_value
;
10856 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
10857 struct elf_link_hash_entry
*h
=
10858 elf_sym_hashes (abfd
)[indx
];
10860 while (h
->root
.type
== bfd_link_hash_indirect
10861 || h
->root
.type
== bfd_link_hash_warning
)
10862 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10863 if (h
->root
.type
== bfd_link_hash_defined
10864 || h
->root
.type
== bfd_link_hash_defweak
)
10865 offset
= h
->root
.u
.def
.value
;
10872 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
10874 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
10875 struct elf_link_hash_entry
*h
;
10877 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
10878 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
10885 pcrel_reloc_fits (xtensa_opcode opc
,
10887 bfd_vma self_address
,
10888 bfd_vma dest_address
)
10890 xtensa_isa isa
= xtensa_default_isa
;
10891 uint32 valp
= dest_address
;
10892 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
10893 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
10900 xtensa_is_property_section (asection
*sec
)
10902 if (xtensa_is_insntable_section (sec
)
10903 || xtensa_is_littable_section (sec
)
10904 || xtensa_is_proptable_section (sec
))
10912 xtensa_is_insntable_section (asection
*sec
)
10914 if (CONST_STRNEQ (sec
->name
, XTENSA_INSN_SEC_NAME
)
10915 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.x."))
10923 xtensa_is_littable_section (asection
*sec
)
10925 if (CONST_STRNEQ (sec
->name
, XTENSA_LIT_SEC_NAME
)
10926 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.p."))
10934 xtensa_is_proptable_section (asection
*sec
)
10936 if (CONST_STRNEQ (sec
->name
, XTENSA_PROP_SEC_NAME
)
10937 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.prop."))
10945 internal_reloc_compare (const void *ap
, const void *bp
)
10947 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
10948 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
10950 if (a
->r_offset
!= b
->r_offset
)
10951 return (a
->r_offset
- b
->r_offset
);
10953 /* We don't need to sort on these criteria for correctness,
10954 but enforcing a more strict ordering prevents unstable qsort
10955 from behaving differently with different implementations.
10956 Without the code below we get correct but different results
10957 on Solaris 2.7 and 2.8. We would like to always produce the
10958 same results no matter the host. */
10960 if (a
->r_info
!= b
->r_info
)
10961 return (a
->r_info
- b
->r_info
);
10963 return (a
->r_addend
- b
->r_addend
);
10968 internal_reloc_matches (const void *ap
, const void *bp
)
10970 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
10971 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
10973 /* Check if one entry overlaps with the other; this shouldn't happen
10974 except when searching for a match. */
10975 return (a
->r_offset
- b
->r_offset
);
10979 /* Predicate function used to look up a section in a particular group. */
10982 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
10984 const char *gname
= inf
;
10985 const char *group_name
= elf_group_name (sec
);
10987 return (group_name
== gname
10988 || (group_name
!= NULL
10990 && strcmp (group_name
, gname
) == 0));
10995 xtensa_add_names (const char *base
, const char *suffix
)
10999 size_t base_len
= strlen (base
);
11000 size_t suffix_len
= strlen (suffix
);
11001 char *str
= bfd_malloc (base_len
+ suffix_len
+ 1);
11003 memcpy (str
, base
, base_len
);
11004 memcpy (str
+ base_len
, suffix
, suffix_len
+ 1);
11009 return strdup (base
);
11013 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11016 xtensa_property_section_name (asection
*sec
, const char *base_name
,
11017 bfd_boolean separate_sections
)
11019 const char *suffix
, *group_name
;
11020 char *prop_sec_name
;
11022 group_name
= elf_group_name (sec
);
11025 suffix
= strrchr (sec
->name
, '.');
11026 if (suffix
== sec
->name
)
11028 prop_sec_name
= xtensa_add_names (base_name
, suffix
);
11030 else if (strncmp (sec
->name
, ".gnu.linkonce.", linkonce_len
) == 0)
11032 char *linkonce_kind
= 0;
11034 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11035 linkonce_kind
= "x.";
11036 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11037 linkonce_kind
= "p.";
11038 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11039 linkonce_kind
= "prop.";
11043 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11044 + strlen (linkonce_kind
) + 1);
11045 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11046 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11048 suffix
= sec
->name
+ linkonce_len
;
11049 /* For backward compatibility, replace "t." instead of inserting
11050 the new linkonce_kind (but not for "prop" sections). */
11051 if (CONST_STRNEQ (suffix
, "t.") && linkonce_kind
[1] == '.')
11053 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11057 prop_sec_name
= xtensa_add_names (base_name
,
11058 separate_sections
? sec
->name
: NULL
);
11061 return prop_sec_name
;
11066 xtensa_get_separate_property_section (asection
*sec
, const char *base_name
,
11067 bfd_boolean separate_section
)
11069 char *prop_sec_name
;
11070 asection
*prop_sec
;
11072 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11074 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11075 match_section_group
,
11076 (void *) elf_group_name (sec
));
11077 free (prop_sec_name
);
11082 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11084 asection
*prop_sec
;
11086 /* Try individual property section first. */
11087 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, TRUE
);
11089 /* Refer to a common property section if individual is not present. */
11091 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, FALSE
);
11098 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11100 char *prop_sec_name
;
11101 asection
*prop_sec
;
11103 /* Check if the section already exists. */
11104 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11105 elf32xtensa_separate_props
);
11106 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11107 match_section_group
,
11108 (void *) elf_group_name (sec
));
11109 /* If not, create it. */
11112 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11113 flags
|= (bfd_get_section_flags (sec
->owner
, sec
)
11114 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11116 prop_sec
= bfd_make_section_anyway_with_flags
11117 (sec
->owner
, strdup (prop_sec_name
), flags
);
11121 elf_group_name (prop_sec
) = elf_group_name (sec
);
11124 free (prop_sec_name
);
11130 xtensa_get_property_predef_flags (asection
*sec
)
11132 if (xtensa_is_insntable_section (sec
))
11133 return (XTENSA_PROP_INSN
11134 | XTENSA_PROP_NO_TRANSFORM
11135 | XTENSA_PROP_INSN_NO_REORDER
);
11137 if (xtensa_is_littable_section (sec
))
11138 return (XTENSA_PROP_LITERAL
11139 | XTENSA_PROP_NO_TRANSFORM
11140 | XTENSA_PROP_INSN_NO_REORDER
);
11146 /* Other functions called directly by the linker. */
11149 xtensa_callback_required_dependence (bfd
*abfd
,
11151 struct bfd_link_info
*link_info
,
11152 deps_callback_t callback
,
11155 Elf_Internal_Rela
*internal_relocs
;
11156 bfd_byte
*contents
;
11158 bfd_boolean ok
= TRUE
;
11159 bfd_size_type sec_size
;
11161 sec_size
= bfd_get_section_limit (abfd
, sec
);
11163 /* ".plt*" sections have no explicit relocations but they contain L32R
11164 instructions that reference the corresponding ".got.plt*" sections. */
11165 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11166 && CONST_STRNEQ (sec
->name
, ".plt"))
11170 /* Find the corresponding ".got.plt*" section. */
11171 if (sec
->name
[4] == '\0')
11172 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11178 BFD_ASSERT (sec
->name
[4] == '.');
11179 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11181 sprintf (got_name
, ".got.plt.%u", chunk
);
11182 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11184 BFD_ASSERT (sgotplt
);
11186 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11187 section referencing a literal at the very beginning of
11188 ".got.plt". This is very close to the real dependence, anyway. */
11189 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11192 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11193 when building uclibc, which runs "ld -b binary /dev/null". */
11194 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11197 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11198 link_info
->keep_memory
);
11199 if (internal_relocs
== NULL
11200 || sec
->reloc_count
== 0)
11203 /* Cache the contents for the duration of this scan. */
11204 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11205 if (contents
== NULL
&& sec_size
!= 0)
11211 if (!xtensa_default_isa
)
11212 xtensa_default_isa
= xtensa_isa_init (0, 0);
11214 for (i
= 0; i
< sec
->reloc_count
; i
++)
11216 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11217 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11220 asection
*target_sec
;
11221 bfd_vma target_offset
;
11223 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11226 /* L32Rs must be local to the input file. */
11227 if (r_reloc_is_defined (&l32r_rel
))
11229 target_sec
= r_reloc_get_section (&l32r_rel
);
11230 target_offset
= l32r_rel
.target_offset
;
11232 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11238 release_internal_relocs (sec
, internal_relocs
);
11239 release_contents (sec
, contents
);
11243 /* The default literal sections should always be marked as "code" (i.e.,
11244 SHF_EXECINSTR). This is particularly important for the Linux kernel
11245 module loader so that the literals are not placed after the text. */
11246 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11248 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11249 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11250 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11251 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11252 { NULL
, 0, 0, 0, 0 }
11255 #define ELF_TARGET_ID XTENSA_ELF_DATA
11257 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11258 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11259 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11260 #define TARGET_BIG_NAME "elf32-xtensa-be"
11261 #define ELF_ARCH bfd_arch_xtensa
11263 #define ELF_MACHINE_CODE EM_XTENSA
11264 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11266 #define ELF_MAXPAGESIZE 0x1000
11267 #endif /* ELF_ARCH */
11269 #define elf_backend_can_gc_sections 1
11270 #define elf_backend_can_refcount 1
11271 #define elf_backend_plt_readonly 1
11272 #define elf_backend_got_header_size 4
11273 #define elf_backend_want_dynbss 0
11274 #define elf_backend_want_got_plt 1
11275 #define elf_backend_dtrel_excludes_plt 1
11277 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11279 #define bfd_elf32_mkobject elf_xtensa_mkobject
11281 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11282 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11283 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11284 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11285 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11286 #define bfd_elf32_bfd_reloc_name_lookup \
11287 elf_xtensa_reloc_name_lookup
11288 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11289 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11291 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11292 #define elf_backend_check_relocs elf_xtensa_check_relocs
11293 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11294 #define elf_backend_discard_info elf_xtensa_discard_info
11295 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11296 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11297 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11298 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11299 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11300 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11301 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11302 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11303 #define elf_backend_object_p elf_xtensa_object_p
11304 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11305 #define elf_backend_relocate_section elf_xtensa_relocate_section
11306 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11307 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11308 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11309 #define elf_backend_special_sections elf_xtensa_special_sections
11310 #define elf_backend_action_discarded elf_xtensa_action_discarded
11311 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11313 #include "elf32-target.h"