1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright (C) 2003-2017 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 3 of the
9 License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
30 #include "elf/xtensa.h"
31 #include "splay-tree.h"
32 #include "xtensa-isa.h"
33 #include "xtensa-config.h"
35 #define XTENSA_NO_NOP_REMOVAL 0
37 /* Local helper functions. */
39 static bfd_boolean
add_extra_plt_sections (struct bfd_link_info
*, int);
40 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
41 static bfd_reloc_status_type bfd_elf_xtensa_reloc
42 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
43 static bfd_boolean do_fix_for_relocatable_link
44 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*);
45 static void do_fix_for_final_link
46 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*, bfd_vma
*);
48 /* Local functions to handle Xtensa configurability. */
50 static bfd_boolean
is_indirect_call_opcode (xtensa_opcode
);
51 static bfd_boolean
is_direct_call_opcode (xtensa_opcode
);
52 static bfd_boolean
is_windowed_call_opcode (xtensa_opcode
);
53 static xtensa_opcode
get_const16_opcode (void);
54 static xtensa_opcode
get_l32r_opcode (void);
55 static bfd_vma
l32r_offset (bfd_vma
, bfd_vma
);
56 static int get_relocation_opnd (xtensa_opcode
, int);
57 static int get_relocation_slot (int);
58 static xtensa_opcode get_relocation_opcode
59 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
60 static bfd_boolean is_l32r_relocation
61 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
62 static bfd_boolean
is_alt_relocation (int);
63 static bfd_boolean
is_operand_relocation (int);
64 static bfd_size_type insn_decode_len
65 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
66 static xtensa_opcode insn_decode_opcode
67 (bfd_byte
*, bfd_size_type
, bfd_size_type
, int);
68 static bfd_boolean check_branch_target_aligned
69 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
70 static bfd_boolean check_loop_aligned
71 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
72 static bfd_boolean
check_branch_target_aligned_address (bfd_vma
, int);
73 static bfd_size_type get_asm_simplify_size
74 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
76 /* Functions for link-time code simplifications. */
78 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
79 (bfd_byte
*, bfd_vma
, bfd_vma
, char **);
80 static bfd_reloc_status_type contract_asm_expansion
81 (bfd_byte
*, bfd_vma
, Elf_Internal_Rela
*, char **);
82 static xtensa_opcode
swap_callx_for_call_opcode (xtensa_opcode
);
83 static xtensa_opcode
get_expanded_call_opcode (bfd_byte
*, int, bfd_boolean
*);
85 /* Access to internal relocations, section contents and symbols. */
87 static Elf_Internal_Rela
*retrieve_internal_relocs
88 (bfd
*, asection
*, bfd_boolean
);
89 static void pin_internal_relocs (asection
*, Elf_Internal_Rela
*);
90 static void release_internal_relocs (asection
*, Elf_Internal_Rela
*);
91 static bfd_byte
*retrieve_contents (bfd
*, asection
*, bfd_boolean
);
92 static void pin_contents (asection
*, bfd_byte
*);
93 static void release_contents (asection
*, bfd_byte
*);
94 static Elf_Internal_Sym
*retrieve_local_syms (bfd
*);
96 /* Miscellaneous utility functions. */
98 static asection
*elf_xtensa_get_plt_section (struct bfd_link_info
*, int);
99 static asection
*elf_xtensa_get_gotplt_section (struct bfd_link_info
*, int);
100 static asection
*get_elf_r_symndx_section (bfd
*, unsigned long);
101 static struct elf_link_hash_entry
*get_elf_r_symndx_hash_entry
102 (bfd
*, unsigned long);
103 static bfd_vma
get_elf_r_symndx_offset (bfd
*, unsigned long);
104 static bfd_boolean
is_reloc_sym_weak (bfd
*, Elf_Internal_Rela
*);
105 static bfd_boolean
pcrel_reloc_fits (xtensa_opcode
, int, bfd_vma
, bfd_vma
);
106 static bfd_boolean
xtensa_is_property_section (asection
*);
107 static bfd_boolean
xtensa_is_insntable_section (asection
*);
108 static bfd_boolean
xtensa_is_littable_section (asection
*);
109 static bfd_boolean
xtensa_is_proptable_section (asection
*);
110 static int internal_reloc_compare (const void *, const void *);
111 static int internal_reloc_matches (const void *, const void *);
112 static asection
*xtensa_get_property_section (asection
*, const char *);
113 static flagword
xtensa_get_property_predef_flags (asection
*);
115 /* Other functions called directly by the linker. */
117 typedef void (*deps_callback_t
)
118 (asection
*, bfd_vma
, asection
*, bfd_vma
, void *);
119 extern bfd_boolean xtensa_callback_required_dependence
120 (bfd
*, asection
*, struct bfd_link_info
*, deps_callback_t
, void *);
123 /* Globally visible flag for choosing size optimization of NOP removal
124 instead of branch-target-aware minimization for NOP removal.
125 When nonzero, narrow all instructions and remove all NOPs possible
126 around longcall expansions. */
128 int elf32xtensa_size_opt
;
131 /* The "new_section_hook" is used to set up a per-section
132 "xtensa_relax_info" data structure with additional information used
133 during relaxation. */
135 typedef struct xtensa_relax_info_struct xtensa_relax_info
;
138 /* The GNU tools do not easily allow extending interfaces to pass around
139 the pointer to the Xtensa ISA information, so instead we add a global
140 variable here (in BFD) that can be used by any of the tools that need
143 xtensa_isa xtensa_default_isa
;
146 /* When this is true, relocations may have been modified to refer to
147 symbols from other input files. The per-section list of "fix"
148 records needs to be checked when resolving relocations. */
150 static bfd_boolean relaxing_section
= FALSE
;
152 /* When this is true, during final links, literals that cannot be
153 coalesced and their relocations may be moved to other sections. */
155 int elf32xtensa_no_literal_movement
= 1;
157 /* Rename one of the generic section flags to better document how it
159 /* Whether relocations have been processed. */
160 #define reloc_done sec_flg0
162 static reloc_howto_type elf_howto_table
[] =
164 HOWTO (R_XTENSA_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
165 bfd_elf_xtensa_reloc
, "R_XTENSA_NONE",
167 HOWTO (R_XTENSA_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
168 bfd_elf_xtensa_reloc
, "R_XTENSA_32",
169 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
171 /* Replace a 32-bit value with a value from the runtime linker (only
172 used by linker-generated stub functions). The r_addend value is
173 special: 1 means to substitute a pointer to the runtime linker's
174 dynamic resolver function; 2 means to substitute the link map for
175 the shared object. */
176 HOWTO (R_XTENSA_RTLD
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
177 NULL
, "R_XTENSA_RTLD", FALSE
, 0, 0, FALSE
),
179 HOWTO (R_XTENSA_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
180 bfd_elf_generic_reloc
, "R_XTENSA_GLOB_DAT",
181 FALSE
, 0, 0xffffffff, FALSE
),
182 HOWTO (R_XTENSA_JMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
183 bfd_elf_generic_reloc
, "R_XTENSA_JMP_SLOT",
184 FALSE
, 0, 0xffffffff, FALSE
),
185 HOWTO (R_XTENSA_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
186 bfd_elf_generic_reloc
, "R_XTENSA_RELATIVE",
187 FALSE
, 0, 0xffffffff, FALSE
),
188 HOWTO (R_XTENSA_PLT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
189 bfd_elf_xtensa_reloc
, "R_XTENSA_PLT",
190 FALSE
, 0, 0xffffffff, FALSE
),
194 /* Old relocations for backward compatibility. */
195 HOWTO (R_XTENSA_OP0
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
196 bfd_elf_xtensa_reloc
, "R_XTENSA_OP0", FALSE
, 0, 0, TRUE
),
197 HOWTO (R_XTENSA_OP1
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
198 bfd_elf_xtensa_reloc
, "R_XTENSA_OP1", FALSE
, 0, 0, TRUE
),
199 HOWTO (R_XTENSA_OP2
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
200 bfd_elf_xtensa_reloc
, "R_XTENSA_OP2", FALSE
, 0, 0, TRUE
),
202 /* Assembly auto-expansion. */
203 HOWTO (R_XTENSA_ASM_EXPAND
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
204 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_EXPAND", FALSE
, 0, 0, TRUE
),
205 /* Relax assembly auto-expansion. */
206 HOWTO (R_XTENSA_ASM_SIMPLIFY
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
207 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_SIMPLIFY", FALSE
, 0, 0, TRUE
),
211 HOWTO (R_XTENSA_32_PCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
212 bfd_elf_xtensa_reloc
, "R_XTENSA_32_PCREL",
213 FALSE
, 0, 0xffffffff, TRUE
),
215 /* GNU extension to record C++ vtable hierarchy. */
216 HOWTO (R_XTENSA_GNU_VTINHERIT
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
217 NULL
, "R_XTENSA_GNU_VTINHERIT",
219 /* GNU extension to record C++ vtable member usage. */
220 HOWTO (R_XTENSA_GNU_VTENTRY
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
221 _bfd_elf_rel_vtable_reloc_fn
, "R_XTENSA_GNU_VTENTRY",
224 /* Relocations for supporting difference of symbols. */
225 HOWTO (R_XTENSA_DIFF8
, 0, 0, 8, FALSE
, 0, complain_overflow_signed
,
226 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF8", FALSE
, 0, 0xff, FALSE
),
227 HOWTO (R_XTENSA_DIFF16
, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,
228 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF16", FALSE
, 0, 0xffff, FALSE
),
229 HOWTO (R_XTENSA_DIFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
230 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF32", FALSE
, 0, 0xffffffff, FALSE
),
232 /* General immediate operand relocations. */
233 HOWTO (R_XTENSA_SLOT0_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
234 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_OP", FALSE
, 0, 0, TRUE
),
235 HOWTO (R_XTENSA_SLOT1_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
236 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_OP", FALSE
, 0, 0, TRUE
),
237 HOWTO (R_XTENSA_SLOT2_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
238 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_OP", FALSE
, 0, 0, TRUE
),
239 HOWTO (R_XTENSA_SLOT3_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
240 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_OP", FALSE
, 0, 0, TRUE
),
241 HOWTO (R_XTENSA_SLOT4_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
242 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_OP", FALSE
, 0, 0, TRUE
),
243 HOWTO (R_XTENSA_SLOT5_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
244 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_OP", FALSE
, 0, 0, TRUE
),
245 HOWTO (R_XTENSA_SLOT6_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
246 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_OP", FALSE
, 0, 0, TRUE
),
247 HOWTO (R_XTENSA_SLOT7_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
248 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_OP", FALSE
, 0, 0, TRUE
),
249 HOWTO (R_XTENSA_SLOT8_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
250 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_OP", FALSE
, 0, 0, TRUE
),
251 HOWTO (R_XTENSA_SLOT9_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
252 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_OP", FALSE
, 0, 0, TRUE
),
253 HOWTO (R_XTENSA_SLOT10_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
254 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_OP", FALSE
, 0, 0, TRUE
),
255 HOWTO (R_XTENSA_SLOT11_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
256 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_OP", FALSE
, 0, 0, TRUE
),
257 HOWTO (R_XTENSA_SLOT12_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
258 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_OP", FALSE
, 0, 0, TRUE
),
259 HOWTO (R_XTENSA_SLOT13_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
260 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_OP", FALSE
, 0, 0, TRUE
),
261 HOWTO (R_XTENSA_SLOT14_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
262 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_OP", FALSE
, 0, 0, TRUE
),
264 /* "Alternate" relocations. The meaning of these is opcode-specific. */
265 HOWTO (R_XTENSA_SLOT0_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
266 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_ALT", FALSE
, 0, 0, TRUE
),
267 HOWTO (R_XTENSA_SLOT1_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
268 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_ALT", FALSE
, 0, 0, TRUE
),
269 HOWTO (R_XTENSA_SLOT2_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
270 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_ALT", FALSE
, 0, 0, TRUE
),
271 HOWTO (R_XTENSA_SLOT3_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
272 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_ALT", FALSE
, 0, 0, TRUE
),
273 HOWTO (R_XTENSA_SLOT4_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
274 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_ALT", FALSE
, 0, 0, TRUE
),
275 HOWTO (R_XTENSA_SLOT5_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
276 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_ALT", FALSE
, 0, 0, TRUE
),
277 HOWTO (R_XTENSA_SLOT6_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
278 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_ALT", FALSE
, 0, 0, TRUE
),
279 HOWTO (R_XTENSA_SLOT7_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
280 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_ALT", FALSE
, 0, 0, TRUE
),
281 HOWTO (R_XTENSA_SLOT8_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
282 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_ALT", FALSE
, 0, 0, TRUE
),
283 HOWTO (R_XTENSA_SLOT9_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
284 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_ALT", FALSE
, 0, 0, TRUE
),
285 HOWTO (R_XTENSA_SLOT10_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
286 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_ALT", FALSE
, 0, 0, TRUE
),
287 HOWTO (R_XTENSA_SLOT11_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
288 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_ALT", FALSE
, 0, 0, TRUE
),
289 HOWTO (R_XTENSA_SLOT12_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
290 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_ALT", FALSE
, 0, 0, TRUE
),
291 HOWTO (R_XTENSA_SLOT13_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
292 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_ALT", FALSE
, 0, 0, TRUE
),
293 HOWTO (R_XTENSA_SLOT14_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
294 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_ALT", FALSE
, 0, 0, TRUE
),
296 /* TLS relocations. */
297 HOWTO (R_XTENSA_TLSDESC_FN
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
298 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_FN",
299 FALSE
, 0, 0xffffffff, FALSE
),
300 HOWTO (R_XTENSA_TLSDESC_ARG
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
301 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_ARG",
302 FALSE
, 0, 0xffffffff, FALSE
),
303 HOWTO (R_XTENSA_TLS_DTPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
304 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_DTPOFF",
305 FALSE
, 0, 0xffffffff, FALSE
),
306 HOWTO (R_XTENSA_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
307 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_TPOFF",
308 FALSE
, 0, 0xffffffff, FALSE
),
309 HOWTO (R_XTENSA_TLS_FUNC
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
310 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_FUNC",
312 HOWTO (R_XTENSA_TLS_ARG
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
313 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_ARG",
315 HOWTO (R_XTENSA_TLS_CALL
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
316 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_CALL",
322 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
327 static reloc_howto_type
*
328 elf_xtensa_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
329 bfd_reloc_code_real_type code
)
334 TRACE ("BFD_RELOC_NONE");
335 return &elf_howto_table
[(unsigned) R_XTENSA_NONE
];
338 TRACE ("BFD_RELOC_32");
339 return &elf_howto_table
[(unsigned) R_XTENSA_32
];
341 case BFD_RELOC_32_PCREL
:
342 TRACE ("BFD_RELOC_32_PCREL");
343 return &elf_howto_table
[(unsigned) R_XTENSA_32_PCREL
];
345 case BFD_RELOC_XTENSA_DIFF8
:
346 TRACE ("BFD_RELOC_XTENSA_DIFF8");
347 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF8
];
349 case BFD_RELOC_XTENSA_DIFF16
:
350 TRACE ("BFD_RELOC_XTENSA_DIFF16");
351 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF16
];
353 case BFD_RELOC_XTENSA_DIFF32
:
354 TRACE ("BFD_RELOC_XTENSA_DIFF32");
355 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF32
];
357 case BFD_RELOC_XTENSA_RTLD
:
358 TRACE ("BFD_RELOC_XTENSA_RTLD");
359 return &elf_howto_table
[(unsigned) R_XTENSA_RTLD
];
361 case BFD_RELOC_XTENSA_GLOB_DAT
:
362 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
363 return &elf_howto_table
[(unsigned) R_XTENSA_GLOB_DAT
];
365 case BFD_RELOC_XTENSA_JMP_SLOT
:
366 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
367 return &elf_howto_table
[(unsigned) R_XTENSA_JMP_SLOT
];
369 case BFD_RELOC_XTENSA_RELATIVE
:
370 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
371 return &elf_howto_table
[(unsigned) R_XTENSA_RELATIVE
];
373 case BFD_RELOC_XTENSA_PLT
:
374 TRACE ("BFD_RELOC_XTENSA_PLT");
375 return &elf_howto_table
[(unsigned) R_XTENSA_PLT
];
377 case BFD_RELOC_XTENSA_OP0
:
378 TRACE ("BFD_RELOC_XTENSA_OP0");
379 return &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
381 case BFD_RELOC_XTENSA_OP1
:
382 TRACE ("BFD_RELOC_XTENSA_OP1");
383 return &elf_howto_table
[(unsigned) R_XTENSA_OP1
];
385 case BFD_RELOC_XTENSA_OP2
:
386 TRACE ("BFD_RELOC_XTENSA_OP2");
387 return &elf_howto_table
[(unsigned) R_XTENSA_OP2
];
389 case BFD_RELOC_XTENSA_ASM_EXPAND
:
390 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
391 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_EXPAND
];
393 case BFD_RELOC_XTENSA_ASM_SIMPLIFY
:
394 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
395 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_SIMPLIFY
];
397 case BFD_RELOC_VTABLE_INHERIT
:
398 TRACE ("BFD_RELOC_VTABLE_INHERIT");
399 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTINHERIT
];
401 case BFD_RELOC_VTABLE_ENTRY
:
402 TRACE ("BFD_RELOC_VTABLE_ENTRY");
403 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTENTRY
];
405 case BFD_RELOC_XTENSA_TLSDESC_FN
:
406 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
407 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_FN
];
409 case BFD_RELOC_XTENSA_TLSDESC_ARG
:
410 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
411 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_ARG
];
413 case BFD_RELOC_XTENSA_TLS_DTPOFF
:
414 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
415 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_DTPOFF
];
417 case BFD_RELOC_XTENSA_TLS_TPOFF
:
418 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
419 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_TPOFF
];
421 case BFD_RELOC_XTENSA_TLS_FUNC
:
422 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
423 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_FUNC
];
425 case BFD_RELOC_XTENSA_TLS_ARG
:
426 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
427 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_ARG
];
429 case BFD_RELOC_XTENSA_TLS_CALL
:
430 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
431 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_CALL
];
434 if (code
>= BFD_RELOC_XTENSA_SLOT0_OP
435 && code
<= BFD_RELOC_XTENSA_SLOT14_OP
)
437 unsigned n
= (R_XTENSA_SLOT0_OP
+
438 (code
- BFD_RELOC_XTENSA_SLOT0_OP
));
439 return &elf_howto_table
[n
];
442 if (code
>= BFD_RELOC_XTENSA_SLOT0_ALT
443 && code
<= BFD_RELOC_XTENSA_SLOT14_ALT
)
445 unsigned n
= (R_XTENSA_SLOT0_ALT
+
446 (code
- BFD_RELOC_XTENSA_SLOT0_ALT
));
447 return &elf_howto_table
[n
];
457 static reloc_howto_type
*
458 elf_xtensa_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
463 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
464 if (elf_howto_table
[i
].name
!= NULL
465 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
466 return &elf_howto_table
[i
];
472 /* Given an ELF "rela" relocation, find the corresponding howto and record
473 it in the BFD internal arelent representation of the relocation. */
476 elf_xtensa_info_to_howto_rela (bfd
*abfd ATTRIBUTE_UNUSED
,
478 Elf_Internal_Rela
*dst
)
480 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
482 if (r_type
>= (unsigned int) R_XTENSA_max
)
484 /* xgettext:c-format */
485 _bfd_error_handler (_("%B: invalid XTENSA reloc number: %d"), abfd
, r_type
);
488 cache_ptr
->howto
= &elf_howto_table
[r_type
];
492 /* Functions for the Xtensa ELF linker. */
494 /* The name of the dynamic interpreter. This is put in the .interp
497 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
499 /* The size in bytes of an entry in the procedure linkage table.
500 (This does _not_ include the space for the literals associated with
503 #define PLT_ENTRY_SIZE 16
505 /* For _really_ large PLTs, we may need to alternate between literals
506 and code to keep the literals within the 256K range of the L32R
507 instructions in the code. It's unlikely that anyone would ever need
508 such a big PLT, but an arbitrary limit on the PLT size would be bad.
509 Thus, we split the PLT into chunks. Since there's very little
510 overhead (2 extra literals) for each chunk, the chunk size is kept
511 small so that the code for handling multiple chunks get used and
512 tested regularly. With 254 entries, there are 1K of literals for
513 each chunk, and that seems like a nice round number. */
515 #define PLT_ENTRIES_PER_CHUNK 254
517 /* PLT entries are actually used as stub functions for lazy symbol
518 resolution. Once the symbol is resolved, the stub function is never
519 invoked. Note: the 32-byte frame size used here cannot be changed
520 without a corresponding change in the runtime linker. */
522 static const bfd_byte elf_xtensa_be_plt_entry
[][PLT_ENTRY_SIZE
] =
525 0x6c, 0x10, 0x04, /* entry sp, 32 */
526 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
527 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
528 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
529 0x0a, 0x80, 0x00, /* jx a8 */
533 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
534 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
535 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
536 0x0a, 0x80, 0x00, /* jx a8 */
541 static const bfd_byte elf_xtensa_le_plt_entry
[][PLT_ENTRY_SIZE
] =
544 0x36, 0x41, 0x00, /* entry sp, 32 */
545 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
546 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
547 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
548 0xa0, 0x08, 0x00, /* jx a8 */
552 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
553 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
554 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
555 0xa0, 0x08, 0x00, /* jx a8 */
560 /* The size of the thread control block. */
563 struct elf_xtensa_link_hash_entry
565 struct elf_link_hash_entry elf
;
567 bfd_signed_vma tlsfunc_refcount
;
569 #define GOT_UNKNOWN 0
571 #define GOT_TLS_GD 2 /* global or local dynamic */
572 #define GOT_TLS_IE 4 /* initial or local exec */
573 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
574 unsigned char tls_type
;
577 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
579 struct elf_xtensa_obj_tdata
581 struct elf_obj_tdata root
;
583 /* tls_type for each local got entry. */
584 char *local_got_tls_type
;
586 bfd_signed_vma
*local_tlsfunc_refcounts
;
589 #define elf_xtensa_tdata(abfd) \
590 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
592 #define elf_xtensa_local_got_tls_type(abfd) \
593 (elf_xtensa_tdata (abfd)->local_got_tls_type)
595 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
596 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
598 #define is_xtensa_elf(bfd) \
599 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
600 && elf_tdata (bfd) != NULL \
601 && elf_object_id (bfd) == XTENSA_ELF_DATA)
604 elf_xtensa_mkobject (bfd
*abfd
)
606 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_xtensa_obj_tdata
),
610 /* Xtensa ELF linker hash table. */
612 struct elf_xtensa_link_hash_table
614 struct elf_link_hash_table elf
;
616 /* Short-cuts to get to dynamic linker sections. */
618 asection
*spltlittbl
;
620 /* Total count of PLT relocations seen during check_relocs.
621 The actual PLT code must be split into multiple sections and all
622 the sections have to be created before size_dynamic_sections,
623 where we figure out the exact number of PLT entries that will be
624 needed. It is OK if this count is an overestimate, e.g., some
625 relocations may be removed by GC. */
628 struct elf_xtensa_link_hash_entry
*tlsbase
;
631 /* Get the Xtensa ELF linker hash table from a link_info structure. */
633 #define elf_xtensa_hash_table(p) \
634 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
635 == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
637 /* Create an entry in an Xtensa ELF linker hash table. */
639 static struct bfd_hash_entry
*
640 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
641 struct bfd_hash_table
*table
,
644 /* Allocate the structure if it has not already been allocated by a
648 entry
= bfd_hash_allocate (table
,
649 sizeof (struct elf_xtensa_link_hash_entry
));
654 /* Call the allocation method of the superclass. */
655 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
658 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (entry
);
659 eh
->tlsfunc_refcount
= 0;
660 eh
->tls_type
= GOT_UNKNOWN
;
666 /* Create an Xtensa ELF linker hash table. */
668 static struct bfd_link_hash_table
*
669 elf_xtensa_link_hash_table_create (bfd
*abfd
)
671 struct elf_link_hash_entry
*tlsbase
;
672 struct elf_xtensa_link_hash_table
*ret
;
673 bfd_size_type amt
= sizeof (struct elf_xtensa_link_hash_table
);
675 ret
= bfd_zmalloc (amt
);
679 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
680 elf_xtensa_link_hash_newfunc
,
681 sizeof (struct elf_xtensa_link_hash_entry
),
688 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
690 tlsbase
= elf_link_hash_lookup (&ret
->elf
, "_TLS_MODULE_BASE_",
692 tlsbase
->root
.type
= bfd_link_hash_new
;
693 tlsbase
->root
.u
.undef
.abfd
= NULL
;
694 tlsbase
->non_elf
= 0;
695 ret
->tlsbase
= elf_xtensa_hash_entry (tlsbase
);
696 ret
->tlsbase
->tls_type
= GOT_UNKNOWN
;
698 return &ret
->elf
.root
;
701 /* Copy the extra info we tack onto an elf_link_hash_entry. */
704 elf_xtensa_copy_indirect_symbol (struct bfd_link_info
*info
,
705 struct elf_link_hash_entry
*dir
,
706 struct elf_link_hash_entry
*ind
)
708 struct elf_xtensa_link_hash_entry
*edir
, *eind
;
710 edir
= elf_xtensa_hash_entry (dir
);
711 eind
= elf_xtensa_hash_entry (ind
);
713 if (ind
->root
.type
== bfd_link_hash_indirect
)
715 edir
->tlsfunc_refcount
+= eind
->tlsfunc_refcount
;
716 eind
->tlsfunc_refcount
= 0;
718 if (dir
->got
.refcount
<= 0)
720 edir
->tls_type
= eind
->tls_type
;
721 eind
->tls_type
= GOT_UNKNOWN
;
725 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
728 static inline bfd_boolean
729 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
730 struct bfd_link_info
*info
)
732 /* Check if we should do dynamic things to this symbol. The
733 "ignore_protected" argument need not be set, because Xtensa code
734 does not require special handling of STV_PROTECTED to make function
735 pointer comparisons work properly. The PLT addresses are never
736 used for function pointers. */
738 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
743 property_table_compare (const void *ap
, const void *bp
)
745 const property_table_entry
*a
= (const property_table_entry
*) ap
;
746 const property_table_entry
*b
= (const property_table_entry
*) bp
;
748 if (a
->address
== b
->address
)
750 if (a
->size
!= b
->size
)
751 return (a
->size
- b
->size
);
753 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
754 return ((b
->flags
& XTENSA_PROP_ALIGN
)
755 - (a
->flags
& XTENSA_PROP_ALIGN
));
757 if ((a
->flags
& XTENSA_PROP_ALIGN
)
758 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
759 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
760 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
761 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
763 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
764 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
765 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
766 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
768 return (a
->flags
- b
->flags
);
771 return (a
->address
- b
->address
);
776 property_table_matches (const void *ap
, const void *bp
)
778 const property_table_entry
*a
= (const property_table_entry
*) ap
;
779 const property_table_entry
*b
= (const property_table_entry
*) bp
;
781 /* Check if one entry overlaps with the other. */
782 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
783 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
786 return (a
->address
- b
->address
);
790 /* Get the literal table or property table entries for the given
791 section. Sets TABLE_P and returns the number of entries. On
792 error, returns a negative value. */
795 xtensa_read_table_entries (bfd
*abfd
,
797 property_table_entry
**table_p
,
798 const char *sec_name
,
799 bfd_boolean output_addr
)
801 asection
*table_section
;
802 bfd_size_type table_size
= 0;
803 bfd_byte
*table_data
;
804 property_table_entry
*blocks
;
805 int blk
, block_count
;
806 bfd_size_type num_records
;
807 Elf_Internal_Rela
*internal_relocs
, *irel
, *rel_end
;
808 bfd_vma section_addr
, off
;
809 flagword predef_flags
;
810 bfd_size_type table_entry_size
, section_limit
;
813 || !(section
->flags
& SEC_ALLOC
)
814 || (section
->flags
& SEC_DEBUGGING
))
820 table_section
= xtensa_get_property_section (section
, sec_name
);
822 table_size
= table_section
->size
;
830 predef_flags
= xtensa_get_property_predef_flags (table_section
);
831 table_entry_size
= 12;
833 table_entry_size
-= 4;
835 num_records
= table_size
/ table_entry_size
;
836 table_data
= retrieve_contents (abfd
, table_section
, TRUE
);
837 blocks
= (property_table_entry
*)
838 bfd_malloc (num_records
* sizeof (property_table_entry
));
842 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
844 section_addr
= section
->vma
;
846 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, TRUE
);
847 if (internal_relocs
&& !table_section
->reloc_done
)
849 qsort (internal_relocs
, table_section
->reloc_count
,
850 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
851 irel
= internal_relocs
;
856 section_limit
= bfd_get_section_limit (abfd
, section
);
857 rel_end
= internal_relocs
+ table_section
->reloc_count
;
859 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
861 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
863 /* Skip any relocations before the current offset. This should help
864 avoid confusion caused by unexpected relocations for the preceding
867 (irel
->r_offset
< off
868 || (irel
->r_offset
== off
869 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
876 if (irel
&& irel
->r_offset
== off
)
879 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
880 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
882 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
885 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
886 BFD_ASSERT (sym_off
== 0);
887 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
891 if (address
< section_addr
892 || address
>= section_addr
+ section_limit
)
896 blocks
[block_count
].address
= address
;
897 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
899 blocks
[block_count
].flags
= predef_flags
;
901 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
905 release_contents (table_section
, table_data
);
906 release_internal_relocs (table_section
, internal_relocs
);
910 /* Now sort them into address order for easy reference. */
911 qsort (blocks
, block_count
, sizeof (property_table_entry
),
912 property_table_compare
);
914 /* Check that the table contents are valid. Problems may occur,
915 for example, if an unrelocated object file is stripped. */
916 for (blk
= 1; blk
< block_count
; blk
++)
918 /* The only circumstance where two entries may legitimately
919 have the same address is when one of them is a zero-size
920 placeholder to mark a place where fill can be inserted.
921 The zero-size entry should come first. */
922 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
923 blocks
[blk
- 1].size
!= 0)
925 /* xgettext:c-format */
926 _bfd_error_handler (_("%B(%A): invalid property table"),
928 bfd_set_error (bfd_error_bad_value
);
940 static property_table_entry
*
941 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
942 int property_table_size
,
945 property_table_entry entry
;
946 property_table_entry
*rv
;
948 if (property_table_size
== 0)
951 entry
.address
= addr
;
955 rv
= bsearch (&entry
, property_table
, property_table_size
,
956 sizeof (property_table_entry
), property_table_matches
);
962 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
966 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
973 /* Look through the relocs for a section during the first phase, and
974 calculate needed space in the dynamic reloc sections. */
977 elf_xtensa_check_relocs (bfd
*abfd
,
978 struct bfd_link_info
*info
,
980 const Elf_Internal_Rela
*relocs
)
982 struct elf_xtensa_link_hash_table
*htab
;
983 Elf_Internal_Shdr
*symtab_hdr
;
984 struct elf_link_hash_entry
**sym_hashes
;
985 const Elf_Internal_Rela
*rel
;
986 const Elf_Internal_Rela
*rel_end
;
988 if (bfd_link_relocatable (info
) || (sec
->flags
& SEC_ALLOC
) == 0)
991 BFD_ASSERT (is_xtensa_elf (abfd
));
993 htab
= elf_xtensa_hash_table (info
);
997 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
998 sym_hashes
= elf_sym_hashes (abfd
);
1000 rel_end
= relocs
+ sec
->reloc_count
;
1001 for (rel
= relocs
; rel
< rel_end
; rel
++)
1003 unsigned int r_type
;
1004 unsigned long r_symndx
;
1005 struct elf_link_hash_entry
*h
= NULL
;
1006 struct elf_xtensa_link_hash_entry
*eh
;
1007 int tls_type
, old_tls_type
;
1008 bfd_boolean is_got
= FALSE
;
1009 bfd_boolean is_plt
= FALSE
;
1010 bfd_boolean is_tlsfunc
= FALSE
;
1012 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1013 r_type
= ELF32_R_TYPE (rel
->r_info
);
1015 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1017 /* xgettext:c-format */
1018 _bfd_error_handler (_("%B: bad symbol index: %d"),
1023 if (r_symndx
>= symtab_hdr
->sh_info
)
1025 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1026 while (h
->root
.type
== bfd_link_hash_indirect
1027 || h
->root
.type
== bfd_link_hash_warning
)
1028 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1030 /* PR15323, ref flags aren't set for references in the same
1032 h
->root
.non_ir_ref_regular
= 1;
1034 eh
= elf_xtensa_hash_entry (h
);
1038 case R_XTENSA_TLSDESC_FN
:
1039 if (bfd_link_pic (info
))
1041 tls_type
= GOT_TLS_GD
;
1046 tls_type
= GOT_TLS_IE
;
1049 case R_XTENSA_TLSDESC_ARG
:
1050 if (bfd_link_pic (info
))
1052 tls_type
= GOT_TLS_GD
;
1057 tls_type
= GOT_TLS_IE
;
1058 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1063 case R_XTENSA_TLS_DTPOFF
:
1064 if (bfd_link_pic (info
))
1065 tls_type
= GOT_TLS_GD
;
1067 tls_type
= GOT_TLS_IE
;
1070 case R_XTENSA_TLS_TPOFF
:
1071 tls_type
= GOT_TLS_IE
;
1072 if (bfd_link_pic (info
))
1073 info
->flags
|= DF_STATIC_TLS
;
1074 if (bfd_link_pic (info
) || h
)
1079 tls_type
= GOT_NORMAL
;
1084 tls_type
= GOT_NORMAL
;
1088 case R_XTENSA_GNU_VTINHERIT
:
1089 /* This relocation describes the C++ object vtable hierarchy.
1090 Reconstruct it for later use during GC. */
1091 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1095 case R_XTENSA_GNU_VTENTRY
:
1096 /* This relocation describes which C++ vtable entries are actually
1097 used. Record for later use during GC. */
1098 BFD_ASSERT (h
!= NULL
);
1100 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1105 /* Nothing to do for any other relocations. */
1113 if (h
->plt
.refcount
<= 0)
1116 h
->plt
.refcount
= 1;
1119 h
->plt
.refcount
+= 1;
1121 /* Keep track of the total PLT relocation count even if we
1122 don't yet know whether the dynamic sections will be
1124 htab
->plt_reloc_count
+= 1;
1126 if (elf_hash_table (info
)->dynamic_sections_created
)
1128 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1134 if (h
->got
.refcount
<= 0)
1135 h
->got
.refcount
= 1;
1137 h
->got
.refcount
+= 1;
1141 eh
->tlsfunc_refcount
+= 1;
1143 old_tls_type
= eh
->tls_type
;
1147 /* Allocate storage the first time. */
1148 if (elf_local_got_refcounts (abfd
) == NULL
)
1150 bfd_size_type size
= symtab_hdr
->sh_info
;
1153 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1156 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1158 mem
= bfd_zalloc (abfd
, size
);
1161 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1163 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1166 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1167 = (bfd_signed_vma
*) mem
;
1170 /* This is a global offset table entry for a local symbol. */
1171 if (is_got
|| is_plt
)
1172 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1175 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1177 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1180 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1181 tls_type
|= old_tls_type
;
1182 /* If a TLS symbol is accessed using IE at least once,
1183 there is no point to use a dynamic model for it. */
1184 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1185 && ((old_tls_type
& GOT_TLS_GD
) == 0
1186 || (tls_type
& GOT_TLS_IE
) == 0))
1188 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1189 tls_type
= old_tls_type
;
1190 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1191 tls_type
|= old_tls_type
;
1195 /* xgettext:c-format */
1196 (_("%B: `%s' accessed both as normal and thread local symbol"),
1198 h
? h
->root
.root
.string
: "<local>");
1203 if (old_tls_type
!= tls_type
)
1206 eh
->tls_type
= tls_type
;
1208 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1217 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1218 struct elf_link_hash_entry
*h
)
1220 if (bfd_link_pic (info
))
1222 if (h
->plt
.refcount
> 0)
1224 /* For shared objects, there's no need for PLT entries for local
1225 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1226 if (h
->got
.refcount
< 0)
1227 h
->got
.refcount
= 0;
1228 h
->got
.refcount
+= h
->plt
.refcount
;
1229 h
->plt
.refcount
= 0;
1234 /* Don't need any dynamic relocations at all. */
1235 h
->plt
.refcount
= 0;
1236 h
->got
.refcount
= 0;
1242 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1243 struct elf_link_hash_entry
*h
,
1244 bfd_boolean force_local
)
1246 /* For a shared link, move the plt refcount to the got refcount to leave
1247 space for RELATIVE relocs. */
1248 elf_xtensa_make_sym_local (info
, h
);
1250 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1254 /* Return the section that should be marked against GC for a given
1258 elf_xtensa_gc_mark_hook (asection
*sec
,
1259 struct bfd_link_info
*info
,
1260 Elf_Internal_Rela
*rel
,
1261 struct elf_link_hash_entry
*h
,
1262 Elf_Internal_Sym
*sym
)
1264 /* Property sections are marked "KEEP" in the linker scripts, but they
1265 should not cause other sections to be marked. (This approach relies
1266 on elf_xtensa_discard_info to remove property table entries that
1267 describe discarded sections. Alternatively, it might be more
1268 efficient to avoid using "KEEP" in the linker scripts and instead use
1269 the gc_mark_extra_sections hook to mark only the property sections
1270 that describe marked sections. That alternative does not work well
1271 with the current property table sections, which do not correspond
1272 one-to-one with the sections they describe, but that should be fixed
1274 if (xtensa_is_property_section (sec
))
1278 switch (ELF32_R_TYPE (rel
->r_info
))
1280 case R_XTENSA_GNU_VTINHERIT
:
1281 case R_XTENSA_GNU_VTENTRY
:
1285 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1289 /* Update the GOT & PLT entry reference counts
1290 for the section being removed. */
1293 elf_xtensa_gc_sweep_hook (bfd
*abfd
,
1294 struct bfd_link_info
*info
,
1296 const Elf_Internal_Rela
*relocs
)
1298 Elf_Internal_Shdr
*symtab_hdr
;
1299 struct elf_link_hash_entry
**sym_hashes
;
1300 const Elf_Internal_Rela
*rel
, *relend
;
1301 struct elf_xtensa_link_hash_table
*htab
;
1303 htab
= elf_xtensa_hash_table (info
);
1307 if (bfd_link_relocatable (info
))
1310 if ((sec
->flags
& SEC_ALLOC
) == 0)
1313 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1314 sym_hashes
= elf_sym_hashes (abfd
);
1316 relend
= relocs
+ sec
->reloc_count
;
1317 for (rel
= relocs
; rel
< relend
; rel
++)
1319 unsigned long r_symndx
;
1320 unsigned int r_type
;
1321 struct elf_link_hash_entry
*h
= NULL
;
1322 struct elf_xtensa_link_hash_entry
*eh
;
1323 bfd_boolean is_got
= FALSE
;
1324 bfd_boolean is_plt
= FALSE
;
1325 bfd_boolean is_tlsfunc
= FALSE
;
1327 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1328 if (r_symndx
>= symtab_hdr
->sh_info
)
1330 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1331 while (h
->root
.type
== bfd_link_hash_indirect
1332 || h
->root
.type
== bfd_link_hash_warning
)
1333 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1335 eh
= elf_xtensa_hash_entry (h
);
1337 r_type
= ELF32_R_TYPE (rel
->r_info
);
1340 case R_XTENSA_TLSDESC_FN
:
1341 if (bfd_link_pic (info
))
1348 case R_XTENSA_TLSDESC_ARG
:
1349 if (bfd_link_pic (info
))
1353 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1358 case R_XTENSA_TLS_TPOFF
:
1359 if (bfd_link_pic (info
) || h
)
1379 /* If the symbol has been localized its plt.refcount got moved
1380 to got.refcount. Handle it as GOT. */
1381 if (h
->plt
.refcount
> 0)
1388 if (h
->got
.refcount
> 0)
1393 if (eh
->tlsfunc_refcount
> 0)
1394 eh
->tlsfunc_refcount
--;
1399 if (is_got
|| is_plt
)
1401 bfd_signed_vma
*got_refcount
1402 = &elf_local_got_refcounts (abfd
) [r_symndx
];
1403 if (*got_refcount
> 0)
1408 bfd_signed_vma
*tlsfunc_refcount
1409 = &elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
];
1410 if (*tlsfunc_refcount
> 0)
1411 *tlsfunc_refcount
-= 1;
1420 /* Create all the dynamic sections. */
1423 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1425 struct elf_xtensa_link_hash_table
*htab
;
1426 flagword flags
, noalloc_flags
;
1428 htab
= elf_xtensa_hash_table (info
);
1432 /* First do all the standard stuff. */
1433 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1436 /* Create any extra PLT sections in case check_relocs has already
1437 been called on all the non-dynamic input files. */
1438 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1441 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1442 | SEC_LINKER_CREATED
| SEC_READONLY
);
1443 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1445 /* Mark the ".got.plt" section READONLY. */
1446 if (htab
->elf
.sgotplt
== NULL
1447 || ! bfd_set_section_flags (dynobj
, htab
->elf
.sgotplt
, flags
))
1450 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1451 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1453 if (htab
->sgotloc
== NULL
1454 || ! bfd_set_section_alignment (dynobj
, htab
->sgotloc
, 2))
1457 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1458 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1460 if (htab
->spltlittbl
== NULL
1461 || ! bfd_set_section_alignment (dynobj
, htab
->spltlittbl
, 2))
1469 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1471 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1474 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1475 ".got.plt" sections. */
1476 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1482 /* Stop when we find a section has already been created. */
1483 if (elf_xtensa_get_plt_section (info
, chunk
))
1486 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1487 | SEC_LINKER_CREATED
| SEC_READONLY
);
1489 sname
= (char *) bfd_malloc (10);
1490 sprintf (sname
, ".plt.%u", chunk
);
1491 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1493 || ! bfd_set_section_alignment (dynobj
, s
, 2))
1496 sname
= (char *) bfd_malloc (14);
1497 sprintf (sname
, ".got.plt.%u", chunk
);
1498 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1500 || ! bfd_set_section_alignment (dynobj
, s
, 2))
1508 /* Adjust a symbol defined by a dynamic object and referenced by a
1509 regular object. The current definition is in some section of the
1510 dynamic object, but we're not including those sections. We have to
1511 change the definition to something the rest of the link can
1515 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1516 struct elf_link_hash_entry
*h
)
1518 /* If this is a weak symbol, and there is a real definition, the
1519 processor independent code will have arranged for us to see the
1520 real definition first, and we can just use the same value. */
1523 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1524 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1525 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1526 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1530 /* This is a reference to a symbol defined by a dynamic object. The
1531 reference must go through the GOT, so there's no need for COPY relocs,
1539 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1541 struct bfd_link_info
*info
;
1542 struct elf_xtensa_link_hash_table
*htab
;
1543 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1545 if (h
->root
.type
== bfd_link_hash_indirect
)
1548 info
= (struct bfd_link_info
*) arg
;
1549 htab
= elf_xtensa_hash_table (info
);
1553 /* If we saw any use of an IE model for this symbol, we can then optimize
1554 away GOT entries for any TLSDESC_FN relocs. */
1555 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1557 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1558 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1561 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1562 elf_xtensa_make_sym_local (info
, h
);
1564 if (h
->plt
.refcount
> 0)
1565 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1567 if (h
->got
.refcount
> 0)
1568 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1575 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1577 struct elf_xtensa_link_hash_table
*htab
;
1580 htab
= elf_xtensa_hash_table (info
);
1584 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1586 bfd_signed_vma
*local_got_refcounts
;
1587 bfd_size_type j
, cnt
;
1588 Elf_Internal_Shdr
*symtab_hdr
;
1590 local_got_refcounts
= elf_local_got_refcounts (i
);
1591 if (!local_got_refcounts
)
1594 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1595 cnt
= symtab_hdr
->sh_info
;
1597 for (j
= 0; j
< cnt
; ++j
)
1599 /* If we saw any use of an IE model for this symbol, we can
1600 then optimize away GOT entries for any TLSDESC_FN relocs. */
1601 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1603 bfd_signed_vma
*tlsfunc_refcount
1604 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1605 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1606 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1609 if (local_got_refcounts
[j
] > 0)
1610 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1611 * sizeof (Elf32_External_Rela
));
1617 /* Set the sizes of the dynamic sections. */
1620 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1621 struct bfd_link_info
*info
)
1623 struct elf_xtensa_link_hash_table
*htab
;
1625 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1626 bfd_boolean relplt
, relgot
;
1627 int plt_entries
, plt_chunks
, chunk
;
1632 htab
= elf_xtensa_hash_table (info
);
1636 dynobj
= elf_hash_table (info
)->dynobj
;
1639 srelgot
= htab
->elf
.srelgot
;
1640 srelplt
= htab
->elf
.srelplt
;
1642 if (elf_hash_table (info
)->dynamic_sections_created
)
1644 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1645 && htab
->elf
.srelplt
!= NULL
1646 && htab
->elf
.sgot
!= NULL
1647 && htab
->spltlittbl
!= NULL
1648 && htab
->sgotloc
!= NULL
);
1650 /* Set the contents of the .interp section to the interpreter. */
1651 if (bfd_link_executable (info
) && !info
->nointerp
)
1653 s
= bfd_get_linker_section (dynobj
, ".interp");
1656 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1657 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1660 /* Allocate room for one word in ".got". */
1661 htab
->elf
.sgot
->size
= 4;
1663 /* Allocate space in ".rela.got" for literals that reference global
1664 symbols and space in ".rela.plt" for literals that have PLT
1666 elf_link_hash_traverse (elf_hash_table (info
),
1667 elf_xtensa_allocate_dynrelocs
,
1670 /* If we are generating a shared object, we also need space in
1671 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1672 reference local symbols. */
1673 if (bfd_link_pic (info
))
1674 elf_xtensa_allocate_local_got_size (info
);
1676 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1677 each PLT entry, we need the PLT code plus a 4-byte literal.
1678 For each chunk of ".plt", we also need two more 4-byte
1679 literals, two corresponding entries in ".rela.got", and an
1680 8-byte entry in ".xt.lit.plt". */
1681 spltlittbl
= htab
->spltlittbl
;
1682 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1684 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1686 /* Iterate over all the PLT chunks, including any extra sections
1687 created earlier because the initial count of PLT relocations
1688 was an overestimate. */
1690 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1695 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1696 BFD_ASSERT (sgotplt
!= NULL
);
1698 if (chunk
< plt_chunks
- 1)
1699 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1700 else if (chunk
== plt_chunks
- 1)
1701 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1705 if (chunk_entries
!= 0)
1707 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1708 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1709 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1710 spltlittbl
->size
+= 8;
1719 /* Allocate space in ".got.loc" to match the total size of all the
1721 sgotloc
= htab
->sgotloc
;
1722 sgotloc
->size
= spltlittbl
->size
;
1723 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1725 if (abfd
->flags
& DYNAMIC
)
1727 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1729 if (! discarded_section (s
)
1730 && xtensa_is_littable_section (s
)
1732 sgotloc
->size
+= s
->size
;
1737 /* Allocate memory for dynamic sections. */
1740 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1744 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1747 /* It's OK to base decisions on the section name, because none
1748 of the dynobj section names depend upon the input files. */
1749 name
= bfd_get_section_name (dynobj
, s
);
1751 if (CONST_STRNEQ (name
, ".rela"))
1755 if (strcmp (name
, ".rela.plt") == 0)
1757 else if (strcmp (name
, ".rela.got") == 0)
1760 /* We use the reloc_count field as a counter if we need
1761 to copy relocs into the output file. */
1765 else if (! CONST_STRNEQ (name
, ".plt.")
1766 && ! CONST_STRNEQ (name
, ".got.plt.")
1767 && strcmp (name
, ".got") != 0
1768 && strcmp (name
, ".plt") != 0
1769 && strcmp (name
, ".got.plt") != 0
1770 && strcmp (name
, ".xt.lit.plt") != 0
1771 && strcmp (name
, ".got.loc") != 0)
1773 /* It's not one of our sections, so don't allocate space. */
1779 /* If we don't need this section, strip it from the output
1780 file. We must create the ".plt*" and ".got.plt*"
1781 sections in create_dynamic_sections and/or check_relocs
1782 based on a conservative estimate of the PLT relocation
1783 count, because the sections must be created before the
1784 linker maps input sections to output sections. The
1785 linker does that before size_dynamic_sections, where we
1786 compute the exact size of the PLT, so there may be more
1787 of these sections than are actually needed. */
1788 s
->flags
|= SEC_EXCLUDE
;
1790 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1792 /* Allocate memory for the section contents. */
1793 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1794 if (s
->contents
== NULL
)
1799 if (elf_hash_table (info
)->dynamic_sections_created
)
1801 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1802 known until finish_dynamic_sections, but we need to get the relocs
1803 in place before they are sorted. */
1804 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1806 Elf_Internal_Rela irela
;
1810 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1813 loc
= (srelgot
->contents
1814 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1815 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1816 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1817 loc
+ sizeof (Elf32_External_Rela
));
1818 srelgot
->reloc_count
+= 2;
1821 /* Add some entries to the .dynamic section. We fill in the
1822 values later, in elf_xtensa_finish_dynamic_sections, but we
1823 must add the entries now so that we get the correct size for
1824 the .dynamic section. The DT_DEBUG entry is filled in by the
1825 dynamic linker and used by the debugger. */
1826 #define add_dynamic_entry(TAG, VAL) \
1827 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1829 if (bfd_link_executable (info
))
1831 if (!add_dynamic_entry (DT_DEBUG
, 0))
1837 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1838 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1839 || !add_dynamic_entry (DT_JMPREL
, 0))
1845 if (!add_dynamic_entry (DT_RELA
, 0)
1846 || !add_dynamic_entry (DT_RELASZ
, 0)
1847 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1851 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1852 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1853 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1856 #undef add_dynamic_entry
1862 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1863 struct bfd_link_info
*info
)
1865 struct elf_xtensa_link_hash_table
*htab
;
1868 htab
= elf_xtensa_hash_table (info
);
1872 tls_sec
= htab
->elf
.tls_sec
;
1874 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1876 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1877 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1878 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1880 tlsbase
->type
= STT_TLS
;
1881 if (!(_bfd_generic_link_add_one_symbol
1882 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1883 tls_sec
, 0, NULL
, FALSE
,
1884 bed
->collect
, &bh
)))
1886 tlsbase
->def_regular
= 1;
1887 tlsbase
->other
= STV_HIDDEN
;
1888 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1895 /* Return the base VMA address which should be subtracted from real addresses
1896 when resolving @dtpoff relocation.
1897 This is PT_TLS segment p_vaddr. */
1900 dtpoff_base (struct bfd_link_info
*info
)
1902 /* If tls_sec is NULL, we should have signalled an error already. */
1903 if (elf_hash_table (info
)->tls_sec
== NULL
)
1905 return elf_hash_table (info
)->tls_sec
->vma
;
1908 /* Return the relocation value for @tpoff relocation
1909 if STT_TLS virtual address is ADDRESS. */
1912 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1914 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1917 /* If tls_sec is NULL, we should have signalled an error already. */
1918 if (htab
->tls_sec
== NULL
)
1920 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1921 return address
- htab
->tls_sec
->vma
+ base
;
1924 /* Perform the specified relocation. The instruction at (contents + address)
1925 is modified to set one operand to represent the value in "relocation". The
1926 operand position is determined by the relocation type recorded in the
1929 #define CALL_SEGMENT_BITS (30)
1930 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1932 static bfd_reloc_status_type
1933 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1935 asection
*input_section
,
1939 bfd_boolean is_weak_undef
,
1940 char **error_message
)
1943 xtensa_opcode opcode
;
1944 xtensa_isa isa
= xtensa_default_isa
;
1945 static xtensa_insnbuf ibuff
= NULL
;
1946 static xtensa_insnbuf sbuff
= NULL
;
1947 bfd_vma self_address
;
1948 bfd_size_type input_size
;
1954 ibuff
= xtensa_insnbuf_alloc (isa
);
1955 sbuff
= xtensa_insnbuf_alloc (isa
);
1958 input_size
= bfd_get_section_limit (abfd
, input_section
);
1960 /* Calculate the PC address for this instruction. */
1961 self_address
= (input_section
->output_section
->vma
1962 + input_section
->output_offset
1965 switch (howto
->type
)
1968 case R_XTENSA_DIFF8
:
1969 case R_XTENSA_DIFF16
:
1970 case R_XTENSA_DIFF32
:
1971 case R_XTENSA_TLS_FUNC
:
1972 case R_XTENSA_TLS_ARG
:
1973 case R_XTENSA_TLS_CALL
:
1974 return bfd_reloc_ok
;
1976 case R_XTENSA_ASM_EXPAND
:
1979 /* Check for windowed CALL across a 1GB boundary. */
1980 opcode
= get_expanded_call_opcode (contents
+ address
,
1981 input_size
- address
, 0);
1982 if (is_windowed_call_opcode (opcode
))
1984 if ((self_address
>> CALL_SEGMENT_BITS
)
1985 != (relocation
>> CALL_SEGMENT_BITS
))
1987 *error_message
= "windowed longcall crosses 1GB boundary; "
1989 return bfd_reloc_dangerous
;
1993 return bfd_reloc_ok
;
1995 case R_XTENSA_ASM_SIMPLIFY
:
1997 /* Convert the L32R/CALLX to CALL. */
1998 bfd_reloc_status_type retval
=
1999 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
2001 if (retval
!= bfd_reloc_ok
)
2002 return bfd_reloc_dangerous
;
2004 /* The CALL needs to be relocated. Continue below for that part. */
2007 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
2014 x
= bfd_get_32 (abfd
, contents
+ address
);
2016 bfd_put_32 (abfd
, x
, contents
+ address
);
2018 return bfd_reloc_ok
;
2020 case R_XTENSA_32_PCREL
:
2021 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
2022 return bfd_reloc_ok
;
2025 case R_XTENSA_TLSDESC_FN
:
2026 case R_XTENSA_TLSDESC_ARG
:
2027 case R_XTENSA_TLS_DTPOFF
:
2028 case R_XTENSA_TLS_TPOFF
:
2029 bfd_put_32 (abfd
, relocation
, contents
+ address
);
2030 return bfd_reloc_ok
;
2033 /* Only instruction slot-specific relocations handled below.... */
2034 slot
= get_relocation_slot (howto
->type
);
2035 if (slot
== XTENSA_UNDEFINED
)
2037 *error_message
= "unexpected relocation";
2038 return bfd_reloc_dangerous
;
2041 /* Read the instruction into a buffer and decode the opcode. */
2042 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
2043 input_size
- address
);
2044 fmt
= xtensa_format_decode (isa
, ibuff
);
2045 if (fmt
== XTENSA_UNDEFINED
)
2047 *error_message
= "cannot decode instruction format";
2048 return bfd_reloc_dangerous
;
2051 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2053 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
2054 if (opcode
== XTENSA_UNDEFINED
)
2056 *error_message
= "cannot decode instruction opcode";
2057 return bfd_reloc_dangerous
;
2060 /* Check for opcode-specific "alternate" relocations. */
2061 if (is_alt_relocation (howto
->type
))
2063 if (opcode
== get_l32r_opcode ())
2065 /* Handle the special-case of non-PC-relative L32R instructions. */
2066 bfd
*output_bfd
= input_section
->output_section
->owner
;
2067 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
2070 *error_message
= "relocation references missing .lit4 section";
2071 return bfd_reloc_dangerous
;
2073 self_address
= ((lit4_sec
->vma
& ~0xfff)
2074 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2075 newval
= relocation
;
2078 else if (opcode
== get_const16_opcode ())
2080 /* ALT used for high 16 bits. */
2081 newval
= relocation
>> 16;
2086 /* No other "alternate" relocations currently defined. */
2087 *error_message
= "unexpected relocation";
2088 return bfd_reloc_dangerous
;
2091 else /* Not an "alternate" relocation.... */
2093 if (opcode
== get_const16_opcode ())
2095 newval
= relocation
& 0xffff;
2100 /* ...normal PC-relative relocation.... */
2102 /* Determine which operand is being relocated. */
2103 opnd
= get_relocation_opnd (opcode
, howto
->type
);
2104 if (opnd
== XTENSA_UNDEFINED
)
2106 *error_message
= "unexpected relocation";
2107 return bfd_reloc_dangerous
;
2110 if (!howto
->pc_relative
)
2112 *error_message
= "expected PC-relative relocation";
2113 return bfd_reloc_dangerous
;
2116 newval
= relocation
;
2120 /* Apply the relocation. */
2121 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
2122 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
2123 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2126 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2129 msg
= "cannot encode";
2130 if (is_direct_call_opcode (opcode
))
2132 if ((relocation
& 0x3) != 0)
2133 msg
= "misaligned call target";
2135 msg
= "call target out of range";
2137 else if (opcode
== get_l32r_opcode ())
2139 if ((relocation
& 0x3) != 0)
2140 msg
= "misaligned literal target";
2141 else if (is_alt_relocation (howto
->type
))
2142 msg
= "literal target out of range (too many literals)";
2143 else if (self_address
> relocation
)
2144 msg
= "literal target out of range (try using text-section-literals)";
2146 msg
= "literal placed after use";
2149 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2150 return bfd_reloc_dangerous
;
2153 /* Check for calls across 1GB boundaries. */
2154 if (is_direct_call_opcode (opcode
)
2155 && is_windowed_call_opcode (opcode
))
2157 if ((self_address
>> CALL_SEGMENT_BITS
)
2158 != (relocation
>> CALL_SEGMENT_BITS
))
2161 "windowed call crosses 1GB boundary; return may fail";
2162 return bfd_reloc_dangerous
;
2166 /* Write the modified instruction back out of the buffer. */
2167 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2168 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2169 input_size
- address
);
2170 return bfd_reloc_ok
;
2175 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2177 /* To reduce the size of the memory leak,
2178 we only use a single message buffer. */
2179 static bfd_size_type alloc_size
= 0;
2180 static char *message
= NULL
;
2181 bfd_size_type orig_len
, len
= 0;
2182 bfd_boolean is_append
;
2185 va_start (ap
, arglen
);
2187 is_append
= (origmsg
== message
);
2189 orig_len
= strlen (origmsg
);
2190 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2191 if (len
> alloc_size
)
2193 message
= (char *) bfd_realloc_or_free (message
, len
);
2196 if (message
!= NULL
)
2199 memcpy (message
, origmsg
, orig_len
);
2200 vsprintf (message
+ orig_len
, fmt
, ap
);
2207 /* This function is registered as the "special_function" in the
2208 Xtensa howto for handling simplify operations.
2209 bfd_perform_relocation / bfd_install_relocation use it to
2210 perform (install) the specified relocation. Since this replaces the code
2211 in bfd_perform_relocation, it is basically an Xtensa-specific,
2212 stripped-down version of bfd_perform_relocation. */
2214 static bfd_reloc_status_type
2215 bfd_elf_xtensa_reloc (bfd
*abfd
,
2216 arelent
*reloc_entry
,
2219 asection
*input_section
,
2221 char **error_message
)
2224 bfd_reloc_status_type flag
;
2225 bfd_size_type octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
2226 bfd_vma output_base
= 0;
2227 reloc_howto_type
*howto
= reloc_entry
->howto
;
2228 asection
*reloc_target_output_section
;
2229 bfd_boolean is_weak_undef
;
2231 if (!xtensa_default_isa
)
2232 xtensa_default_isa
= xtensa_isa_init (0, 0);
2234 /* ELF relocs are against symbols. If we are producing relocatable
2235 output, and the reloc is against an external symbol, the resulting
2236 reloc will also be against the same symbol. In such a case, we
2237 don't want to change anything about the way the reloc is handled,
2238 since it will all be done at final link time. This test is similar
2239 to what bfd_elf_generic_reloc does except that it lets relocs with
2240 howto->partial_inplace go through even if the addend is non-zero.
2241 (The real problem is that partial_inplace is set for XTENSA_32
2242 relocs to begin with, but that's a long story and there's little we
2243 can do about it now....) */
2245 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2247 reloc_entry
->address
+= input_section
->output_offset
;
2248 return bfd_reloc_ok
;
2251 /* Is the address of the relocation really within the section? */
2252 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2253 return bfd_reloc_outofrange
;
2255 /* Work out which section the relocation is targeted at and the
2256 initial relocation command value. */
2258 /* Get symbol value. (Common symbols are special.) */
2259 if (bfd_is_com_section (symbol
->section
))
2262 relocation
= symbol
->value
;
2264 reloc_target_output_section
= symbol
->section
->output_section
;
2266 /* Convert input-section-relative symbol value to absolute. */
2267 if ((output_bfd
&& !howto
->partial_inplace
)
2268 || reloc_target_output_section
== NULL
)
2271 output_base
= reloc_target_output_section
->vma
;
2273 relocation
+= output_base
+ symbol
->section
->output_offset
;
2275 /* Add in supplied addend. */
2276 relocation
+= reloc_entry
->addend
;
2278 /* Here the variable relocation holds the final address of the
2279 symbol we are relocating against, plus any addend. */
2282 if (!howto
->partial_inplace
)
2284 /* This is a partial relocation, and we want to apply the relocation
2285 to the reloc entry rather than the raw data. Everything except
2286 relocations against section symbols has already been handled
2289 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2290 reloc_entry
->addend
= relocation
;
2291 reloc_entry
->address
+= input_section
->output_offset
;
2292 return bfd_reloc_ok
;
2296 reloc_entry
->address
+= input_section
->output_offset
;
2297 reloc_entry
->addend
= 0;
2301 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2302 && (symbol
->flags
& BSF_WEAK
) != 0);
2303 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2304 (bfd_byte
*) data
, (bfd_vma
) octets
,
2305 is_weak_undef
, error_message
);
2307 if (flag
== bfd_reloc_dangerous
)
2309 /* Add the symbol name to the error message. */
2310 if (! *error_message
)
2311 *error_message
= "";
2312 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2313 strlen (symbol
->name
) + 17,
2315 (unsigned long) reloc_entry
->addend
);
2322 /* Set up an entry in the procedure linkage table. */
2325 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2327 unsigned reloc_index
)
2329 asection
*splt
, *sgotplt
;
2330 bfd_vma plt_base
, got_base
;
2331 bfd_vma code_offset
, lit_offset
, abi_offset
;
2334 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2335 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2336 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2337 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2339 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2340 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2342 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2343 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2345 /* Fill in the literal entry. This is the offset of the dynamic
2346 relocation entry. */
2347 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2348 sgotplt
->contents
+ lit_offset
);
2350 /* Fill in the entry in the procedure linkage table. */
2351 memcpy (splt
->contents
+ code_offset
,
2352 (bfd_big_endian (output_bfd
)
2353 ? elf_xtensa_be_plt_entry
[XSHAL_ABI
!= XTHAL_ABI_WINDOWED
]
2354 : elf_xtensa_le_plt_entry
[XSHAL_ABI
!= XTHAL_ABI_WINDOWED
]),
2356 abi_offset
= XSHAL_ABI
== XTHAL_ABI_WINDOWED
? 3 : 0;
2357 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2358 plt_base
+ code_offset
+ abi_offset
),
2359 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2360 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2361 plt_base
+ code_offset
+ abi_offset
+ 3),
2362 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2363 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2364 plt_base
+ code_offset
+ abi_offset
+ 6),
2365 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2367 return plt_base
+ code_offset
;
2371 static bfd_boolean
get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2374 replace_tls_insn (Elf_Internal_Rela
*rel
,
2376 asection
*input_section
,
2378 bfd_boolean is_ld_model
,
2379 char **error_message
)
2381 static xtensa_insnbuf ibuff
= NULL
;
2382 static xtensa_insnbuf sbuff
= NULL
;
2383 xtensa_isa isa
= xtensa_default_isa
;
2385 xtensa_opcode old_op
, new_op
;
2386 bfd_size_type input_size
;
2388 unsigned dest_reg
, src_reg
;
2392 ibuff
= xtensa_insnbuf_alloc (isa
);
2393 sbuff
= xtensa_insnbuf_alloc (isa
);
2396 input_size
= bfd_get_section_limit (abfd
, input_section
);
2398 /* Read the instruction into a buffer and decode the opcode. */
2399 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2400 input_size
- rel
->r_offset
);
2401 fmt
= xtensa_format_decode (isa
, ibuff
);
2402 if (fmt
== XTENSA_UNDEFINED
)
2404 *error_message
= "cannot decode instruction format";
2408 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2409 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2411 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2412 if (old_op
== XTENSA_UNDEFINED
)
2414 *error_message
= "cannot decode instruction opcode";
2418 r_type
= ELF32_R_TYPE (rel
->r_info
);
2421 case R_XTENSA_TLS_FUNC
:
2422 case R_XTENSA_TLS_ARG
:
2423 if (old_op
!= get_l32r_opcode ()
2424 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2425 sbuff
, &dest_reg
) != 0)
2427 *error_message
= "cannot extract L32R destination for TLS access";
2432 case R_XTENSA_TLS_CALL
:
2433 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2434 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2435 sbuff
, &src_reg
) != 0)
2437 *error_message
= "cannot extract CALLXn operands for TLS access";
2450 case R_XTENSA_TLS_FUNC
:
2451 case R_XTENSA_TLS_ARG
:
2452 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2453 versions of Xtensa). */
2454 new_op
= xtensa_opcode_lookup (isa
, "nop");
2455 if (new_op
== XTENSA_UNDEFINED
)
2457 new_op
= xtensa_opcode_lookup (isa
, "or");
2458 if (new_op
== XTENSA_UNDEFINED
2459 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2460 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2462 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2464 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2467 *error_message
= "cannot encode OR for TLS access";
2473 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2475 *error_message
= "cannot encode NOP for TLS access";
2481 case R_XTENSA_TLS_CALL
:
2482 /* Read THREADPTR into the CALLX's return value register. */
2483 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2484 if (new_op
== XTENSA_UNDEFINED
2485 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2486 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2487 sbuff
, dest_reg
+ 2) != 0)
2489 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2499 case R_XTENSA_TLS_FUNC
:
2500 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2501 if (new_op
== XTENSA_UNDEFINED
2502 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2503 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2504 sbuff
, dest_reg
) != 0)
2506 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2511 case R_XTENSA_TLS_ARG
:
2512 /* Nothing to do. Keep the original L32R instruction. */
2515 case R_XTENSA_TLS_CALL
:
2516 /* Add the CALLX's src register (holding the THREADPTR value)
2517 to the first argument register (holding the offset) and put
2518 the result in the CALLX's return value register. */
2519 new_op
= xtensa_opcode_lookup (isa
, "add");
2520 if (new_op
== XTENSA_UNDEFINED
2521 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2522 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2523 sbuff
, dest_reg
+ 2) != 0
2524 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2525 sbuff
, dest_reg
+ 2) != 0
2526 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2527 sbuff
, src_reg
) != 0)
2529 *error_message
= "cannot encode ADD for TLS access";
2536 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2537 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2538 input_size
- rel
->r_offset
);
2544 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2545 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2546 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2547 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2548 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2549 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2550 || (R_TYPE) == R_XTENSA_TLS_ARG \
2551 || (R_TYPE) == R_XTENSA_TLS_CALL)
2553 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2554 both relocatable and final links. */
2557 elf_xtensa_relocate_section (bfd
*output_bfd
,
2558 struct bfd_link_info
*info
,
2560 asection
*input_section
,
2562 Elf_Internal_Rela
*relocs
,
2563 Elf_Internal_Sym
*local_syms
,
2564 asection
**local_sections
)
2566 struct elf_xtensa_link_hash_table
*htab
;
2567 Elf_Internal_Shdr
*symtab_hdr
;
2568 Elf_Internal_Rela
*rel
;
2569 Elf_Internal_Rela
*relend
;
2570 struct elf_link_hash_entry
**sym_hashes
;
2571 property_table_entry
*lit_table
= 0;
2573 char *local_got_tls_types
;
2574 char *error_message
= NULL
;
2575 bfd_size_type input_size
;
2578 if (!xtensa_default_isa
)
2579 xtensa_default_isa
= xtensa_isa_init (0, 0);
2581 BFD_ASSERT (is_xtensa_elf (input_bfd
));
2583 htab
= elf_xtensa_hash_table (info
);
2587 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2588 sym_hashes
= elf_sym_hashes (input_bfd
);
2589 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2591 if (elf_hash_table (info
)->dynamic_sections_created
)
2593 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2594 &lit_table
, XTENSA_LIT_SEC_NAME
,
2600 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2603 relend
= relocs
+ input_section
->reloc_count
;
2604 for (; rel
< relend
; rel
++)
2607 reloc_howto_type
*howto
;
2608 unsigned long r_symndx
;
2609 struct elf_link_hash_entry
*h
;
2610 Elf_Internal_Sym
*sym
;
2615 bfd_reloc_status_type r
;
2616 bfd_boolean is_weak_undef
;
2617 bfd_boolean unresolved_reloc
;
2619 bfd_boolean dynamic_symbol
;
2621 r_type
= ELF32_R_TYPE (rel
->r_info
);
2622 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2623 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2626 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2628 bfd_set_error (bfd_error_bad_value
);
2631 howto
= &elf_howto_table
[r_type
];
2633 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2638 is_weak_undef
= FALSE
;
2639 unresolved_reloc
= FALSE
;
2642 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2644 /* Because R_XTENSA_32 was made partial_inplace to fix some
2645 problems with DWARF info in partial links, there may be
2646 an addend stored in the contents. Take it out of there
2647 and move it back into the addend field of the reloc. */
2648 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2649 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2652 if (r_symndx
< symtab_hdr
->sh_info
)
2654 sym
= local_syms
+ r_symndx
;
2655 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2656 sec
= local_sections
[r_symndx
];
2657 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2661 bfd_boolean ignored
;
2663 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2664 r_symndx
, symtab_hdr
, sym_hashes
,
2666 unresolved_reloc
, warned
, ignored
);
2669 && !unresolved_reloc
2670 && h
->root
.type
== bfd_link_hash_undefweak
)
2671 is_weak_undef
= TRUE
;
2676 if (sec
!= NULL
&& discarded_section (sec
))
2677 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2678 rel
, 1, relend
, howto
, 0, contents
);
2680 if (bfd_link_relocatable (info
))
2683 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2685 /* This is a relocatable link.
2686 1) If the reloc is against a section symbol, adjust
2687 according to the output section.
2688 2) If there is a new target for this relocation,
2689 the new target will be in the same output section.
2690 We adjust the relocation by the output section
2693 if (relaxing_section
)
2695 /* Check if this references a section in another input file. */
2696 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2701 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2702 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2704 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2706 error_message
= NULL
;
2707 /* Convert ASM_SIMPLIFY into the simpler relocation
2708 so that they never escape a relaxing link. */
2709 r
= contract_asm_expansion (contents
, input_size
, rel
,
2711 if (r
!= bfd_reloc_ok
)
2712 (*info
->callbacks
->reloc_dangerous
)
2713 (info
, error_message
,
2714 input_bfd
, input_section
, rel
->r_offset
);
2716 r_type
= ELF32_R_TYPE (rel
->r_info
);
2719 /* This is a relocatable link, so we don't have to change
2720 anything unless the reloc is against a section symbol,
2721 in which case we have to adjust according to where the
2722 section symbol winds up in the output section. */
2723 if (r_symndx
< symtab_hdr
->sh_info
)
2725 sym
= local_syms
+ r_symndx
;
2726 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2728 sec
= local_sections
[r_symndx
];
2729 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2733 /* If there is an addend with a partial_inplace howto,
2734 then move the addend to the contents. This is a hack
2735 to work around problems with DWARF in relocatable links
2736 with some previous version of BFD. Now we can't easily get
2737 rid of the hack without breaking backward compatibility.... */
2739 howto
= &elf_howto_table
[r_type
];
2740 if (howto
->partial_inplace
&& rel
->r_addend
)
2742 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2743 rel
->r_addend
, contents
,
2744 rel
->r_offset
, FALSE
,
2750 /* Put the correct bits in the target instruction, even
2751 though the relocation will still be present in the output
2752 file. This makes disassembly clearer, as well as
2753 allowing loadable kernel modules to work without needing
2754 relocations on anything other than calls and l32r's. */
2756 /* If it is not in the same section, there is nothing we can do. */
2757 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2758 sym_sec
->output_section
== input_section
->output_section
)
2760 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2761 dest_addr
, contents
,
2762 rel
->r_offset
, FALSE
,
2766 if (r
!= bfd_reloc_ok
)
2767 (*info
->callbacks
->reloc_dangerous
)
2768 (info
, error_message
,
2769 input_bfd
, input_section
, rel
->r_offset
);
2771 /* Done with work for relocatable link; continue with next reloc. */
2775 /* This is a final link. */
2777 if (relaxing_section
)
2779 /* Check if this references a section in another input file. */
2780 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2784 /* Sanity check the address. */
2785 if (rel
->r_offset
>= input_size
2786 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2789 /* xgettext:c-format */
2790 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2791 input_bfd
, input_section
, rel
->r_offset
, input_size
);
2792 bfd_set_error (bfd_error_bad_value
);
2797 name
= h
->root
.root
.string
;
2800 name
= (bfd_elf_string_from_elf_section
2801 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2802 if (name
== NULL
|| *name
== '\0')
2803 name
= bfd_section_name (input_bfd
, sec
);
2806 if (r_symndx
!= STN_UNDEF
2807 && r_type
!= R_XTENSA_NONE
2809 || h
->root
.type
== bfd_link_hash_defined
2810 || h
->root
.type
== bfd_link_hash_defweak
)
2811 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2814 ((sym_type
== STT_TLS
2815 /* xgettext:c-format */
2816 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
2817 /* xgettext:c-format */
2818 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
2821 (long) rel
->r_offset
,
2826 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2828 tls_type
= GOT_UNKNOWN
;
2830 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2831 else if (local_got_tls_types
)
2832 tls_type
= local_got_tls_types
[r_symndx
];
2838 if (elf_hash_table (info
)->dynamic_sections_created
2839 && (input_section
->flags
& SEC_ALLOC
) != 0
2840 && (dynamic_symbol
|| bfd_link_pic (info
)))
2842 Elf_Internal_Rela outrel
;
2846 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2847 srel
= htab
->elf
.srelplt
;
2849 srel
= htab
->elf
.srelgot
;
2851 BFD_ASSERT (srel
!= NULL
);
2854 _bfd_elf_section_offset (output_bfd
, info
,
2855 input_section
, rel
->r_offset
);
2857 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2858 memset (&outrel
, 0, sizeof outrel
);
2861 outrel
.r_offset
+= (input_section
->output_section
->vma
2862 + input_section
->output_offset
);
2864 /* Complain if the relocation is in a read-only section
2865 and not in a literal pool. */
2866 if ((input_section
->flags
& SEC_READONLY
) != 0
2867 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2871 _("dynamic relocation in read-only section");
2872 (*info
->callbacks
->reloc_dangerous
)
2873 (info
, error_message
,
2874 input_bfd
, input_section
, rel
->r_offset
);
2879 outrel
.r_addend
= rel
->r_addend
;
2882 if (r_type
== R_XTENSA_32
)
2885 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2888 else /* r_type == R_XTENSA_PLT */
2891 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2893 /* Create the PLT entry and set the initial
2894 contents of the literal entry to the address of
2897 elf_xtensa_create_plt_entry (info
, output_bfd
,
2900 unresolved_reloc
= FALSE
;
2904 /* Generate a RELATIVE relocation. */
2905 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2906 outrel
.r_addend
= 0;
2910 loc
= (srel
->contents
2911 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2912 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2913 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2916 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2918 /* This should only happen for non-PIC code, which is not
2919 supposed to be used on systems with dynamic linking.
2920 Just ignore these relocations. */
2925 case R_XTENSA_TLS_TPOFF
:
2926 /* Switch to LE model for local symbols in an executable. */
2927 if (! bfd_link_pic (info
) && ! dynamic_symbol
)
2929 relocation
= tpoff (info
, relocation
);
2934 case R_XTENSA_TLSDESC_FN
:
2935 case R_XTENSA_TLSDESC_ARG
:
2937 if (r_type
== R_XTENSA_TLSDESC_FN
)
2939 if (! bfd_link_pic (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2940 r_type
= R_XTENSA_NONE
;
2942 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2944 if (bfd_link_pic (info
))
2946 if ((tls_type
& GOT_TLS_IE
) != 0)
2947 r_type
= R_XTENSA_TLS_TPOFF
;
2951 r_type
= R_XTENSA_TLS_TPOFF
;
2952 if (! dynamic_symbol
)
2954 relocation
= tpoff (info
, relocation
);
2960 if (r_type
== R_XTENSA_NONE
)
2961 /* Nothing to do here; skip to the next reloc. */
2964 if (! elf_hash_table (info
)->dynamic_sections_created
)
2967 _("TLS relocation invalid without dynamic sections");
2968 (*info
->callbacks
->reloc_dangerous
)
2969 (info
, error_message
,
2970 input_bfd
, input_section
, rel
->r_offset
);
2974 Elf_Internal_Rela outrel
;
2976 asection
*srel
= htab
->elf
.srelgot
;
2979 outrel
.r_offset
= (input_section
->output_section
->vma
2980 + input_section
->output_offset
2983 /* Complain if the relocation is in a read-only section
2984 and not in a literal pool. */
2985 if ((input_section
->flags
& SEC_READONLY
) != 0
2986 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2990 _("dynamic relocation in read-only section");
2991 (*info
->callbacks
->reloc_dangerous
)
2992 (info
, error_message
,
2993 input_bfd
, input_section
, rel
->r_offset
);
2996 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2998 outrel
.r_addend
= relocation
- dtpoff_base (info
);
3000 outrel
.r_addend
= 0;
3003 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
3005 unresolved_reloc
= FALSE
;
3008 loc
= (srel
->contents
3009 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
3010 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3011 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
3017 case R_XTENSA_TLS_DTPOFF
:
3018 if (! bfd_link_pic (info
))
3019 /* Switch from LD model to LE model. */
3020 relocation
= tpoff (info
, relocation
);
3022 relocation
-= dtpoff_base (info
);
3025 case R_XTENSA_TLS_FUNC
:
3026 case R_XTENSA_TLS_ARG
:
3027 case R_XTENSA_TLS_CALL
:
3028 /* Check if optimizing to IE or LE model. */
3029 if ((tls_type
& GOT_TLS_IE
) != 0)
3031 bfd_boolean is_ld_model
=
3032 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
3033 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
3034 is_ld_model
, &error_message
))
3035 (*info
->callbacks
->reloc_dangerous
)
3036 (info
, error_message
,
3037 input_bfd
, input_section
, rel
->r_offset
);
3039 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
3041 /* Skip subsequent relocations on the same instruction. */
3042 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
3049 if (elf_hash_table (info
)->dynamic_sections_created
3050 && dynamic_symbol
&& (is_operand_relocation (r_type
)
3051 || r_type
== R_XTENSA_32_PCREL
))
3054 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3055 strlen (name
) + 2, name
);
3056 (*info
->callbacks
->reloc_dangerous
)
3057 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3063 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3064 because such sections are not SEC_ALLOC and thus ld.so will
3065 not process them. */
3066 if (unresolved_reloc
3067 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
3069 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3070 rel
->r_offset
) != (bfd_vma
) -1)
3073 /* xgettext:c-format */
3074 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3077 (long) rel
->r_offset
,
3083 /* TLS optimizations may have changed r_type; update "howto". */
3084 howto
= &elf_howto_table
[r_type
];
3086 /* There's no point in calling bfd_perform_relocation here.
3087 Just go directly to our "special function". */
3088 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
3089 relocation
+ rel
->r_addend
,
3090 contents
, rel
->r_offset
, is_weak_undef
,
3093 if (r
!= bfd_reloc_ok
&& !warned
)
3095 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
3096 BFD_ASSERT (error_message
!= NULL
);
3098 if (rel
->r_addend
== 0)
3099 error_message
= vsprint_msg (error_message
, ": %s",
3100 strlen (name
) + 2, name
);
3102 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
3104 name
, (int) rel
->r_addend
);
3106 (*info
->callbacks
->reloc_dangerous
)
3107 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3114 input_section
->reloc_done
= TRUE
;
3120 /* Finish up dynamic symbol handling. There's not much to do here since
3121 the PLT and GOT entries are all set up by relocate_section. */
3124 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3125 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3126 struct elf_link_hash_entry
*h
,
3127 Elf_Internal_Sym
*sym
)
3129 if (h
->needs_plt
&& !h
->def_regular
)
3131 /* Mark the symbol as undefined, rather than as defined in
3132 the .plt section. Leave the value alone. */
3133 sym
->st_shndx
= SHN_UNDEF
;
3134 /* If the symbol is weak, we do need to clear the value.
3135 Otherwise, the PLT entry would provide a definition for
3136 the symbol even if the symbol wasn't defined anywhere,
3137 and so the symbol would never be NULL. */
3138 if (!h
->ref_regular_nonweak
)
3142 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3143 if (h
== elf_hash_table (info
)->hdynamic
3144 || h
== elf_hash_table (info
)->hgot
)
3145 sym
->st_shndx
= SHN_ABS
;
3151 /* Combine adjacent literal table entries in the output. Adjacent
3152 entries within each input section may have been removed during
3153 relaxation, but we repeat the process here, even though it's too late
3154 to shrink the output section, because it's important to minimize the
3155 number of literal table entries to reduce the start-up work for the
3156 runtime linker. Returns the number of remaining table entries or -1
3160 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3165 property_table_entry
*table
;
3166 bfd_size_type section_size
, sgotloc_size
;
3170 section_size
= sxtlit
->size
;
3171 BFD_ASSERT (section_size
% 8 == 0);
3172 num
= section_size
/ 8;
3174 sgotloc_size
= sgotloc
->size
;
3175 if (sgotloc_size
!= section_size
)
3178 (_("internal inconsistency in size of .got.loc section"));
3182 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3186 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3187 propagates to the output section, where it doesn't really apply and
3188 where it breaks the following call to bfd_malloc_and_get_section. */
3189 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3191 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3199 /* There should never be any relocations left at this point, so this
3200 is quite a bit easier than what is done during relaxation. */
3202 /* Copy the raw contents into a property table array and sort it. */
3204 for (n
= 0; n
< num
; n
++)
3206 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3207 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3210 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3212 for (n
= 0; n
< num
; n
++)
3214 bfd_boolean remove_entry
= FALSE
;
3216 if (table
[n
].size
== 0)
3217 remove_entry
= TRUE
;
3219 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3221 table
[n
-1].size
+= table
[n
].size
;
3222 remove_entry
= TRUE
;
3227 for (m
= n
; m
< num
- 1; m
++)
3229 table
[m
].address
= table
[m
+1].address
;
3230 table
[m
].size
= table
[m
+1].size
;
3238 /* Copy the data back to the raw contents. */
3240 for (n
= 0; n
< num
; n
++)
3242 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3243 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3247 /* Clear the removed bytes. */
3248 if ((bfd_size_type
) (num
* 8) < section_size
)
3249 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3251 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3255 /* Copy the contents to ".got.loc". */
3256 memcpy (sgotloc
->contents
, contents
, section_size
);
3264 /* Finish up the dynamic sections. */
3267 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3268 struct bfd_link_info
*info
)
3270 struct elf_xtensa_link_hash_table
*htab
;
3272 asection
*sdyn
, *srelplt
, *sgot
, *sxtlit
, *sgotloc
;
3273 Elf32_External_Dyn
*dyncon
, *dynconend
;
3274 int num_xtlit_entries
= 0;
3276 if (! elf_hash_table (info
)->dynamic_sections_created
)
3279 htab
= elf_xtensa_hash_table (info
);
3283 dynobj
= elf_hash_table (info
)->dynobj
;
3284 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3285 BFD_ASSERT (sdyn
!= NULL
);
3287 /* Set the first entry in the global offset table to the address of
3288 the dynamic section. */
3289 sgot
= htab
->elf
.sgot
;
3292 BFD_ASSERT (sgot
->size
== 4);
3294 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3296 bfd_put_32 (output_bfd
,
3297 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3301 srelplt
= htab
->elf
.srelplt
;
3302 if (srelplt
&& srelplt
->size
!= 0)
3304 asection
*sgotplt
, *srelgot
, *spltlittbl
;
3305 int chunk
, plt_chunks
, plt_entries
;
3306 Elf_Internal_Rela irela
;
3308 unsigned rtld_reloc
;
3310 srelgot
= htab
->elf
.srelgot
;
3311 spltlittbl
= htab
->spltlittbl
;
3312 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3314 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3315 of them follow immediately after.... */
3316 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3318 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3319 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3320 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3323 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3325 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3327 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3329 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3331 int chunk_entries
= 0;
3333 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3334 BFD_ASSERT (sgotplt
!= NULL
);
3336 /* Emit special RTLD relocations for the first two entries in
3337 each chunk of the .got.plt section. */
3339 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3340 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3341 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3342 irela
.r_offset
= (sgotplt
->output_section
->vma
3343 + sgotplt
->output_offset
);
3344 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3345 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3347 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3349 /* Next literal immediately follows the first. */
3350 loc
+= sizeof (Elf32_External_Rela
);
3351 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3352 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3353 irela
.r_offset
= (sgotplt
->output_section
->vma
3354 + sgotplt
->output_offset
+ 4);
3355 /* Tell rtld to set value to object's link map. */
3357 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3359 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3361 /* Fill in the literal table. */
3362 if (chunk
< plt_chunks
- 1)
3363 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3365 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3367 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3368 bfd_put_32 (output_bfd
,
3369 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3370 spltlittbl
->contents
+ (chunk
* 8) + 0);
3371 bfd_put_32 (output_bfd
,
3372 8 + (chunk_entries
* 4),
3373 spltlittbl
->contents
+ (chunk
* 8) + 4);
3376 /* All the dynamic relocations have been emitted at this point.
3377 Make sure the relocation sections are the correct size. */
3378 if (srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3379 * srelgot
->reloc_count
)
3380 || srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3381 * srelplt
->reloc_count
))
3384 /* The .xt.lit.plt section has just been modified. This must
3385 happen before the code below which combines adjacent literal
3386 table entries, and the .xt.lit.plt contents have to be forced to
3388 if (! bfd_set_section_contents (output_bfd
,
3389 spltlittbl
->output_section
,
3390 spltlittbl
->contents
,
3391 spltlittbl
->output_offset
,
3394 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3395 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3398 /* Combine adjacent literal table entries. */
3399 BFD_ASSERT (! bfd_link_relocatable (info
));
3400 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3401 sgotloc
= htab
->sgotloc
;
3402 BFD_ASSERT (sgotloc
);
3406 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3407 if (num_xtlit_entries
< 0)
3411 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3412 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3413 for (; dyncon
< dynconend
; dyncon
++)
3415 Elf_Internal_Dyn dyn
;
3417 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3424 case DT_XTENSA_GOT_LOC_SZ
:
3425 dyn
.d_un
.d_val
= num_xtlit_entries
;
3428 case DT_XTENSA_GOT_LOC_OFF
:
3429 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3430 + htab
->sgotloc
->output_offset
);
3434 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3435 + htab
->elf
.sgot
->output_offset
);
3439 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3440 + htab
->elf
.srelplt
->output_offset
);
3444 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3448 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3455 /* Functions for dealing with the e_flags field. */
3457 /* Merge backend specific data from an object file to the output
3458 object file when linking. */
3461 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3463 bfd
*obfd
= info
->output_bfd
;
3464 unsigned out_mach
, in_mach
;
3465 flagword out_flag
, in_flag
;
3467 /* Check if we have the same endianness. */
3468 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3471 /* Don't even pretend to support mixed-format linking. */
3472 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3473 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3476 out_flag
= elf_elfheader (obfd
)->e_flags
;
3477 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3479 out_mach
= out_flag
& EF_XTENSA_MACH
;
3480 in_mach
= in_flag
& EF_XTENSA_MACH
;
3481 if (out_mach
!= in_mach
)
3484 /* xgettext:c-format */
3485 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
3486 ibfd
, out_mach
, in_mach
);
3487 bfd_set_error (bfd_error_wrong_format
);
3491 if (! elf_flags_init (obfd
))
3493 elf_flags_init (obfd
) = TRUE
;
3494 elf_elfheader (obfd
)->e_flags
= in_flag
;
3496 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3497 && bfd_get_arch_info (obfd
)->the_default
)
3498 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3499 bfd_get_mach (ibfd
));
3504 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3505 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3507 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3508 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3515 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3517 BFD_ASSERT (!elf_flags_init (abfd
)
3518 || elf_elfheader (abfd
)->e_flags
== flags
);
3520 elf_elfheader (abfd
)->e_flags
|= flags
;
3521 elf_flags_init (abfd
) = TRUE
;
3528 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3530 FILE *f
= (FILE *) farg
;
3531 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3533 fprintf (f
, "\nXtensa header:\n");
3534 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3535 fprintf (f
, "\nMachine = Base\n");
3537 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3539 fprintf (f
, "Insn tables = %s\n",
3540 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3542 fprintf (f
, "Literal tables = %s\n",
3543 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3545 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3549 /* Set the right machine number for an Xtensa ELF file. */
3552 elf_xtensa_object_p (bfd
*abfd
)
3555 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3560 mach
= bfd_mach_xtensa
;
3566 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3571 /* The final processing done just before writing out an Xtensa ELF object
3572 file. This gets the Xtensa architecture right based on the machine
3576 elf_xtensa_final_write_processing (bfd
*abfd
,
3577 bfd_boolean linker ATTRIBUTE_UNUSED
)
3582 switch (mach
= bfd_get_mach (abfd
))
3584 case bfd_mach_xtensa
:
3585 val
= E_XTENSA_MACH
;
3591 elf_elfheader (abfd
)->e_flags
&= (~ EF_XTENSA_MACH
);
3592 elf_elfheader (abfd
)->e_flags
|= val
;
3596 static enum elf_reloc_type_class
3597 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3598 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3599 const Elf_Internal_Rela
*rela
)
3601 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3603 case R_XTENSA_RELATIVE
:
3604 return reloc_class_relative
;
3605 case R_XTENSA_JMP_SLOT
:
3606 return reloc_class_plt
;
3608 return reloc_class_normal
;
3614 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3615 struct elf_reloc_cookie
*cookie
,
3616 struct bfd_link_info
*info
,
3620 bfd_vma offset
, actual_offset
;
3621 bfd_size_type removed_bytes
= 0;
3622 bfd_size_type entry_size
;
3624 if (sec
->output_section
3625 && bfd_is_abs_section (sec
->output_section
))
3628 if (xtensa_is_proptable_section (sec
))
3633 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3636 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3640 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3643 release_contents (sec
, contents
);
3647 /* Sort the relocations. They should already be in order when
3648 relaxation is enabled, but it might not be. */
3649 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3650 internal_reloc_compare
);
3652 cookie
->rel
= cookie
->rels
;
3653 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3655 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3657 actual_offset
= offset
- removed_bytes
;
3659 /* The ...symbol_deleted_p function will skip over relocs but it
3660 won't adjust their offsets, so do that here. */
3661 while (cookie
->rel
< cookie
->relend
3662 && cookie
->rel
->r_offset
< offset
)
3664 cookie
->rel
->r_offset
-= removed_bytes
;
3668 while (cookie
->rel
< cookie
->relend
3669 && cookie
->rel
->r_offset
== offset
)
3671 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3673 /* Remove the table entry. (If the reloc type is NONE, then
3674 the entry has already been merged with another and deleted
3675 during relaxation.) */
3676 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3678 /* Shift the contents up. */
3679 if (offset
+ entry_size
< sec
->size
)
3680 memmove (&contents
[actual_offset
],
3681 &contents
[actual_offset
+ entry_size
],
3682 sec
->size
- offset
- entry_size
);
3683 removed_bytes
+= entry_size
;
3686 /* Remove this relocation. */
3687 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3690 /* Adjust the relocation offset for previous removals. This
3691 should not be done before calling ...symbol_deleted_p
3692 because it might mess up the offset comparisons there.
3693 Make sure the offset doesn't underflow in the case where
3694 the first entry is removed. */
3695 if (cookie
->rel
->r_offset
>= removed_bytes
)
3696 cookie
->rel
->r_offset
-= removed_bytes
;
3698 cookie
->rel
->r_offset
= 0;
3704 if (removed_bytes
!= 0)
3706 /* Adjust any remaining relocs (shouldn't be any). */
3707 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3709 if (cookie
->rel
->r_offset
>= removed_bytes
)
3710 cookie
->rel
->r_offset
-= removed_bytes
;
3712 cookie
->rel
->r_offset
= 0;
3715 /* Clear the removed bytes. */
3716 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3718 pin_contents (sec
, contents
);
3719 pin_internal_relocs (sec
, cookie
->rels
);
3722 if (sec
->rawsize
== 0)
3723 sec
->rawsize
= sec
->size
;
3724 sec
->size
-= removed_bytes
;
3726 if (xtensa_is_littable_section (sec
))
3728 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3730 sgotloc
->size
-= removed_bytes
;
3735 release_contents (sec
, contents
);
3736 release_internal_relocs (sec
, cookie
->rels
);
3739 return (removed_bytes
!= 0);
3744 elf_xtensa_discard_info (bfd
*abfd
,
3745 struct elf_reloc_cookie
*cookie
,
3746 struct bfd_link_info
*info
)
3749 bfd_boolean changed
= FALSE
;
3751 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3753 if (xtensa_is_property_section (sec
))
3755 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3765 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3767 return xtensa_is_property_section (sec
);
3772 elf_xtensa_action_discarded (asection
*sec
)
3774 if (strcmp (".xt_except_table", sec
->name
) == 0)
3777 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3780 return _bfd_elf_default_action_discarded (sec
);
3784 /* Support for core dump NOTE sections. */
3787 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3792 /* The size for Xtensa is variable, so don't try to recognize the format
3793 based on the size. Just assume this is GNU/Linux. */
3796 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3799 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3803 size
= note
->descsz
- offset
- 4;
3805 /* Make a ".reg/999" section. */
3806 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3807 size
, note
->descpos
+ offset
);
3812 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3814 switch (note
->descsz
)
3819 case 128: /* GNU/Linux elf_prpsinfo */
3820 elf_tdata (abfd
)->core
->program
3821 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3822 elf_tdata (abfd
)->core
->command
3823 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3826 /* Note that for some reason, a spurious space is tacked
3827 onto the end of the args in some (at least one anyway)
3828 implementations, so strip it off if it exists. */
3831 char *command
= elf_tdata (abfd
)->core
->command
;
3832 int n
= strlen (command
);
3834 if (0 < n
&& command
[n
- 1] == ' ')
3835 command
[n
- 1] = '\0';
3842 /* Generic Xtensa configurability stuff. */
3844 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3845 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3846 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3847 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3848 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3849 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3850 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3851 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3854 init_call_opcodes (void)
3856 if (callx0_op
== XTENSA_UNDEFINED
)
3858 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3859 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3860 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3861 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3862 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3863 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3864 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3865 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3871 is_indirect_call_opcode (xtensa_opcode opcode
)
3873 init_call_opcodes ();
3874 return (opcode
== callx0_op
3875 || opcode
== callx4_op
3876 || opcode
== callx8_op
3877 || opcode
== callx12_op
);
3882 is_direct_call_opcode (xtensa_opcode opcode
)
3884 init_call_opcodes ();
3885 return (opcode
== call0_op
3886 || opcode
== call4_op
3887 || opcode
== call8_op
3888 || opcode
== call12_op
);
3893 is_windowed_call_opcode (xtensa_opcode opcode
)
3895 init_call_opcodes ();
3896 return (opcode
== call4_op
3897 || opcode
== call8_op
3898 || opcode
== call12_op
3899 || opcode
== callx4_op
3900 || opcode
== callx8_op
3901 || opcode
== callx12_op
);
3906 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3908 unsigned dst
= (unsigned) -1;
3910 init_call_opcodes ();
3911 if (opcode
== callx0_op
)
3913 else if (opcode
== callx4_op
)
3915 else if (opcode
== callx8_op
)
3917 else if (opcode
== callx12_op
)
3920 if (dst
== (unsigned) -1)
3928 static xtensa_opcode
3929 get_const16_opcode (void)
3931 static bfd_boolean done_lookup
= FALSE
;
3932 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3935 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3938 return const16_opcode
;
3942 static xtensa_opcode
3943 get_l32r_opcode (void)
3945 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3946 static bfd_boolean done_lookup
= FALSE
;
3950 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3958 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3962 offset
= addr
- ((pc
+3) & -4);
3963 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3964 offset
= (signed int) offset
>> 2;
3965 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3971 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3973 xtensa_isa isa
= xtensa_default_isa
;
3974 int last_immed
, last_opnd
, opi
;
3976 if (opcode
== XTENSA_UNDEFINED
)
3977 return XTENSA_UNDEFINED
;
3979 /* Find the last visible PC-relative immediate operand for the opcode.
3980 If there are no PC-relative immediates, then choose the last visible
3981 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3982 last_immed
= XTENSA_UNDEFINED
;
3983 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3984 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3986 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3988 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3993 if (last_immed
== XTENSA_UNDEFINED
3994 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3998 return XTENSA_UNDEFINED
;
4000 /* If the operand number was specified in an old-style relocation,
4001 check for consistency with the operand computed above. */
4002 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
4004 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
4005 if (reloc_opnd
!= last_immed
)
4006 return XTENSA_UNDEFINED
;
4014 get_relocation_slot (int r_type
)
4024 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4025 return r_type
- R_XTENSA_SLOT0_OP
;
4026 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4027 return r_type
- R_XTENSA_SLOT0_ALT
;
4031 return XTENSA_UNDEFINED
;
4035 /* Get the opcode for a relocation. */
4037 static xtensa_opcode
4038 get_relocation_opcode (bfd
*abfd
,
4041 Elf_Internal_Rela
*irel
)
4043 static xtensa_insnbuf ibuff
= NULL
;
4044 static xtensa_insnbuf sbuff
= NULL
;
4045 xtensa_isa isa
= xtensa_default_isa
;
4049 if (contents
== NULL
)
4050 return XTENSA_UNDEFINED
;
4052 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
4053 return XTENSA_UNDEFINED
;
4057 ibuff
= xtensa_insnbuf_alloc (isa
);
4058 sbuff
= xtensa_insnbuf_alloc (isa
);
4061 /* Decode the instruction. */
4062 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
4063 sec
->size
- irel
->r_offset
);
4064 fmt
= xtensa_format_decode (isa
, ibuff
);
4065 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
4066 if (slot
== XTENSA_UNDEFINED
)
4067 return XTENSA_UNDEFINED
;
4068 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
4069 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
4074 is_l32r_relocation (bfd
*abfd
,
4077 Elf_Internal_Rela
*irel
)
4079 xtensa_opcode opcode
;
4080 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
4082 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
4083 return (opcode
== get_l32r_opcode ());
4087 static bfd_size_type
4088 get_asm_simplify_size (bfd_byte
*contents
,
4089 bfd_size_type content_len
,
4090 bfd_size_type offset
)
4092 bfd_size_type insnlen
, size
= 0;
4094 /* Decode the size of the next two instructions. */
4095 insnlen
= insn_decode_len (contents
, content_len
, offset
);
4101 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
4111 is_alt_relocation (int r_type
)
4113 return (r_type
>= R_XTENSA_SLOT0_ALT
4114 && r_type
<= R_XTENSA_SLOT14_ALT
);
4119 is_operand_relocation (int r_type
)
4129 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4131 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4140 #define MIN_INSN_LENGTH 2
4142 /* Return 0 if it fails to decode. */
4145 insn_decode_len (bfd_byte
*contents
,
4146 bfd_size_type content_len
,
4147 bfd_size_type offset
)
4150 xtensa_isa isa
= xtensa_default_isa
;
4152 static xtensa_insnbuf ibuff
= NULL
;
4154 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4158 ibuff
= xtensa_insnbuf_alloc (isa
);
4159 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4160 content_len
- offset
);
4161 fmt
= xtensa_format_decode (isa
, ibuff
);
4162 if (fmt
== XTENSA_UNDEFINED
)
4164 insn_len
= xtensa_format_length (isa
, fmt
);
4165 if (insn_len
== XTENSA_UNDEFINED
)
4171 /* Decode the opcode for a single slot instruction.
4172 Return 0 if it fails to decode or the instruction is multi-slot. */
4175 insn_decode_opcode (bfd_byte
*contents
,
4176 bfd_size_type content_len
,
4177 bfd_size_type offset
,
4180 xtensa_isa isa
= xtensa_default_isa
;
4182 static xtensa_insnbuf insnbuf
= NULL
;
4183 static xtensa_insnbuf slotbuf
= NULL
;
4185 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4186 return XTENSA_UNDEFINED
;
4188 if (insnbuf
== NULL
)
4190 insnbuf
= xtensa_insnbuf_alloc (isa
);
4191 slotbuf
= xtensa_insnbuf_alloc (isa
);
4194 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4195 content_len
- offset
);
4196 fmt
= xtensa_format_decode (isa
, insnbuf
);
4197 if (fmt
== XTENSA_UNDEFINED
)
4198 return XTENSA_UNDEFINED
;
4200 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4201 return XTENSA_UNDEFINED
;
4203 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4204 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4208 /* The offset is the offset in the contents.
4209 The address is the address of that offset. */
4212 check_branch_target_aligned (bfd_byte
*contents
,
4213 bfd_size_type content_length
,
4217 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4220 return check_branch_target_aligned_address (address
, insn_len
);
4225 check_loop_aligned (bfd_byte
*contents
,
4226 bfd_size_type content_length
,
4230 bfd_size_type loop_len
, insn_len
;
4231 xtensa_opcode opcode
;
4233 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4234 if (opcode
== XTENSA_UNDEFINED
4235 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4241 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4242 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4243 if (loop_len
== 0 || insn_len
== 0)
4249 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4254 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4257 return (addr
% 8 == 0);
4258 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4262 /* Instruction widening and narrowing. */
4264 /* When FLIX is available we need to access certain instructions only
4265 when they are 16-bit or 24-bit instructions. This table caches
4266 information about such instructions by walking through all the
4267 opcodes and finding the smallest single-slot format into which each
4270 static xtensa_format
*op_single_fmt_table
= NULL
;
4274 init_op_single_format_table (void)
4276 xtensa_isa isa
= xtensa_default_isa
;
4277 xtensa_insnbuf ibuf
;
4278 xtensa_opcode opcode
;
4282 if (op_single_fmt_table
)
4285 ibuf
= xtensa_insnbuf_alloc (isa
);
4286 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4288 op_single_fmt_table
= (xtensa_format
*)
4289 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4290 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4292 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4293 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4295 if (xtensa_format_num_slots (isa
, fmt
) == 1
4296 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4298 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4299 int fmt_length
= xtensa_format_length (isa
, fmt
);
4300 if (old_fmt
== XTENSA_UNDEFINED
4301 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4302 op_single_fmt_table
[opcode
] = fmt
;
4306 xtensa_insnbuf_free (isa
, ibuf
);
4310 static xtensa_format
4311 get_single_format (xtensa_opcode opcode
)
4313 init_op_single_format_table ();
4314 return op_single_fmt_table
[opcode
];
4318 /* For the set of narrowable instructions we do NOT include the
4319 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4320 involved during linker relaxation that may require these to
4321 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4322 requires special case code to ensure it only works when op1 == op2. */
4330 struct string_pair narrowable
[] =
4333 { "addi", "addi.n" },
4334 { "addmi", "addi.n" },
4335 { "l32i", "l32i.n" },
4336 { "movi", "movi.n" },
4338 { "retw", "retw.n" },
4339 { "s32i", "s32i.n" },
4340 { "or", "mov.n" } /* special case only when op1 == op2 */
4343 struct string_pair widenable
[] =
4346 { "addi", "addi.n" },
4347 { "addmi", "addi.n" },
4348 { "beqz", "beqz.n" },
4349 { "bnez", "bnez.n" },
4350 { "l32i", "l32i.n" },
4351 { "movi", "movi.n" },
4353 { "retw", "retw.n" },
4354 { "s32i", "s32i.n" },
4355 { "or", "mov.n" } /* special case only when op1 == op2 */
4359 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4360 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4361 return the instruction buffer holding the narrow instruction. Otherwise,
4362 return 0. The set of valid narrowing are specified by a string table
4363 but require some special case operand checks in some cases. */
4365 static xtensa_insnbuf
4366 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4368 xtensa_opcode opcode
)
4370 xtensa_isa isa
= xtensa_default_isa
;
4371 xtensa_format o_fmt
;
4374 static xtensa_insnbuf o_insnbuf
= NULL
;
4375 static xtensa_insnbuf o_slotbuf
= NULL
;
4377 if (o_insnbuf
== NULL
)
4379 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4380 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4383 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4385 bfd_boolean is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4387 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4389 uint32 value
, newval
;
4390 int i
, operand_count
, o_operand_count
;
4391 xtensa_opcode o_opcode
;
4393 /* Address does not matter in this case. We might need to
4394 fix it to handle branches/jumps. */
4395 bfd_vma self_address
= 0;
4397 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4398 if (o_opcode
== XTENSA_UNDEFINED
)
4400 o_fmt
= get_single_format (o_opcode
);
4401 if (o_fmt
== XTENSA_UNDEFINED
)
4404 if (xtensa_format_length (isa
, fmt
) != 3
4405 || xtensa_format_length (isa
, o_fmt
) != 2)
4408 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4409 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4410 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4412 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4417 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4422 uint32 rawval0
, rawval1
, rawval2
;
4424 if (o_operand_count
+ 1 != operand_count
4425 || xtensa_operand_get_field (isa
, opcode
, 0,
4426 fmt
, 0, slotbuf
, &rawval0
) != 0
4427 || xtensa_operand_get_field (isa
, opcode
, 1,
4428 fmt
, 0, slotbuf
, &rawval1
) != 0
4429 || xtensa_operand_get_field (isa
, opcode
, 2,
4430 fmt
, 0, slotbuf
, &rawval2
) != 0
4431 || rawval1
!= rawval2
4432 || rawval0
== rawval1
/* it is a nop */)
4436 for (i
= 0; i
< o_operand_count
; ++i
)
4438 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4440 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4443 /* PC-relative branches need adjustment, but
4444 the PC-rel operand will always have a relocation. */
4446 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4448 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4449 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4454 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4464 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4465 the action in-place directly into the contents and return TRUE. Otherwise,
4466 the return value is FALSE and the contents are not modified. */
4469 narrow_instruction (bfd_byte
*contents
,
4470 bfd_size_type content_length
,
4471 bfd_size_type offset
)
4473 xtensa_opcode opcode
;
4474 bfd_size_type insn_len
;
4475 xtensa_isa isa
= xtensa_default_isa
;
4477 xtensa_insnbuf o_insnbuf
;
4479 static xtensa_insnbuf insnbuf
= NULL
;
4480 static xtensa_insnbuf slotbuf
= NULL
;
4482 if (insnbuf
== NULL
)
4484 insnbuf
= xtensa_insnbuf_alloc (isa
);
4485 slotbuf
= xtensa_insnbuf_alloc (isa
);
4488 BFD_ASSERT (offset
< content_length
);
4490 if (content_length
< 2)
4493 /* We will hand-code a few of these for a little while.
4494 These have all been specified in the assembler aleady. */
4495 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4496 content_length
- offset
);
4497 fmt
= xtensa_format_decode (isa
, insnbuf
);
4498 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4501 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4504 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4505 if (opcode
== XTENSA_UNDEFINED
)
4507 insn_len
= xtensa_format_length (isa
, fmt
);
4508 if (insn_len
> content_length
)
4511 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4514 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4515 content_length
- offset
);
4523 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4524 "density" instruction to a standard 3-byte instruction. If it is valid,
4525 return the instruction buffer holding the wide instruction. Otherwise,
4526 return 0. The set of valid widenings are specified by a string table
4527 but require some special case operand checks in some cases. */
4529 static xtensa_insnbuf
4530 can_widen_instruction (xtensa_insnbuf slotbuf
,
4532 xtensa_opcode opcode
)
4534 xtensa_isa isa
= xtensa_default_isa
;
4535 xtensa_format o_fmt
;
4538 static xtensa_insnbuf o_insnbuf
= NULL
;
4539 static xtensa_insnbuf o_slotbuf
= NULL
;
4541 if (o_insnbuf
== NULL
)
4543 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4544 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4547 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4549 bfd_boolean is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4550 bfd_boolean is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4551 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4553 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4555 uint32 value
, newval
;
4556 int i
, operand_count
, o_operand_count
, check_operand_count
;
4557 xtensa_opcode o_opcode
;
4559 /* Address does not matter in this case. We might need to fix it
4560 to handle branches/jumps. */
4561 bfd_vma self_address
= 0;
4563 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4564 if (o_opcode
== XTENSA_UNDEFINED
)
4566 o_fmt
= get_single_format (o_opcode
);
4567 if (o_fmt
== XTENSA_UNDEFINED
)
4570 if (xtensa_format_length (isa
, fmt
) != 2
4571 || xtensa_format_length (isa
, o_fmt
) != 3)
4574 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4575 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4576 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4577 check_operand_count
= o_operand_count
;
4579 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4584 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4589 uint32 rawval0
, rawval1
;
4591 if (o_operand_count
!= operand_count
+ 1
4592 || xtensa_operand_get_field (isa
, opcode
, 0,
4593 fmt
, 0, slotbuf
, &rawval0
) != 0
4594 || xtensa_operand_get_field (isa
, opcode
, 1,
4595 fmt
, 0, slotbuf
, &rawval1
) != 0
4596 || rawval0
== rawval1
/* it is a nop */)
4600 check_operand_count
--;
4602 for (i
= 0; i
< check_operand_count
; i
++)
4605 if (is_or
&& i
== o_operand_count
- 1)
4607 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4609 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4612 /* PC-relative branches need adjustment, but
4613 the PC-rel operand will always have a relocation. */
4615 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4617 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4618 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4623 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4633 /* Attempt to widen an instruction. If the widening is valid, perform
4634 the action in-place directly into the contents and return TRUE. Otherwise,
4635 the return value is FALSE and the contents are not modified. */
4638 widen_instruction (bfd_byte
*contents
,
4639 bfd_size_type content_length
,
4640 bfd_size_type offset
)
4642 xtensa_opcode opcode
;
4643 bfd_size_type insn_len
;
4644 xtensa_isa isa
= xtensa_default_isa
;
4646 xtensa_insnbuf o_insnbuf
;
4648 static xtensa_insnbuf insnbuf
= NULL
;
4649 static xtensa_insnbuf slotbuf
= NULL
;
4651 if (insnbuf
== NULL
)
4653 insnbuf
= xtensa_insnbuf_alloc (isa
);
4654 slotbuf
= xtensa_insnbuf_alloc (isa
);
4657 BFD_ASSERT (offset
< content_length
);
4659 if (content_length
< 2)
4662 /* We will hand-code a few of these for a little while.
4663 These have all been specified in the assembler aleady. */
4664 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4665 content_length
- offset
);
4666 fmt
= xtensa_format_decode (isa
, insnbuf
);
4667 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4670 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4673 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4674 if (opcode
== XTENSA_UNDEFINED
)
4676 insn_len
= xtensa_format_length (isa
, fmt
);
4677 if (insn_len
> content_length
)
4680 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4683 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4684 content_length
- offset
);
4691 /* Code for transforming CALLs at link-time. */
4693 static bfd_reloc_status_type
4694 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4696 bfd_vma content_length
,
4697 char **error_message
)
4699 static xtensa_insnbuf insnbuf
= NULL
;
4700 static xtensa_insnbuf slotbuf
= NULL
;
4701 xtensa_format core_format
= XTENSA_UNDEFINED
;
4702 xtensa_opcode opcode
;
4703 xtensa_opcode direct_call_opcode
;
4704 xtensa_isa isa
= xtensa_default_isa
;
4705 bfd_byte
*chbuf
= contents
+ address
;
4708 if (insnbuf
== NULL
)
4710 insnbuf
= xtensa_insnbuf_alloc (isa
);
4711 slotbuf
= xtensa_insnbuf_alloc (isa
);
4714 if (content_length
< address
)
4716 *error_message
= _("Attempt to convert L32R/CALLX to CALL failed");
4717 return bfd_reloc_other
;
4720 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4721 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4722 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4724 *error_message
= _("Attempt to convert L32R/CALLX to CALL failed");
4725 return bfd_reloc_other
;
4728 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4729 core_format
= xtensa_format_lookup (isa
, "x24");
4730 opcode
= xtensa_opcode_lookup (isa
, "or");
4731 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4732 for (opn
= 0; opn
< 3; opn
++)
4735 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4736 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4739 xtensa_format_encode (isa
, core_format
, insnbuf
);
4740 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4741 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4743 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4744 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4745 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4747 xtensa_format_encode (isa
, core_format
, insnbuf
);
4748 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4749 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4750 content_length
- address
- 3);
4752 return bfd_reloc_ok
;
4756 static bfd_reloc_status_type
4757 contract_asm_expansion (bfd_byte
*contents
,
4758 bfd_vma content_length
,
4759 Elf_Internal_Rela
*irel
,
4760 char **error_message
)
4762 bfd_reloc_status_type retval
=
4763 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4766 if (retval
!= bfd_reloc_ok
)
4767 return bfd_reloc_dangerous
;
4769 /* Update the irel->r_offset field so that the right immediate and
4770 the right instruction are modified during the relocation. */
4771 irel
->r_offset
+= 3;
4772 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4773 return bfd_reloc_ok
;
4777 static xtensa_opcode
4778 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4780 init_call_opcodes ();
4782 if (opcode
== callx0_op
) return call0_op
;
4783 if (opcode
== callx4_op
) return call4_op
;
4784 if (opcode
== callx8_op
) return call8_op
;
4785 if (opcode
== callx12_op
) return call12_op
;
4787 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4788 return XTENSA_UNDEFINED
;
4792 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4793 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4794 If not, return XTENSA_UNDEFINED. */
4796 #define L32R_TARGET_REG_OPERAND 0
4797 #define CONST16_TARGET_REG_OPERAND 0
4798 #define CALLN_SOURCE_OPERAND 0
4800 static xtensa_opcode
4801 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bfd_boolean
*p_uses_l32r
)
4803 static xtensa_insnbuf insnbuf
= NULL
;
4804 static xtensa_insnbuf slotbuf
= NULL
;
4806 xtensa_opcode opcode
;
4807 xtensa_isa isa
= xtensa_default_isa
;
4808 uint32 regno
, const16_regno
, call_regno
;
4811 if (insnbuf
== NULL
)
4813 insnbuf
= xtensa_insnbuf_alloc (isa
);
4814 slotbuf
= xtensa_insnbuf_alloc (isa
);
4817 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4818 fmt
= xtensa_format_decode (isa
, insnbuf
);
4819 if (fmt
== XTENSA_UNDEFINED
4820 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4821 return XTENSA_UNDEFINED
;
4823 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4824 if (opcode
== XTENSA_UNDEFINED
)
4825 return XTENSA_UNDEFINED
;
4827 if (opcode
== get_l32r_opcode ())
4830 *p_uses_l32r
= TRUE
;
4831 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4832 fmt
, 0, slotbuf
, ®no
)
4833 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4835 return XTENSA_UNDEFINED
;
4837 else if (opcode
== get_const16_opcode ())
4840 *p_uses_l32r
= FALSE
;
4841 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4842 fmt
, 0, slotbuf
, ®no
)
4843 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4845 return XTENSA_UNDEFINED
;
4847 /* Check that the next instruction is also CONST16. */
4848 offset
+= xtensa_format_length (isa
, fmt
);
4849 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4850 fmt
= xtensa_format_decode (isa
, insnbuf
);
4851 if (fmt
== XTENSA_UNDEFINED
4852 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4853 return XTENSA_UNDEFINED
;
4854 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4855 if (opcode
!= get_const16_opcode ())
4856 return XTENSA_UNDEFINED
;
4858 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4859 fmt
, 0, slotbuf
, &const16_regno
)
4860 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4862 || const16_regno
!= regno
)
4863 return XTENSA_UNDEFINED
;
4866 return XTENSA_UNDEFINED
;
4868 /* Next instruction should be an CALLXn with operand 0 == regno. */
4869 offset
+= xtensa_format_length (isa
, fmt
);
4870 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4871 fmt
= xtensa_format_decode (isa
, insnbuf
);
4872 if (fmt
== XTENSA_UNDEFINED
4873 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4874 return XTENSA_UNDEFINED
;
4875 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4876 if (opcode
== XTENSA_UNDEFINED
4877 || !is_indirect_call_opcode (opcode
))
4878 return XTENSA_UNDEFINED
;
4880 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4881 fmt
, 0, slotbuf
, &call_regno
)
4882 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4884 return XTENSA_UNDEFINED
;
4886 if (call_regno
!= regno
)
4887 return XTENSA_UNDEFINED
;
4893 /* Data structures used during relaxation. */
4895 /* r_reloc: relocation values. */
4897 /* Through the relaxation process, we need to keep track of the values
4898 that will result from evaluating relocations. The standard ELF
4899 relocation structure is not sufficient for this purpose because we're
4900 operating on multiple input files at once, so we need to know which
4901 input file a relocation refers to. The r_reloc structure thus
4902 records both the input file (bfd) and ELF relocation.
4904 For efficiency, an r_reloc also contains a "target_offset" field to
4905 cache the target-section-relative offset value that is represented by
4908 The r_reloc also contains a virtual offset that allows multiple
4909 inserted literals to be placed at the same "address" with
4910 different offsets. */
4912 typedef struct r_reloc_struct r_reloc
;
4914 struct r_reloc_struct
4917 Elf_Internal_Rela rela
;
4918 bfd_vma target_offset
;
4919 bfd_vma virtual_offset
;
4923 /* The r_reloc structure is included by value in literal_value, but not
4924 every literal_value has an associated relocation -- some are simple
4925 constants. In such cases, we set all the fields in the r_reloc
4926 struct to zero. The r_reloc_is_const function should be used to
4927 detect this case. */
4930 r_reloc_is_const (const r_reloc
*r_rel
)
4932 return (r_rel
->abfd
== NULL
);
4937 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4939 bfd_vma target_offset
;
4940 unsigned long r_symndx
;
4942 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4943 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4944 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4945 return (target_offset
+ r_rel
->rela
.r_addend
);
4949 static struct elf_link_hash_entry
*
4950 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4952 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4953 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4958 r_reloc_get_section (const r_reloc
*r_rel
)
4960 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4961 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4966 r_reloc_is_defined (const r_reloc
*r_rel
)
4972 sec
= r_reloc_get_section (r_rel
);
4973 if (sec
== bfd_abs_section_ptr
4974 || sec
== bfd_com_section_ptr
4975 || sec
== bfd_und_section_ptr
)
4982 r_reloc_init (r_reloc
*r_rel
,
4984 Elf_Internal_Rela
*irel
,
4986 bfd_size_type content_length
)
4989 reloc_howto_type
*howto
;
4993 r_rel
->rela
= *irel
;
4995 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
4996 r_rel
->virtual_offset
= 0;
4997 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
4998 howto
= &elf_howto_table
[r_type
];
4999 if (howto
->partial_inplace
)
5001 bfd_vma inplace_val
;
5002 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
5004 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
5005 r_rel
->target_offset
+= inplace_val
;
5009 memset (r_rel
, 0, sizeof (r_reloc
));
5016 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
5018 if (r_reloc_is_defined (r_rel
))
5020 asection
*sec
= r_reloc_get_section (r_rel
);
5021 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
5023 else if (r_reloc_get_hash_entry (r_rel
))
5024 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
5026 fprintf (fp
, " ?? + ");
5028 fprintf_vma (fp
, r_rel
->target_offset
);
5029 if (r_rel
->virtual_offset
)
5031 fprintf (fp
, " + ");
5032 fprintf_vma (fp
, r_rel
->virtual_offset
);
5041 /* source_reloc: relocations that reference literals. */
5043 /* To determine whether literals can be coalesced, we need to first
5044 record all the relocations that reference the literals. The
5045 source_reloc structure below is used for this purpose. The
5046 source_reloc entries are kept in a per-literal-section array, sorted
5047 by offset within the literal section (i.e., target offset).
5049 The source_sec and r_rel.rela.r_offset fields identify the source of
5050 the relocation. The r_rel field records the relocation value, i.e.,
5051 the offset of the literal being referenced. The opnd field is needed
5052 to determine the range of the immediate field to which the relocation
5053 applies, so we can determine whether another literal with the same
5054 value is within range. The is_null field is true when the relocation
5055 is being removed (e.g., when an L32R is being removed due to a CALLX
5056 that is converted to a direct CALL). */
5058 typedef struct source_reloc_struct source_reloc
;
5060 struct source_reloc_struct
5062 asection
*source_sec
;
5064 xtensa_opcode opcode
;
5066 bfd_boolean is_null
;
5067 bfd_boolean is_abs_literal
;
5072 init_source_reloc (source_reloc
*reloc
,
5073 asection
*source_sec
,
5074 const r_reloc
*r_rel
,
5075 xtensa_opcode opcode
,
5077 bfd_boolean is_abs_literal
)
5079 reloc
->source_sec
= source_sec
;
5080 reloc
->r_rel
= *r_rel
;
5081 reloc
->opcode
= opcode
;
5083 reloc
->is_null
= FALSE
;
5084 reloc
->is_abs_literal
= is_abs_literal
;
5088 /* Find the source_reloc for a particular source offset and relocation
5089 type. Note that the array is sorted by _target_ offset, so this is
5090 just a linear search. */
5092 static source_reloc
*
5093 find_source_reloc (source_reloc
*src_relocs
,
5096 Elf_Internal_Rela
*irel
)
5100 for (i
= 0; i
< src_count
; i
++)
5102 if (src_relocs
[i
].source_sec
== sec
5103 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
5104 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
5105 == ELF32_R_TYPE (irel
->r_info
)))
5106 return &src_relocs
[i
];
5114 source_reloc_compare (const void *ap
, const void *bp
)
5116 const source_reloc
*a
= (const source_reloc
*) ap
;
5117 const source_reloc
*b
= (const source_reloc
*) bp
;
5119 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
5120 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5122 /* We don't need to sort on these criteria for correctness,
5123 but enforcing a more strict ordering prevents unstable qsort
5124 from behaving differently with different implementations.
5125 Without the code below we get correct but different results
5126 on Solaris 2.7 and 2.8. We would like to always produce the
5127 same results no matter the host. */
5129 if ((!a
->is_null
) - (!b
->is_null
))
5130 return ((!a
->is_null
) - (!b
->is_null
));
5131 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5135 /* Literal values and value hash tables. */
5137 /* Literals with the same value can be coalesced. The literal_value
5138 structure records the value of a literal: the "r_rel" field holds the
5139 information from the relocation on the literal (if there is one) and
5140 the "value" field holds the contents of the literal word itself.
5142 The value_map structure records a literal value along with the
5143 location of a literal holding that value. The value_map hash table
5144 is indexed by the literal value, so that we can quickly check if a
5145 particular literal value has been seen before and is thus a candidate
5148 typedef struct literal_value_struct literal_value
;
5149 typedef struct value_map_struct value_map
;
5150 typedef struct value_map_hash_table_struct value_map_hash_table
;
5152 struct literal_value_struct
5155 unsigned long value
;
5156 bfd_boolean is_abs_literal
;
5159 struct value_map_struct
5161 literal_value val
; /* The literal value. */
5162 r_reloc loc
; /* Location of the literal. */
5166 struct value_map_hash_table_struct
5168 unsigned bucket_count
;
5169 value_map
**buckets
;
5171 bfd_boolean has_last_loc
;
5177 init_literal_value (literal_value
*lit
,
5178 const r_reloc
*r_rel
,
5179 unsigned long value
,
5180 bfd_boolean is_abs_literal
)
5182 lit
->r_rel
= *r_rel
;
5184 lit
->is_abs_literal
= is_abs_literal
;
5189 literal_value_equal (const literal_value
*src1
,
5190 const literal_value
*src2
,
5191 bfd_boolean final_static_link
)
5193 struct elf_link_hash_entry
*h1
, *h2
;
5195 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5198 if (r_reloc_is_const (&src1
->r_rel
))
5199 return (src1
->value
== src2
->value
);
5201 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5202 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5205 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5208 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5211 if (src1
->value
!= src2
->value
)
5214 /* Now check for the same section (if defined) or the same elf_hash
5215 (if undefined or weak). */
5216 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5217 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5218 if (r_reloc_is_defined (&src1
->r_rel
)
5219 && (final_static_link
5220 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5221 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5223 if (r_reloc_get_section (&src1
->r_rel
)
5224 != r_reloc_get_section (&src2
->r_rel
))
5229 /* Require that the hash entries (i.e., symbols) be identical. */
5230 if (h1
!= h2
|| h1
== 0)
5234 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5241 /* Must be power of 2. */
5242 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5244 static value_map_hash_table
*
5245 value_map_hash_table_init (void)
5247 value_map_hash_table
*values
;
5249 values
= (value_map_hash_table
*)
5250 bfd_zmalloc (sizeof (value_map_hash_table
));
5251 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5253 values
->buckets
= (value_map
**)
5254 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5255 if (values
->buckets
== NULL
)
5260 values
->has_last_loc
= FALSE
;
5267 value_map_hash_table_delete (value_map_hash_table
*table
)
5269 free (table
->buckets
);
5275 hash_bfd_vma (bfd_vma val
)
5277 return (val
>> 2) + (val
>> 10);
5282 literal_value_hash (const literal_value
*src
)
5286 hash_val
= hash_bfd_vma (src
->value
);
5287 if (!r_reloc_is_const (&src
->r_rel
))
5291 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5292 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5293 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5295 /* Now check for the same section and the same elf_hash. */
5296 if (r_reloc_is_defined (&src
->r_rel
))
5297 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5299 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5300 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5306 /* Check if the specified literal_value has been seen before. */
5309 value_map_get_cached_value (value_map_hash_table
*map
,
5310 const literal_value
*val
,
5311 bfd_boolean final_static_link
)
5317 idx
= literal_value_hash (val
);
5318 idx
= idx
& (map
->bucket_count
- 1);
5319 bucket
= map
->buckets
[idx
];
5320 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5322 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5329 /* Record a new literal value. It is illegal to call this if VALUE
5330 already has an entry here. */
5333 add_value_map (value_map_hash_table
*map
,
5334 const literal_value
*val
,
5336 bfd_boolean final_static_link
)
5338 value_map
**bucket_p
;
5341 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5344 bfd_set_error (bfd_error_no_memory
);
5348 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5352 idx
= literal_value_hash (val
);
5353 idx
= idx
& (map
->bucket_count
- 1);
5354 bucket_p
= &map
->buckets
[idx
];
5356 val_e
->next
= *bucket_p
;
5359 /* FIXME: Consider resizing the hash table if we get too many entries. */
5365 /* Lists of text actions (ta_) for narrowing, widening, longcall
5366 conversion, space fill, code & literal removal, etc. */
5368 /* The following text actions are generated:
5370 "ta_remove_insn" remove an instruction or instructions
5371 "ta_remove_longcall" convert longcall to call
5372 "ta_convert_longcall" convert longcall to nop/call
5373 "ta_narrow_insn" narrow a wide instruction
5374 "ta_widen" widen a narrow instruction
5375 "ta_fill" add fill or remove fill
5376 removed < 0 is a fill; branches to the fill address will be
5377 changed to address + fill size (e.g., address - removed)
5378 removed >= 0 branches to the fill address will stay unchanged
5379 "ta_remove_literal" remove a literal; this action is
5380 indicated when a literal is removed
5382 "ta_add_literal" insert a new literal; this action is
5383 indicated when a literal has been moved.
5384 It may use a virtual_offset because
5385 multiple literals can be placed at the
5388 For each of these text actions, we also record the number of bytes
5389 removed by performing the text action. In the case of a "ta_widen"
5390 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5392 typedef struct text_action_struct text_action
;
5393 typedef struct text_action_list_struct text_action_list
;
5394 typedef enum text_action_enum_t text_action_t
;
5396 enum text_action_enum_t
5399 ta_remove_insn
, /* removed = -size */
5400 ta_remove_longcall
, /* removed = -size */
5401 ta_convert_longcall
, /* removed = 0 */
5402 ta_narrow_insn
, /* removed = -1 */
5403 ta_widen_insn
, /* removed = +1 */
5404 ta_fill
, /* removed = +size */
5410 /* Structure for a text action record. */
5411 struct text_action_struct
5413 text_action_t action
;
5414 asection
*sec
; /* Optional */
5416 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5418 literal_value value
; /* Only valid when adding literals. */
5421 struct removal_by_action_entry_struct
5426 int eq_removed_before_fill
;
5428 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5430 struct removal_by_action_map_struct
5433 removal_by_action_entry
*entry
;
5435 typedef struct removal_by_action_map_struct removal_by_action_map
;
5438 /* List of all of the actions taken on a text section. */
5439 struct text_action_list_struct
5443 removal_by_action_map map
;
5447 static text_action
*
5448 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5452 /* It is not necessary to fill at the end of a section. */
5453 if (sec
->size
== offset
)
5459 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5461 return (text_action
*)node
->value
;
5467 compute_removed_action_diff (const text_action
*ta
,
5471 int removable_space
)
5474 int current_removed
= 0;
5477 current_removed
= ta
->removed_bytes
;
5479 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5480 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5482 /* It is not necessary to fill at the end of a section. Clean this up. */
5483 if (sec
->size
== offset
)
5484 new_removed
= removable_space
- 0;
5488 int added
= -removed
- current_removed
;
5489 /* Ignore multiples of the section alignment. */
5490 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5491 new_removed
= (-added
);
5493 /* Modify for removable. */
5494 space
= removable_space
- new_removed
;
5495 new_removed
= (removable_space
5496 - (((1 << sec
->alignment_power
) - 1) & space
));
5498 return (new_removed
- current_removed
);
5503 adjust_fill_action (text_action
*ta
, int fill_diff
)
5505 ta
->removed_bytes
+= fill_diff
;
5510 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5512 text_action
*pa
= (text_action
*)a
;
5513 text_action
*pb
= (text_action
*)b
;
5514 static const int action_priority
[] =
5518 [ta_convert_longcall
] = 2,
5519 [ta_narrow_insn
] = 3,
5520 [ta_remove_insn
] = 4,
5521 [ta_remove_longcall
] = 5,
5522 [ta_remove_literal
] = 6,
5523 [ta_widen_insn
] = 7,
5524 [ta_add_literal
] = 8,
5527 if (pa
->offset
== pb
->offset
)
5529 if (pa
->action
== pb
->action
)
5531 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5534 return pa
->offset
< pb
->offset
? -1 : 1;
5537 static text_action
*
5538 action_first (text_action_list
*action_list
)
5540 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5541 return node
? (text_action
*)node
->value
: NULL
;
5544 static text_action
*
5545 action_next (text_action_list
*action_list
, text_action
*action
)
5547 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5548 (splay_tree_key
)action
);
5549 return node
? (text_action
*)node
->value
: NULL
;
5552 /* Add a modification action to the text. For the case of adding or
5553 removing space, modify any current fill and assume that
5554 "unreachable_space" bytes can be freely contracted. Note that a
5555 negative removed value is a fill. */
5558 text_action_add (text_action_list
*l
,
5559 text_action_t action
,
5567 /* It is not necessary to fill at the end of a section. */
5568 if (action
== ta_fill
&& sec
->size
== offset
)
5571 /* It is not necessary to fill 0 bytes. */
5572 if (action
== ta_fill
&& removed
== 0)
5578 if (action
== ta_fill
)
5580 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5584 ta
= (text_action
*)node
->value
;
5585 ta
->removed_bytes
+= removed
;
5590 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5592 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5593 ta
->action
= action
;
5595 ta
->offset
= offset
;
5596 ta
->removed_bytes
= removed
;
5597 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5603 text_action_add_literal (text_action_list
*l
,
5604 text_action_t action
,
5606 const literal_value
*value
,
5610 asection
*sec
= r_reloc_get_section (loc
);
5611 bfd_vma offset
= loc
->target_offset
;
5612 bfd_vma virtual_offset
= loc
->virtual_offset
;
5614 BFD_ASSERT (action
== ta_add_literal
);
5616 /* Create a new record and fill it up. */
5617 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5618 ta
->action
= action
;
5620 ta
->offset
= offset
;
5621 ta
->virtual_offset
= virtual_offset
;
5623 ta
->removed_bytes
= removed
;
5625 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5626 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5631 /* Find the total offset adjustment for the relaxations specified by
5632 text_actions, beginning from a particular starting action. This is
5633 typically used from offset_with_removed_text to search an entire list of
5634 actions, but it may also be called directly when adjusting adjacent offsets
5635 so that each search may begin where the previous one left off. */
5638 removed_by_actions (text_action_list
*action_list
,
5639 text_action
**p_start_action
,
5641 bfd_boolean before_fill
)
5646 r
= *p_start_action
;
5649 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5651 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5656 if (r
->offset
> offset
)
5659 if (r
->offset
== offset
5660 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5663 removed
+= r
->removed_bytes
;
5665 r
= action_next (action_list
, r
);
5668 *p_start_action
= r
;
5674 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5676 text_action
*r
= action_first (action_list
);
5678 return offset
- removed_by_actions (action_list
, &r
, offset
, FALSE
);
5683 action_list_count (text_action_list
*action_list
)
5685 return action_list
->count
;
5688 typedef struct map_action_fn_context_struct map_action_fn_context
;
5689 struct map_action_fn_context_struct
5692 removal_by_action_map map
;
5693 bfd_boolean eq_complete
;
5697 map_action_fn (splay_tree_node node
, void *p
)
5699 map_action_fn_context
*ctx
= p
;
5700 text_action
*r
= (text_action
*)node
->value
;
5701 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5703 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5709 ++ctx
->map
.n_entries
;
5710 ctx
->eq_complete
= FALSE
;
5711 ientry
->offset
= r
->offset
;
5712 ientry
->eq_removed_before_fill
= ctx
->removed
;
5715 if (!ctx
->eq_complete
)
5717 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5719 ientry
->eq_removed
= ctx
->removed
;
5720 ctx
->eq_complete
= TRUE
;
5723 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5726 ctx
->removed
+= r
->removed_bytes
;
5727 ientry
->removed
= ctx
->removed
;
5732 map_removal_by_action (text_action_list
*action_list
)
5734 map_action_fn_context ctx
;
5737 ctx
.map
.n_entries
= 0;
5738 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5739 sizeof (removal_by_action_entry
));
5740 ctx
.eq_complete
= FALSE
;
5742 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5743 action_list
->map
= ctx
.map
;
5747 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5748 bfd_boolean before_fill
)
5752 if (!action_list
->map
.entry
)
5753 map_removal_by_action (action_list
);
5755 if (!action_list
->map
.n_entries
)
5759 b
= action_list
->map
.n_entries
;
5763 unsigned c
= (a
+ b
) / 2;
5765 if (action_list
->map
.entry
[c
].offset
<= offset
)
5771 if (action_list
->map
.entry
[a
].offset
< offset
)
5773 return action_list
->map
.entry
[a
].removed
;
5775 else if (action_list
->map
.entry
[a
].offset
== offset
)
5777 return before_fill
?
5778 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5779 action_list
->map
.entry
[a
].eq_removed
;
5788 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5790 int removed
= removed_by_actions_map (action_list
, offset
, FALSE
);
5791 return offset
- removed
;
5795 /* The find_insn_action routine will only find non-fill actions. */
5797 static text_action
*
5798 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5800 static const text_action_t action
[] =
5802 ta_convert_longcall
,
5812 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5814 splay_tree_node node
;
5816 a
.action
= action
[i
];
5817 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5819 return (text_action
*)node
->value
;
5828 print_action (FILE *fp
, text_action
*r
)
5830 const char *t
= "unknown";
5833 case ta_remove_insn
:
5834 t
= "remove_insn"; break;
5835 case ta_remove_longcall
:
5836 t
= "remove_longcall"; break;
5837 case ta_convert_longcall
:
5838 t
= "convert_longcall"; break;
5839 case ta_narrow_insn
:
5840 t
= "narrow_insn"; break;
5842 t
= "widen_insn"; break;
5847 case ta_remove_literal
:
5848 t
= "remove_literal"; break;
5849 case ta_add_literal
:
5850 t
= "add_literal"; break;
5853 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5854 r
->sec
->owner
->filename
,
5855 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5859 print_action_list_fn (splay_tree_node node
, void *p
)
5861 text_action
*r
= (text_action
*)node
->value
;
5863 print_action (p
, r
);
5868 print_action_list (FILE *fp
, text_action_list
*action_list
)
5870 fprintf (fp
, "Text Action\n");
5871 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5877 /* Lists of literals being coalesced or removed. */
5879 /* In the usual case, the literal identified by "from" is being
5880 coalesced with another literal identified by "to". If the literal is
5881 unused and is being removed altogether, "to.abfd" will be NULL.
5882 The removed_literal entries are kept on a per-section list, sorted
5883 by the "from" offset field. */
5885 typedef struct removed_literal_struct removed_literal
;
5886 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5887 typedef struct removed_literal_list_struct removed_literal_list
;
5889 struct removed_literal_struct
5893 removed_literal
*next
;
5896 struct removed_literal_map_entry_struct
5899 removed_literal
*literal
;
5902 struct removed_literal_list_struct
5904 removed_literal
*head
;
5905 removed_literal
*tail
;
5908 removed_literal_map_entry
*map
;
5912 /* Record that the literal at "from" is being removed. If "to" is not
5913 NULL, the "from" literal is being coalesced with the "to" literal. */
5916 add_removed_literal (removed_literal_list
*removed_list
,
5917 const r_reloc
*from
,
5920 removed_literal
*r
, *new_r
, *next_r
;
5922 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5924 new_r
->from
= *from
;
5928 new_r
->to
.abfd
= NULL
;
5931 r
= removed_list
->head
;
5934 removed_list
->head
= new_r
;
5935 removed_list
->tail
= new_r
;
5937 /* Special check for common case of append. */
5938 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5940 removed_list
->tail
->next
= new_r
;
5941 removed_list
->tail
= new_r
;
5945 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5951 new_r
->next
= next_r
;
5953 removed_list
->tail
= new_r
;
5958 map_removed_literal (removed_literal_list
*removed_list
)
5962 removed_literal_map_entry
*map
= NULL
;
5963 removed_literal
*r
= removed_list
->head
;
5965 for (i
= 0; r
; ++i
, r
= r
->next
)
5969 n_map
= (n_map
* 2) + 2;
5970 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5972 map
[i
].addr
= r
->from
.target_offset
;
5975 removed_list
->map
= map
;
5976 removed_list
->n_map
= i
;
5980 removed_literal_compare (const void *a
, const void *b
)
5982 const removed_literal_map_entry
*pa
= a
;
5983 const removed_literal_map_entry
*pb
= b
;
5985 if (pa
->addr
== pb
->addr
)
5988 return pa
->addr
< pb
->addr
? -1 : 1;
5991 /* Check if the list of removed literals contains an entry for the
5992 given address. Return the entry if found. */
5994 static removed_literal
*
5995 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
5997 removed_literal_map_entry
*p
;
5998 removed_literal
*r
= NULL
;
6000 if (removed_list
->map
== NULL
)
6001 map_removed_literal (removed_list
);
6003 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
6004 sizeof (*removed_list
->map
), removed_literal_compare
);
6007 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
6018 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
6021 r
= removed_list
->head
;
6023 fprintf (fp
, "Removed Literals\n");
6024 for (; r
!= NULL
; r
= r
->next
)
6026 print_r_reloc (fp
, &r
->from
);
6027 fprintf (fp
, " => ");
6028 if (r
->to
.abfd
== NULL
)
6029 fprintf (fp
, "REMOVED");
6031 print_r_reloc (fp
, &r
->to
);
6039 /* Per-section data for relaxation. */
6041 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
6043 struct xtensa_relax_info_struct
6045 bfd_boolean is_relaxable_literal_section
;
6046 bfd_boolean is_relaxable_asm_section
;
6047 int visited
; /* Number of times visited. */
6049 source_reloc
*src_relocs
; /* Array[src_count]. */
6051 int src_next
; /* Next src_relocs entry to assign. */
6053 removed_literal_list removed_list
;
6054 text_action_list action_list
;
6056 reloc_bfd_fix
*fix_list
;
6057 reloc_bfd_fix
*fix_array
;
6058 unsigned fix_array_count
;
6060 /* Support for expanding the reloc array that is stored
6061 in the section structure. If the relocations have been
6062 reallocated, the newly allocated relocations will be referenced
6063 here along with the actual size allocated. The relocation
6064 count will always be found in the section structure. */
6065 Elf_Internal_Rela
*allocated_relocs
;
6066 unsigned relocs_count
;
6067 unsigned allocated_relocs_count
;
6070 struct elf_xtensa_section_data
6072 struct bfd_elf_section_data elf
;
6073 xtensa_relax_info relax_info
;
6078 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
6080 if (!sec
->used_by_bfd
)
6082 struct elf_xtensa_section_data
*sdata
;
6083 bfd_size_type amt
= sizeof (*sdata
);
6085 sdata
= bfd_zalloc (abfd
, amt
);
6088 sec
->used_by_bfd
= sdata
;
6091 return _bfd_elf_new_section_hook (abfd
, sec
);
6095 static xtensa_relax_info
*
6096 get_xtensa_relax_info (asection
*sec
)
6098 struct elf_xtensa_section_data
*section_data
;
6100 /* No info available if no section or if it is an output section. */
6101 if (!sec
|| sec
== sec
->output_section
)
6104 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
6105 return §ion_data
->relax_info
;
6110 init_xtensa_relax_info (asection
*sec
)
6112 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6114 relax_info
->is_relaxable_literal_section
= FALSE
;
6115 relax_info
->is_relaxable_asm_section
= FALSE
;
6116 relax_info
->visited
= 0;
6118 relax_info
->src_relocs
= NULL
;
6119 relax_info
->src_count
= 0;
6120 relax_info
->src_next
= 0;
6122 relax_info
->removed_list
.head
= NULL
;
6123 relax_info
->removed_list
.tail
= NULL
;
6125 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6127 relax_info
->action_list
.map
.n_entries
= 0;
6128 relax_info
->action_list
.map
.entry
= NULL
;
6130 relax_info
->fix_list
= NULL
;
6131 relax_info
->fix_array
= NULL
;
6132 relax_info
->fix_array_count
= 0;
6134 relax_info
->allocated_relocs
= NULL
;
6135 relax_info
->relocs_count
= 0;
6136 relax_info
->allocated_relocs_count
= 0;
6140 /* Coalescing literals may require a relocation to refer to a section in
6141 a different input file, but the standard relocation information
6142 cannot express that. Instead, the reloc_bfd_fix structures are used
6143 to "fix" the relocations that refer to sections in other input files.
6144 These structures are kept on per-section lists. The "src_type" field
6145 records the relocation type in case there are multiple relocations on
6146 the same location. FIXME: This is ugly; an alternative might be to
6147 add new symbols with the "owner" field to some other input file. */
6149 struct reloc_bfd_fix_struct
6153 unsigned src_type
; /* Relocation type. */
6155 asection
*target_sec
;
6156 bfd_vma target_offset
;
6157 bfd_boolean translated
;
6159 reloc_bfd_fix
*next
;
6163 static reloc_bfd_fix
*
6164 reloc_bfd_fix_init (asection
*src_sec
,
6167 asection
*target_sec
,
6168 bfd_vma target_offset
,
6169 bfd_boolean translated
)
6173 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6174 fix
->src_sec
= src_sec
;
6175 fix
->src_offset
= src_offset
;
6176 fix
->src_type
= src_type
;
6177 fix
->target_sec
= target_sec
;
6178 fix
->target_offset
= target_offset
;
6179 fix
->translated
= translated
;
6186 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6188 xtensa_relax_info
*relax_info
;
6190 relax_info
= get_xtensa_relax_info (src_sec
);
6191 fix
->next
= relax_info
->fix_list
;
6192 relax_info
->fix_list
= fix
;
6197 fix_compare (const void *ap
, const void *bp
)
6199 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6200 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6202 if (a
->src_offset
!= b
->src_offset
)
6203 return (a
->src_offset
- b
->src_offset
);
6204 return (a
->src_type
- b
->src_type
);
6209 cache_fix_array (asection
*sec
)
6211 unsigned i
, count
= 0;
6213 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6215 if (relax_info
== NULL
)
6217 if (relax_info
->fix_list
== NULL
)
6220 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6223 relax_info
->fix_array
=
6224 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6225 relax_info
->fix_array_count
= count
;
6227 r
= relax_info
->fix_list
;
6228 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6230 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6231 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6234 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6235 sizeof (reloc_bfd_fix
), fix_compare
);
6239 static reloc_bfd_fix
*
6240 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6242 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6246 if (relax_info
== NULL
)
6248 if (relax_info
->fix_list
== NULL
)
6251 if (relax_info
->fix_array
== NULL
)
6252 cache_fix_array (sec
);
6254 key
.src_offset
= offset
;
6255 key
.src_type
= type
;
6256 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6257 sizeof (reloc_bfd_fix
), fix_compare
);
6262 /* Section caching. */
6264 typedef struct section_cache_struct section_cache_t
;
6266 struct section_cache_struct
6270 bfd_byte
*contents
; /* Cache of the section contents. */
6271 bfd_size_type content_length
;
6273 property_table_entry
*ptbl
; /* Cache of the section property table. */
6276 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6277 unsigned reloc_count
;
6282 init_section_cache (section_cache_t
*sec_cache
)
6284 memset (sec_cache
, 0, sizeof (*sec_cache
));
6289 free_section_cache (section_cache_t
*sec_cache
)
6293 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6294 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6295 if (sec_cache
->ptbl
)
6296 free (sec_cache
->ptbl
);
6302 section_cache_section (section_cache_t
*sec_cache
,
6304 struct bfd_link_info
*link_info
)
6307 property_table_entry
*prop_table
= NULL
;
6309 bfd_byte
*contents
= NULL
;
6310 Elf_Internal_Rela
*internal_relocs
= NULL
;
6311 bfd_size_type sec_size
;
6315 if (sec
== sec_cache
->sec
)
6319 sec_size
= bfd_get_section_limit (abfd
, sec
);
6321 /* Get the contents. */
6322 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6323 if (contents
== NULL
&& sec_size
!= 0)
6326 /* Get the relocations. */
6327 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6328 link_info
->keep_memory
);
6330 /* Get the entry table. */
6331 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6332 XTENSA_PROP_SEC_NAME
, FALSE
);
6336 /* Fill in the new section cache. */
6337 free_section_cache (sec_cache
);
6338 init_section_cache (sec_cache
);
6340 sec_cache
->sec
= sec
;
6341 sec_cache
->contents
= contents
;
6342 sec_cache
->content_length
= sec_size
;
6343 sec_cache
->relocs
= internal_relocs
;
6344 sec_cache
->reloc_count
= sec
->reloc_count
;
6345 sec_cache
->pte_count
= ptblsize
;
6346 sec_cache
->ptbl
= prop_table
;
6351 release_contents (sec
, contents
);
6352 release_internal_relocs (sec
, internal_relocs
);
6359 /* Extended basic blocks. */
6361 /* An ebb_struct represents an Extended Basic Block. Within this
6362 range, we guarantee that all instructions are decodable, the
6363 property table entries are contiguous, and no property table
6364 specifies a segment that cannot have instructions moved. This
6365 structure contains caches of the contents, property table and
6366 relocations for the specified section for easy use. The range is
6367 specified by ranges of indices for the byte offset, property table
6368 offsets and relocation offsets. These must be consistent. */
6370 typedef struct ebb_struct ebb_t
;
6376 bfd_byte
*contents
; /* Cache of the section contents. */
6377 bfd_size_type content_length
;
6379 property_table_entry
*ptbl
; /* Cache of the section property table. */
6382 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6383 unsigned reloc_count
;
6385 bfd_vma start_offset
; /* Offset in section. */
6386 unsigned start_ptbl_idx
; /* Offset in the property table. */
6387 unsigned start_reloc_idx
; /* Offset in the relocations. */
6390 unsigned end_ptbl_idx
;
6391 unsigned end_reloc_idx
;
6393 bfd_boolean ends_section
; /* Is this the last ebb in a section? */
6395 /* The unreachable property table at the end of this set of blocks;
6396 NULL if the end is not an unreachable block. */
6397 property_table_entry
*ends_unreachable
;
6401 enum ebb_target_enum
6404 EBB_DESIRE_TGT_ALIGN
,
6405 EBB_REQUIRE_TGT_ALIGN
,
6406 EBB_REQUIRE_LOOP_ALIGN
,
6411 /* proposed_action_struct is similar to the text_action_struct except
6412 that is represents a potential transformation, not one that will
6413 occur. We build a list of these for an extended basic block
6414 and use them to compute the actual actions desired. We must be
6415 careful that the entire set of actual actions we perform do not
6416 break any relocations that would fit if the actions were not
6419 typedef struct proposed_action_struct proposed_action
;
6421 struct proposed_action_struct
6423 enum ebb_target_enum align_type
; /* for the target alignment */
6424 bfd_vma alignment_pow
;
6425 text_action_t action
;
6428 bfd_boolean do_action
; /* If false, then we will not perform the action. */
6432 /* The ebb_constraint_struct keeps a set of proposed actions for an
6433 extended basic block. */
6435 typedef struct ebb_constraint_struct ebb_constraint
;
6437 struct ebb_constraint_struct
6440 bfd_boolean start_movable
;
6442 /* Bytes of extra space at the beginning if movable. */
6443 int start_extra_space
;
6445 enum ebb_target_enum start_align
;
6447 bfd_boolean end_movable
;
6449 /* Bytes of extra space at the end if movable. */
6450 int end_extra_space
;
6452 unsigned action_count
;
6453 unsigned action_allocated
;
6455 /* Array of proposed actions. */
6456 proposed_action
*actions
;
6458 /* Action alignments -- one for each proposed action. */
6459 enum ebb_target_enum
*action_aligns
;
6464 init_ebb_constraint (ebb_constraint
*c
)
6466 memset (c
, 0, sizeof (ebb_constraint
));
6471 free_ebb_constraint (ebb_constraint
*c
)
6479 init_ebb (ebb_t
*ebb
,
6482 bfd_size_type content_length
,
6483 property_table_entry
*prop_table
,
6485 Elf_Internal_Rela
*internal_relocs
,
6486 unsigned reloc_count
)
6488 memset (ebb
, 0, sizeof (ebb_t
));
6490 ebb
->contents
= contents
;
6491 ebb
->content_length
= content_length
;
6492 ebb
->ptbl
= prop_table
;
6493 ebb
->pte_count
= ptblsize
;
6494 ebb
->relocs
= internal_relocs
;
6495 ebb
->reloc_count
= reloc_count
;
6496 ebb
->start_offset
= 0;
6497 ebb
->end_offset
= ebb
->content_length
- 1;
6498 ebb
->start_ptbl_idx
= 0;
6499 ebb
->end_ptbl_idx
= ptblsize
;
6500 ebb
->start_reloc_idx
= 0;
6501 ebb
->end_reloc_idx
= reloc_count
;
6505 /* Extend the ebb to all decodable contiguous sections. The algorithm
6506 for building a basic block around an instruction is to push it
6507 forward until we hit the end of a section, an unreachable block or
6508 a block that cannot be transformed. Then we push it backwards
6509 searching for similar conditions. */
6511 static bfd_boolean
extend_ebb_bounds_forward (ebb_t
*);
6512 static bfd_boolean
extend_ebb_bounds_backward (ebb_t
*);
6513 static bfd_size_type insn_block_decodable_len
6514 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6517 extend_ebb_bounds (ebb_t
*ebb
)
6519 if (!extend_ebb_bounds_forward (ebb
))
6521 if (!extend_ebb_bounds_backward (ebb
))
6528 extend_ebb_bounds_forward (ebb_t
*ebb
)
6530 property_table_entry
*the_entry
, *new_entry
;
6532 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6534 /* Stop when (1) we cannot decode an instruction, (2) we are at
6535 the end of the property tables, (3) we hit a non-contiguous property
6536 table entry, (4) we hit a NO_TRANSFORM region. */
6541 bfd_size_type insn_block_len
;
6543 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6545 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6547 entry_end
- ebb
->end_offset
);
6548 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6551 /* xgettext:c-format */
6552 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6553 ebb
->sec
->owner
, ebb
->sec
, ebb
->end_offset
+ insn_block_len
);
6556 ebb
->end_offset
+= insn_block_len
;
6558 if (ebb
->end_offset
== ebb
->sec
->size
)
6559 ebb
->ends_section
= TRUE
;
6561 /* Update the reloc counter. */
6562 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6563 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6566 ebb
->end_reloc_idx
++;
6569 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6572 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6573 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6574 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6575 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6578 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6581 the_entry
= new_entry
;
6582 ebb
->end_ptbl_idx
++;
6585 /* Quick check for an unreachable or end of file just at the end. */
6586 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6588 if (ebb
->end_offset
== ebb
->content_length
)
6589 ebb
->ends_section
= TRUE
;
6593 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6594 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6595 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6596 ebb
->ends_unreachable
= new_entry
;
6599 /* Any other ending requires exact alignment. */
6605 extend_ebb_bounds_backward (ebb_t
*ebb
)
6607 property_table_entry
*the_entry
, *new_entry
;
6609 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6611 /* Stop when (1) we cannot decode the instructions in the current entry.
6612 (2) we are at the beginning of the property tables, (3) we hit a
6613 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6617 bfd_vma block_begin
;
6618 bfd_size_type insn_block_len
;
6620 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6622 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6624 ebb
->start_offset
- block_begin
);
6625 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6628 /* xgettext:c-format */
6629 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6630 ebb
->sec
->owner
, ebb
->sec
, ebb
->end_offset
+ insn_block_len
);
6633 ebb
->start_offset
-= insn_block_len
;
6635 /* Update the reloc counter. */
6636 while (ebb
->start_reloc_idx
> 0
6637 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6638 >= ebb
->start_offset
))
6640 ebb
->start_reloc_idx
--;
6643 if (ebb
->start_ptbl_idx
== 0)
6646 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6647 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6648 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6649 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6651 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6654 the_entry
= new_entry
;
6655 ebb
->start_ptbl_idx
--;
6661 static bfd_size_type
6662 insn_block_decodable_len (bfd_byte
*contents
,
6663 bfd_size_type content_len
,
6664 bfd_vma block_offset
,
6665 bfd_size_type block_len
)
6667 bfd_vma offset
= block_offset
;
6669 while (offset
< block_offset
+ block_len
)
6671 bfd_size_type insn_len
= 0;
6673 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6675 return (offset
- block_offset
);
6678 return (offset
- block_offset
);
6683 ebb_propose_action (ebb_constraint
*c
,
6684 enum ebb_target_enum align_type
,
6685 bfd_vma alignment_pow
,
6686 text_action_t action
,
6689 bfd_boolean do_action
)
6691 proposed_action
*act
;
6693 if (c
->action_allocated
<= c
->action_count
)
6695 unsigned new_allocated
, i
;
6696 proposed_action
*new_actions
;
6698 new_allocated
= (c
->action_count
+ 2) * 2;
6699 new_actions
= (proposed_action
*)
6700 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6702 for (i
= 0; i
< c
->action_count
; i
++)
6703 new_actions
[i
] = c
->actions
[i
];
6706 c
->actions
= new_actions
;
6707 c
->action_allocated
= new_allocated
;
6710 act
= &c
->actions
[c
->action_count
];
6711 act
->align_type
= align_type
;
6712 act
->alignment_pow
= alignment_pow
;
6713 act
->action
= action
;
6714 act
->offset
= offset
;
6715 act
->removed_bytes
= removed_bytes
;
6716 act
->do_action
= do_action
;
6722 /* Access to internal relocations, section contents and symbols. */
6724 /* During relaxation, we need to modify relocations, section contents,
6725 and symbol definitions, and we need to keep the original values from
6726 being reloaded from the input files, i.e., we need to "pin" the
6727 modified values in memory. We also want to continue to observe the
6728 setting of the "keep-memory" flag. The following functions wrap the
6729 standard BFD functions to take care of this for us. */
6731 static Elf_Internal_Rela
*
6732 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6734 Elf_Internal_Rela
*internal_relocs
;
6736 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6739 internal_relocs
= elf_section_data (sec
)->relocs
;
6740 if (internal_relocs
== NULL
)
6741 internal_relocs
= (_bfd_elf_link_read_relocs
6742 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6743 return internal_relocs
;
6748 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6750 elf_section_data (sec
)->relocs
= internal_relocs
;
6755 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6758 && elf_section_data (sec
)->relocs
!= internal_relocs
)
6759 free (internal_relocs
);
6764 retrieve_contents (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6767 bfd_size_type sec_size
;
6769 sec_size
= bfd_get_section_limit (abfd
, sec
);
6770 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6772 if (contents
== NULL
&& sec_size
!= 0)
6774 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6781 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6788 pin_contents (asection
*sec
, bfd_byte
*contents
)
6790 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6795 release_contents (asection
*sec
, bfd_byte
*contents
)
6797 if (contents
&& elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6802 static Elf_Internal_Sym
*
6803 retrieve_local_syms (bfd
*input_bfd
)
6805 Elf_Internal_Shdr
*symtab_hdr
;
6806 Elf_Internal_Sym
*isymbuf
;
6809 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6810 locsymcount
= symtab_hdr
->sh_info
;
6812 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6813 if (isymbuf
== NULL
&& locsymcount
!= 0)
6814 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6817 /* Save the symbols for this input file so they won't be read again. */
6818 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6819 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6825 /* Code for link-time relaxation. */
6827 /* Initialization for relaxation: */
6828 static bfd_boolean
analyze_relocations (struct bfd_link_info
*);
6829 static bfd_boolean find_relaxable_sections
6830 (bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*);
6831 static bfd_boolean collect_source_relocs
6832 (bfd
*, asection
*, struct bfd_link_info
*);
6833 static bfd_boolean is_resolvable_asm_expansion
6834 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6836 static Elf_Internal_Rela
*find_associated_l32r_irel
6837 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6838 static bfd_boolean compute_text_actions
6839 (bfd
*, asection
*, struct bfd_link_info
*);
6840 static bfd_boolean
compute_ebb_proposed_actions (ebb_constraint
*);
6841 static bfd_boolean
compute_ebb_actions (ebb_constraint
*);
6842 typedef struct reloc_range_list_struct reloc_range_list
;
6843 static bfd_boolean check_section_ebb_pcrels_fit
6844 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6845 reloc_range_list
*, const ebb_constraint
*,
6846 const xtensa_opcode
*);
6847 static bfd_boolean
check_section_ebb_reduces (const ebb_constraint
*);
6848 static void text_action_add_proposed
6849 (text_action_list
*, const ebb_constraint
*, asection
*);
6850 static int compute_fill_extra_space (property_table_entry
*);
6853 static bfd_boolean compute_removed_literals
6854 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6855 static Elf_Internal_Rela
*get_irel_at_offset
6856 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6857 static bfd_boolean is_removable_literal
6858 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6859 property_table_entry
*, int);
6860 static bfd_boolean remove_dead_literal
6861 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6862 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6863 static bfd_boolean identify_literal_placement
6864 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6865 value_map_hash_table
*, bfd_boolean
*, Elf_Internal_Rela
*, int,
6866 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6868 static bfd_boolean
relocations_reach (source_reloc
*, int, const r_reloc
*);
6869 static bfd_boolean coalesce_shared_literal
6870 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6871 static bfd_boolean move_shared_literal
6872 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6873 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6876 static bfd_boolean
relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6877 static bfd_boolean
translate_section_fixes (asection
*);
6878 static bfd_boolean
translate_reloc_bfd_fix (reloc_bfd_fix
*);
6879 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6880 static void shrink_dynamic_reloc_sections
6881 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6882 static bfd_boolean move_literal
6883 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6884 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6885 static bfd_boolean relax_property_section
6886 (bfd
*, asection
*, struct bfd_link_info
*);
6889 static bfd_boolean
relax_section_symbols (bfd
*, asection
*);
6893 elf_xtensa_relax_section (bfd
*abfd
,
6895 struct bfd_link_info
*link_info
,
6898 static value_map_hash_table
*values
= NULL
;
6899 static bfd_boolean relocations_analyzed
= FALSE
;
6900 xtensa_relax_info
*relax_info
;
6902 if (!relocations_analyzed
)
6904 /* Do some overall initialization for relaxation. */
6905 values
= value_map_hash_table_init ();
6908 relaxing_section
= TRUE
;
6909 if (!analyze_relocations (link_info
))
6911 relocations_analyzed
= TRUE
;
6915 /* Don't mess with linker-created sections. */
6916 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6919 relax_info
= get_xtensa_relax_info (sec
);
6920 BFD_ASSERT (relax_info
!= NULL
);
6922 switch (relax_info
->visited
)
6925 /* Note: It would be nice to fold this pass into
6926 analyze_relocations, but it is important for this step that the
6927 sections be examined in link order. */
6928 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6935 value_map_hash_table_delete (values
);
6937 if (!relax_section (abfd
, sec
, link_info
))
6943 if (!relax_section_symbols (abfd
, sec
))
6948 relax_info
->visited
++;
6953 /* Initialization for relaxation. */
6955 /* This function is called once at the start of relaxation. It scans
6956 all the input sections and marks the ones that are relaxable (i.e.,
6957 literal sections with L32R relocations against them), and then
6958 collects source_reloc information for all the relocations against
6959 those relaxable sections. During this process, it also detects
6960 longcalls, i.e., calls relaxed by the assembler into indirect
6961 calls, that can be optimized back into direct calls. Within each
6962 extended basic block (ebb) containing an optimized longcall, it
6963 computes a set of "text actions" that can be performed to remove
6964 the L32R associated with the longcall while optionally preserving
6965 branch target alignments. */
6968 analyze_relocations (struct bfd_link_info
*link_info
)
6972 bfd_boolean is_relaxable
= FALSE
;
6974 /* Initialize the per-section relaxation info. */
6975 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6976 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6978 init_xtensa_relax_info (sec
);
6981 /* Mark relaxable sections (and count relocations against each one). */
6982 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6983 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6985 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
6989 /* Bail out if there are no relaxable sections. */
6993 /* Allocate space for source_relocs. */
6994 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6995 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6997 xtensa_relax_info
*relax_info
;
6999 relax_info
= get_xtensa_relax_info (sec
);
7000 if (relax_info
->is_relaxable_literal_section
7001 || relax_info
->is_relaxable_asm_section
)
7003 relax_info
->src_relocs
= (source_reloc
*)
7004 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
7007 relax_info
->src_count
= 0;
7010 /* Collect info on relocations against each relaxable section. */
7011 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7012 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7014 if (!collect_source_relocs (abfd
, sec
, link_info
))
7018 /* Compute the text actions. */
7019 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
7020 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7022 if (!compute_text_actions (abfd
, sec
, link_info
))
7030 /* Find all the sections that might be relaxed. The motivation for
7031 this pass is that collect_source_relocs() needs to record _all_ the
7032 relocations that target each relaxable section. That is expensive
7033 and unnecessary unless the target section is actually going to be
7034 relaxed. This pass identifies all such sections by checking if
7035 they have L32Rs pointing to them. In the process, the total number
7036 of relocations targeting each section is also counted so that we
7037 know how much space to allocate for source_relocs against each
7038 relaxable literal section. */
7041 find_relaxable_sections (bfd
*abfd
,
7043 struct bfd_link_info
*link_info
,
7044 bfd_boolean
*is_relaxable_p
)
7046 Elf_Internal_Rela
*internal_relocs
;
7048 bfd_boolean ok
= TRUE
;
7050 xtensa_relax_info
*source_relax_info
;
7051 bfd_boolean is_l32r_reloc
;
7053 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7054 link_info
->keep_memory
);
7055 if (internal_relocs
== NULL
)
7058 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7059 if (contents
== NULL
&& sec
->size
!= 0)
7065 source_relax_info
= get_xtensa_relax_info (sec
);
7066 for (i
= 0; i
< sec
->reloc_count
; i
++)
7068 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7070 asection
*target_sec
;
7071 xtensa_relax_info
*target_relax_info
;
7073 /* If this section has not already been marked as "relaxable", and
7074 if it contains any ASM_EXPAND relocations (marking expanded
7075 longcalls) that can be optimized into direct calls, then mark
7076 the section as "relaxable". */
7077 if (source_relax_info
7078 && !source_relax_info
->is_relaxable_asm_section
7079 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
7081 bfd_boolean is_reachable
= FALSE
;
7082 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
7083 link_info
, &is_reachable
)
7086 source_relax_info
->is_relaxable_asm_section
= TRUE
;
7087 *is_relaxable_p
= TRUE
;
7091 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7092 bfd_get_section_limit (abfd
, sec
));
7094 target_sec
= r_reloc_get_section (&r_rel
);
7095 target_relax_info
= get_xtensa_relax_info (target_sec
);
7096 if (!target_relax_info
)
7099 /* Count PC-relative operand relocations against the target section.
7100 Note: The conditions tested here must match the conditions under
7101 which init_source_reloc is called in collect_source_relocs(). */
7102 is_l32r_reloc
= FALSE
;
7103 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7105 xtensa_opcode opcode
=
7106 get_relocation_opcode (abfd
, sec
, contents
, irel
);
7107 if (opcode
!= XTENSA_UNDEFINED
)
7109 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
7110 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
7112 target_relax_info
->src_count
++;
7116 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7118 /* Mark the target section as relaxable. */
7119 target_relax_info
->is_relaxable_literal_section
= TRUE
;
7120 *is_relaxable_p
= TRUE
;
7125 release_contents (sec
, contents
);
7126 release_internal_relocs (sec
, internal_relocs
);
7131 /* Record _all_ the relocations that point to relaxable sections, and
7132 get rid of ASM_EXPAND relocs by either converting them to
7133 ASM_SIMPLIFY or by removing them. */
7136 collect_source_relocs (bfd
*abfd
,
7138 struct bfd_link_info
*link_info
)
7140 Elf_Internal_Rela
*internal_relocs
;
7142 bfd_boolean ok
= TRUE
;
7144 bfd_size_type sec_size
;
7146 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7147 link_info
->keep_memory
);
7148 if (internal_relocs
== NULL
)
7151 sec_size
= bfd_get_section_limit (abfd
, sec
);
7152 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7153 if (contents
== NULL
&& sec_size
!= 0)
7159 /* Record relocations against relaxable literal sections. */
7160 for (i
= 0; i
< sec
->reloc_count
; i
++)
7162 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7164 asection
*target_sec
;
7165 xtensa_relax_info
*target_relax_info
;
7167 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7169 target_sec
= r_reloc_get_section (&r_rel
);
7170 target_relax_info
= get_xtensa_relax_info (target_sec
);
7172 if (target_relax_info
7173 && (target_relax_info
->is_relaxable_literal_section
7174 || target_relax_info
->is_relaxable_asm_section
))
7176 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7178 bfd_boolean is_abs_literal
= FALSE
;
7180 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7182 /* None of the current alternate relocs are PC-relative,
7183 and only PC-relative relocs matter here. However, we
7184 still need to record the opcode for literal
7186 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7187 if (opcode
== get_l32r_opcode ())
7189 is_abs_literal
= TRUE
;
7193 opcode
= XTENSA_UNDEFINED
;
7195 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7197 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7198 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7201 if (opcode
!= XTENSA_UNDEFINED
)
7203 int src_next
= target_relax_info
->src_next
++;
7204 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7206 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7212 /* Now get rid of ASM_EXPAND relocations. At this point, the
7213 src_relocs array for the target literal section may still be
7214 incomplete, but it must at least contain the entries for the L32R
7215 relocations associated with ASM_EXPANDs because they were just
7216 added in the preceding loop over the relocations. */
7218 for (i
= 0; i
< sec
->reloc_count
; i
++)
7220 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7221 bfd_boolean is_reachable
;
7223 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7229 Elf_Internal_Rela
*l32r_irel
;
7231 asection
*target_sec
;
7232 xtensa_relax_info
*target_relax_info
;
7234 /* Mark the source_reloc for the L32R so that it will be
7235 removed in compute_removed_literals(), along with the
7236 associated literal. */
7237 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7238 irel
, internal_relocs
);
7239 if (l32r_irel
== NULL
)
7242 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7244 target_sec
= r_reloc_get_section (&r_rel
);
7245 target_relax_info
= get_xtensa_relax_info (target_sec
);
7247 if (target_relax_info
7248 && (target_relax_info
->is_relaxable_literal_section
7249 || target_relax_info
->is_relaxable_asm_section
))
7251 source_reloc
*s_reloc
;
7253 /* Search the source_relocs for the entry corresponding to
7254 the l32r_irel. Note: The src_relocs array is not yet
7255 sorted, but it wouldn't matter anyway because we're
7256 searching by source offset instead of target offset. */
7257 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7258 target_relax_info
->src_next
,
7260 BFD_ASSERT (s_reloc
);
7261 s_reloc
->is_null
= TRUE
;
7264 /* Convert this reloc to ASM_SIMPLIFY. */
7265 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7266 R_XTENSA_ASM_SIMPLIFY
);
7267 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7269 pin_internal_relocs (sec
, internal_relocs
);
7273 /* It is resolvable but doesn't reach. We resolve now
7274 by eliminating the relocation -- the call will remain
7275 expanded into L32R/CALLX. */
7276 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7277 pin_internal_relocs (sec
, internal_relocs
);
7282 release_contents (sec
, contents
);
7283 release_internal_relocs (sec
, internal_relocs
);
7288 /* Return TRUE if the asm expansion can be resolved. Generally it can
7289 be resolved on a final link or when a partial link locates it in the
7290 same section as the target. Set "is_reachable" flag if the target of
7291 the call is within the range of a direct call, given the current VMA
7292 for this section and the target section. */
7295 is_resolvable_asm_expansion (bfd
*abfd
,
7298 Elf_Internal_Rela
*irel
,
7299 struct bfd_link_info
*link_info
,
7300 bfd_boolean
*is_reachable_p
)
7302 asection
*target_sec
;
7303 bfd_vma target_offset
;
7305 xtensa_opcode opcode
, direct_call_opcode
;
7306 bfd_vma self_address
;
7307 bfd_vma dest_address
;
7308 bfd_boolean uses_l32r
;
7309 bfd_size_type sec_size
;
7311 *is_reachable_p
= FALSE
;
7313 if (contents
== NULL
)
7316 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7319 sec_size
= bfd_get_section_limit (abfd
, sec
);
7320 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7321 sec_size
- irel
->r_offset
, &uses_l32r
);
7322 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7326 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7327 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7330 /* Check and see that the target resolves. */
7331 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7332 if (!r_reloc_is_defined (&r_rel
))
7335 target_sec
= r_reloc_get_section (&r_rel
);
7336 target_offset
= r_rel
.target_offset
;
7338 /* If the target is in a shared library, then it doesn't reach. This
7339 isn't supposed to come up because the compiler should never generate
7340 non-PIC calls on systems that use shared libraries, but the linker
7341 shouldn't crash regardless. */
7342 if (!target_sec
->output_section
)
7345 /* For relocatable sections, we can only simplify when the output
7346 section of the target is the same as the output section of the
7348 if (bfd_link_relocatable (link_info
)
7349 && (target_sec
->output_section
!= sec
->output_section
7350 || is_reloc_sym_weak (abfd
, irel
)))
7353 if (target_sec
->output_section
!= sec
->output_section
)
7355 /* If the two sections are sufficiently far away that relaxation
7356 might take the call out of range, we can't simplify. For
7357 example, a positive displacement call into another memory
7358 could get moved to a lower address due to literal removal,
7359 but the destination won't move, and so the displacment might
7362 If the displacement is negative, assume the destination could
7363 move as far back as the start of the output section. The
7364 self_address will be at least as far into the output section
7365 as it is prior to relaxation.
7367 If the displacement is postive, assume the destination will be in
7368 it's pre-relaxed location (because relaxation only makes sections
7369 smaller). The self_address could go all the way to the beginning
7370 of the output section. */
7372 dest_address
= target_sec
->output_section
->vma
;
7373 self_address
= sec
->output_section
->vma
;
7375 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7376 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7378 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7379 /* Call targets should be four-byte aligned. */
7380 dest_address
= (dest_address
+ 3) & ~3;
7385 self_address
= (sec
->output_section
->vma
7386 + sec
->output_offset
+ irel
->r_offset
+ 3);
7387 dest_address
= (target_sec
->output_section
->vma
7388 + target_sec
->output_offset
+ target_offset
);
7391 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7392 self_address
, dest_address
);
7394 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7395 (dest_address
>> CALL_SEGMENT_BITS
))
7402 static Elf_Internal_Rela
*
7403 find_associated_l32r_irel (bfd
*abfd
,
7406 Elf_Internal_Rela
*other_irel
,
7407 Elf_Internal_Rela
*internal_relocs
)
7411 for (i
= 0; i
< sec
->reloc_count
; i
++)
7413 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7415 if (irel
== other_irel
)
7417 if (irel
->r_offset
!= other_irel
->r_offset
)
7419 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7427 static xtensa_opcode
*
7428 build_reloc_opcodes (bfd
*abfd
,
7431 Elf_Internal_Rela
*internal_relocs
)
7434 xtensa_opcode
*reloc_opcodes
=
7435 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7436 for (i
= 0; i
< sec
->reloc_count
; i
++)
7438 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7439 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7441 return reloc_opcodes
;
7444 struct reloc_range_struct
7447 bfd_boolean add
; /* TRUE if start of a range, FALSE otherwise. */
7448 /* Original irel index in the array of relocations for a section. */
7449 unsigned irel_index
;
7451 typedef struct reloc_range_struct reloc_range
;
7453 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7454 struct reloc_range_list_entry_struct
7456 reloc_range_list_entry
*next
;
7457 reloc_range_list_entry
*prev
;
7458 Elf_Internal_Rela
*irel
;
7459 xtensa_opcode opcode
;
7463 struct reloc_range_list_struct
7465 /* The rest of the structure is only meaningful when ok is TRUE. */
7468 unsigned n_range
; /* Number of range markers. */
7469 reloc_range
*range
; /* Sorted range markers. */
7471 unsigned first
; /* Index of a first range element in the list. */
7472 unsigned last
; /* One past index of a last range element in the list. */
7474 unsigned n_list
; /* Number of list elements. */
7475 reloc_range_list_entry
*reloc
; /* */
7476 reloc_range_list_entry list_root
;
7480 reloc_range_compare (const void *a
, const void *b
)
7482 const reloc_range
*ra
= a
;
7483 const reloc_range
*rb
= b
;
7485 if (ra
->addr
!= rb
->addr
)
7486 return ra
->addr
< rb
->addr
? -1 : 1;
7487 if (ra
->add
!= rb
->add
)
7488 return ra
->add
? -1 : 1;
7493 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7495 Elf_Internal_Rela
*internal_relocs
,
7496 xtensa_opcode
*reloc_opcodes
,
7497 reloc_range_list
*list
)
7502 reloc_range
*ranges
= NULL
;
7503 reloc_range_list_entry
*reloc
=
7504 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7506 memset (list
, 0, sizeof (*list
));
7509 for (i
= 0; i
< sec
->reloc_count
; i
++)
7511 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7512 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7513 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7516 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7517 || r_type
== R_XTENSA_32_PCREL
7518 || !howto
->pc_relative
)
7521 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7522 bfd_get_section_limit (abfd
, sec
));
7524 if (r_reloc_get_section (&r_rel
) != sec
)
7529 max_n
= (max_n
+ 2) * 2;
7530 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7533 ranges
[n
].addr
= irel
->r_offset
;
7534 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7536 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7537 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7539 ranges
[n
].irel_index
= i
;
7540 ranges
[n
+ 1].irel_index
= i
;
7544 reloc
[i
].irel
= irel
;
7546 /* Every relocation won't possibly be checked in the optimized version of
7547 check_section_ebb_pcrels_fit, so this needs to be done here. */
7548 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7550 /* None of the current alternate relocs are PC-relative,
7551 and only PC-relative relocs matter here. */
7555 xtensa_opcode opcode
;
7559 opcode
= reloc_opcodes
[i
];
7561 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7563 if (opcode
== XTENSA_UNDEFINED
)
7569 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7570 if (opnum
== XTENSA_UNDEFINED
)
7576 /* Record relocation opcode and opnum as we've calculated them
7577 anyway and they won't change. */
7578 reloc
[i
].opcode
= opcode
;
7579 reloc
[i
].opnum
= opnum
;
7585 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7586 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7589 list
->range
= ranges
;
7590 list
->reloc
= reloc
;
7591 list
->list_root
.prev
= &list
->list_root
;
7592 list
->list_root
.next
= &list
->list_root
;
7601 static void reloc_range_list_append (reloc_range_list
*list
,
7602 unsigned irel_index
)
7604 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7606 entry
->prev
= list
->list_root
.prev
;
7607 entry
->next
= &list
->list_root
;
7608 entry
->prev
->next
= entry
;
7609 entry
->next
->prev
= entry
;
7613 static void reloc_range_list_remove (reloc_range_list
*list
,
7614 unsigned irel_index
)
7616 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7618 entry
->next
->prev
= entry
->prev
;
7619 entry
->prev
->next
= entry
->next
;
7623 /* Update relocation list object so that it lists all relocations that cross
7624 [first; last] range. Range bounds should not decrease with successive
7626 static void reloc_range_list_update_range (reloc_range_list
*list
,
7627 bfd_vma first
, bfd_vma last
)
7629 /* This should not happen: EBBs are iterated from lower addresses to higher.
7630 But even if that happens there's no need to break: just flush current list
7631 and start from scratch. */
7632 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7633 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7638 list
->list_root
.next
= &list
->list_root
;
7639 list
->list_root
.prev
= &list
->list_root
;
7640 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7643 for (; list
->last
< list
->n_range
&&
7644 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7645 if (list
->range
[list
->last
].add
)
7646 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7648 for (; list
->first
< list
->n_range
&&
7649 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7650 if (!list
->range
[list
->first
].add
)
7651 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7654 static void free_reloc_range_list (reloc_range_list
*list
)
7660 /* The compute_text_actions function will build a list of potential
7661 transformation actions for code in the extended basic block of each
7662 longcall that is optimized to a direct call. From this list we
7663 generate a set of actions to actually perform that optimizes for
7664 space and, if not using size_opt, maintains branch target
7667 These actions to be performed are placed on a per-section list.
7668 The actual changes are performed by relax_section() in the second
7672 compute_text_actions (bfd
*abfd
,
7674 struct bfd_link_info
*link_info
)
7676 xtensa_opcode
*reloc_opcodes
= NULL
;
7677 xtensa_relax_info
*relax_info
;
7679 Elf_Internal_Rela
*internal_relocs
;
7680 bfd_boolean ok
= TRUE
;
7682 property_table_entry
*prop_table
= 0;
7684 bfd_size_type sec_size
;
7685 reloc_range_list relevant_relocs
;
7687 relax_info
= get_xtensa_relax_info (sec
);
7688 BFD_ASSERT (relax_info
);
7689 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7691 /* Do nothing if the section contains no optimized longcalls. */
7692 if (!relax_info
->is_relaxable_asm_section
)
7695 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7696 link_info
->keep_memory
);
7698 if (internal_relocs
)
7699 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7700 internal_reloc_compare
);
7702 sec_size
= bfd_get_section_limit (abfd
, sec
);
7703 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7704 if (contents
== NULL
&& sec_size
!= 0)
7710 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7711 XTENSA_PROP_SEC_NAME
, FALSE
);
7718 /* Precompute the opcode for each relocation. */
7719 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7721 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7724 for (i
= 0; i
< sec
->reloc_count
; i
++)
7726 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7728 property_table_entry
*the_entry
;
7731 ebb_constraint ebb_table
;
7732 bfd_size_type simplify_size
;
7734 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7736 r_offset
= irel
->r_offset
;
7738 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7739 if (simplify_size
== 0)
7742 /* xgettext:c-format */
7743 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
7744 sec
->owner
, sec
, r_offset
);
7748 /* If the instruction table is not around, then don't do this
7750 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7751 sec
->vma
+ irel
->r_offset
);
7752 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7754 text_action_add (&relax_info
->action_list
,
7755 ta_convert_longcall
, sec
, r_offset
,
7760 /* If the next longcall happens to be at the same address as an
7761 unreachable section of size 0, then skip forward. */
7762 ptbl_idx
= the_entry
- prop_table
;
7763 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7764 && the_entry
->size
== 0
7765 && ptbl_idx
+ 1 < ptblsize
7766 && (prop_table
[ptbl_idx
+ 1].address
7767 == prop_table
[ptbl_idx
].address
))
7773 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7774 /* NO_REORDER is OK */
7777 init_ebb_constraint (&ebb_table
);
7778 ebb
= &ebb_table
.ebb
;
7779 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7780 internal_relocs
, sec
->reloc_count
);
7781 ebb
->start_offset
= r_offset
+ simplify_size
;
7782 ebb
->end_offset
= r_offset
+ simplify_size
;
7783 ebb
->start_ptbl_idx
= ptbl_idx
;
7784 ebb
->end_ptbl_idx
= ptbl_idx
;
7785 ebb
->start_reloc_idx
= i
;
7786 ebb
->end_reloc_idx
= i
;
7788 if (!extend_ebb_bounds (ebb
)
7789 || !compute_ebb_proposed_actions (&ebb_table
)
7790 || !compute_ebb_actions (&ebb_table
)
7791 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7794 &ebb_table
, reloc_opcodes
)
7795 || !check_section_ebb_reduces (&ebb_table
))
7797 /* If anything goes wrong or we get unlucky and something does
7798 not fit, with our plan because of expansion between
7799 critical branches, just convert to a NOP. */
7801 text_action_add (&relax_info
->action_list
,
7802 ta_convert_longcall
, sec
, r_offset
, 0);
7803 i
= ebb_table
.ebb
.end_reloc_idx
;
7804 free_ebb_constraint (&ebb_table
);
7808 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7810 /* Update the index so we do not go looking at the relocations
7811 we have already processed. */
7812 i
= ebb_table
.ebb
.end_reloc_idx
;
7813 free_ebb_constraint (&ebb_table
);
7816 free_reloc_range_list (&relevant_relocs
);
7819 if (action_list_count (&relax_info
->action_list
))
7820 print_action_list (stderr
, &relax_info
->action_list
);
7824 release_contents (sec
, contents
);
7825 release_internal_relocs (sec
, internal_relocs
);
7829 free (reloc_opcodes
);
7835 /* Do not widen an instruction if it is preceeded by a
7836 loop opcode. It might cause misalignment. */
7839 prev_instr_is_a_loop (bfd_byte
*contents
,
7840 bfd_size_type content_length
,
7841 bfd_size_type offset
)
7843 xtensa_opcode prev_opcode
;
7847 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7848 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7852 /* Find all of the possible actions for an extended basic block. */
7855 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7857 const ebb_t
*ebb
= &ebb_table
->ebb
;
7858 unsigned rel_idx
= ebb
->start_reloc_idx
;
7859 property_table_entry
*entry
, *start_entry
, *end_entry
;
7861 xtensa_isa isa
= xtensa_default_isa
;
7863 static xtensa_insnbuf insnbuf
= NULL
;
7864 static xtensa_insnbuf slotbuf
= NULL
;
7866 if (insnbuf
== NULL
)
7868 insnbuf
= xtensa_insnbuf_alloc (isa
);
7869 slotbuf
= xtensa_insnbuf_alloc (isa
);
7872 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7873 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7875 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7877 bfd_vma start_offset
, end_offset
;
7878 bfd_size_type insn_len
;
7880 start_offset
= entry
->address
- ebb
->sec
->vma
;
7881 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7883 if (entry
== start_entry
)
7884 start_offset
= ebb
->start_offset
;
7885 if (entry
== end_entry
)
7886 end_offset
= ebb
->end_offset
;
7887 offset
= start_offset
;
7889 if (offset
== entry
->address
- ebb
->sec
->vma
7890 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7892 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7893 BFD_ASSERT (offset
!= end_offset
);
7894 if (offset
== end_offset
)
7897 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7902 if (check_branch_target_aligned_address (offset
, insn_len
))
7903 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7905 ebb_propose_action (ebb_table
, align_type
, 0,
7906 ta_none
, offset
, 0, TRUE
);
7909 while (offset
!= end_offset
)
7911 Elf_Internal_Rela
*irel
;
7912 xtensa_opcode opcode
;
7914 while (rel_idx
< ebb
->end_reloc_idx
7915 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7916 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7917 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
7918 != R_XTENSA_ASM_SIMPLIFY
))))
7921 /* Check for longcall. */
7922 irel
= &ebb
->relocs
[rel_idx
];
7923 if (irel
->r_offset
== offset
7924 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
7926 bfd_size_type simplify_size
;
7928 simplify_size
= get_asm_simplify_size (ebb
->contents
,
7929 ebb
->content_length
,
7931 if (simplify_size
== 0)
7934 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7935 ta_convert_longcall
, offset
, 0, TRUE
);
7937 offset
+= simplify_size
;
7941 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
7943 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
7944 ebb
->content_length
- offset
);
7945 fmt
= xtensa_format_decode (isa
, insnbuf
);
7946 if (fmt
== XTENSA_UNDEFINED
)
7948 insn_len
= xtensa_format_length (isa
, fmt
);
7949 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
7952 if (xtensa_format_num_slots (isa
, fmt
) != 1)
7958 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
7959 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
7960 if (opcode
== XTENSA_UNDEFINED
)
7963 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
7964 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
7965 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
7967 /* Add an instruction narrow action. */
7968 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7969 ta_narrow_insn
, offset
, 0, FALSE
);
7971 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
7972 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
7973 && ! prev_instr_is_a_loop (ebb
->contents
,
7974 ebb
->content_length
, offset
))
7976 /* Add an instruction widen action. */
7977 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7978 ta_widen_insn
, offset
, 0, FALSE
);
7980 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
7982 /* Check for branch targets. */
7983 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
7984 ta_none
, offset
, 0, TRUE
);
7991 if (ebb
->ends_unreachable
)
7993 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7994 ta_fill
, ebb
->end_offset
, 0, TRUE
);
8001 /* xgettext:c-format */
8002 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
8003 ebb
->sec
->owner
, ebb
->sec
, offset
);
8008 /* After all of the information has collected about the
8009 transformations possible in an EBB, compute the appropriate actions
8010 here in compute_ebb_actions. We still must check later to make
8011 sure that the actions do not break any relocations. The algorithm
8012 used here is pretty greedy. Basically, it removes as many no-ops
8013 as possible so that the end of the EBB has the same alignment
8014 characteristics as the original. First, it uses narrowing, then
8015 fill space at the end of the EBB, and finally widenings. If that
8016 does not work, it tries again with one fewer no-op removed. The
8017 optimization will only be performed if all of the branch targets
8018 that were aligned before transformation are also aligned after the
8021 When the size_opt flag is set, ignore the branch target alignments,
8022 narrow all wide instructions, and remove all no-ops unless the end
8023 of the EBB prevents it. */
8026 compute_ebb_actions (ebb_constraint
*ebb_table
)
8030 int removed_bytes
= 0;
8031 ebb_t
*ebb
= &ebb_table
->ebb
;
8032 unsigned seg_idx_start
= 0;
8033 unsigned seg_idx_end
= 0;
8035 /* We perform this like the assembler relaxation algorithm: Start by
8036 assuming all instructions are narrow and all no-ops removed; then
8039 /* For each segment of this that has a solid constraint, check to
8040 see if there are any combinations that will keep the constraint.
8042 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
8044 bfd_boolean requires_text_end_align
= FALSE
;
8045 unsigned longcall_count
= 0;
8046 unsigned longcall_convert_count
= 0;
8047 unsigned narrowable_count
= 0;
8048 unsigned narrowable_convert_count
= 0;
8049 unsigned widenable_count
= 0;
8050 unsigned widenable_convert_count
= 0;
8052 proposed_action
*action
= NULL
;
8053 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
8055 seg_idx_start
= seg_idx_end
;
8057 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
8059 action
= &ebb_table
->actions
[i
];
8060 if (action
->action
== ta_convert_longcall
)
8062 if (action
->action
== ta_narrow_insn
)
8064 if (action
->action
== ta_widen_insn
)
8066 if (action
->action
== ta_fill
)
8068 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8070 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
8071 && !elf32xtensa_size_opt
)
8076 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
8077 requires_text_end_align
= TRUE
;
8079 if (elf32xtensa_size_opt
&& !requires_text_end_align
8080 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
8081 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
8083 longcall_convert_count
= longcall_count
;
8084 narrowable_convert_count
= narrowable_count
;
8085 widenable_convert_count
= 0;
8089 /* There is a constraint. Convert the max number of longcalls. */
8090 narrowable_convert_count
= 0;
8091 longcall_convert_count
= 0;
8092 widenable_convert_count
= 0;
8094 for (j
= 0; j
< longcall_count
; j
++)
8096 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
8097 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
8098 unsigned desire_widen
= removed
;
8099 if (desire_narrow
<= narrowable_count
)
8101 narrowable_convert_count
= desire_narrow
;
8102 narrowable_convert_count
+=
8103 (align
* ((narrowable_count
- narrowable_convert_count
)
8105 longcall_convert_count
= (longcall_count
- j
);
8106 widenable_convert_count
= 0;
8109 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
8111 narrowable_convert_count
= 0;
8112 longcall_convert_count
= longcall_count
- j
;
8113 widenable_convert_count
= desire_widen
;
8119 /* Now the number of conversions are saved. Do them. */
8120 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
8122 action
= &ebb_table
->actions
[i
];
8123 switch (action
->action
)
8125 case ta_convert_longcall
:
8126 if (longcall_convert_count
!= 0)
8128 action
->action
= ta_remove_longcall
;
8129 action
->do_action
= TRUE
;
8130 action
->removed_bytes
+= 3;
8131 longcall_convert_count
--;
8134 case ta_narrow_insn
:
8135 if (narrowable_convert_count
!= 0)
8137 action
->do_action
= TRUE
;
8138 action
->removed_bytes
+= 1;
8139 narrowable_convert_count
--;
8143 if (widenable_convert_count
!= 0)
8145 action
->do_action
= TRUE
;
8146 action
->removed_bytes
-= 1;
8147 widenable_convert_count
--;
8156 /* Now we move on to some local opts. Try to remove each of the
8157 remaining longcalls. */
8159 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8162 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8164 int old_removed_bytes
= removed_bytes
;
8165 proposed_action
*action
= &ebb_table
->actions
[i
];
8167 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8169 bfd_boolean bad_alignment
= FALSE
;
8171 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8173 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8174 bfd_vma offset
= new_action
->offset
;
8175 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8177 if (!check_branch_target_aligned
8178 (ebb_table
->ebb
.contents
,
8179 ebb_table
->ebb
.content_length
,
8180 offset
, offset
- removed_bytes
))
8182 bad_alignment
= TRUE
;
8186 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8188 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8189 ebb_table
->ebb
.content_length
,
8191 offset
- removed_bytes
))
8193 bad_alignment
= TRUE
;
8197 if (new_action
->action
== ta_narrow_insn
8198 && !new_action
->do_action
8199 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8201 /* Narrow an instruction and we are done. */
8202 new_action
->do_action
= TRUE
;
8203 new_action
->removed_bytes
+= 1;
8204 bad_alignment
= FALSE
;
8207 if (new_action
->action
== ta_widen_insn
8208 && new_action
->do_action
8209 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8211 /* Narrow an instruction and we are done. */
8212 new_action
->do_action
= FALSE
;
8213 new_action
->removed_bytes
+= 1;
8214 bad_alignment
= FALSE
;
8217 if (new_action
->do_action
)
8218 removed_bytes
+= new_action
->removed_bytes
;
8222 action
->removed_bytes
+= 3;
8223 action
->action
= ta_remove_longcall
;
8224 action
->do_action
= TRUE
;
8227 removed_bytes
= old_removed_bytes
;
8228 if (action
->do_action
)
8229 removed_bytes
+= action
->removed_bytes
;
8234 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8236 proposed_action
*action
= &ebb_table
->actions
[i
];
8237 if (action
->do_action
)
8238 removed_bytes
+= action
->removed_bytes
;
8241 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8242 && ebb
->ends_unreachable
)
8244 proposed_action
*action
;
8248 BFD_ASSERT (ebb_table
->action_count
!= 0);
8249 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8250 BFD_ASSERT (action
->action
== ta_fill
);
8251 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8253 extra_space
= compute_fill_extra_space (ebb
->ends_unreachable
);
8254 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8255 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8257 action
->removed_bytes
= extra_space
- br
;
8263 /* The xlate_map is a sorted array of address mappings designed to
8264 answer the offset_with_removed_text() query with a binary search instead
8265 of a linear search through the section's action_list. */
8267 typedef struct xlate_map_entry xlate_map_entry_t
;
8268 typedef struct xlate_map xlate_map_t
;
8270 struct xlate_map_entry
8272 unsigned orig_address
;
8273 unsigned new_address
;
8279 unsigned entry_count
;
8280 xlate_map_entry_t
*entry
;
8285 xlate_compare (const void *a_v
, const void *b_v
)
8287 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8288 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8289 if (a
->orig_address
< b
->orig_address
)
8291 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8298 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8299 text_action_list
*action_list
,
8303 xlate_map_entry_t
*e
;
8306 return offset_with_removed_text (action_list
, offset
);
8308 if (map
->entry_count
== 0)
8311 r
= bsearch (&offset
, map
->entry
, map
->entry_count
,
8312 sizeof (xlate_map_entry_t
), &xlate_compare
);
8313 e
= (xlate_map_entry_t
*) r
;
8315 BFD_ASSERT (e
!= NULL
);
8318 return e
->new_address
- e
->orig_address
+ offset
;
8321 typedef struct xlate_map_context_struct xlate_map_context
;
8322 struct xlate_map_context_struct
8325 xlate_map_entry_t
*current_entry
;
8330 xlate_map_fn (splay_tree_node node
, void *p
)
8332 text_action
*r
= (text_action
*)node
->value
;
8333 xlate_map_context
*ctx
= p
;
8334 unsigned orig_size
= 0;
8339 case ta_remove_insn
:
8340 case ta_convert_longcall
:
8341 case ta_remove_literal
:
8342 case ta_add_literal
:
8344 case ta_remove_longcall
:
8347 case ta_narrow_insn
:
8356 ctx
->current_entry
->size
=
8357 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8358 if (ctx
->current_entry
->size
!= 0)
8360 ctx
->current_entry
++;
8361 ctx
->map
->entry_count
++;
8363 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8364 ctx
->removed
+= r
->removed_bytes
;
8365 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8366 ctx
->current_entry
->size
= 0;
8370 /* Build a binary searchable offset translation map from a section's
8373 static xlate_map_t
*
8374 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8376 text_action_list
*action_list
= &relax_info
->action_list
;
8377 unsigned num_actions
= 0;
8378 xlate_map_context ctx
;
8380 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8382 if (ctx
.map
== NULL
)
8385 num_actions
= action_list_count (action_list
);
8386 ctx
.map
->entry
= (xlate_map_entry_t
*)
8387 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8388 if (ctx
.map
->entry
== NULL
)
8393 ctx
.map
->entry_count
= 0;
8396 ctx
.current_entry
= &ctx
.map
->entry
[0];
8398 ctx
.current_entry
->orig_address
= 0;
8399 ctx
.current_entry
->new_address
= 0;
8400 ctx
.current_entry
->size
= 0;
8402 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8404 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8405 - ctx
.current_entry
->orig_address
);
8406 if (ctx
.current_entry
->size
!= 0)
8407 ctx
.map
->entry_count
++;
8413 /* Free an offset translation map. */
8416 free_xlate_map (xlate_map_t
*map
)
8418 if (map
&& map
->entry
)
8425 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8426 relocations in a section will fit if a proposed set of actions
8430 check_section_ebb_pcrels_fit (bfd
*abfd
,
8433 Elf_Internal_Rela
*internal_relocs
,
8434 reloc_range_list
*relevant_relocs
,
8435 const ebb_constraint
*constraint
,
8436 const xtensa_opcode
*reloc_opcodes
)
8439 unsigned n
= sec
->reloc_count
;
8440 Elf_Internal_Rela
*irel
;
8441 xlate_map_t
*xmap
= NULL
;
8442 bfd_boolean ok
= TRUE
;
8443 xtensa_relax_info
*relax_info
;
8444 reloc_range_list_entry
*entry
= NULL
;
8446 relax_info
= get_xtensa_relax_info (sec
);
8448 if (relax_info
&& sec
->reloc_count
> 100)
8450 xmap
= build_xlate_map (sec
, relax_info
);
8451 /* NULL indicates out of memory, but the slow version
8452 can still be used. */
8455 if (relevant_relocs
&& constraint
->action_count
)
8457 if (!relevant_relocs
->ok
)
8464 bfd_vma min_offset
, max_offset
;
8465 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8467 for (i
= 1; i
< constraint
->action_count
; ++i
)
8469 proposed_action
*action
= &constraint
->actions
[i
];
8470 bfd_vma offset
= action
->offset
;
8472 if (offset
< min_offset
)
8473 min_offset
= offset
;
8474 if (offset
> max_offset
)
8475 max_offset
= offset
;
8477 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8479 n
= relevant_relocs
->n_list
;
8480 entry
= &relevant_relocs
->list_root
;
8485 relevant_relocs
= NULL
;
8488 for (i
= 0; i
< n
; i
++)
8491 bfd_vma orig_self_offset
, orig_target_offset
;
8492 bfd_vma self_offset
, target_offset
;
8494 reloc_howto_type
*howto
;
8495 int self_removed_bytes
, target_removed_bytes
;
8497 if (relevant_relocs
)
8499 entry
= entry
->next
;
8504 irel
= internal_relocs
+ i
;
8506 r_type
= ELF32_R_TYPE (irel
->r_info
);
8508 howto
= &elf_howto_table
[r_type
];
8509 /* We maintain the required invariant: PC-relative relocations
8510 that fit before linking must fit after linking. Thus we only
8511 need to deal with relocations to the same section that are
8513 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8514 || r_type
== R_XTENSA_32_PCREL
8515 || !howto
->pc_relative
)
8518 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8519 bfd_get_section_limit (abfd
, sec
));
8521 if (r_reloc_get_section (&r_rel
) != sec
)
8524 orig_self_offset
= irel
->r_offset
;
8525 orig_target_offset
= r_rel
.target_offset
;
8527 self_offset
= orig_self_offset
;
8528 target_offset
= orig_target_offset
;
8533 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8536 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8537 orig_target_offset
);
8540 self_removed_bytes
= 0;
8541 target_removed_bytes
= 0;
8543 for (j
= 0; j
< constraint
->action_count
; ++j
)
8545 proposed_action
*action
= &constraint
->actions
[j
];
8546 bfd_vma offset
= action
->offset
;
8547 int removed_bytes
= action
->removed_bytes
;
8548 if (offset
< orig_self_offset
8549 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8550 && action
->removed_bytes
< 0))
8551 self_removed_bytes
+= removed_bytes
;
8552 if (offset
< orig_target_offset
8553 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8554 && action
->removed_bytes
< 0))
8555 target_removed_bytes
+= removed_bytes
;
8557 self_offset
-= self_removed_bytes
;
8558 target_offset
-= target_removed_bytes
;
8560 /* Try to encode it. Get the operand and check. */
8561 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8563 /* None of the current alternate relocs are PC-relative,
8564 and only PC-relative relocs matter here. */
8568 xtensa_opcode opcode
;
8571 if (relevant_relocs
)
8573 opcode
= entry
->opcode
;
8574 opnum
= entry
->opnum
;
8579 opcode
= reloc_opcodes
[relevant_relocs
?
8580 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8582 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8583 if (opcode
== XTENSA_UNDEFINED
)
8589 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8590 if (opnum
== XTENSA_UNDEFINED
)
8597 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8606 free_xlate_map (xmap
);
8613 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8618 for (i
= 0; i
< constraint
->action_count
; i
++)
8620 const proposed_action
*action
= &constraint
->actions
[i
];
8621 if (action
->do_action
)
8622 removed
+= action
->removed_bytes
;
8632 text_action_add_proposed (text_action_list
*l
,
8633 const ebb_constraint
*ebb_table
,
8638 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8640 proposed_action
*action
= &ebb_table
->actions
[i
];
8642 if (!action
->do_action
)
8644 switch (action
->action
)
8646 case ta_remove_insn
:
8647 case ta_remove_longcall
:
8648 case ta_convert_longcall
:
8649 case ta_narrow_insn
:
8652 case ta_remove_literal
:
8653 text_action_add (l
, action
->action
, sec
, action
->offset
,
8654 action
->removed_bytes
);
8667 compute_fill_extra_space (property_table_entry
*entry
)
8669 int fill_extra_space
;
8674 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8677 fill_extra_space
= entry
->size
;
8678 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8680 /* Fill bytes for alignment:
8681 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8682 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8683 int nsm
= (1 << pow
) - 1;
8684 bfd_vma addr
= entry
->address
+ entry
->size
;
8685 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8686 fill_extra_space
+= align_fill
;
8688 return fill_extra_space
;
8692 /* First relaxation pass. */
8694 /* If the section contains relaxable literals, check each literal to
8695 see if it has the same value as another literal that has already
8696 been seen, either in the current section or a previous one. If so,
8697 add an entry to the per-section list of removed literals. The
8698 actual changes are deferred until the next pass. */
8701 compute_removed_literals (bfd
*abfd
,
8703 struct bfd_link_info
*link_info
,
8704 value_map_hash_table
*values
)
8706 xtensa_relax_info
*relax_info
;
8708 Elf_Internal_Rela
*internal_relocs
;
8709 source_reloc
*src_relocs
, *rel
;
8710 bfd_boolean ok
= TRUE
;
8711 property_table_entry
*prop_table
= NULL
;
8714 bfd_boolean last_loc_is_prev
= FALSE
;
8715 bfd_vma last_target_offset
= 0;
8716 section_cache_t target_sec_cache
;
8717 bfd_size_type sec_size
;
8719 init_section_cache (&target_sec_cache
);
8721 /* Do nothing if it is not a relaxable literal section. */
8722 relax_info
= get_xtensa_relax_info (sec
);
8723 BFD_ASSERT (relax_info
);
8724 if (!relax_info
->is_relaxable_literal_section
)
8727 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8728 link_info
->keep_memory
);
8730 sec_size
= bfd_get_section_limit (abfd
, sec
);
8731 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8732 if (contents
== NULL
&& sec_size
!= 0)
8738 /* Sort the source_relocs by target offset. */
8739 src_relocs
= relax_info
->src_relocs
;
8740 qsort (src_relocs
, relax_info
->src_count
,
8741 sizeof (source_reloc
), source_reloc_compare
);
8742 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8743 internal_reloc_compare
);
8745 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8746 XTENSA_PROP_SEC_NAME
, FALSE
);
8754 for (i
= 0; i
< relax_info
->src_count
; i
++)
8756 Elf_Internal_Rela
*irel
= NULL
;
8758 rel
= &src_relocs
[i
];
8759 if (get_l32r_opcode () != rel
->opcode
)
8761 irel
= get_irel_at_offset (sec
, internal_relocs
,
8762 rel
->r_rel
.target_offset
);
8764 /* If the relocation on this is not a simple R_XTENSA_32 or
8765 R_XTENSA_PLT then do not consider it. This may happen when
8766 the difference of two symbols is used in a literal. */
8767 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8768 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8771 /* If the target_offset for this relocation is the same as the
8772 previous relocation, then we've already considered whether the
8773 literal can be coalesced. Skip to the next one.... */
8774 if (i
!= 0 && prev_i
!= -1
8775 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8779 if (last_loc_is_prev
&&
8780 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8781 last_loc_is_prev
= FALSE
;
8783 /* Check if the relocation was from an L32R that is being removed
8784 because a CALLX was converted to a direct CALL, and check if
8785 there are no other relocations to the literal. */
8786 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8787 sec
, prop_table
, ptblsize
))
8789 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8790 irel
, rel
, prop_table
, ptblsize
))
8795 last_target_offset
= rel
->r_rel
.target_offset
;
8799 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8801 &last_loc_is_prev
, irel
,
8802 relax_info
->src_count
- i
, rel
,
8803 prop_table
, ptblsize
,
8804 &target_sec_cache
, rel
->is_abs_literal
))
8809 last_target_offset
= rel
->r_rel
.target_offset
;
8813 print_removed_literals (stderr
, &relax_info
->removed_list
);
8814 print_action_list (stderr
, &relax_info
->action_list
);
8820 free_section_cache (&target_sec_cache
);
8822 release_contents (sec
, contents
);
8823 release_internal_relocs (sec
, internal_relocs
);
8828 static Elf_Internal_Rela
*
8829 get_irel_at_offset (asection
*sec
,
8830 Elf_Internal_Rela
*internal_relocs
,
8834 Elf_Internal_Rela
*irel
;
8836 Elf_Internal_Rela key
;
8838 if (!internal_relocs
)
8841 key
.r_offset
= offset
;
8842 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8843 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8847 /* bsearch does not guarantee which will be returned if there are
8848 multiple matches. We need the first that is not an alignment. */
8849 i
= irel
- internal_relocs
;
8852 if (internal_relocs
[i
-1].r_offset
!= offset
)
8856 for ( ; i
< sec
->reloc_count
; i
++)
8858 irel
= &internal_relocs
[i
];
8859 r_type
= ELF32_R_TYPE (irel
->r_info
);
8860 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8869 is_removable_literal (const source_reloc
*rel
,
8871 const source_reloc
*src_relocs
,
8874 property_table_entry
*prop_table
,
8877 const source_reloc
*curr_rel
;
8878 property_table_entry
*entry
;
8883 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8884 sec
->vma
+ rel
->r_rel
.target_offset
);
8885 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8888 for (++i
; i
< src_count
; ++i
)
8890 curr_rel
= &src_relocs
[i
];
8891 /* If all others have the same target offset.... */
8892 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8895 if (!curr_rel
->is_null
8896 && !xtensa_is_property_section (curr_rel
->source_sec
)
8897 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8905 remove_dead_literal (bfd
*abfd
,
8907 struct bfd_link_info
*link_info
,
8908 Elf_Internal_Rela
*internal_relocs
,
8909 Elf_Internal_Rela
*irel
,
8911 property_table_entry
*prop_table
,
8914 property_table_entry
*entry
;
8915 xtensa_relax_info
*relax_info
;
8917 relax_info
= get_xtensa_relax_info (sec
);
8921 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8922 sec
->vma
+ rel
->r_rel
.target_offset
);
8924 /* Mark the unused literal so that it will be removed. */
8925 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
8927 text_action_add (&relax_info
->action_list
,
8928 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
8930 /* If the section is 4-byte aligned, do not add fill. */
8931 if (sec
->alignment_power
> 2)
8933 int fill_extra_space
;
8934 bfd_vma entry_sec_offset
;
8936 property_table_entry
*the_add_entry
;
8940 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
8942 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
8944 /* If the literal range is at the end of the section,
8946 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8948 fill_extra_space
= compute_fill_extra_space (the_add_entry
);
8950 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
8951 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
8952 -4, fill_extra_space
);
8954 adjust_fill_action (fa
, removed_diff
);
8956 text_action_add (&relax_info
->action_list
,
8957 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
8960 /* Zero out the relocation on this literal location. */
8963 if (elf_hash_table (link_info
)->dynamic_sections_created
)
8964 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
8966 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
8967 pin_internal_relocs (sec
, internal_relocs
);
8970 /* Do not modify "last_loc_is_prev". */
8976 identify_literal_placement (bfd
*abfd
,
8979 struct bfd_link_info
*link_info
,
8980 value_map_hash_table
*values
,
8981 bfd_boolean
*last_loc_is_prev_p
,
8982 Elf_Internal_Rela
*irel
,
8983 int remaining_src_rels
,
8985 property_table_entry
*prop_table
,
8987 section_cache_t
*target_sec_cache
,
8988 bfd_boolean is_abs_literal
)
8992 xtensa_relax_info
*relax_info
;
8993 bfd_boolean literal_placed
= FALSE
;
8995 unsigned long value
;
8996 bfd_boolean final_static_link
;
8997 bfd_size_type sec_size
;
8999 relax_info
= get_xtensa_relax_info (sec
);
9003 sec_size
= bfd_get_section_limit (abfd
, sec
);
9006 (!bfd_link_relocatable (link_info
)
9007 && !elf_hash_table (link_info
)->dynamic_sections_created
);
9009 /* The placement algorithm first checks to see if the literal is
9010 already in the value map. If so and the value map is reachable
9011 from all uses, then the literal is moved to that location. If
9012 not, then we identify the last location where a fresh literal was
9013 placed. If the literal can be safely moved there, then we do so.
9014 If not, then we assume that the literal is not to move and leave
9015 the literal where it is, marking it as the last literal
9018 /* Find the literal value. */
9020 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9023 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
9024 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
9026 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
9028 /* Check if we've seen another literal with the same value that
9029 is in the same output section. */
9030 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
9033 && (r_reloc_get_section (&val_map
->loc
)->output_section
9034 == sec
->output_section
)
9035 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
9036 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
9038 /* No change to last_loc_is_prev. */
9039 literal_placed
= TRUE
;
9042 /* For relocatable links, do not try to move literals. To do it
9043 correctly might increase the number of relocations in an input
9044 section making the default relocatable linking fail. */
9045 if (!bfd_link_relocatable (link_info
) && !literal_placed
9046 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
9048 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
9049 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
9051 /* Increment the virtual offset. */
9052 r_reloc try_loc
= values
->last_loc
;
9053 try_loc
.virtual_offset
+= 4;
9055 /* There is a last loc that was in the same output section. */
9056 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
9057 && move_shared_literal (sec
, link_info
, rel
,
9058 prop_table
, ptblsize
,
9059 &try_loc
, &val
, target_sec_cache
))
9061 values
->last_loc
.virtual_offset
+= 4;
9062 literal_placed
= TRUE
;
9064 val_map
= add_value_map (values
, &val
, &try_loc
,
9067 val_map
->loc
= try_loc
;
9072 if (!literal_placed
)
9074 /* Nothing worked, leave the literal alone but update the last loc. */
9075 values
->has_last_loc
= TRUE
;
9076 values
->last_loc
= rel
->r_rel
;
9078 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
9080 val_map
->loc
= rel
->r_rel
;
9081 *last_loc_is_prev_p
= TRUE
;
9088 /* Check if the original relocations (presumably on L32R instructions)
9089 identified by reloc[0..N] can be changed to reference the literal
9090 identified by r_rel. If r_rel is out of range for any of the
9091 original relocations, then we don't want to coalesce the original
9092 literal with the one at r_rel. We only check reloc[0..N], where the
9093 offsets are all the same as for reloc[0] (i.e., they're all
9094 referencing the same literal) and where N is also bounded by the
9095 number of remaining entries in the "reloc" array. The "reloc" array
9096 is sorted by target offset so we know all the entries for the same
9097 literal will be contiguous. */
9100 relocations_reach (source_reloc
*reloc
,
9101 int remaining_relocs
,
9102 const r_reloc
*r_rel
)
9104 bfd_vma from_offset
, source_address
, dest_address
;
9108 if (!r_reloc_is_defined (r_rel
))
9111 sec
= r_reloc_get_section (r_rel
);
9112 from_offset
= reloc
[0].r_rel
.target_offset
;
9114 for (i
= 0; i
< remaining_relocs
; i
++)
9116 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9119 /* Ignore relocations that have been removed. */
9120 if (reloc
[i
].is_null
)
9123 /* The original and new output section for these must be the same
9124 in order to coalesce. */
9125 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9126 != sec
->output_section
)
9129 /* Absolute literals in the same output section can always be
9131 if (reloc
[i
].is_abs_literal
)
9134 /* A literal with no PC-relative relocations can be moved anywhere. */
9135 if (reloc
[i
].opnd
!= -1)
9137 /* Otherwise, check to see that it fits. */
9138 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9139 + reloc
[i
].source_sec
->output_offset
9140 + reloc
[i
].r_rel
.rela
.r_offset
);
9141 dest_address
= (sec
->output_section
->vma
9142 + sec
->output_offset
9143 + r_rel
->target_offset
);
9145 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9146 source_address
, dest_address
))
9155 /* Move a literal to another literal location because it is
9156 the same as the other literal value. */
9159 coalesce_shared_literal (asection
*sec
,
9161 property_table_entry
*prop_table
,
9165 property_table_entry
*entry
;
9167 property_table_entry
*the_add_entry
;
9169 xtensa_relax_info
*relax_info
;
9171 relax_info
= get_xtensa_relax_info (sec
);
9175 entry
= elf_xtensa_find_property_entry
9176 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9177 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9180 /* Mark that the literal will be coalesced. */
9181 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9183 text_action_add (&relax_info
->action_list
,
9184 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9186 /* If the section is 4-byte aligned, do not add fill. */
9187 if (sec
->alignment_power
> 2)
9189 int fill_extra_space
;
9190 bfd_vma entry_sec_offset
;
9193 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9195 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9197 /* If the literal range is at the end of the section,
9199 fill_extra_space
= 0;
9200 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9202 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9203 fill_extra_space
= the_add_entry
->size
;
9205 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9206 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9207 -4, fill_extra_space
);
9209 adjust_fill_action (fa
, removed_diff
);
9211 text_action_add (&relax_info
->action_list
,
9212 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9219 /* Move a literal to another location. This may actually increase the
9220 total amount of space used because of alignments so we need to do
9221 this carefully. Also, it may make a branch go out of range. */
9224 move_shared_literal (asection
*sec
,
9225 struct bfd_link_info
*link_info
,
9227 property_table_entry
*prop_table
,
9229 const r_reloc
*target_loc
,
9230 const literal_value
*lit_value
,
9231 section_cache_t
*target_sec_cache
)
9233 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9234 text_action
*fa
, *target_fa
;
9236 xtensa_relax_info
*relax_info
, *target_relax_info
;
9237 asection
*target_sec
;
9239 ebb_constraint ebb_table
;
9240 bfd_boolean relocs_fit
;
9242 /* If this routine always returns FALSE, the literals that cannot be
9243 coalesced will not be moved. */
9244 if (elf32xtensa_no_literal_movement
)
9247 relax_info
= get_xtensa_relax_info (sec
);
9251 target_sec
= r_reloc_get_section (target_loc
);
9252 target_relax_info
= get_xtensa_relax_info (target_sec
);
9254 /* Literals to undefined sections may not be moved because they
9255 must report an error. */
9256 if (bfd_is_und_section (target_sec
))
9259 src_entry
= elf_xtensa_find_property_entry
9260 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9262 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9265 target_entry
= elf_xtensa_find_property_entry
9266 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9267 target_sec
->vma
+ target_loc
->target_offset
);
9272 /* Make sure that we have not broken any branches. */
9275 init_ebb_constraint (&ebb_table
);
9276 ebb
= &ebb_table
.ebb
;
9277 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9278 target_sec_cache
->content_length
,
9279 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9280 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9282 /* Propose to add 4 bytes + worst-case alignment size increase to
9284 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9285 ta_fill
, target_loc
->target_offset
,
9286 -4 - (1 << target_sec
->alignment_power
), TRUE
);
9288 /* Check all of the PC-relative relocations to make sure they still fit. */
9289 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9290 target_sec_cache
->contents
,
9291 target_sec_cache
->relocs
, NULL
,
9297 text_action_add_literal (&target_relax_info
->action_list
,
9298 ta_add_literal
, target_loc
, lit_value
, -4);
9300 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9302 /* May need to add or remove some fill to maintain alignment. */
9303 int fill_extra_space
;
9304 bfd_vma entry_sec_offset
;
9307 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9309 /* If the literal range is at the end of the section,
9311 fill_extra_space
= 0;
9313 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9314 target_sec_cache
->pte_count
,
9316 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9317 fill_extra_space
= the_add_entry
->size
;
9319 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9320 target_sec
, entry_sec_offset
);
9321 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9322 entry_sec_offset
, 4,
9325 adjust_fill_action (target_fa
, removed_diff
);
9327 text_action_add (&target_relax_info
->action_list
,
9328 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9331 /* Mark that the literal will be moved to the new location. */
9332 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9334 /* Remove the literal. */
9335 text_action_add (&relax_info
->action_list
,
9336 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9338 /* If the section is 4-byte aligned, do not add fill. */
9339 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9341 int fill_extra_space
;
9342 bfd_vma entry_sec_offset
;
9345 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9347 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9349 /* If the literal range is at the end of the section,
9351 fill_extra_space
= 0;
9352 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9354 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9355 fill_extra_space
= the_add_entry
->size
;
9357 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9358 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9359 -4, fill_extra_space
);
9361 adjust_fill_action (fa
, removed_diff
);
9363 text_action_add (&relax_info
->action_list
,
9364 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9371 /* Second relaxation pass. */
9374 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9376 bfd_size_type
*final_size
= p
;
9377 text_action
*action
= (text_action
*)node
->value
;
9379 *final_size
-= action
->removed_bytes
;
9383 /* Modify all of the relocations to point to the right spot, and if this
9384 is a relaxable section, delete the unwanted literals and fix the
9388 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9390 Elf_Internal_Rela
*internal_relocs
;
9391 xtensa_relax_info
*relax_info
;
9393 bfd_boolean ok
= TRUE
;
9395 bfd_boolean rv
= FALSE
;
9396 bfd_boolean virtual_action
;
9397 bfd_size_type sec_size
;
9399 sec_size
= bfd_get_section_limit (abfd
, sec
);
9400 relax_info
= get_xtensa_relax_info (sec
);
9401 BFD_ASSERT (relax_info
);
9403 /* First translate any of the fixes that have been added already. */
9404 translate_section_fixes (sec
);
9406 /* Handle property sections (e.g., literal tables) specially. */
9407 if (xtensa_is_property_section (sec
))
9409 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9410 return relax_property_section (abfd
, sec
, link_info
);
9413 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9414 link_info
->keep_memory
);
9415 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9418 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9419 if (contents
== NULL
&& sec_size
!= 0)
9425 if (internal_relocs
)
9427 for (i
= 0; i
< sec
->reloc_count
; i
++)
9429 Elf_Internal_Rela
*irel
;
9430 xtensa_relax_info
*target_relax_info
;
9431 bfd_vma source_offset
, old_source_offset
;
9434 asection
*target_sec
;
9436 /* Locally change the source address.
9437 Translate the target to the new target address.
9438 If it points to this section and has been removed,
9442 irel
= &internal_relocs
[i
];
9443 source_offset
= irel
->r_offset
;
9444 old_source_offset
= source_offset
;
9446 r_type
= ELF32_R_TYPE (irel
->r_info
);
9447 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9448 bfd_get_section_limit (abfd
, sec
));
9450 /* If this section could have changed then we may need to
9451 change the relocation's offset. */
9453 if (relax_info
->is_relaxable_literal_section
9454 || relax_info
->is_relaxable_asm_section
)
9456 pin_internal_relocs (sec
, internal_relocs
);
9458 if (r_type
!= R_XTENSA_NONE
9459 && find_removed_literal (&relax_info
->removed_list
,
9462 /* Remove this relocation. */
9463 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9464 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9465 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9466 irel
->r_offset
= offset_with_removed_text_map
9467 (&relax_info
->action_list
, irel
->r_offset
);
9471 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9473 text_action
*action
=
9474 find_insn_action (&relax_info
->action_list
,
9476 if (action
&& (action
->action
== ta_convert_longcall
9477 || action
->action
== ta_remove_longcall
))
9479 bfd_reloc_status_type retval
;
9480 char *error_message
= NULL
;
9482 retval
= contract_asm_expansion (contents
, sec_size
,
9483 irel
, &error_message
);
9484 if (retval
!= bfd_reloc_ok
)
9486 (*link_info
->callbacks
->reloc_dangerous
)
9487 (link_info
, error_message
, abfd
, sec
,
9491 /* Update the action so that the code that moves
9492 the contents will do the right thing. */
9493 /* ta_remove_longcall and ta_remove_insn actions are
9494 grouped together in the tree as well as
9495 ta_convert_longcall and ta_none, so that changes below
9496 can be done w/o removing and reinserting action into
9499 if (action
->action
== ta_remove_longcall
)
9500 action
->action
= ta_remove_insn
;
9502 action
->action
= ta_none
;
9503 /* Refresh the info in the r_rel. */
9504 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9505 r_type
= ELF32_R_TYPE (irel
->r_info
);
9509 source_offset
= offset_with_removed_text_map
9510 (&relax_info
->action_list
, irel
->r_offset
);
9511 irel
->r_offset
= source_offset
;
9514 /* If the target section could have changed then
9515 we may need to change the relocation's target offset. */
9517 target_sec
= r_reloc_get_section (&r_rel
);
9519 /* For a reference to a discarded section from a DWARF section,
9520 i.e., where action_discarded is PRETEND, the symbol will
9521 eventually be modified to refer to the kept section (at least if
9522 the kept and discarded sections are the same size). Anticipate
9523 that here and adjust things accordingly. */
9524 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9525 && elf_xtensa_action_discarded (sec
) == PRETEND
9526 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9527 && target_sec
!= NULL
9528 && discarded_section (target_sec
))
9530 /* It would be natural to call _bfd_elf_check_kept_section
9531 here, but it's not exported from elflink.c. It's also a
9532 fairly expensive check. Adjusting the relocations to the
9533 discarded section is fairly harmless; it will only adjust
9534 some addends and difference values. If it turns out that
9535 _bfd_elf_check_kept_section fails later, it won't matter,
9536 so just compare the section names to find the right group
9538 asection
*kept
= target_sec
->kept_section
;
9541 if ((kept
->flags
& SEC_GROUP
) != 0)
9543 asection
*first
= elf_next_in_group (kept
);
9544 asection
*s
= first
;
9549 if (strcmp (s
->name
, target_sec
->name
) == 0)
9554 s
= elf_next_in_group (s
);
9561 && ((target_sec
->rawsize
!= 0
9562 ? target_sec
->rawsize
: target_sec
->size
)
9563 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9567 target_relax_info
= get_xtensa_relax_info (target_sec
);
9568 if (target_relax_info
9569 && (target_relax_info
->is_relaxable_literal_section
9570 || target_relax_info
->is_relaxable_asm_section
))
9573 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9575 if (r_type
== R_XTENSA_DIFF8
9576 || r_type
== R_XTENSA_DIFF16
9577 || r_type
== R_XTENSA_DIFF32
)
9579 bfd_signed_vma diff_value
= 0;
9580 bfd_vma new_end_offset
, diff_mask
= 0;
9582 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9584 (*link_info
->callbacks
->reloc_dangerous
)
9585 (link_info
, _("invalid relocation address"),
9586 abfd
, sec
, old_source_offset
);
9592 case R_XTENSA_DIFF8
:
9594 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9596 case R_XTENSA_DIFF16
:
9598 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9600 case R_XTENSA_DIFF32
:
9602 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9606 new_end_offset
= offset_with_removed_text_map
9607 (&target_relax_info
->action_list
,
9608 r_rel
.target_offset
+ diff_value
);
9609 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9613 case R_XTENSA_DIFF8
:
9615 bfd_put_signed_8 (abfd
, diff_value
,
9616 &contents
[old_source_offset
]);
9618 case R_XTENSA_DIFF16
:
9620 bfd_put_signed_16 (abfd
, diff_value
,
9621 &contents
[old_source_offset
]);
9623 case R_XTENSA_DIFF32
:
9624 diff_mask
= 0x7fffffff;
9625 bfd_put_signed_32 (abfd
, diff_value
,
9626 &contents
[old_source_offset
]);
9630 /* Check for overflow. Sign bits must be all zeroes or all ones */
9631 if ((diff_value
& ~diff_mask
) != 0 &&
9632 (diff_value
& ~diff_mask
) != (-1 & ~diff_mask
))
9634 (*link_info
->callbacks
->reloc_dangerous
)
9635 (link_info
, _("overflow after relaxation"),
9636 abfd
, sec
, old_source_offset
);
9640 pin_contents (sec
, contents
);
9643 /* If the relocation still references a section in the same
9644 input file, modify the relocation directly instead of
9645 adding a "fix" record. */
9646 if (target_sec
->owner
== abfd
)
9648 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9649 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9650 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9651 pin_internal_relocs (sec
, internal_relocs
);
9655 bfd_vma addend_displacement
;
9658 addend_displacement
=
9659 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9660 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9662 addend_displacement
, TRUE
);
9669 if ((relax_info
->is_relaxable_literal_section
9670 || relax_info
->is_relaxable_asm_section
)
9671 && action_list_count (&relax_info
->action_list
))
9673 /* Walk through the planned actions and build up a table
9674 of move, copy and fill records. Use the move, copy and
9675 fill records to perform the actions once. */
9677 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9678 bfd_byte
*scratch
= NULL
;
9679 bfd_byte
*dup_contents
= NULL
;
9680 bfd_size_type orig_size
= sec
->size
;
9681 bfd_vma orig_dot
= 0;
9682 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9683 orig dot in physical memory. */
9684 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9685 bfd_vma dup_dot
= 0;
9687 text_action
*action
;
9689 final_size
= sec
->size
;
9691 splay_tree_foreach (relax_info
->action_list
.tree
,
9692 action_remove_bytes_fn
, &final_size
);
9693 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9694 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9696 /* The dot is the current fill location. */
9698 print_action_list (stderr
, &relax_info
->action_list
);
9701 for (action
= action_first (&relax_info
->action_list
); action
;
9702 action
= action_next (&relax_info
->action_list
, action
))
9704 virtual_action
= FALSE
;
9705 if (action
->offset
> orig_dot
)
9707 orig_dot
+= orig_dot_copied
;
9708 orig_dot_copied
= 0;
9710 /* Out of the virtual world. */
9713 if (action
->offset
> orig_dot
)
9715 copy_size
= action
->offset
- orig_dot
;
9716 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9717 orig_dot
+= copy_size
;
9718 dup_dot
+= copy_size
;
9719 BFD_ASSERT (action
->offset
== orig_dot
);
9721 else if (action
->offset
< orig_dot
)
9723 if (action
->action
== ta_fill
9724 && action
->offset
- action
->removed_bytes
== orig_dot
)
9726 /* This is OK because the fill only effects the dup_dot. */
9728 else if (action
->action
== ta_add_literal
)
9730 /* TBD. Might need to handle this. */
9733 if (action
->offset
== orig_dot
)
9735 if (action
->virtual_offset
> orig_dot_vo
)
9737 if (orig_dot_vo
== 0)
9739 /* Need to copy virtual_offset bytes. Probably four. */
9740 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9741 memmove (&dup_contents
[dup_dot
],
9742 &contents
[orig_dot
], copy_size
);
9743 orig_dot_copied
= copy_size
;
9744 dup_dot
+= copy_size
;
9746 virtual_action
= TRUE
;
9749 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9751 switch (action
->action
)
9753 case ta_remove_literal
:
9754 case ta_remove_insn
:
9755 BFD_ASSERT (action
->removed_bytes
>= 0);
9756 orig_dot
+= action
->removed_bytes
;
9759 case ta_narrow_insn
:
9762 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9763 BFD_ASSERT (action
->removed_bytes
== 1);
9764 rv
= narrow_instruction (scratch
, final_size
, 0);
9766 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9767 orig_dot
+= orig_insn_size
;
9768 dup_dot
+= copy_size
;
9772 if (action
->removed_bytes
>= 0)
9773 orig_dot
+= action
->removed_bytes
;
9776 /* Already zeroed in dup_contents. Just bump the
9778 dup_dot
+= (-action
->removed_bytes
);
9783 BFD_ASSERT (action
->removed_bytes
== 0);
9786 case ta_convert_longcall
:
9787 case ta_remove_longcall
:
9788 /* These will be removed or converted before we get here. */
9795 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9796 BFD_ASSERT (action
->removed_bytes
== -1);
9797 rv
= widen_instruction (scratch
, final_size
, 0);
9799 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9800 orig_dot
+= orig_insn_size
;
9801 dup_dot
+= copy_size
;
9804 case ta_add_literal
:
9807 BFD_ASSERT (action
->removed_bytes
== -4);
9808 /* TBD -- place the literal value here and insert
9810 memset (&dup_contents
[dup_dot
], 0, 4);
9811 pin_internal_relocs (sec
, internal_relocs
);
9812 pin_contents (sec
, contents
);
9814 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9815 relax_info
, &internal_relocs
, &action
->value
))
9819 orig_dot_vo
+= copy_size
;
9821 orig_dot
+= orig_insn_size
;
9822 dup_dot
+= copy_size
;
9826 /* Not implemented yet. */
9831 BFD_ASSERT (dup_dot
<= final_size
);
9832 BFD_ASSERT (orig_dot
<= orig_size
);
9835 orig_dot
+= orig_dot_copied
;
9836 orig_dot_copied
= 0;
9838 if (orig_dot
!= orig_size
)
9840 copy_size
= orig_size
- orig_dot
;
9841 BFD_ASSERT (orig_size
> orig_dot
);
9842 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9843 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9844 orig_dot
+= copy_size
;
9845 dup_dot
+= copy_size
;
9847 BFD_ASSERT (orig_size
== orig_dot
);
9848 BFD_ASSERT (final_size
== dup_dot
);
9850 /* Move the dup_contents back. */
9851 if (final_size
> orig_size
)
9853 /* Contents need to be reallocated. Swap the dup_contents into
9855 sec
->contents
= dup_contents
;
9857 contents
= dup_contents
;
9858 pin_contents (sec
, contents
);
9862 BFD_ASSERT (final_size
<= orig_size
);
9863 memset (contents
, 0, orig_size
);
9864 memcpy (contents
, dup_contents
, final_size
);
9865 free (dup_contents
);
9868 pin_contents (sec
, contents
);
9870 if (sec
->rawsize
== 0)
9871 sec
->rawsize
= sec
->size
;
9872 sec
->size
= final_size
;
9876 release_internal_relocs (sec
, internal_relocs
);
9877 release_contents (sec
, contents
);
9883 translate_section_fixes (asection
*sec
)
9885 xtensa_relax_info
*relax_info
;
9888 relax_info
= get_xtensa_relax_info (sec
);
9892 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
9893 if (!translate_reloc_bfd_fix (r
))
9900 /* Translate a fix given the mapping in the relax info for the target
9901 section. If it has already been translated, no work is required. */
9904 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
9906 reloc_bfd_fix new_fix
;
9908 xtensa_relax_info
*relax_info
;
9909 removed_literal
*removed
;
9910 bfd_vma new_offset
, target_offset
;
9912 if (fix
->translated
)
9915 sec
= fix
->target_sec
;
9916 target_offset
= fix
->target_offset
;
9918 relax_info
= get_xtensa_relax_info (sec
);
9921 fix
->translated
= TRUE
;
9927 /* The fix does not need to be translated if the section cannot change. */
9928 if (!relax_info
->is_relaxable_literal_section
9929 && !relax_info
->is_relaxable_asm_section
)
9931 fix
->translated
= TRUE
;
9935 /* If the literal has been moved and this relocation was on an
9936 opcode, then the relocation should move to the new literal
9937 location. Otherwise, the relocation should move within the
9941 if (is_operand_relocation (fix
->src_type
))
9943 /* Check if the original relocation is against a literal being
9945 removed
= find_removed_literal (&relax_info
->removed_list
,
9953 /* The fact that there is still a relocation to this literal indicates
9954 that the literal is being coalesced, not simply removed. */
9955 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
9957 /* This was moved to some other address (possibly another section). */
9958 new_sec
= r_reloc_get_section (&removed
->to
);
9962 relax_info
= get_xtensa_relax_info (sec
);
9964 (!relax_info
->is_relaxable_literal_section
9965 && !relax_info
->is_relaxable_asm_section
))
9967 target_offset
= removed
->to
.target_offset
;
9968 new_fix
.target_sec
= new_sec
;
9969 new_fix
.target_offset
= target_offset
;
9970 new_fix
.translated
= TRUE
;
9975 target_offset
= removed
->to
.target_offset
;
9976 new_fix
.target_sec
= new_sec
;
9979 /* The target address may have been moved within its section. */
9980 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
9983 new_fix
.target_offset
= new_offset
;
9984 new_fix
.target_offset
= new_offset
;
9985 new_fix
.translated
= TRUE
;
9991 /* Fix up a relocation to take account of removed literals. */
9994 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
9996 xtensa_relax_info
*relax_info
;
9997 removed_literal
*removed
;
9998 bfd_vma target_offset
, base_offset
;
10000 *new_rel
= *orig_rel
;
10002 if (!r_reloc_is_defined (orig_rel
))
10005 relax_info
= get_xtensa_relax_info (sec
);
10006 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
10007 || relax_info
->is_relaxable_asm_section
));
10009 target_offset
= orig_rel
->target_offset
;
10012 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
10014 /* Check if the original relocation is against a literal being
10016 removed
= find_removed_literal (&relax_info
->removed_list
,
10019 if (removed
&& removed
->to
.abfd
)
10023 /* The fact that there is still a relocation to this literal indicates
10024 that the literal is being coalesced, not simply removed. */
10025 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10027 /* This was moved to some other address
10028 (possibly in another section). */
10029 *new_rel
= removed
->to
;
10030 new_sec
= r_reloc_get_section (new_rel
);
10031 if (new_sec
!= sec
)
10034 relax_info
= get_xtensa_relax_info (sec
);
10036 || (!relax_info
->is_relaxable_literal_section
10037 && !relax_info
->is_relaxable_asm_section
))
10040 target_offset
= new_rel
->target_offset
;
10043 /* Find the base offset of the reloc symbol, excluding any addend from the
10044 reloc or from the section contents (for a partial_inplace reloc). Then
10045 find the adjusted values of the offsets due to relaxation. The base
10046 offset is needed to determine the change to the reloc's addend; the reloc
10047 addend should not be adjusted due to relaxations located before the base
10050 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
10051 if (base_offset
<= target_offset
)
10053 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
10054 base_offset
, FALSE
);
10055 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10056 target_offset
, FALSE
) -
10059 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
10060 new_rel
->rela
.r_addend
-= addend_removed
;
10064 /* Handle a negative addend. The base offset comes first. */
10065 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
10066 target_offset
, FALSE
);
10067 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10068 base_offset
, FALSE
) -
10071 new_rel
->target_offset
= target_offset
- tgt_removed
;
10072 new_rel
->rela
.r_addend
+= addend_removed
;
10079 /* For dynamic links, there may be a dynamic relocation for each
10080 literal. The number of dynamic relocations must be computed in
10081 size_dynamic_sections, which occurs before relaxation. When a
10082 literal is removed, this function checks if there is a corresponding
10083 dynamic relocation and shrinks the size of the appropriate dynamic
10084 relocation section accordingly. At this point, the contents of the
10085 dynamic relocation sections have not yet been filled in, so there's
10086 nothing else that needs to be done. */
10089 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
10091 asection
*input_section
,
10092 Elf_Internal_Rela
*rel
)
10094 struct elf_xtensa_link_hash_table
*htab
;
10095 Elf_Internal_Shdr
*symtab_hdr
;
10096 struct elf_link_hash_entry
**sym_hashes
;
10097 unsigned long r_symndx
;
10099 struct elf_link_hash_entry
*h
;
10100 bfd_boolean dynamic_symbol
;
10102 htab
= elf_xtensa_hash_table (info
);
10106 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10107 sym_hashes
= elf_sym_hashes (abfd
);
10109 r_type
= ELF32_R_TYPE (rel
->r_info
);
10110 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10112 if (r_symndx
< symtab_hdr
->sh_info
)
10115 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10117 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10119 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10120 && (input_section
->flags
& SEC_ALLOC
) != 0
10121 && (dynamic_symbol
|| bfd_link_pic (info
)))
10124 bfd_boolean is_plt
= FALSE
;
10126 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10128 srel
= htab
->elf
.srelplt
;
10132 srel
= htab
->elf
.srelgot
;
10134 /* Reduce size of the .rela.* section by one reloc. */
10135 BFD_ASSERT (srel
!= NULL
);
10136 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10137 srel
->size
-= sizeof (Elf32_External_Rela
);
10141 asection
*splt
, *sgotplt
, *srelgot
;
10142 int reloc_index
, chunk
;
10144 /* Find the PLT reloc index of the entry being removed. This
10145 is computed from the size of ".rela.plt". It is needed to
10146 figure out which PLT chunk to resize. Usually "last index
10147 = size - 1" since the index starts at zero, but in this
10148 context, the size has just been decremented so there's no
10149 need to subtract one. */
10150 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10152 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10153 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10154 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10155 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10157 /* Check if an entire PLT chunk has just been eliminated. */
10158 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10160 /* The two magic GOT entries for that chunk can go away. */
10161 srelgot
= htab
->elf
.srelgot
;
10162 BFD_ASSERT (srelgot
!= NULL
);
10163 srelgot
->reloc_count
-= 2;
10164 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10165 sgotplt
->size
-= 8;
10167 /* There should be only one entry left (and it will be
10169 BFD_ASSERT (sgotplt
->size
== 4);
10170 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10173 BFD_ASSERT (sgotplt
->size
>= 4);
10174 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10176 sgotplt
->size
-= 4;
10177 splt
->size
-= PLT_ENTRY_SIZE
;
10183 /* Take an r_rel and move it to another section. This usually
10184 requires extending the interal_relocation array and pinning it. If
10185 the original r_rel is from the same BFD, we can complete this here.
10186 Otherwise, we add a fix record to let the final link fix the
10187 appropriate address. Contents and internal relocations for the
10188 section must be pinned after calling this routine. */
10191 move_literal (bfd
*abfd
,
10192 struct bfd_link_info
*link_info
,
10195 bfd_byte
*contents
,
10196 xtensa_relax_info
*relax_info
,
10197 Elf_Internal_Rela
**internal_relocs_p
,
10198 const literal_value
*lit
)
10200 Elf_Internal_Rela
*new_relocs
= NULL
;
10201 size_t new_relocs_count
= 0;
10202 Elf_Internal_Rela this_rela
;
10203 const r_reloc
*r_rel
;
10205 r_rel
= &lit
->r_rel
;
10206 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10208 if (r_reloc_is_const (r_rel
))
10209 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10214 reloc_bfd_fix
*fix
;
10215 unsigned insert_at
;
10217 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10219 /* This is the difficult case. We have to create a fix up. */
10220 this_rela
.r_offset
= offset
;
10221 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10222 this_rela
.r_addend
=
10223 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10224 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10226 /* Currently, we cannot move relocations during a relocatable link. */
10227 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10228 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10229 r_reloc_get_section (r_rel
),
10230 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10232 /* We also need to mark that relocations are needed here. */
10233 sec
->flags
|= SEC_RELOC
;
10235 translate_reloc_bfd_fix (fix
);
10236 /* This fix has not yet been translated. */
10237 add_fix (sec
, fix
);
10239 /* Add the relocation. If we have already allocated our own
10240 space for the relocations and we have room for more, then use
10241 it. Otherwise, allocate new space and move the literals. */
10242 insert_at
= sec
->reloc_count
;
10243 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10245 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10252 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10253 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10255 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10256 || sec
->reloc_count
== relax_info
->relocs_count
);
10258 if (relax_info
->allocated_relocs_count
== 0)
10259 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10261 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10263 new_relocs
= (Elf_Internal_Rela
*)
10264 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10268 /* We could handle this more quickly by finding the split point. */
10269 if (insert_at
!= 0)
10270 memcpy (new_relocs
, *internal_relocs_p
,
10271 insert_at
* sizeof (Elf_Internal_Rela
));
10273 new_relocs
[insert_at
] = this_rela
;
10275 if (insert_at
!= sec
->reloc_count
)
10276 memcpy (new_relocs
+ insert_at
+ 1,
10277 (*internal_relocs_p
) + insert_at
,
10278 (sec
->reloc_count
- insert_at
)
10279 * sizeof (Elf_Internal_Rela
));
10281 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10283 /* The first time we re-allocate, we can only free the
10284 old relocs if they were allocated with bfd_malloc.
10285 This is not true when keep_memory is in effect. */
10286 if (!link_info
->keep_memory
)
10287 free (*internal_relocs_p
);
10290 free (*internal_relocs_p
);
10291 relax_info
->allocated_relocs
= new_relocs
;
10292 relax_info
->allocated_relocs_count
= new_relocs_count
;
10293 elf_section_data (sec
)->relocs
= new_relocs
;
10294 sec
->reloc_count
++;
10295 relax_info
->relocs_count
= sec
->reloc_count
;
10296 *internal_relocs_p
= new_relocs
;
10300 if (insert_at
!= sec
->reloc_count
)
10303 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10304 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10306 (*internal_relocs_p
)[insert_at
] = this_rela
;
10307 sec
->reloc_count
++;
10308 if (relax_info
->allocated_relocs
)
10309 relax_info
->relocs_count
= sec
->reloc_count
;
10316 /* This is similar to relax_section except that when a target is moved,
10317 we shift addresses up. We also need to modify the size. This
10318 algorithm does NOT allow for relocations into the middle of the
10319 property sections. */
10322 relax_property_section (bfd
*abfd
,
10324 struct bfd_link_info
*link_info
)
10326 Elf_Internal_Rela
*internal_relocs
;
10327 bfd_byte
*contents
;
10329 bfd_boolean ok
= TRUE
;
10330 bfd_boolean is_full_prop_section
;
10331 size_t last_zfill_target_offset
= 0;
10332 asection
*last_zfill_target_sec
= NULL
;
10333 bfd_size_type sec_size
;
10334 bfd_size_type entry_size
;
10336 sec_size
= bfd_get_section_limit (abfd
, sec
);
10337 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10338 link_info
->keep_memory
);
10339 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10340 if (contents
== NULL
&& sec_size
!= 0)
10346 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10347 if (is_full_prop_section
)
10352 if (internal_relocs
)
10354 for (i
= 0; i
< sec
->reloc_count
; i
++)
10356 Elf_Internal_Rela
*irel
;
10357 xtensa_relax_info
*target_relax_info
;
10359 asection
*target_sec
;
10361 bfd_byte
*size_p
, *flags_p
;
10363 /* Locally change the source address.
10364 Translate the target to the new target address.
10365 If it points to this section and has been removed, MOVE IT.
10366 Also, don't forget to modify the associated SIZE at
10369 irel
= &internal_relocs
[i
];
10370 r_type
= ELF32_R_TYPE (irel
->r_info
);
10371 if (r_type
== R_XTENSA_NONE
)
10374 /* Find the literal value. */
10375 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10376 size_p
= &contents
[irel
->r_offset
+ 4];
10378 if (is_full_prop_section
)
10379 flags_p
= &contents
[irel
->r_offset
+ 8];
10380 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10382 target_sec
= r_reloc_get_section (&val
.r_rel
);
10383 target_relax_info
= get_xtensa_relax_info (target_sec
);
10385 if (target_relax_info
10386 && (target_relax_info
->is_relaxable_literal_section
10387 || target_relax_info
->is_relaxable_asm_section
))
10389 /* Translate the relocation's destination. */
10390 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10391 bfd_vma new_offset
;
10392 long old_size
, new_size
;
10393 int removed_by_old_offset
=
10394 removed_by_actions_map (&target_relax_info
->action_list
,
10395 old_offset
, FALSE
);
10396 new_offset
= old_offset
- removed_by_old_offset
;
10398 /* Assert that we are not out of bounds. */
10399 old_size
= bfd_get_32 (abfd
, size_p
);
10400 new_size
= old_size
;
10404 /* Only the first zero-sized unreachable entry is
10405 allowed to expand. In this case the new offset
10406 should be the offset before the fill and the new
10407 size is the expansion size. For other zero-sized
10408 entries the resulting size should be zero with an
10409 offset before or after the fill address depending
10410 on whether the expanding unreachable entry
10412 if (last_zfill_target_sec
== 0
10413 || last_zfill_target_sec
!= target_sec
10414 || last_zfill_target_offset
!= old_offset
)
10416 bfd_vma new_end_offset
= new_offset
;
10418 /* Recompute the new_offset, but this time don't
10419 include any fill inserted by relaxation. */
10420 removed_by_old_offset
=
10421 removed_by_actions_map (&target_relax_info
->action_list
,
10423 new_offset
= old_offset
- removed_by_old_offset
;
10425 /* If it is not unreachable and we have not yet
10426 seen an unreachable at this address, place it
10427 before the fill address. */
10428 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10429 & XTENSA_PROP_UNREACHABLE
) != 0)
10431 new_size
= new_end_offset
- new_offset
;
10433 last_zfill_target_sec
= target_sec
;
10434 last_zfill_target_offset
= old_offset
;
10440 int removed_by_old_offset_size
=
10441 removed_by_actions_map (&target_relax_info
->action_list
,
10442 old_offset
+ old_size
, TRUE
);
10443 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10446 if (new_size
!= old_size
)
10448 bfd_put_32 (abfd
, new_size
, size_p
);
10449 pin_contents (sec
, contents
);
10452 if (new_offset
!= old_offset
)
10454 bfd_vma diff
= new_offset
- old_offset
;
10455 irel
->r_addend
+= diff
;
10456 pin_internal_relocs (sec
, internal_relocs
);
10462 /* Combine adjacent property table entries. This is also done in
10463 finish_dynamic_sections() but at that point it's too late to
10464 reclaim the space in the output section, so we do this twice. */
10466 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10467 || xtensa_is_littable_section (sec
)))
10469 Elf_Internal_Rela
*last_irel
= NULL
;
10470 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10471 int removed_bytes
= 0;
10473 flagword predef_flags
;
10475 predef_flags
= xtensa_get_property_predef_flags (sec
);
10477 /* Walk over memory and relocations at the same time.
10478 This REQUIRES that the internal_relocs be sorted by offset. */
10479 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10480 internal_reloc_compare
);
10482 pin_internal_relocs (sec
, internal_relocs
);
10483 pin_contents (sec
, contents
);
10485 next_rel
= internal_relocs
;
10486 rel_end
= internal_relocs
+ sec
->reloc_count
;
10488 BFD_ASSERT (sec
->size
% entry_size
== 0);
10490 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10492 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10493 bfd_vma bytes_to_remove
, size
, actual_offset
;
10494 bfd_boolean remove_this_rel
;
10497 /* Find the first relocation for the entry at the current offset.
10498 Adjust the offsets of any extra relocations for the previous
10503 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10505 if ((irel
->r_offset
== offset
10506 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10507 || irel
->r_offset
> offset
)
10512 irel
->r_offset
-= removed_bytes
;
10516 /* Find the next relocation (if there are any left). */
10520 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10522 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10530 /* Check if there are relocations on the current entry. There
10531 should usually be a relocation on the offset field. If there
10532 are relocations on the size or flags, then we can't optimize
10533 this entry. Also, find the next relocation to examine on the
10537 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10539 next_rel
= offset_rel
;
10540 /* There are no relocations on the current entry, but we
10541 might still be able to remove it if the size is zero. */
10544 else if (offset_rel
->r_offset
> offset
10546 && extra_rel
->r_offset
< offset
+ entry_size
))
10548 /* There is a relocation on the size or flags, so we can't
10549 do anything with this entry. Continue with the next. */
10550 next_rel
= offset_rel
;
10555 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10556 offset_rel
->r_offset
-= removed_bytes
;
10557 next_rel
= offset_rel
+ 1;
10563 remove_this_rel
= FALSE
;
10564 bytes_to_remove
= 0;
10565 actual_offset
= offset
- removed_bytes
;
10566 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10568 if (is_full_prop_section
)
10569 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10571 flags
= predef_flags
;
10574 && (flags
& XTENSA_PROP_ALIGN
) == 0
10575 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10577 /* Always remove entries with zero size and no alignment. */
10578 bytes_to_remove
= entry_size
;
10580 remove_this_rel
= TRUE
;
10582 else if (offset_rel
10583 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10587 flagword old_flags
;
10589 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10590 bfd_vma old_address
=
10591 (last_irel
->r_addend
10592 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10593 bfd_vma new_address
=
10594 (offset_rel
->r_addend
10595 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10596 if (is_full_prop_section
)
10597 old_flags
= bfd_get_32
10598 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10600 old_flags
= predef_flags
;
10602 if ((ELF32_R_SYM (offset_rel
->r_info
)
10603 == ELF32_R_SYM (last_irel
->r_info
))
10604 && old_address
+ old_size
== new_address
10605 && old_flags
== flags
10606 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10607 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10609 /* Fix the old size. */
10610 bfd_put_32 (abfd
, old_size
+ size
,
10611 &contents
[last_irel
->r_offset
+ 4]);
10612 bytes_to_remove
= entry_size
;
10613 remove_this_rel
= TRUE
;
10616 last_irel
= offset_rel
;
10619 last_irel
= offset_rel
;
10622 if (remove_this_rel
)
10624 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10625 offset_rel
->r_offset
= 0;
10628 if (bytes_to_remove
!= 0)
10630 removed_bytes
+= bytes_to_remove
;
10631 if (offset
+ bytes_to_remove
< sec
->size
)
10632 memmove (&contents
[actual_offset
],
10633 &contents
[actual_offset
+ bytes_to_remove
],
10634 sec
->size
- offset
- bytes_to_remove
);
10640 /* Fix up any extra relocations on the last entry. */
10641 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10642 irel
->r_offset
-= removed_bytes
;
10644 /* Clear the removed bytes. */
10645 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10647 if (sec
->rawsize
== 0)
10648 sec
->rawsize
= sec
->size
;
10649 sec
->size
-= removed_bytes
;
10651 if (xtensa_is_littable_section (sec
))
10653 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10655 sgotloc
->size
-= removed_bytes
;
10661 release_internal_relocs (sec
, internal_relocs
);
10662 release_contents (sec
, contents
);
10667 /* Third relaxation pass. */
10669 /* Change symbol values to account for removed literals. */
10672 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10674 xtensa_relax_info
*relax_info
;
10675 unsigned int sec_shndx
;
10676 Elf_Internal_Shdr
*symtab_hdr
;
10677 Elf_Internal_Sym
*isymbuf
;
10678 unsigned i
, num_syms
, num_locals
;
10680 relax_info
= get_xtensa_relax_info (sec
);
10681 BFD_ASSERT (relax_info
);
10683 if (!relax_info
->is_relaxable_literal_section
10684 && !relax_info
->is_relaxable_asm_section
)
10687 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10689 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10690 isymbuf
= retrieve_local_syms (abfd
);
10692 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10693 num_locals
= symtab_hdr
->sh_info
;
10695 /* Adjust the local symbols defined in this section. */
10696 for (i
= 0; i
< num_locals
; i
++)
10698 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10700 if (isym
->st_shndx
== sec_shndx
)
10702 bfd_vma orig_addr
= isym
->st_value
;
10703 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10706 isym
->st_value
-= removed
;
10707 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10709 removed_by_actions_map (&relax_info
->action_list
,
10710 orig_addr
+ isym
->st_size
, FALSE
) -
10715 /* Now adjust the global symbols defined in this section. */
10716 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10718 struct elf_link_hash_entry
*sym_hash
;
10720 sym_hash
= elf_sym_hashes (abfd
)[i
];
10722 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10723 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10725 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10726 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10727 && sym_hash
->root
.u
.def
.section
== sec
)
10729 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10730 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10733 sym_hash
->root
.u
.def
.value
-= removed
;
10735 if (sym_hash
->type
== STT_FUNC
)
10737 removed_by_actions_map (&relax_info
->action_list
,
10738 orig_addr
+ sym_hash
->size
, FALSE
) -
10747 /* "Fix" handling functions, called while performing relocations. */
10750 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10752 asection
*input_section
,
10753 bfd_byte
*contents
)
10756 asection
*sec
, *old_sec
;
10757 bfd_vma old_offset
;
10758 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10759 reloc_bfd_fix
*fix
;
10761 if (r_type
== R_XTENSA_NONE
)
10764 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10768 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10769 bfd_get_section_limit (input_bfd
, input_section
));
10770 old_sec
= r_reloc_get_section (&r_rel
);
10771 old_offset
= r_rel
.target_offset
;
10773 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10775 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10778 /* xgettext:c-format */
10779 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
10780 input_bfd
, input_section
, rel
->r_offset
,
10781 elf_howto_table
[r_type
].name
);
10784 /* Leave it be. Resolution will happen in a later stage. */
10788 sec
= fix
->target_sec
;
10789 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10790 - (old_sec
->output_offset
+ old_offset
));
10797 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10799 asection
*input_section
,
10800 bfd_byte
*contents
,
10801 bfd_vma
*relocationp
)
10804 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10805 reloc_bfd_fix
*fix
;
10806 bfd_vma fixup_diff
;
10808 if (r_type
== R_XTENSA_NONE
)
10811 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10815 sec
= fix
->target_sec
;
10817 fixup_diff
= rel
->r_addend
;
10818 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10820 bfd_vma inplace_val
;
10821 BFD_ASSERT (fix
->src_offset
10822 < bfd_get_section_limit (input_bfd
, input_section
));
10823 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10824 fixup_diff
+= inplace_val
;
10827 *relocationp
= (sec
->output_section
->vma
10828 + sec
->output_offset
10829 + fix
->target_offset
- fixup_diff
);
10833 /* Miscellaneous utility functions.... */
10836 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10842 return elf_hash_table (info
)->splt
;
10844 dynobj
= elf_hash_table (info
)->dynobj
;
10845 sprintf (plt_name
, ".plt.%u", chunk
);
10846 return bfd_get_linker_section (dynobj
, plt_name
);
10851 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10857 return elf_hash_table (info
)->sgotplt
;
10859 dynobj
= elf_hash_table (info
)->dynobj
;
10860 sprintf (got_name
, ".got.plt.%u", chunk
);
10861 return bfd_get_linker_section (dynobj
, got_name
);
10865 /* Get the input section for a given symbol index.
10867 . a section symbol, return the section;
10868 . a common symbol, return the common section;
10869 . an undefined symbol, return the undefined section;
10870 . an indirect symbol, follow the links;
10871 . an absolute value, return the absolute section. */
10874 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
10876 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10877 asection
*target_sec
= NULL
;
10878 if (r_symndx
< symtab_hdr
->sh_info
)
10880 Elf_Internal_Sym
*isymbuf
;
10881 unsigned int section_index
;
10883 isymbuf
= retrieve_local_syms (abfd
);
10884 section_index
= isymbuf
[r_symndx
].st_shndx
;
10886 if (section_index
== SHN_UNDEF
)
10887 target_sec
= bfd_und_section_ptr
;
10888 else if (section_index
== SHN_ABS
)
10889 target_sec
= bfd_abs_section_ptr
;
10890 else if (section_index
== SHN_COMMON
)
10891 target_sec
= bfd_com_section_ptr
;
10893 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
10897 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
10898 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
10900 while (h
->root
.type
== bfd_link_hash_indirect
10901 || h
->root
.type
== bfd_link_hash_warning
)
10902 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10904 switch (h
->root
.type
)
10906 case bfd_link_hash_defined
:
10907 case bfd_link_hash_defweak
:
10908 target_sec
= h
->root
.u
.def
.section
;
10910 case bfd_link_hash_common
:
10911 target_sec
= bfd_com_section_ptr
;
10913 case bfd_link_hash_undefined
:
10914 case bfd_link_hash_undefweak
:
10915 target_sec
= bfd_und_section_ptr
;
10917 default: /* New indirect warning. */
10918 target_sec
= bfd_und_section_ptr
;
10926 static struct elf_link_hash_entry
*
10927 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
10929 unsigned long indx
;
10930 struct elf_link_hash_entry
*h
;
10931 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10933 if (r_symndx
< symtab_hdr
->sh_info
)
10936 indx
= r_symndx
- symtab_hdr
->sh_info
;
10937 h
= elf_sym_hashes (abfd
)[indx
];
10938 while (h
->root
.type
== bfd_link_hash_indirect
10939 || h
->root
.type
== bfd_link_hash_warning
)
10940 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10945 /* Get the section-relative offset for a symbol number. */
10948 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
10950 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10951 bfd_vma offset
= 0;
10953 if (r_symndx
< symtab_hdr
->sh_info
)
10955 Elf_Internal_Sym
*isymbuf
;
10956 isymbuf
= retrieve_local_syms (abfd
);
10957 offset
= isymbuf
[r_symndx
].st_value
;
10961 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
10962 struct elf_link_hash_entry
*h
=
10963 elf_sym_hashes (abfd
)[indx
];
10965 while (h
->root
.type
== bfd_link_hash_indirect
10966 || h
->root
.type
== bfd_link_hash_warning
)
10967 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10968 if (h
->root
.type
== bfd_link_hash_defined
10969 || h
->root
.type
== bfd_link_hash_defweak
)
10970 offset
= h
->root
.u
.def
.value
;
10977 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
10979 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
10980 struct elf_link_hash_entry
*h
;
10982 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
10983 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
10990 pcrel_reloc_fits (xtensa_opcode opc
,
10992 bfd_vma self_address
,
10993 bfd_vma dest_address
)
10995 xtensa_isa isa
= xtensa_default_isa
;
10996 uint32 valp
= dest_address
;
10997 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
10998 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
11005 xtensa_is_property_section (asection
*sec
)
11007 if (xtensa_is_insntable_section (sec
)
11008 || xtensa_is_littable_section (sec
)
11009 || xtensa_is_proptable_section (sec
))
11017 xtensa_is_insntable_section (asection
*sec
)
11019 if (CONST_STRNEQ (sec
->name
, XTENSA_INSN_SEC_NAME
)
11020 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.x."))
11028 xtensa_is_littable_section (asection
*sec
)
11030 if (CONST_STRNEQ (sec
->name
, XTENSA_LIT_SEC_NAME
)
11031 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.p."))
11039 xtensa_is_proptable_section (asection
*sec
)
11041 if (CONST_STRNEQ (sec
->name
, XTENSA_PROP_SEC_NAME
)
11042 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.prop."))
11050 internal_reloc_compare (const void *ap
, const void *bp
)
11052 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11053 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11055 if (a
->r_offset
!= b
->r_offset
)
11056 return (a
->r_offset
- b
->r_offset
);
11058 /* We don't need to sort on these criteria for correctness,
11059 but enforcing a more strict ordering prevents unstable qsort
11060 from behaving differently with different implementations.
11061 Without the code below we get correct but different results
11062 on Solaris 2.7 and 2.8. We would like to always produce the
11063 same results no matter the host. */
11065 if (a
->r_info
!= b
->r_info
)
11066 return (a
->r_info
- b
->r_info
);
11068 return (a
->r_addend
- b
->r_addend
);
11073 internal_reloc_matches (const void *ap
, const void *bp
)
11075 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11076 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11078 /* Check if one entry overlaps with the other; this shouldn't happen
11079 except when searching for a match. */
11080 return (a
->r_offset
- b
->r_offset
);
11084 /* Predicate function used to look up a section in a particular group. */
11087 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
11089 const char *gname
= inf
;
11090 const char *group_name
= elf_group_name (sec
);
11092 return (group_name
== gname
11093 || (group_name
!= NULL
11095 && strcmp (group_name
, gname
) == 0));
11099 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11102 xtensa_property_section_name (asection
*sec
, const char *base_name
)
11104 const char *suffix
, *group_name
;
11105 char *prop_sec_name
;
11107 group_name
= elf_group_name (sec
);
11110 suffix
= strrchr (sec
->name
, '.');
11111 if (suffix
== sec
->name
)
11113 prop_sec_name
= (char *) bfd_malloc (strlen (base_name
) + 1
11114 + (suffix
? strlen (suffix
) : 0));
11115 strcpy (prop_sec_name
, base_name
);
11117 strcat (prop_sec_name
, suffix
);
11119 else if (strncmp (sec
->name
, ".gnu.linkonce.", linkonce_len
) == 0)
11121 char *linkonce_kind
= 0;
11123 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11124 linkonce_kind
= "x.";
11125 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11126 linkonce_kind
= "p.";
11127 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11128 linkonce_kind
= "prop.";
11132 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11133 + strlen (linkonce_kind
) + 1);
11134 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11135 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11137 suffix
= sec
->name
+ linkonce_len
;
11138 /* For backward compatibility, replace "t." instead of inserting
11139 the new linkonce_kind (but not for "prop" sections). */
11140 if (CONST_STRNEQ (suffix
, "t.") && linkonce_kind
[1] == '.')
11142 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11145 prop_sec_name
= strdup (base_name
);
11147 return prop_sec_name
;
11152 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11154 char *prop_sec_name
;
11155 asection
*prop_sec
;
11157 prop_sec_name
= xtensa_property_section_name (sec
, base_name
);
11158 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11159 match_section_group
,
11160 (void *) elf_group_name (sec
));
11161 free (prop_sec_name
);
11167 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11169 char *prop_sec_name
;
11170 asection
*prop_sec
;
11172 /* Check if the section already exists. */
11173 prop_sec_name
= xtensa_property_section_name (sec
, base_name
);
11174 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11175 match_section_group
,
11176 (void *) elf_group_name (sec
));
11177 /* If not, create it. */
11180 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11181 flags
|= (bfd_get_section_flags (sec
->owner
, sec
)
11182 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11184 prop_sec
= bfd_make_section_anyway_with_flags
11185 (sec
->owner
, strdup (prop_sec_name
), flags
);
11189 elf_group_name (prop_sec
) = elf_group_name (sec
);
11192 free (prop_sec_name
);
11198 xtensa_get_property_predef_flags (asection
*sec
)
11200 if (xtensa_is_insntable_section (sec
))
11201 return (XTENSA_PROP_INSN
11202 | XTENSA_PROP_NO_TRANSFORM
11203 | XTENSA_PROP_INSN_NO_REORDER
);
11205 if (xtensa_is_littable_section (sec
))
11206 return (XTENSA_PROP_LITERAL
11207 | XTENSA_PROP_NO_TRANSFORM
11208 | XTENSA_PROP_INSN_NO_REORDER
);
11214 /* Other functions called directly by the linker. */
11217 xtensa_callback_required_dependence (bfd
*abfd
,
11219 struct bfd_link_info
*link_info
,
11220 deps_callback_t callback
,
11223 Elf_Internal_Rela
*internal_relocs
;
11224 bfd_byte
*contents
;
11226 bfd_boolean ok
= TRUE
;
11227 bfd_size_type sec_size
;
11229 sec_size
= bfd_get_section_limit (abfd
, sec
);
11231 /* ".plt*" sections have no explicit relocations but they contain L32R
11232 instructions that reference the corresponding ".got.plt*" sections. */
11233 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11234 && CONST_STRNEQ (sec
->name
, ".plt"))
11238 /* Find the corresponding ".got.plt*" section. */
11239 if (sec
->name
[4] == '\0')
11240 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11246 BFD_ASSERT (sec
->name
[4] == '.');
11247 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11249 sprintf (got_name
, ".got.plt.%u", chunk
);
11250 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11252 BFD_ASSERT (sgotplt
);
11254 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11255 section referencing a literal at the very beginning of
11256 ".got.plt". This is very close to the real dependence, anyway. */
11257 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11260 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11261 when building uclibc, which runs "ld -b binary /dev/null". */
11262 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11265 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11266 link_info
->keep_memory
);
11267 if (internal_relocs
== NULL
11268 || sec
->reloc_count
== 0)
11271 /* Cache the contents for the duration of this scan. */
11272 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11273 if (contents
== NULL
&& sec_size
!= 0)
11279 if (!xtensa_default_isa
)
11280 xtensa_default_isa
= xtensa_isa_init (0, 0);
11282 for (i
= 0; i
< sec
->reloc_count
; i
++)
11284 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11285 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11288 asection
*target_sec
;
11289 bfd_vma target_offset
;
11291 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11294 /* L32Rs must be local to the input file. */
11295 if (r_reloc_is_defined (&l32r_rel
))
11297 target_sec
= r_reloc_get_section (&l32r_rel
);
11298 target_offset
= l32r_rel
.target_offset
;
11300 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11306 release_internal_relocs (sec
, internal_relocs
);
11307 release_contents (sec
, contents
);
11311 /* The default literal sections should always be marked as "code" (i.e.,
11312 SHF_EXECINSTR). This is particularly important for the Linux kernel
11313 module loader so that the literals are not placed after the text. */
11314 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11316 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11317 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11318 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11319 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11320 { NULL
, 0, 0, 0, 0 }
11323 #define ELF_TARGET_ID XTENSA_ELF_DATA
11325 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11326 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11327 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11328 #define TARGET_BIG_NAME "elf32-xtensa-be"
11329 #define ELF_ARCH bfd_arch_xtensa
11331 #define ELF_MACHINE_CODE EM_XTENSA
11332 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11334 #define ELF_MAXPAGESIZE 0x1000
11335 #endif /* ELF_ARCH */
11337 #define elf_backend_can_gc_sections 1
11338 #define elf_backend_can_refcount 1
11339 #define elf_backend_plt_readonly 1
11340 #define elf_backend_got_header_size 4
11341 #define elf_backend_want_dynbss 0
11342 #define elf_backend_want_got_plt 1
11343 #define elf_backend_dtrel_excludes_plt 1
11345 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11347 #define bfd_elf32_mkobject elf_xtensa_mkobject
11349 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11350 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11351 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11352 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11353 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11354 #define bfd_elf32_bfd_reloc_name_lookup \
11355 elf_xtensa_reloc_name_lookup
11356 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11357 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11359 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11360 #define elf_backend_check_relocs elf_xtensa_check_relocs
11361 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11362 #define elf_backend_discard_info elf_xtensa_discard_info
11363 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11364 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11365 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11366 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11367 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11368 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
11369 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11370 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11371 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11372 #define elf_backend_object_p elf_xtensa_object_p
11373 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11374 #define elf_backend_relocate_section elf_xtensa_relocate_section
11375 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11376 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11377 #define elf_backend_omit_section_dynsym \
11378 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
11379 #define elf_backend_special_sections elf_xtensa_special_sections
11380 #define elf_backend_action_discarded elf_xtensa_action_discarded
11381 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11383 #include "elf32-target.h"