Do not create $(bfdlibdir) and $(bfdincludedir) if !INSTALL_LIBBFD.
[binutils.git] / bfd / elf32-xtensa.c
blob4200f6fbdb46af9c4340defb6461f3325dd77a59
1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright 2003, 2004, 2005, 2006, 2007, 2008 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
19 02110-1301, USA. */
21 #include "sysdep.h"
22 #include "bfd.h"
24 #include <stdarg.h>
25 #include <strings.h>
27 #include "bfdlink.h"
28 #include "libbfd.h"
29 #include "elf-bfd.h"
30 #include "elf/xtensa.h"
31 #include "xtensa-isa.h"
32 #include "xtensa-config.h"
34 #define XTENSA_NO_NOP_REMOVAL 0
36 /* Local helper functions. */
38 static bfd_boolean add_extra_plt_sections (struct bfd_link_info *, int);
39 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
40 static bfd_reloc_status_type bfd_elf_xtensa_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_boolean do_fix_for_relocatable_link
43 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *);
44 static void do_fix_for_final_link
45 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *, bfd_vma *);
47 /* Local functions to handle Xtensa configurability. */
49 static bfd_boolean is_indirect_call_opcode (xtensa_opcode);
50 static bfd_boolean is_direct_call_opcode (xtensa_opcode);
51 static bfd_boolean is_windowed_call_opcode (xtensa_opcode);
52 static xtensa_opcode get_const16_opcode (void);
53 static xtensa_opcode get_l32r_opcode (void);
54 static bfd_vma l32r_offset (bfd_vma, bfd_vma);
55 static int get_relocation_opnd (xtensa_opcode, int);
56 static int get_relocation_slot (int);
57 static xtensa_opcode get_relocation_opcode
58 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
59 static bfd_boolean is_l32r_relocation
60 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
61 static bfd_boolean is_alt_relocation (int);
62 static bfd_boolean is_operand_relocation (int);
63 static bfd_size_type insn_decode_len
64 (bfd_byte *, bfd_size_type, bfd_size_type);
65 static xtensa_opcode insn_decode_opcode
66 (bfd_byte *, bfd_size_type, bfd_size_type, int);
67 static bfd_boolean check_branch_target_aligned
68 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
69 static bfd_boolean check_loop_aligned
70 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
71 static bfd_boolean check_branch_target_aligned_address (bfd_vma, int);
72 static bfd_size_type get_asm_simplify_size
73 (bfd_byte *, bfd_size_type, bfd_size_type);
75 /* Functions for link-time code simplifications. */
77 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
78 (bfd_byte *, bfd_vma, bfd_vma, char **);
79 static bfd_reloc_status_type contract_asm_expansion
80 (bfd_byte *, bfd_vma, Elf_Internal_Rela *, char **);
81 static xtensa_opcode swap_callx_for_call_opcode (xtensa_opcode);
82 static xtensa_opcode get_expanded_call_opcode (bfd_byte *, int, bfd_boolean *);
84 /* Access to internal relocations, section contents and symbols. */
86 static Elf_Internal_Rela *retrieve_internal_relocs
87 (bfd *, asection *, bfd_boolean);
88 static void pin_internal_relocs (asection *, Elf_Internal_Rela *);
89 static void release_internal_relocs (asection *, Elf_Internal_Rela *);
90 static bfd_byte *retrieve_contents (bfd *, asection *, bfd_boolean);
91 static void pin_contents (asection *, bfd_byte *);
92 static void release_contents (asection *, bfd_byte *);
93 static Elf_Internal_Sym *retrieve_local_syms (bfd *);
95 /* Miscellaneous utility functions. */
97 static asection *elf_xtensa_get_plt_section (struct bfd_link_info *, int);
98 static asection *elf_xtensa_get_gotplt_section (struct bfd_link_info *, int);
99 static asection *get_elf_r_symndx_section (bfd *, unsigned long);
100 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
101 (bfd *, unsigned long);
102 static bfd_vma get_elf_r_symndx_offset (bfd *, unsigned long);
103 static bfd_boolean is_reloc_sym_weak (bfd *, Elf_Internal_Rela *);
104 static bfd_boolean pcrel_reloc_fits (xtensa_opcode, int, bfd_vma, bfd_vma);
105 static bfd_boolean xtensa_is_property_section (asection *);
106 static bfd_boolean xtensa_is_insntable_section (asection *);
107 static bfd_boolean xtensa_is_littable_section (asection *);
108 static bfd_boolean xtensa_is_proptable_section (asection *);
109 static int internal_reloc_compare (const void *, const void *);
110 static int internal_reloc_matches (const void *, const void *);
111 static asection *xtensa_get_property_section (asection *, const char *);
112 extern asection *xtensa_make_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
141 this information. */
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;
158 static reloc_howto_type elf_howto_table[] =
160 HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
161 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
162 FALSE, 0, 0, FALSE),
163 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
164 bfd_elf_xtensa_reloc, "R_XTENSA_32",
165 TRUE, 0xffffffff, 0xffffffff, FALSE),
167 /* Replace a 32-bit value with a value from the runtime linker (only
168 used by linker-generated stub functions). The r_addend value is
169 special: 1 means to substitute a pointer to the runtime linker's
170 dynamic resolver function; 2 means to substitute the link map for
171 the shared object. */
172 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
173 NULL, "R_XTENSA_RTLD", FALSE, 0, 0, FALSE),
175 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
176 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
177 FALSE, 0, 0xffffffff, FALSE),
178 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
179 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
180 FALSE, 0, 0xffffffff, FALSE),
181 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
182 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
183 FALSE, 0, 0xffffffff, FALSE),
184 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
185 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
186 FALSE, 0, 0xffffffff, FALSE),
188 EMPTY_HOWTO (7),
190 /* Old relocations for backward compatibility. */
191 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
192 bfd_elf_xtensa_reloc, "R_XTENSA_OP0", FALSE, 0, 0, TRUE),
193 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
194 bfd_elf_xtensa_reloc, "R_XTENSA_OP1", FALSE, 0, 0, TRUE),
195 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
196 bfd_elf_xtensa_reloc, "R_XTENSA_OP2", FALSE, 0, 0, TRUE),
198 /* Assembly auto-expansion. */
199 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
200 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND", FALSE, 0, 0, TRUE),
201 /* Relax assembly auto-expansion. */
202 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
203 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY", FALSE, 0, 0, TRUE),
205 EMPTY_HOWTO (13),
207 HOWTO (R_XTENSA_32_PCREL, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
208 bfd_elf_xtensa_reloc, "R_XTENSA_32_PCREL",
209 FALSE, 0, 0xffffffff, TRUE),
211 /* GNU extension to record C++ vtable hierarchy. */
212 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
213 NULL, "R_XTENSA_GNU_VTINHERIT",
214 FALSE, 0, 0, FALSE),
215 /* GNU extension to record C++ vtable member usage. */
216 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
217 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
218 FALSE, 0, 0, FALSE),
220 /* Relocations for supporting difference of symbols. */
221 HOWTO (R_XTENSA_DIFF8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
222 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF8", FALSE, 0, 0xff, FALSE),
223 HOWTO (R_XTENSA_DIFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
224 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF16", FALSE, 0, 0xffff, FALSE),
225 HOWTO (R_XTENSA_DIFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
226 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF32", FALSE, 0, 0xffffffff, FALSE),
228 /* General immediate operand relocations. */
229 HOWTO (R_XTENSA_SLOT0_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
230 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_OP", FALSE, 0, 0, TRUE),
231 HOWTO (R_XTENSA_SLOT1_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
232 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_OP", FALSE, 0, 0, TRUE),
233 HOWTO (R_XTENSA_SLOT2_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
234 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_OP", FALSE, 0, 0, TRUE),
235 HOWTO (R_XTENSA_SLOT3_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
236 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_OP", FALSE, 0, 0, TRUE),
237 HOWTO (R_XTENSA_SLOT4_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
238 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_OP", FALSE, 0, 0, TRUE),
239 HOWTO (R_XTENSA_SLOT5_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
240 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_OP", FALSE, 0, 0, TRUE),
241 HOWTO (R_XTENSA_SLOT6_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
242 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_OP", FALSE, 0, 0, TRUE),
243 HOWTO (R_XTENSA_SLOT7_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
244 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_OP", FALSE, 0, 0, TRUE),
245 HOWTO (R_XTENSA_SLOT8_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
246 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_OP", FALSE, 0, 0, TRUE),
247 HOWTO (R_XTENSA_SLOT9_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
248 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_OP", FALSE, 0, 0, TRUE),
249 HOWTO (R_XTENSA_SLOT10_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
250 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_OP", FALSE, 0, 0, TRUE),
251 HOWTO (R_XTENSA_SLOT11_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
252 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_OP", FALSE, 0, 0, TRUE),
253 HOWTO (R_XTENSA_SLOT12_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
254 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_OP", FALSE, 0, 0, TRUE),
255 HOWTO (R_XTENSA_SLOT13_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
256 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_OP", FALSE, 0, 0, TRUE),
257 HOWTO (R_XTENSA_SLOT14_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
258 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_OP", FALSE, 0, 0, TRUE),
260 /* "Alternate" relocations. The meaning of these is opcode-specific. */
261 HOWTO (R_XTENSA_SLOT0_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
262 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_ALT", FALSE, 0, 0, TRUE),
263 HOWTO (R_XTENSA_SLOT1_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
264 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_ALT", FALSE, 0, 0, TRUE),
265 HOWTO (R_XTENSA_SLOT2_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
266 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_ALT", FALSE, 0, 0, TRUE),
267 HOWTO (R_XTENSA_SLOT3_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
268 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_ALT", FALSE, 0, 0, TRUE),
269 HOWTO (R_XTENSA_SLOT4_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
270 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_ALT", FALSE, 0, 0, TRUE),
271 HOWTO (R_XTENSA_SLOT5_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
272 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_ALT", FALSE, 0, 0, TRUE),
273 HOWTO (R_XTENSA_SLOT6_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
274 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_ALT", FALSE, 0, 0, TRUE),
275 HOWTO (R_XTENSA_SLOT7_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
276 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_ALT", FALSE, 0, 0, TRUE),
277 HOWTO (R_XTENSA_SLOT8_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
278 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_ALT", FALSE, 0, 0, TRUE),
279 HOWTO (R_XTENSA_SLOT9_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
280 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_ALT", FALSE, 0, 0, TRUE),
281 HOWTO (R_XTENSA_SLOT10_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
282 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_ALT", FALSE, 0, 0, TRUE),
283 HOWTO (R_XTENSA_SLOT11_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
284 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_ALT", FALSE, 0, 0, TRUE),
285 HOWTO (R_XTENSA_SLOT12_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
286 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_ALT", FALSE, 0, 0, TRUE),
287 HOWTO (R_XTENSA_SLOT13_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
288 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_ALT", FALSE, 0, 0, TRUE),
289 HOWTO (R_XTENSA_SLOT14_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
290 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_ALT", FALSE, 0, 0, TRUE),
292 /* TLS relocations. */
293 HOWTO (R_XTENSA_TLSDESC_FN, 0, 2, 32, FALSE, 0, complain_overflow_dont,
294 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_FN",
295 FALSE, 0, 0xffffffff, FALSE),
296 HOWTO (R_XTENSA_TLSDESC_ARG, 0, 2, 32, FALSE, 0, complain_overflow_dont,
297 bfd_elf_xtensa_reloc, "R_XTENSA_TLSDESC_ARG",
298 FALSE, 0, 0xffffffff, FALSE),
299 HOWTO (R_XTENSA_TLS_DTPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
300 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_DTPOFF",
301 FALSE, 0, 0xffffffff, FALSE),
302 HOWTO (R_XTENSA_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_dont,
303 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_TPOFF",
304 FALSE, 0, 0xffffffff, FALSE),
305 HOWTO (R_XTENSA_TLS_FUNC, 0, 0, 0, FALSE, 0, complain_overflow_dont,
306 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_FUNC",
307 FALSE, 0, 0, FALSE),
308 HOWTO (R_XTENSA_TLS_ARG, 0, 0, 0, FALSE, 0, complain_overflow_dont,
309 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_ARG",
310 FALSE, 0, 0, FALSE),
311 HOWTO (R_XTENSA_TLS_CALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
312 bfd_elf_xtensa_reloc, "R_XTENSA_TLS_CALL",
313 FALSE, 0, 0, FALSE),
316 #if DEBUG_GEN_RELOC
317 #define TRACE(str) \
318 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
319 #else
320 #define TRACE(str)
321 #endif
323 static reloc_howto_type *
324 elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
325 bfd_reloc_code_real_type code)
327 switch (code)
329 case BFD_RELOC_NONE:
330 TRACE ("BFD_RELOC_NONE");
331 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
333 case BFD_RELOC_32:
334 TRACE ("BFD_RELOC_32");
335 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
337 case BFD_RELOC_32_PCREL:
338 TRACE ("BFD_RELOC_32_PCREL");
339 return &elf_howto_table[(unsigned) R_XTENSA_32_PCREL ];
341 case BFD_RELOC_XTENSA_DIFF8:
342 TRACE ("BFD_RELOC_XTENSA_DIFF8");
343 return &elf_howto_table[(unsigned) R_XTENSA_DIFF8 ];
345 case BFD_RELOC_XTENSA_DIFF16:
346 TRACE ("BFD_RELOC_XTENSA_DIFF16");
347 return &elf_howto_table[(unsigned) R_XTENSA_DIFF16 ];
349 case BFD_RELOC_XTENSA_DIFF32:
350 TRACE ("BFD_RELOC_XTENSA_DIFF32");
351 return &elf_howto_table[(unsigned) R_XTENSA_DIFF32 ];
353 case BFD_RELOC_XTENSA_RTLD:
354 TRACE ("BFD_RELOC_XTENSA_RTLD");
355 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
357 case BFD_RELOC_XTENSA_GLOB_DAT:
358 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
359 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
361 case BFD_RELOC_XTENSA_JMP_SLOT:
362 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
363 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
365 case BFD_RELOC_XTENSA_RELATIVE:
366 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
367 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
369 case BFD_RELOC_XTENSA_PLT:
370 TRACE ("BFD_RELOC_XTENSA_PLT");
371 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
373 case BFD_RELOC_XTENSA_OP0:
374 TRACE ("BFD_RELOC_XTENSA_OP0");
375 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
377 case BFD_RELOC_XTENSA_OP1:
378 TRACE ("BFD_RELOC_XTENSA_OP1");
379 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
381 case BFD_RELOC_XTENSA_OP2:
382 TRACE ("BFD_RELOC_XTENSA_OP2");
383 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
385 case BFD_RELOC_XTENSA_ASM_EXPAND:
386 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
387 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
389 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
390 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
391 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
393 case BFD_RELOC_VTABLE_INHERIT:
394 TRACE ("BFD_RELOC_VTABLE_INHERIT");
395 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
397 case BFD_RELOC_VTABLE_ENTRY:
398 TRACE ("BFD_RELOC_VTABLE_ENTRY");
399 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
401 case BFD_RELOC_XTENSA_TLSDESC_FN:
402 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
403 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_FN ];
405 case BFD_RELOC_XTENSA_TLSDESC_ARG:
406 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
407 return &elf_howto_table[(unsigned) R_XTENSA_TLSDESC_ARG ];
409 case BFD_RELOC_XTENSA_TLS_DTPOFF:
410 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
411 return &elf_howto_table[(unsigned) R_XTENSA_TLS_DTPOFF ];
413 case BFD_RELOC_XTENSA_TLS_TPOFF:
414 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
415 return &elf_howto_table[(unsigned) R_XTENSA_TLS_TPOFF ];
417 case BFD_RELOC_XTENSA_TLS_FUNC:
418 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
419 return &elf_howto_table[(unsigned) R_XTENSA_TLS_FUNC ];
421 case BFD_RELOC_XTENSA_TLS_ARG:
422 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
423 return &elf_howto_table[(unsigned) R_XTENSA_TLS_ARG ];
425 case BFD_RELOC_XTENSA_TLS_CALL:
426 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
427 return &elf_howto_table[(unsigned) R_XTENSA_TLS_CALL ];
429 default:
430 if (code >= BFD_RELOC_XTENSA_SLOT0_OP
431 && code <= BFD_RELOC_XTENSA_SLOT14_OP)
433 unsigned n = (R_XTENSA_SLOT0_OP +
434 (code - BFD_RELOC_XTENSA_SLOT0_OP));
435 return &elf_howto_table[n];
438 if (code >= BFD_RELOC_XTENSA_SLOT0_ALT
439 && code <= BFD_RELOC_XTENSA_SLOT14_ALT)
441 unsigned n = (R_XTENSA_SLOT0_ALT +
442 (code - BFD_RELOC_XTENSA_SLOT0_ALT));
443 return &elf_howto_table[n];
446 break;
449 TRACE ("Unknown");
450 return NULL;
453 static reloc_howto_type *
454 elf_xtensa_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
455 const char *r_name)
457 unsigned int i;
459 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
460 if (elf_howto_table[i].name != NULL
461 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
462 return &elf_howto_table[i];
464 return NULL;
468 /* Given an ELF "rela" relocation, find the corresponding howto and record
469 it in the BFD internal arelent representation of the relocation. */
471 static void
472 elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
473 arelent *cache_ptr,
474 Elf_Internal_Rela *dst)
476 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
478 BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max);
479 cache_ptr->howto = &elf_howto_table[r_type];
483 /* Functions for the Xtensa ELF linker. */
485 /* The name of the dynamic interpreter. This is put in the .interp
486 section. */
488 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
490 /* The size in bytes of an entry in the procedure linkage table.
491 (This does _not_ include the space for the literals associated with
492 the PLT entry.) */
494 #define PLT_ENTRY_SIZE 16
496 /* For _really_ large PLTs, we may need to alternate between literals
497 and code to keep the literals within the 256K range of the L32R
498 instructions in the code. It's unlikely that anyone would ever need
499 such a big PLT, but an arbitrary limit on the PLT size would be bad.
500 Thus, we split the PLT into chunks. Since there's very little
501 overhead (2 extra literals) for each chunk, the chunk size is kept
502 small so that the code for handling multiple chunks get used and
503 tested regularly. With 254 entries, there are 1K of literals for
504 each chunk, and that seems like a nice round number. */
506 #define PLT_ENTRIES_PER_CHUNK 254
508 /* PLT entries are actually used as stub functions for lazy symbol
509 resolution. Once the symbol is resolved, the stub function is never
510 invoked. Note: the 32-byte frame size used here cannot be changed
511 without a corresponding change in the runtime linker. */
513 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
515 0x6c, 0x10, 0x04, /* entry sp, 32 */
516 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
517 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
518 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
519 0x0a, 0x80, 0x00, /* jx a8 */
520 0 /* unused */
523 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
525 0x36, 0x41, 0x00, /* entry sp, 32 */
526 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
527 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
528 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
529 0xa0, 0x08, 0x00, /* jx a8 */
530 0 /* unused */
533 /* The size of the thread control block. */
534 #define TCB_SIZE 8
536 struct elf_xtensa_link_hash_entry
538 struct elf_link_hash_entry elf;
540 bfd_signed_vma tlsfunc_refcount;
542 #define GOT_UNKNOWN 0
543 #define GOT_NORMAL 1
544 #define GOT_TLS_GD 2 /* global or local dynamic */
545 #define GOT_TLS_IE 4 /* initial or local exec */
546 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
547 unsigned char tls_type;
550 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
552 struct elf_xtensa_obj_tdata
554 struct elf_obj_tdata root;
556 /* tls_type for each local got entry. */
557 char *local_got_tls_type;
559 bfd_signed_vma *local_tlsfunc_refcounts;
562 #define elf_xtensa_tdata(abfd) \
563 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
565 #define elf_xtensa_local_got_tls_type(abfd) \
566 (elf_xtensa_tdata (abfd)->local_got_tls_type)
568 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
569 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
571 #define is_xtensa_elf(bfd) \
572 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
573 && elf_tdata (bfd) != NULL \
574 && elf_object_id (bfd) == XTENSA_ELF_TDATA)
576 static bfd_boolean
577 elf_xtensa_mkobject (bfd *abfd)
579 return bfd_elf_allocate_object (abfd, sizeof (struct elf_xtensa_obj_tdata),
580 XTENSA_ELF_TDATA);
583 /* Xtensa ELF linker hash table. */
585 struct elf_xtensa_link_hash_table
587 struct elf_link_hash_table elf;
589 /* Short-cuts to get to dynamic linker sections. */
590 asection *sgot;
591 asection *sgotplt;
592 asection *srelgot;
593 asection *splt;
594 asection *srelplt;
595 asection *sgotloc;
596 asection *spltlittbl;
598 /* Total count of PLT relocations seen during check_relocs.
599 The actual PLT code must be split into multiple sections and all
600 the sections have to be created before size_dynamic_sections,
601 where we figure out the exact number of PLT entries that will be
602 needed. It is OK if this count is an overestimate, e.g., some
603 relocations may be removed by GC. */
604 int plt_reloc_count;
606 struct elf_xtensa_link_hash_entry *tlsbase;
609 /* Get the Xtensa ELF linker hash table from a link_info structure. */
611 #define elf_xtensa_hash_table(p) \
612 ((struct elf_xtensa_link_hash_table *) ((p)->hash))
614 /* Create an entry in an Xtensa ELF linker hash table. */
616 static struct bfd_hash_entry *
617 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry *entry,
618 struct bfd_hash_table *table,
619 const char *string)
621 /* Allocate the structure if it has not already been allocated by a
622 subclass. */
623 if (entry == NULL)
625 entry = bfd_hash_allocate (table,
626 sizeof (struct elf_xtensa_link_hash_entry));
627 if (entry == NULL)
628 return entry;
631 /* Call the allocation method of the superclass. */
632 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
633 if (entry != NULL)
635 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (entry);
636 eh->tlsfunc_refcount = 0;
637 eh->tls_type = GOT_UNKNOWN;
640 return entry;
643 /* Create an Xtensa ELF linker hash table. */
645 static struct bfd_link_hash_table *
646 elf_xtensa_link_hash_table_create (bfd *abfd)
648 struct elf_link_hash_entry *tlsbase;
649 struct elf_xtensa_link_hash_table *ret;
650 bfd_size_type amt = sizeof (struct elf_xtensa_link_hash_table);
652 ret = bfd_malloc (amt);
653 if (ret == NULL)
654 return NULL;
656 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
657 elf_xtensa_link_hash_newfunc,
658 sizeof (struct elf_xtensa_link_hash_entry)))
660 free (ret);
661 return NULL;
664 ret->sgot = NULL;
665 ret->sgotplt = NULL;
666 ret->srelgot = NULL;
667 ret->splt = NULL;
668 ret->srelplt = NULL;
669 ret->sgotloc = NULL;
670 ret->spltlittbl = NULL;
672 ret->plt_reloc_count = 0;
674 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
675 for it later. */
676 tlsbase = elf_link_hash_lookup (&ret->elf, "_TLS_MODULE_BASE_",
677 TRUE, FALSE, FALSE);
678 tlsbase->root.type = bfd_link_hash_new;
679 tlsbase->root.u.undef.abfd = NULL;
680 tlsbase->non_elf = 0;
681 ret->tlsbase = elf_xtensa_hash_entry (tlsbase);
682 ret->tlsbase->tls_type = GOT_UNKNOWN;
684 return &ret->elf.root;
687 /* Copy the extra info we tack onto an elf_link_hash_entry. */
689 static void
690 elf_xtensa_copy_indirect_symbol (struct bfd_link_info *info,
691 struct elf_link_hash_entry *dir,
692 struct elf_link_hash_entry *ind)
694 struct elf_xtensa_link_hash_entry *edir, *eind;
696 edir = elf_xtensa_hash_entry (dir);
697 eind = elf_xtensa_hash_entry (ind);
699 if (ind->root.type == bfd_link_hash_indirect)
701 edir->tlsfunc_refcount += eind->tlsfunc_refcount;
702 eind->tlsfunc_refcount = 0;
704 if (dir->got.refcount <= 0)
706 edir->tls_type = eind->tls_type;
707 eind->tls_type = GOT_UNKNOWN;
711 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
714 static inline bfd_boolean
715 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry *h,
716 struct bfd_link_info *info)
718 /* Check if we should do dynamic things to this symbol. The
719 "ignore_protected" argument need not be set, because Xtensa code
720 does not require special handling of STV_PROTECTED to make function
721 pointer comparisons work properly. The PLT addresses are never
722 used for function pointers. */
724 return _bfd_elf_dynamic_symbol_p (h, info, 0);
728 static int
729 property_table_compare (const void *ap, const void *bp)
731 const property_table_entry *a = (const property_table_entry *) ap;
732 const property_table_entry *b = (const property_table_entry *) bp;
734 if (a->address == b->address)
736 if (a->size != b->size)
737 return (a->size - b->size);
739 if ((a->flags & XTENSA_PROP_ALIGN) != (b->flags & XTENSA_PROP_ALIGN))
740 return ((b->flags & XTENSA_PROP_ALIGN)
741 - (a->flags & XTENSA_PROP_ALIGN));
743 if ((a->flags & XTENSA_PROP_ALIGN)
744 && (GET_XTENSA_PROP_ALIGNMENT (a->flags)
745 != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
746 return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
747 - GET_XTENSA_PROP_ALIGNMENT (b->flags));
749 if ((a->flags & XTENSA_PROP_UNREACHABLE)
750 != (b->flags & XTENSA_PROP_UNREACHABLE))
751 return ((b->flags & XTENSA_PROP_UNREACHABLE)
752 - (a->flags & XTENSA_PROP_UNREACHABLE));
754 return (a->flags - b->flags);
757 return (a->address - b->address);
761 static int
762 property_table_matches (const void *ap, const void *bp)
764 const property_table_entry *a = (const property_table_entry *) ap;
765 const property_table_entry *b = (const property_table_entry *) bp;
767 /* Check if one entry overlaps with the other. */
768 if ((b->address >= a->address && b->address < (a->address + a->size))
769 || (a->address >= b->address && a->address < (b->address + b->size)))
770 return 0;
772 return (a->address - b->address);
776 /* Get the literal table or property table entries for the given
777 section. Sets TABLE_P and returns the number of entries. On
778 error, returns a negative value. */
780 static int
781 xtensa_read_table_entries (bfd *abfd,
782 asection *section,
783 property_table_entry **table_p,
784 const char *sec_name,
785 bfd_boolean output_addr)
787 asection *table_section;
788 bfd_size_type table_size = 0;
789 bfd_byte *table_data;
790 property_table_entry *blocks;
791 int blk, block_count;
792 bfd_size_type num_records;
793 Elf_Internal_Rela *internal_relocs, *irel, *rel_end;
794 bfd_vma section_addr, off;
795 flagword predef_flags;
796 bfd_size_type table_entry_size, section_limit;
798 if (!section
799 || !(section->flags & SEC_ALLOC)
800 || (section->flags & SEC_DEBUGGING))
802 *table_p = NULL;
803 return 0;
806 table_section = xtensa_get_property_section (section, sec_name);
807 if (table_section)
808 table_size = table_section->size;
810 if (table_size == 0)
812 *table_p = NULL;
813 return 0;
816 predef_flags = xtensa_get_property_predef_flags (table_section);
817 table_entry_size = 12;
818 if (predef_flags)
819 table_entry_size -= 4;
821 num_records = table_size / table_entry_size;
822 table_data = retrieve_contents (abfd, table_section, TRUE);
823 blocks = (property_table_entry *)
824 bfd_malloc (num_records * sizeof (property_table_entry));
825 block_count = 0;
827 if (output_addr)
828 section_addr = section->output_section->vma + section->output_offset;
829 else
830 section_addr = section->vma;
832 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
833 if (internal_relocs && !table_section->reloc_done)
835 qsort (internal_relocs, table_section->reloc_count,
836 sizeof (Elf_Internal_Rela), internal_reloc_compare);
837 irel = internal_relocs;
839 else
840 irel = NULL;
842 section_limit = bfd_get_section_limit (abfd, section);
843 rel_end = internal_relocs + table_section->reloc_count;
845 for (off = 0; off < table_size; off += table_entry_size)
847 bfd_vma address = bfd_get_32 (abfd, table_data + off);
849 /* Skip any relocations before the current offset. This should help
850 avoid confusion caused by unexpected relocations for the preceding
851 table entry. */
852 while (irel &&
853 (irel->r_offset < off
854 || (irel->r_offset == off
855 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_NONE)))
857 irel += 1;
858 if (irel >= rel_end)
859 irel = 0;
862 if (irel && irel->r_offset == off)
864 bfd_vma sym_off;
865 unsigned long r_symndx = ELF32_R_SYM (irel->r_info);
866 BFD_ASSERT (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32);
868 if (get_elf_r_symndx_section (abfd, r_symndx) != section)
869 continue;
871 sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
872 BFD_ASSERT (sym_off == 0);
873 address += (section_addr + sym_off + irel->r_addend);
875 else
877 if (address < section_addr
878 || address >= section_addr + section_limit)
879 continue;
882 blocks[block_count].address = address;
883 blocks[block_count].size = bfd_get_32 (abfd, table_data + off + 4);
884 if (predef_flags)
885 blocks[block_count].flags = predef_flags;
886 else
887 blocks[block_count].flags = bfd_get_32 (abfd, table_data + off + 8);
888 block_count++;
891 release_contents (table_section, table_data);
892 release_internal_relocs (table_section, internal_relocs);
894 if (block_count > 0)
896 /* Now sort them into address order for easy reference. */
897 qsort (blocks, block_count, sizeof (property_table_entry),
898 property_table_compare);
900 /* Check that the table contents are valid. Problems may occur,
901 for example, if an unrelocated object file is stripped. */
902 for (blk = 1; blk < block_count; blk++)
904 /* The only circumstance where two entries may legitimately
905 have the same address is when one of them is a zero-size
906 placeholder to mark a place where fill can be inserted.
907 The zero-size entry should come first. */
908 if (blocks[blk - 1].address == blocks[blk].address &&
909 blocks[blk - 1].size != 0)
911 (*_bfd_error_handler) (_("%B(%A): invalid property table"),
912 abfd, section);
913 bfd_set_error (bfd_error_bad_value);
914 free (blocks);
915 return -1;
920 *table_p = blocks;
921 return block_count;
925 static property_table_entry *
926 elf_xtensa_find_property_entry (property_table_entry *property_table,
927 int property_table_size,
928 bfd_vma addr)
930 property_table_entry entry;
931 property_table_entry *rv;
933 if (property_table_size == 0)
934 return NULL;
936 entry.address = addr;
937 entry.size = 1;
938 entry.flags = 0;
940 rv = bsearch (&entry, property_table, property_table_size,
941 sizeof (property_table_entry), property_table_matches);
942 return rv;
946 static bfd_boolean
947 elf_xtensa_in_literal_pool (property_table_entry *lit_table,
948 int lit_table_size,
949 bfd_vma addr)
951 if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
952 return TRUE;
954 return FALSE;
958 /* Look through the relocs for a section during the first phase, and
959 calculate needed space in the dynamic reloc sections. */
961 static bfd_boolean
962 elf_xtensa_check_relocs (bfd *abfd,
963 struct bfd_link_info *info,
964 asection *sec,
965 const Elf_Internal_Rela *relocs)
967 struct elf_xtensa_link_hash_table *htab;
968 Elf_Internal_Shdr *symtab_hdr;
969 struct elf_link_hash_entry **sym_hashes;
970 const Elf_Internal_Rela *rel;
971 const Elf_Internal_Rela *rel_end;
973 if (info->relocatable || (sec->flags & SEC_ALLOC) == 0)
974 return TRUE;
976 BFD_ASSERT (is_xtensa_elf (abfd));
978 htab = elf_xtensa_hash_table (info);
979 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
980 sym_hashes = elf_sym_hashes (abfd);
982 rel_end = relocs + sec->reloc_count;
983 for (rel = relocs; rel < rel_end; rel++)
985 unsigned int r_type;
986 unsigned long r_symndx;
987 struct elf_link_hash_entry *h = NULL;
988 struct elf_xtensa_link_hash_entry *eh;
989 int tls_type, old_tls_type;
990 bfd_boolean is_got = FALSE;
991 bfd_boolean is_plt = FALSE;
992 bfd_boolean is_tlsfunc = FALSE;
994 r_symndx = ELF32_R_SYM (rel->r_info);
995 r_type = ELF32_R_TYPE (rel->r_info);
997 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
999 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1000 abfd, r_symndx);
1001 return FALSE;
1004 if (r_symndx >= symtab_hdr->sh_info)
1006 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1007 while (h->root.type == bfd_link_hash_indirect
1008 || h->root.type == bfd_link_hash_warning)
1009 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1011 eh = elf_xtensa_hash_entry (h);
1013 switch (r_type)
1015 case R_XTENSA_TLSDESC_FN:
1016 if (info->shared)
1018 tls_type = GOT_TLS_GD;
1019 is_got = TRUE;
1020 is_tlsfunc = TRUE;
1022 else
1023 tls_type = GOT_TLS_IE;
1024 break;
1026 case R_XTENSA_TLSDESC_ARG:
1027 if (info->shared)
1029 tls_type = GOT_TLS_GD;
1030 is_got = TRUE;
1032 else
1034 tls_type = GOT_TLS_IE;
1035 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1036 is_got = TRUE;
1038 break;
1040 case R_XTENSA_TLS_DTPOFF:
1041 if (info->shared)
1042 tls_type = GOT_TLS_GD;
1043 else
1044 tls_type = GOT_TLS_IE;
1045 break;
1047 case R_XTENSA_TLS_TPOFF:
1048 tls_type = GOT_TLS_IE;
1049 if (info->shared)
1050 info->flags |= DF_STATIC_TLS;
1051 if (info->shared || h)
1052 is_got = TRUE;
1053 break;
1055 case R_XTENSA_32:
1056 tls_type = GOT_NORMAL;
1057 is_got = TRUE;
1058 break;
1060 case R_XTENSA_PLT:
1061 tls_type = GOT_NORMAL;
1062 is_plt = TRUE;
1063 break;
1065 case R_XTENSA_GNU_VTINHERIT:
1066 /* This relocation describes the C++ object vtable hierarchy.
1067 Reconstruct it for later use during GC. */
1068 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1069 return FALSE;
1070 continue;
1072 case R_XTENSA_GNU_VTENTRY:
1073 /* This relocation describes which C++ vtable entries are actually
1074 used. Record for later use during GC. */
1075 BFD_ASSERT (h != NULL);
1076 if (h != NULL
1077 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1078 return FALSE;
1079 continue;
1081 default:
1082 /* Nothing to do for any other relocations. */
1083 continue;
1086 if (h)
1088 if (is_plt)
1090 if (h->plt.refcount <= 0)
1092 h->needs_plt = 1;
1093 h->plt.refcount = 1;
1095 else
1096 h->plt.refcount += 1;
1098 /* Keep track of the total PLT relocation count even if we
1099 don't yet know whether the dynamic sections will be
1100 created. */
1101 htab->plt_reloc_count += 1;
1103 if (elf_hash_table (info)->dynamic_sections_created)
1105 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1106 return FALSE;
1109 else if (is_got)
1111 if (h->got.refcount <= 0)
1112 h->got.refcount = 1;
1113 else
1114 h->got.refcount += 1;
1117 if (is_tlsfunc)
1118 eh->tlsfunc_refcount += 1;
1120 old_tls_type = eh->tls_type;
1122 else
1124 /* Allocate storage the first time. */
1125 if (elf_local_got_refcounts (abfd) == NULL)
1127 bfd_size_type size = symtab_hdr->sh_info;
1128 void *mem;
1130 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1131 if (mem == NULL)
1132 return FALSE;
1133 elf_local_got_refcounts (abfd) = (bfd_signed_vma *) mem;
1135 mem = bfd_zalloc (abfd, size);
1136 if (mem == NULL)
1137 return FALSE;
1138 elf_xtensa_local_got_tls_type (abfd) = (char *) mem;
1140 mem = bfd_zalloc (abfd, size * sizeof (bfd_signed_vma));
1141 if (mem == NULL)
1142 return FALSE;
1143 elf_xtensa_local_tlsfunc_refcounts (abfd)
1144 = (bfd_signed_vma *) mem;
1147 /* This is a global offset table entry for a local symbol. */
1148 if (is_got || is_plt)
1149 elf_local_got_refcounts (abfd) [r_symndx] += 1;
1151 if (is_tlsfunc)
1152 elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx] += 1;
1154 old_tls_type = elf_xtensa_local_got_tls_type (abfd) [r_symndx];
1157 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_IE))
1158 tls_type |= old_tls_type;
1159 /* If a TLS symbol is accessed using IE at least once,
1160 there is no point to use a dynamic model for it. */
1161 else if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1162 && ((old_tls_type & GOT_TLS_GD) == 0
1163 || (tls_type & GOT_TLS_IE) == 0))
1165 if ((old_tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_GD))
1166 tls_type = old_tls_type;
1167 else if ((old_tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_GD))
1168 tls_type |= old_tls_type;
1169 else
1171 (*_bfd_error_handler)
1172 (_("%B: `%s' accessed both as normal and thread local symbol"),
1173 abfd,
1174 h ? h->root.root.string : "<local>");
1175 return FALSE;
1179 if (old_tls_type != tls_type)
1181 if (eh)
1182 eh->tls_type = tls_type;
1183 else
1184 elf_xtensa_local_got_tls_type (abfd) [r_symndx] = tls_type;
1188 return TRUE;
1192 static void
1193 elf_xtensa_make_sym_local (struct bfd_link_info *info,
1194 struct elf_link_hash_entry *h)
1196 if (info->shared)
1198 if (h->plt.refcount > 0)
1200 /* For shared objects, there's no need for PLT entries for local
1201 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1202 if (h->got.refcount < 0)
1203 h->got.refcount = 0;
1204 h->got.refcount += h->plt.refcount;
1205 h->plt.refcount = 0;
1208 else
1210 /* Don't need any dynamic relocations at all. */
1211 h->plt.refcount = 0;
1212 h->got.refcount = 0;
1217 static void
1218 elf_xtensa_hide_symbol (struct bfd_link_info *info,
1219 struct elf_link_hash_entry *h,
1220 bfd_boolean force_local)
1222 /* For a shared link, move the plt refcount to the got refcount to leave
1223 space for RELATIVE relocs. */
1224 elf_xtensa_make_sym_local (info, h);
1226 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
1230 /* Return the section that should be marked against GC for a given
1231 relocation. */
1233 static asection *
1234 elf_xtensa_gc_mark_hook (asection *sec,
1235 struct bfd_link_info *info,
1236 Elf_Internal_Rela *rel,
1237 struct elf_link_hash_entry *h,
1238 Elf_Internal_Sym *sym)
1240 /* Property sections are marked "KEEP" in the linker scripts, but they
1241 should not cause other sections to be marked. (This approach relies
1242 on elf_xtensa_discard_info to remove property table entries that
1243 describe discarded sections. Alternatively, it might be more
1244 efficient to avoid using "KEEP" in the linker scripts and instead use
1245 the gc_mark_extra_sections hook to mark only the property sections
1246 that describe marked sections. That alternative does not work well
1247 with the current property table sections, which do not correspond
1248 one-to-one with the sections they describe, but that should be fixed
1249 someday.) */
1250 if (xtensa_is_property_section (sec))
1251 return NULL;
1253 if (h != NULL)
1254 switch (ELF32_R_TYPE (rel->r_info))
1256 case R_XTENSA_GNU_VTINHERIT:
1257 case R_XTENSA_GNU_VTENTRY:
1258 return NULL;
1261 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1265 /* Update the GOT & PLT entry reference counts
1266 for the section being removed. */
1268 static bfd_boolean
1269 elf_xtensa_gc_sweep_hook (bfd *abfd,
1270 struct bfd_link_info *info,
1271 asection *sec,
1272 const Elf_Internal_Rela *relocs)
1274 Elf_Internal_Shdr *symtab_hdr;
1275 struct elf_link_hash_entry **sym_hashes;
1276 const Elf_Internal_Rela *rel, *relend;
1277 struct elf_xtensa_link_hash_table *htab;
1279 htab = elf_xtensa_hash_table (info);
1281 if (info->relocatable)
1282 return TRUE;
1284 if ((sec->flags & SEC_ALLOC) == 0)
1285 return TRUE;
1287 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1288 sym_hashes = elf_sym_hashes (abfd);
1290 relend = relocs + sec->reloc_count;
1291 for (rel = relocs; rel < relend; rel++)
1293 unsigned long r_symndx;
1294 unsigned int r_type;
1295 struct elf_link_hash_entry *h = NULL;
1296 struct elf_xtensa_link_hash_entry *eh;
1297 bfd_boolean is_got = FALSE;
1298 bfd_boolean is_plt = FALSE;
1299 bfd_boolean is_tlsfunc = FALSE;
1301 r_symndx = ELF32_R_SYM (rel->r_info);
1302 if (r_symndx >= symtab_hdr->sh_info)
1304 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1305 while (h->root.type == bfd_link_hash_indirect
1306 || h->root.type == bfd_link_hash_warning)
1307 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1309 eh = elf_xtensa_hash_entry (h);
1311 r_type = ELF32_R_TYPE (rel->r_info);
1312 switch (r_type)
1314 case R_XTENSA_TLSDESC_FN:
1315 if (info->shared)
1317 is_got = TRUE;
1318 is_tlsfunc = TRUE;
1320 break;
1322 case R_XTENSA_TLSDESC_ARG:
1323 if (info->shared)
1324 is_got = TRUE;
1325 else
1327 if (h && elf_xtensa_hash_entry (h) != htab->tlsbase)
1328 is_got = TRUE;
1330 break;
1332 case R_XTENSA_TLS_TPOFF:
1333 if (info->shared || h)
1334 is_got = TRUE;
1335 break;
1337 case R_XTENSA_32:
1338 is_got = TRUE;
1339 break;
1341 case R_XTENSA_PLT:
1342 is_plt = TRUE;
1343 break;
1345 default:
1346 continue;
1349 if (h)
1351 if (is_plt)
1353 if (h->plt.refcount > 0)
1354 h->plt.refcount--;
1356 else if (is_got)
1358 if (h->got.refcount > 0)
1359 h->got.refcount--;
1361 if (is_tlsfunc)
1363 if (eh->tlsfunc_refcount > 0)
1364 eh->tlsfunc_refcount--;
1367 else
1369 if (is_got || is_plt)
1371 bfd_signed_vma *got_refcount
1372 = &elf_local_got_refcounts (abfd) [r_symndx];
1373 if (*got_refcount > 0)
1374 *got_refcount -= 1;
1376 if (is_tlsfunc)
1378 bfd_signed_vma *tlsfunc_refcount
1379 = &elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx];
1380 if (*tlsfunc_refcount > 0)
1381 *tlsfunc_refcount -= 1;
1386 return TRUE;
1390 /* Create all the dynamic sections. */
1392 static bfd_boolean
1393 elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1395 struct elf_xtensa_link_hash_table *htab;
1396 flagword flags, noalloc_flags;
1398 htab = elf_xtensa_hash_table (info);
1400 /* First do all the standard stuff. */
1401 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
1402 return FALSE;
1403 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1404 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1405 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1406 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1407 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1409 /* Create any extra PLT sections in case check_relocs has already
1410 been called on all the non-dynamic input files. */
1411 if (! add_extra_plt_sections (info, htab->plt_reloc_count))
1412 return FALSE;
1414 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
1415 | SEC_LINKER_CREATED | SEC_READONLY);
1416 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
1418 /* Mark the ".got.plt" section READONLY. */
1419 if (htab->sgotplt == NULL
1420 || ! bfd_set_section_flags (dynobj, htab->sgotplt, flags))
1421 return FALSE;
1423 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1424 htab->sgotloc = bfd_make_section_with_flags (dynobj, ".got.loc", flags);
1425 if (htab->sgotloc == NULL
1426 || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2))
1427 return FALSE;
1429 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1430 htab->spltlittbl = bfd_make_section_with_flags (dynobj, ".xt.lit.plt",
1431 noalloc_flags);
1432 if (htab->spltlittbl == NULL
1433 || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2))
1434 return FALSE;
1436 return TRUE;
1440 static bfd_boolean
1441 add_extra_plt_sections (struct bfd_link_info *info, int count)
1443 bfd *dynobj = elf_hash_table (info)->dynobj;
1444 int chunk;
1446 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1447 ".got.plt" sections. */
1448 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1450 char *sname;
1451 flagword flags;
1452 asection *s;
1454 /* Stop when we find a section has already been created. */
1455 if (elf_xtensa_get_plt_section (info, chunk))
1456 break;
1458 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1459 | SEC_LINKER_CREATED | SEC_READONLY);
1461 sname = (char *) bfd_malloc (10);
1462 sprintf (sname, ".plt.%u", chunk);
1463 s = bfd_make_section_with_flags (dynobj, sname, flags | SEC_CODE);
1464 if (s == NULL
1465 || ! bfd_set_section_alignment (dynobj, s, 2))
1466 return FALSE;
1468 sname = (char *) bfd_malloc (14);
1469 sprintf (sname, ".got.plt.%u", chunk);
1470 s = bfd_make_section_with_flags (dynobj, sname, flags);
1471 if (s == NULL
1472 || ! bfd_set_section_alignment (dynobj, s, 2))
1473 return FALSE;
1476 return TRUE;
1480 /* Adjust a symbol defined by a dynamic object and referenced by a
1481 regular object. The current definition is in some section of the
1482 dynamic object, but we're not including those sections. We have to
1483 change the definition to something the rest of the link can
1484 understand. */
1486 static bfd_boolean
1487 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1488 struct elf_link_hash_entry *h)
1490 /* If this is a weak symbol, and there is a real definition, the
1491 processor independent code will have arranged for us to see the
1492 real definition first, and we can just use the same value. */
1493 if (h->u.weakdef)
1495 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1496 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1497 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1498 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1499 return TRUE;
1502 /* This is a reference to a symbol defined by a dynamic object. The
1503 reference must go through the GOT, so there's no need for COPY relocs,
1504 .dynbss, etc. */
1506 return TRUE;
1510 static bfd_boolean
1511 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry *h, void *arg)
1513 struct bfd_link_info *info;
1514 struct elf_xtensa_link_hash_table *htab;
1515 struct elf_xtensa_link_hash_entry *eh = elf_xtensa_hash_entry (h);
1517 if (h->root.type == bfd_link_hash_indirect)
1518 return TRUE;
1520 if (h->root.type == bfd_link_hash_warning)
1521 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1523 info = (struct bfd_link_info *) arg;
1524 htab = elf_xtensa_hash_table (info);
1526 /* If we saw any use of an IE model for this symbol, we can then optimize
1527 away GOT entries for any TLSDESC_FN relocs. */
1528 if ((eh->tls_type & GOT_TLS_IE) != 0)
1530 BFD_ASSERT (h->got.refcount >= eh->tlsfunc_refcount);
1531 h->got.refcount -= eh->tlsfunc_refcount;
1534 if (! elf_xtensa_dynamic_symbol_p (h, info))
1535 elf_xtensa_make_sym_local (info, h);
1537 if (h->plt.refcount > 0)
1538 htab->srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1540 if (h->got.refcount > 0)
1541 htab->srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
1543 return TRUE;
1547 static void
1548 elf_xtensa_allocate_local_got_size (struct bfd_link_info *info)
1550 struct elf_xtensa_link_hash_table *htab;
1551 bfd *i;
1553 htab = elf_xtensa_hash_table (info);
1555 for (i = info->input_bfds; i; i = i->link_next)
1557 bfd_signed_vma *local_got_refcounts;
1558 bfd_size_type j, cnt;
1559 Elf_Internal_Shdr *symtab_hdr;
1561 local_got_refcounts = elf_local_got_refcounts (i);
1562 if (!local_got_refcounts)
1563 continue;
1565 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1566 cnt = symtab_hdr->sh_info;
1568 for (j = 0; j < cnt; ++j)
1570 /* If we saw any use of an IE model for this symbol, we can
1571 then optimize away GOT entries for any TLSDESC_FN relocs. */
1572 if ((elf_xtensa_local_got_tls_type (i) [j] & GOT_TLS_IE) != 0)
1574 bfd_signed_vma *tlsfunc_refcount
1575 = &elf_xtensa_local_tlsfunc_refcounts (i) [j];
1576 BFD_ASSERT (local_got_refcounts[j] >= *tlsfunc_refcount);
1577 local_got_refcounts[j] -= *tlsfunc_refcount;
1580 if (local_got_refcounts[j] > 0)
1581 htab->srelgot->size += (local_got_refcounts[j]
1582 * sizeof (Elf32_External_Rela));
1588 /* Set the sizes of the dynamic sections. */
1590 static bfd_boolean
1591 elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1592 struct bfd_link_info *info)
1594 struct elf_xtensa_link_hash_table *htab;
1595 bfd *dynobj, *abfd;
1596 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1597 bfd_boolean relplt, relgot;
1598 int plt_entries, plt_chunks, chunk;
1600 plt_entries = 0;
1601 plt_chunks = 0;
1603 htab = elf_xtensa_hash_table (info);
1604 dynobj = elf_hash_table (info)->dynobj;
1605 if (dynobj == NULL)
1606 abort ();
1607 srelgot = htab->srelgot;
1608 srelplt = htab->srelplt;
1610 if (elf_hash_table (info)->dynamic_sections_created)
1612 BFD_ASSERT (htab->srelgot != NULL
1613 && htab->srelplt != NULL
1614 && htab->sgot != NULL
1615 && htab->spltlittbl != NULL
1616 && htab->sgotloc != NULL);
1618 /* Set the contents of the .interp section to the interpreter. */
1619 if (info->executable)
1621 s = bfd_get_section_by_name (dynobj, ".interp");
1622 if (s == NULL)
1623 abort ();
1624 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1625 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1628 /* Allocate room for one word in ".got". */
1629 htab->sgot->size = 4;
1631 /* Allocate space in ".rela.got" for literals that reference global
1632 symbols and space in ".rela.plt" for literals that have PLT
1633 entries. */
1634 elf_link_hash_traverse (elf_hash_table (info),
1635 elf_xtensa_allocate_dynrelocs,
1636 (void *) info);
1638 /* If we are generating a shared object, we also need space in
1639 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1640 reference local symbols. */
1641 if (info->shared)
1642 elf_xtensa_allocate_local_got_size (info);
1644 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1645 each PLT entry, we need the PLT code plus a 4-byte literal.
1646 For each chunk of ".plt", we also need two more 4-byte
1647 literals, two corresponding entries in ".rela.got", and an
1648 8-byte entry in ".xt.lit.plt". */
1649 spltlittbl = htab->spltlittbl;
1650 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
1651 plt_chunks =
1652 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1654 /* Iterate over all the PLT chunks, including any extra sections
1655 created earlier because the initial count of PLT relocations
1656 was an overestimate. */
1657 for (chunk = 0;
1658 (splt = elf_xtensa_get_plt_section (info, chunk)) != NULL;
1659 chunk++)
1661 int chunk_entries;
1663 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
1664 BFD_ASSERT (sgotplt != NULL);
1666 if (chunk < plt_chunks - 1)
1667 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1668 else if (chunk == plt_chunks - 1)
1669 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1670 else
1671 chunk_entries = 0;
1673 if (chunk_entries != 0)
1675 sgotplt->size = 4 * (chunk_entries + 2);
1676 splt->size = PLT_ENTRY_SIZE * chunk_entries;
1677 srelgot->size += 2 * sizeof (Elf32_External_Rela);
1678 spltlittbl->size += 8;
1680 else
1682 sgotplt->size = 0;
1683 splt->size = 0;
1687 /* Allocate space in ".got.loc" to match the total size of all the
1688 literal tables. */
1689 sgotloc = htab->sgotloc;
1690 sgotloc->size = spltlittbl->size;
1691 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1693 if (abfd->flags & DYNAMIC)
1694 continue;
1695 for (s = abfd->sections; s != NULL; s = s->next)
1697 if (! elf_discarded_section (s)
1698 && xtensa_is_littable_section (s)
1699 && s != spltlittbl)
1700 sgotloc->size += s->size;
1705 /* Allocate memory for dynamic sections. */
1706 relplt = FALSE;
1707 relgot = FALSE;
1708 for (s = dynobj->sections; s != NULL; s = s->next)
1710 const char *name;
1712 if ((s->flags & SEC_LINKER_CREATED) == 0)
1713 continue;
1715 /* It's OK to base decisions on the section name, because none
1716 of the dynobj section names depend upon the input files. */
1717 name = bfd_get_section_name (dynobj, s);
1719 if (CONST_STRNEQ (name, ".rela"))
1721 if (s->size != 0)
1723 if (strcmp (name, ".rela.plt") == 0)
1724 relplt = TRUE;
1725 else if (strcmp (name, ".rela.got") == 0)
1726 relgot = TRUE;
1728 /* We use the reloc_count field as a counter if we need
1729 to copy relocs into the output file. */
1730 s->reloc_count = 0;
1733 else if (! CONST_STRNEQ (name, ".plt.")
1734 && ! CONST_STRNEQ (name, ".got.plt.")
1735 && strcmp (name, ".got") != 0
1736 && strcmp (name, ".plt") != 0
1737 && strcmp (name, ".got.plt") != 0
1738 && strcmp (name, ".xt.lit.plt") != 0
1739 && strcmp (name, ".got.loc") != 0)
1741 /* It's not one of our sections, so don't allocate space. */
1742 continue;
1745 if (s->size == 0)
1747 /* If we don't need this section, strip it from the output
1748 file. We must create the ".plt*" and ".got.plt*"
1749 sections in create_dynamic_sections and/or check_relocs
1750 based on a conservative estimate of the PLT relocation
1751 count, because the sections must be created before the
1752 linker maps input sections to output sections. The
1753 linker does that before size_dynamic_sections, where we
1754 compute the exact size of the PLT, so there may be more
1755 of these sections than are actually needed. */
1756 s->flags |= SEC_EXCLUDE;
1758 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
1760 /* Allocate memory for the section contents. */
1761 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1762 if (s->contents == NULL)
1763 return FALSE;
1767 if (elf_hash_table (info)->dynamic_sections_created)
1769 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1770 known until finish_dynamic_sections, but we need to get the relocs
1771 in place before they are sorted. */
1772 for (chunk = 0; chunk < plt_chunks; chunk++)
1774 Elf_Internal_Rela irela;
1775 bfd_byte *loc;
1777 irela.r_offset = 0;
1778 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1779 irela.r_addend = 0;
1781 loc = (srelgot->contents
1782 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1783 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1784 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1785 loc + sizeof (Elf32_External_Rela));
1786 srelgot->reloc_count += 2;
1789 /* Add some entries to the .dynamic section. We fill in the
1790 values later, in elf_xtensa_finish_dynamic_sections, but we
1791 must add the entries now so that we get the correct size for
1792 the .dynamic section. The DT_DEBUG entry is filled in by the
1793 dynamic linker and used by the debugger. */
1794 #define add_dynamic_entry(TAG, VAL) \
1795 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1797 if (info->executable)
1799 if (!add_dynamic_entry (DT_DEBUG, 0))
1800 return FALSE;
1803 if (relplt)
1805 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1806 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1807 || !add_dynamic_entry (DT_JMPREL, 0))
1808 return FALSE;
1811 if (relgot)
1813 if (!add_dynamic_entry (DT_RELA, 0)
1814 || !add_dynamic_entry (DT_RELASZ, 0)
1815 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1816 return FALSE;
1819 if (!add_dynamic_entry (DT_PLTGOT, 0)
1820 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1821 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1822 return FALSE;
1824 #undef add_dynamic_entry
1826 return TRUE;
1829 static bfd_boolean
1830 elf_xtensa_always_size_sections (bfd *output_bfd,
1831 struct bfd_link_info *info)
1833 struct elf_xtensa_link_hash_table *htab;
1834 asection *tls_sec;
1836 htab = elf_xtensa_hash_table (info);
1837 tls_sec = htab->elf.tls_sec;
1839 if (tls_sec && (htab->tlsbase->tls_type & GOT_TLS_ANY) != 0)
1841 struct elf_link_hash_entry *tlsbase = &htab->tlsbase->elf;
1842 struct bfd_link_hash_entry *bh = &tlsbase->root;
1843 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
1845 tlsbase->type = STT_TLS;
1846 if (!(_bfd_generic_link_add_one_symbol
1847 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1848 tls_sec, 0, NULL, FALSE,
1849 bed->collect, &bh)))
1850 return FALSE;
1851 tlsbase->def_regular = 1;
1852 tlsbase->other = STV_HIDDEN;
1853 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1856 return TRUE;
1860 /* Return the base VMA address which should be subtracted from real addresses
1861 when resolving @dtpoff relocation.
1862 This is PT_TLS segment p_vaddr. */
1864 static bfd_vma
1865 dtpoff_base (struct bfd_link_info *info)
1867 /* If tls_sec is NULL, we should have signalled an error already. */
1868 if (elf_hash_table (info)->tls_sec == NULL)
1869 return 0;
1870 return elf_hash_table (info)->tls_sec->vma;
1873 /* Return the relocation value for @tpoff relocation
1874 if STT_TLS virtual address is ADDRESS. */
1876 static bfd_vma
1877 tpoff (struct bfd_link_info *info, bfd_vma address)
1879 struct elf_link_hash_table *htab = elf_hash_table (info);
1880 bfd_vma base;
1882 /* If tls_sec is NULL, we should have signalled an error already. */
1883 if (htab->tls_sec == NULL)
1884 return 0;
1885 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
1886 return address - htab->tls_sec->vma + base;
1889 /* Perform the specified relocation. The instruction at (contents + address)
1890 is modified to set one operand to represent the value in "relocation". The
1891 operand position is determined by the relocation type recorded in the
1892 howto. */
1894 #define CALL_SEGMENT_BITS (30)
1895 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1897 static bfd_reloc_status_type
1898 elf_xtensa_do_reloc (reloc_howto_type *howto,
1899 bfd *abfd,
1900 asection *input_section,
1901 bfd_vma relocation,
1902 bfd_byte *contents,
1903 bfd_vma address,
1904 bfd_boolean is_weak_undef,
1905 char **error_message)
1907 xtensa_format fmt;
1908 xtensa_opcode opcode;
1909 xtensa_isa isa = xtensa_default_isa;
1910 static xtensa_insnbuf ibuff = NULL;
1911 static xtensa_insnbuf sbuff = NULL;
1912 bfd_vma self_address;
1913 bfd_size_type input_size;
1914 int opnd, slot;
1915 uint32 newval;
1917 if (!ibuff)
1919 ibuff = xtensa_insnbuf_alloc (isa);
1920 sbuff = xtensa_insnbuf_alloc (isa);
1923 input_size = bfd_get_section_limit (abfd, input_section);
1925 /* Calculate the PC address for this instruction. */
1926 self_address = (input_section->output_section->vma
1927 + input_section->output_offset
1928 + address);
1930 switch (howto->type)
1932 case R_XTENSA_NONE:
1933 case R_XTENSA_DIFF8:
1934 case R_XTENSA_DIFF16:
1935 case R_XTENSA_DIFF32:
1936 case R_XTENSA_TLS_FUNC:
1937 case R_XTENSA_TLS_ARG:
1938 case R_XTENSA_TLS_CALL:
1939 return bfd_reloc_ok;
1941 case R_XTENSA_ASM_EXPAND:
1942 if (!is_weak_undef)
1944 /* Check for windowed CALL across a 1GB boundary. */
1945 xtensa_opcode opcode =
1946 get_expanded_call_opcode (contents + address,
1947 input_size - address, 0);
1948 if (is_windowed_call_opcode (opcode))
1950 if ((self_address >> CALL_SEGMENT_BITS)
1951 != (relocation >> CALL_SEGMENT_BITS))
1953 *error_message = "windowed longcall crosses 1GB boundary; "
1954 "return may fail";
1955 return bfd_reloc_dangerous;
1959 return bfd_reloc_ok;
1961 case R_XTENSA_ASM_SIMPLIFY:
1963 /* Convert the L32R/CALLX to CALL. */
1964 bfd_reloc_status_type retval =
1965 elf_xtensa_do_asm_simplify (contents, address, input_size,
1966 error_message);
1967 if (retval != bfd_reloc_ok)
1968 return bfd_reloc_dangerous;
1970 /* The CALL needs to be relocated. Continue below for that part. */
1971 address += 3;
1972 self_address += 3;
1973 howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
1975 break;
1977 case R_XTENSA_32:
1979 bfd_vma x;
1980 x = bfd_get_32 (abfd, contents + address);
1981 x = x + relocation;
1982 bfd_put_32 (abfd, x, contents + address);
1984 return bfd_reloc_ok;
1986 case R_XTENSA_32_PCREL:
1987 bfd_put_32 (abfd, relocation - self_address, contents + address);
1988 return bfd_reloc_ok;
1990 case R_XTENSA_PLT:
1991 case R_XTENSA_TLSDESC_FN:
1992 case R_XTENSA_TLSDESC_ARG:
1993 case R_XTENSA_TLS_DTPOFF:
1994 case R_XTENSA_TLS_TPOFF:
1995 bfd_put_32 (abfd, relocation, contents + address);
1996 return bfd_reloc_ok;
1999 /* Only instruction slot-specific relocations handled below.... */
2000 slot = get_relocation_slot (howto->type);
2001 if (slot == XTENSA_UNDEFINED)
2003 *error_message = "unexpected relocation";
2004 return bfd_reloc_dangerous;
2007 /* Read the instruction into a buffer and decode the opcode. */
2008 xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
2009 input_size - address);
2010 fmt = xtensa_format_decode (isa, ibuff);
2011 if (fmt == XTENSA_UNDEFINED)
2013 *error_message = "cannot decode instruction format";
2014 return bfd_reloc_dangerous;
2017 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
2019 opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
2020 if (opcode == XTENSA_UNDEFINED)
2022 *error_message = "cannot decode instruction opcode";
2023 return bfd_reloc_dangerous;
2026 /* Check for opcode-specific "alternate" relocations. */
2027 if (is_alt_relocation (howto->type))
2029 if (opcode == get_l32r_opcode ())
2031 /* Handle the special-case of non-PC-relative L32R instructions. */
2032 bfd *output_bfd = input_section->output_section->owner;
2033 asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
2034 if (!lit4_sec)
2036 *error_message = "relocation references missing .lit4 section";
2037 return bfd_reloc_dangerous;
2039 self_address = ((lit4_sec->vma & ~0xfff)
2040 + 0x40000 - 3); /* -3 to compensate for do_reloc */
2041 newval = relocation;
2042 opnd = 1;
2044 else if (opcode == get_const16_opcode ())
2046 /* ALT used for high 16 bits. */
2047 newval = relocation >> 16;
2048 opnd = 1;
2050 else
2052 /* No other "alternate" relocations currently defined. */
2053 *error_message = "unexpected relocation";
2054 return bfd_reloc_dangerous;
2057 else /* Not an "alternate" relocation.... */
2059 if (opcode == get_const16_opcode ())
2061 newval = relocation & 0xffff;
2062 opnd = 1;
2064 else
2066 /* ...normal PC-relative relocation.... */
2068 /* Determine which operand is being relocated. */
2069 opnd = get_relocation_opnd (opcode, howto->type);
2070 if (opnd == XTENSA_UNDEFINED)
2072 *error_message = "unexpected relocation";
2073 return bfd_reloc_dangerous;
2076 if (!howto->pc_relative)
2078 *error_message = "expected PC-relative relocation";
2079 return bfd_reloc_dangerous;
2082 newval = relocation;
2086 /* Apply the relocation. */
2087 if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
2088 || xtensa_operand_encode (isa, opcode, opnd, &newval)
2089 || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
2090 sbuff, newval))
2092 const char *opname = xtensa_opcode_name (isa, opcode);
2093 const char *msg;
2095 msg = "cannot encode";
2096 if (is_direct_call_opcode (opcode))
2098 if ((relocation & 0x3) != 0)
2099 msg = "misaligned call target";
2100 else
2101 msg = "call target out of range";
2103 else if (opcode == get_l32r_opcode ())
2105 if ((relocation & 0x3) != 0)
2106 msg = "misaligned literal target";
2107 else if (is_alt_relocation (howto->type))
2108 msg = "literal target out of range (too many literals)";
2109 else if (self_address > relocation)
2110 msg = "literal target out of range (try using text-section-literals)";
2111 else
2112 msg = "literal placed after use";
2115 *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
2116 return bfd_reloc_dangerous;
2119 /* Check for calls across 1GB boundaries. */
2120 if (is_direct_call_opcode (opcode)
2121 && is_windowed_call_opcode (opcode))
2123 if ((self_address >> CALL_SEGMENT_BITS)
2124 != (relocation >> CALL_SEGMENT_BITS))
2126 *error_message =
2127 "windowed call crosses 1GB boundary; return may fail";
2128 return bfd_reloc_dangerous;
2132 /* Write the modified instruction back out of the buffer. */
2133 xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
2134 xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
2135 input_size - address);
2136 return bfd_reloc_ok;
2140 static char *
2141 vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
2143 /* To reduce the size of the memory leak,
2144 we only use a single message buffer. */
2145 static bfd_size_type alloc_size = 0;
2146 static char *message = NULL;
2147 bfd_size_type orig_len, len = 0;
2148 bfd_boolean is_append;
2150 VA_OPEN (ap, arglen);
2151 VA_FIXEDARG (ap, const char *, origmsg);
2153 is_append = (origmsg == message);
2155 orig_len = strlen (origmsg);
2156 len = orig_len + strlen (fmt) + arglen + 20;
2157 if (len > alloc_size)
2159 message = (char *) bfd_realloc_or_free (message, len);
2160 alloc_size = len;
2162 if (message != NULL)
2164 if (!is_append)
2165 memcpy (message, origmsg, orig_len);
2166 vsprintf (message + orig_len, fmt, ap);
2168 VA_CLOSE (ap);
2169 return message;
2173 /* This function is registered as the "special_function" in the
2174 Xtensa howto for handling simplify operations.
2175 bfd_perform_relocation / bfd_install_relocation use it to
2176 perform (install) the specified relocation. Since this replaces the code
2177 in bfd_perform_relocation, it is basically an Xtensa-specific,
2178 stripped-down version of bfd_perform_relocation. */
2180 static bfd_reloc_status_type
2181 bfd_elf_xtensa_reloc (bfd *abfd,
2182 arelent *reloc_entry,
2183 asymbol *symbol,
2184 void *data,
2185 asection *input_section,
2186 bfd *output_bfd,
2187 char **error_message)
2189 bfd_vma relocation;
2190 bfd_reloc_status_type flag;
2191 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2192 bfd_vma output_base = 0;
2193 reloc_howto_type *howto = reloc_entry->howto;
2194 asection *reloc_target_output_section;
2195 bfd_boolean is_weak_undef;
2197 if (!xtensa_default_isa)
2198 xtensa_default_isa = xtensa_isa_init (0, 0);
2200 /* ELF relocs are against symbols. If we are producing relocatable
2201 output, and the reloc is against an external symbol, the resulting
2202 reloc will also be against the same symbol. In such a case, we
2203 don't want to change anything about the way the reloc is handled,
2204 since it will all be done at final link time. This test is similar
2205 to what bfd_elf_generic_reloc does except that it lets relocs with
2206 howto->partial_inplace go through even if the addend is non-zero.
2207 (The real problem is that partial_inplace is set for XTENSA_32
2208 relocs to begin with, but that's a long story and there's little we
2209 can do about it now....) */
2211 if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
2213 reloc_entry->address += input_section->output_offset;
2214 return bfd_reloc_ok;
2217 /* Is the address of the relocation really within the section? */
2218 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
2219 return bfd_reloc_outofrange;
2221 /* Work out which section the relocation is targeted at and the
2222 initial relocation command value. */
2224 /* Get symbol value. (Common symbols are special.) */
2225 if (bfd_is_com_section (symbol->section))
2226 relocation = 0;
2227 else
2228 relocation = symbol->value;
2230 reloc_target_output_section = symbol->section->output_section;
2232 /* Convert input-section-relative symbol value to absolute. */
2233 if ((output_bfd && !howto->partial_inplace)
2234 || reloc_target_output_section == NULL)
2235 output_base = 0;
2236 else
2237 output_base = reloc_target_output_section->vma;
2239 relocation += output_base + symbol->section->output_offset;
2241 /* Add in supplied addend. */
2242 relocation += reloc_entry->addend;
2244 /* Here the variable relocation holds the final address of the
2245 symbol we are relocating against, plus any addend. */
2246 if (output_bfd)
2248 if (!howto->partial_inplace)
2250 /* This is a partial relocation, and we want to apply the relocation
2251 to the reloc entry rather than the raw data. Everything except
2252 relocations against section symbols has already been handled
2253 above. */
2255 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
2256 reloc_entry->addend = relocation;
2257 reloc_entry->address += input_section->output_offset;
2258 return bfd_reloc_ok;
2260 else
2262 reloc_entry->address += input_section->output_offset;
2263 reloc_entry->addend = 0;
2267 is_weak_undef = (bfd_is_und_section (symbol->section)
2268 && (symbol->flags & BSF_WEAK) != 0);
2269 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
2270 (bfd_byte *) data, (bfd_vma) octets,
2271 is_weak_undef, error_message);
2273 if (flag == bfd_reloc_dangerous)
2275 /* Add the symbol name to the error message. */
2276 if (! *error_message)
2277 *error_message = "";
2278 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
2279 strlen (symbol->name) + 17,
2280 symbol->name,
2281 (unsigned long) reloc_entry->addend);
2284 return flag;
2288 /* Set up an entry in the procedure linkage table. */
2290 static bfd_vma
2291 elf_xtensa_create_plt_entry (struct bfd_link_info *info,
2292 bfd *output_bfd,
2293 unsigned reloc_index)
2295 asection *splt, *sgotplt;
2296 bfd_vma plt_base, got_base;
2297 bfd_vma code_offset, lit_offset;
2298 int chunk;
2300 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
2301 splt = elf_xtensa_get_plt_section (info, chunk);
2302 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
2303 BFD_ASSERT (splt != NULL && sgotplt != NULL);
2305 plt_base = splt->output_section->vma + splt->output_offset;
2306 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
2308 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
2309 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
2311 /* Fill in the literal entry. This is the offset of the dynamic
2312 relocation entry. */
2313 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
2314 sgotplt->contents + lit_offset);
2316 /* Fill in the entry in the procedure linkage table. */
2317 memcpy (splt->contents + code_offset,
2318 (bfd_big_endian (output_bfd)
2319 ? elf_xtensa_be_plt_entry
2320 : elf_xtensa_le_plt_entry),
2321 PLT_ENTRY_SIZE);
2322 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
2323 plt_base + code_offset + 3),
2324 splt->contents + code_offset + 4);
2325 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
2326 plt_base + code_offset + 6),
2327 splt->contents + code_offset + 7);
2328 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
2329 plt_base + code_offset + 9),
2330 splt->contents + code_offset + 10);
2332 return plt_base + code_offset;
2336 static bfd_boolean get_indirect_call_dest_reg (xtensa_opcode, unsigned *);
2338 static bfd_boolean
2339 replace_tls_insn (Elf_Internal_Rela *rel,
2340 bfd *abfd,
2341 asection *input_section,
2342 bfd_byte *contents,
2343 bfd_boolean is_ld_model,
2344 char **error_message)
2346 static xtensa_insnbuf ibuff = NULL;
2347 static xtensa_insnbuf sbuff = NULL;
2348 xtensa_isa isa = xtensa_default_isa;
2349 xtensa_format fmt;
2350 xtensa_opcode old_op, new_op;
2351 bfd_size_type input_size;
2352 int r_type;
2353 unsigned dest_reg, src_reg;
2355 if (ibuff == NULL)
2357 ibuff = xtensa_insnbuf_alloc (isa);
2358 sbuff = xtensa_insnbuf_alloc (isa);
2361 input_size = bfd_get_section_limit (abfd, input_section);
2363 /* Read the instruction into a buffer and decode the opcode. */
2364 xtensa_insnbuf_from_chars (isa, ibuff, contents + rel->r_offset,
2365 input_size - rel->r_offset);
2366 fmt = xtensa_format_decode (isa, ibuff);
2367 if (fmt == XTENSA_UNDEFINED)
2369 *error_message = "cannot decode instruction format";
2370 return FALSE;
2373 BFD_ASSERT (xtensa_format_num_slots (isa, fmt) == 1);
2374 xtensa_format_get_slot (isa, fmt, 0, ibuff, sbuff);
2376 old_op = xtensa_opcode_decode (isa, fmt, 0, sbuff);
2377 if (old_op == XTENSA_UNDEFINED)
2379 *error_message = "cannot decode instruction opcode";
2380 return FALSE;
2383 r_type = ELF32_R_TYPE (rel->r_info);
2384 switch (r_type)
2386 case R_XTENSA_TLS_FUNC:
2387 case R_XTENSA_TLS_ARG:
2388 if (old_op != get_l32r_opcode ()
2389 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2390 sbuff, &dest_reg) != 0)
2392 *error_message = "cannot extract L32R destination for TLS access";
2393 return FALSE;
2395 break;
2397 case R_XTENSA_TLS_CALL:
2398 if (! get_indirect_call_dest_reg (old_op, &dest_reg)
2399 || xtensa_operand_get_field (isa, old_op, 0, fmt, 0,
2400 sbuff, &src_reg) != 0)
2402 *error_message = "cannot extract CALLXn operands for TLS access";
2403 return FALSE;
2405 break;
2407 default:
2408 abort ();
2411 if (is_ld_model)
2413 switch (r_type)
2415 case R_XTENSA_TLS_FUNC:
2416 case R_XTENSA_TLS_ARG:
2417 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2418 versions of Xtensa). */
2419 new_op = xtensa_opcode_lookup (isa, "nop");
2420 if (new_op == XTENSA_UNDEFINED)
2422 new_op = xtensa_opcode_lookup (isa, "or");
2423 if (new_op == XTENSA_UNDEFINED
2424 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2425 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2426 sbuff, 1) != 0
2427 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2428 sbuff, 1) != 0
2429 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2430 sbuff, 1) != 0)
2432 *error_message = "cannot encode OR for TLS access";
2433 return FALSE;
2436 else
2438 if (xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0)
2440 *error_message = "cannot encode NOP for TLS access";
2441 return FALSE;
2444 break;
2446 case R_XTENSA_TLS_CALL:
2447 /* Read THREADPTR into the CALLX's return value register. */
2448 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2449 if (new_op == XTENSA_UNDEFINED
2450 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2451 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2452 sbuff, dest_reg + 2) != 0)
2454 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2455 return FALSE;
2457 break;
2460 else
2462 switch (r_type)
2464 case R_XTENSA_TLS_FUNC:
2465 new_op = xtensa_opcode_lookup (isa, "rur.threadptr");
2466 if (new_op == XTENSA_UNDEFINED
2467 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2468 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2469 sbuff, dest_reg) != 0)
2471 *error_message = "cannot encode RUR.THREADPTR for TLS access";
2472 return FALSE;
2474 break;
2476 case R_XTENSA_TLS_ARG:
2477 /* Nothing to do. Keep the original L32R instruction. */
2478 return TRUE;
2480 case R_XTENSA_TLS_CALL:
2481 /* Add the CALLX's src register (holding the THREADPTR value)
2482 to the first argument register (holding the offset) and put
2483 the result in the CALLX's return value register. */
2484 new_op = xtensa_opcode_lookup (isa, "add");
2485 if (new_op == XTENSA_UNDEFINED
2486 || xtensa_opcode_encode (isa, fmt, 0, sbuff, new_op) != 0
2487 || xtensa_operand_set_field (isa, new_op, 0, fmt, 0,
2488 sbuff, dest_reg + 2) != 0
2489 || xtensa_operand_set_field (isa, new_op, 1, fmt, 0,
2490 sbuff, dest_reg + 2) != 0
2491 || xtensa_operand_set_field (isa, new_op, 2, fmt, 0,
2492 sbuff, src_reg) != 0)
2494 *error_message = "cannot encode ADD for TLS access";
2495 return FALSE;
2497 break;
2501 xtensa_format_set_slot (isa, fmt, 0, ibuff, sbuff);
2502 xtensa_insnbuf_to_chars (isa, ibuff, contents + rel->r_offset,
2503 input_size - rel->r_offset);
2505 return TRUE;
2509 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2510 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2511 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2512 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2513 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2514 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2515 || (R_TYPE) == R_XTENSA_TLS_ARG \
2516 || (R_TYPE) == R_XTENSA_TLS_CALL)
2518 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2519 both relocatable and final links. */
2521 static bfd_boolean
2522 elf_xtensa_relocate_section (bfd *output_bfd,
2523 struct bfd_link_info *info,
2524 bfd *input_bfd,
2525 asection *input_section,
2526 bfd_byte *contents,
2527 Elf_Internal_Rela *relocs,
2528 Elf_Internal_Sym *local_syms,
2529 asection **local_sections)
2531 struct elf_xtensa_link_hash_table *htab;
2532 Elf_Internal_Shdr *symtab_hdr;
2533 Elf_Internal_Rela *rel;
2534 Elf_Internal_Rela *relend;
2535 struct elf_link_hash_entry **sym_hashes;
2536 property_table_entry *lit_table = 0;
2537 int ltblsize = 0;
2538 char *local_got_tls_types;
2539 char *error_message = NULL;
2540 bfd_size_type input_size;
2541 int tls_type;
2543 if (!xtensa_default_isa)
2544 xtensa_default_isa = xtensa_isa_init (0, 0);
2546 BFD_ASSERT (is_xtensa_elf (input_bfd));
2548 htab = elf_xtensa_hash_table (info);
2549 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2550 sym_hashes = elf_sym_hashes (input_bfd);
2551 local_got_tls_types = elf_xtensa_local_got_tls_type (input_bfd);
2553 if (elf_hash_table (info)->dynamic_sections_created)
2555 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
2556 &lit_table, XTENSA_LIT_SEC_NAME,
2557 TRUE);
2558 if (ltblsize < 0)
2559 return FALSE;
2562 input_size = bfd_get_section_limit (input_bfd, input_section);
2564 rel = relocs;
2565 relend = relocs + input_section->reloc_count;
2566 for (; rel < relend; rel++)
2568 int r_type;
2569 reloc_howto_type *howto;
2570 unsigned long r_symndx;
2571 struct elf_link_hash_entry *h;
2572 Elf_Internal_Sym *sym;
2573 char sym_type;
2574 const char *name;
2575 asection *sec;
2576 bfd_vma relocation;
2577 bfd_reloc_status_type r;
2578 bfd_boolean is_weak_undef;
2579 bfd_boolean unresolved_reloc;
2580 bfd_boolean warned;
2581 bfd_boolean dynamic_symbol;
2583 r_type = ELF32_R_TYPE (rel->r_info);
2584 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2585 || r_type == (int) R_XTENSA_GNU_VTENTRY)
2586 continue;
2588 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2590 bfd_set_error (bfd_error_bad_value);
2591 return FALSE;
2593 howto = &elf_howto_table[r_type];
2595 r_symndx = ELF32_R_SYM (rel->r_info);
2597 h = NULL;
2598 sym = NULL;
2599 sec = NULL;
2600 is_weak_undef = FALSE;
2601 unresolved_reloc = FALSE;
2602 warned = FALSE;
2604 if (howto->partial_inplace && !info->relocatable)
2606 /* Because R_XTENSA_32 was made partial_inplace to fix some
2607 problems with DWARF info in partial links, there may be
2608 an addend stored in the contents. Take it out of there
2609 and move it back into the addend field of the reloc. */
2610 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2611 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2614 if (r_symndx < symtab_hdr->sh_info)
2616 sym = local_syms + r_symndx;
2617 sym_type = ELF32_ST_TYPE (sym->st_info);
2618 sec = local_sections[r_symndx];
2619 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2621 else
2623 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2624 r_symndx, symtab_hdr, sym_hashes,
2625 h, sec, relocation,
2626 unresolved_reloc, warned);
2628 if (relocation == 0
2629 && !unresolved_reloc
2630 && h->root.type == bfd_link_hash_undefweak)
2631 is_weak_undef = TRUE;
2633 sym_type = h->type;
2636 if (sec != NULL && elf_discarded_section (sec))
2638 /* For relocs against symbols from removed linkonce sections,
2639 or sections discarded by a linker script, we just want the
2640 section contents zeroed. Avoid any special processing. */
2641 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2642 rel->r_info = 0;
2643 rel->r_addend = 0;
2644 continue;
2647 if (info->relocatable)
2649 /* This is a relocatable link.
2650 1) If the reloc is against a section symbol, adjust
2651 according to the output section.
2652 2) If there is a new target for this relocation,
2653 the new target will be in the same output section.
2654 We adjust the relocation by the output section
2655 difference. */
2657 if (relaxing_section)
2659 /* Check if this references a section in another input file. */
2660 if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2661 contents))
2662 return FALSE;
2665 if (r_type == R_XTENSA_ASM_SIMPLIFY)
2667 char *error_message = NULL;
2668 /* Convert ASM_SIMPLIFY into the simpler relocation
2669 so that they never escape a relaxing link. */
2670 r = contract_asm_expansion (contents, input_size, rel,
2671 &error_message);
2672 if (r != bfd_reloc_ok)
2674 if (!((*info->callbacks->reloc_dangerous)
2675 (info, error_message, input_bfd, input_section,
2676 rel->r_offset)))
2677 return FALSE;
2679 r_type = ELF32_R_TYPE (rel->r_info);
2682 /* This is a relocatable link, so we don't have to change
2683 anything unless the reloc is against a section symbol,
2684 in which case we have to adjust according to where the
2685 section symbol winds up in the output section. */
2686 if (r_symndx < symtab_hdr->sh_info)
2688 sym = local_syms + r_symndx;
2689 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2691 sec = local_sections[r_symndx];
2692 rel->r_addend += sec->output_offset + sym->st_value;
2696 /* If there is an addend with a partial_inplace howto,
2697 then move the addend to the contents. This is a hack
2698 to work around problems with DWARF in relocatable links
2699 with some previous version of BFD. Now we can't easily get
2700 rid of the hack without breaking backward compatibility.... */
2701 if (rel->r_addend)
2703 howto = &elf_howto_table[r_type];
2704 if (howto->partial_inplace)
2706 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2707 rel->r_addend, contents,
2708 rel->r_offset, FALSE,
2709 &error_message);
2710 if (r != bfd_reloc_ok)
2712 if (!((*info->callbacks->reloc_dangerous)
2713 (info, error_message, input_bfd, input_section,
2714 rel->r_offset)))
2715 return FALSE;
2717 rel->r_addend = 0;
2721 /* Done with work for relocatable link; continue with next reloc. */
2722 continue;
2725 /* This is a final link. */
2727 if (relaxing_section)
2729 /* Check if this references a section in another input file. */
2730 do_fix_for_final_link (rel, input_bfd, input_section, contents,
2731 &relocation);
2734 /* Sanity check the address. */
2735 if (rel->r_offset >= input_size
2736 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2738 (*_bfd_error_handler)
2739 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2740 input_bfd, input_section, rel->r_offset, input_size);
2741 bfd_set_error (bfd_error_bad_value);
2742 return FALSE;
2745 if (h != NULL)
2746 name = h->root.root.string;
2747 else
2749 name = (bfd_elf_string_from_elf_section
2750 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2751 if (name == NULL || *name == '\0')
2752 name = bfd_section_name (input_bfd, sec);
2755 if (r_symndx != 0
2756 && r_type != R_XTENSA_NONE
2757 && (h == NULL
2758 || h->root.type == bfd_link_hash_defined
2759 || h->root.type == bfd_link_hash_defweak)
2760 && IS_XTENSA_TLS_RELOC (r_type) != (sym_type == STT_TLS))
2762 (*_bfd_error_handler)
2763 ((sym_type == STT_TLS
2764 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
2765 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
2766 input_bfd,
2767 input_section,
2768 (long) rel->r_offset,
2769 howto->name,
2770 name);
2773 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
2775 tls_type = GOT_UNKNOWN;
2776 if (h)
2777 tls_type = elf_xtensa_hash_entry (h)->tls_type;
2778 else if (local_got_tls_types)
2779 tls_type = local_got_tls_types [r_symndx];
2781 switch (r_type)
2783 case R_XTENSA_32:
2784 case R_XTENSA_PLT:
2785 if (elf_hash_table (info)->dynamic_sections_created
2786 && (input_section->flags & SEC_ALLOC) != 0
2787 && (dynamic_symbol || info->shared))
2789 Elf_Internal_Rela outrel;
2790 bfd_byte *loc;
2791 asection *srel;
2793 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2794 srel = htab->srelplt;
2795 else
2796 srel = htab->srelgot;
2798 BFD_ASSERT (srel != NULL);
2800 outrel.r_offset =
2801 _bfd_elf_section_offset (output_bfd, info,
2802 input_section, rel->r_offset);
2804 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2805 memset (&outrel, 0, sizeof outrel);
2806 else
2808 outrel.r_offset += (input_section->output_section->vma
2809 + input_section->output_offset);
2811 /* Complain if the relocation is in a read-only section
2812 and not in a literal pool. */
2813 if ((input_section->flags & SEC_READONLY) != 0
2814 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
2815 outrel.r_offset))
2817 error_message =
2818 _("dynamic relocation in read-only section");
2819 if (!((*info->callbacks->reloc_dangerous)
2820 (info, error_message, input_bfd, input_section,
2821 rel->r_offset)))
2822 return FALSE;
2825 if (dynamic_symbol)
2827 outrel.r_addend = rel->r_addend;
2828 rel->r_addend = 0;
2830 if (r_type == R_XTENSA_32)
2832 outrel.r_info =
2833 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2834 relocation = 0;
2836 else /* r_type == R_XTENSA_PLT */
2838 outrel.r_info =
2839 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2841 /* Create the PLT entry and set the initial
2842 contents of the literal entry to the address of
2843 the PLT entry. */
2844 relocation =
2845 elf_xtensa_create_plt_entry (info, output_bfd,
2846 srel->reloc_count);
2848 unresolved_reloc = FALSE;
2850 else
2852 /* Generate a RELATIVE relocation. */
2853 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2854 outrel.r_addend = 0;
2858 loc = (srel->contents
2859 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2860 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2861 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2862 <= srel->size);
2864 else if (r_type == R_XTENSA_ASM_EXPAND && dynamic_symbol)
2866 /* This should only happen for non-PIC code, which is not
2867 supposed to be used on systems with dynamic linking.
2868 Just ignore these relocations. */
2869 continue;
2871 break;
2873 case R_XTENSA_TLS_TPOFF:
2874 /* Switch to LE model for local symbols in an executable. */
2875 if (! info->shared && ! dynamic_symbol)
2877 relocation = tpoff (info, relocation);
2878 break;
2880 /* fall through */
2882 case R_XTENSA_TLSDESC_FN:
2883 case R_XTENSA_TLSDESC_ARG:
2885 if (r_type == R_XTENSA_TLSDESC_FN)
2887 if (! info->shared || (tls_type & GOT_TLS_IE) != 0)
2888 r_type = R_XTENSA_NONE;
2890 else if (r_type == R_XTENSA_TLSDESC_ARG)
2892 if (info->shared)
2894 if ((tls_type & GOT_TLS_IE) != 0)
2895 r_type = R_XTENSA_TLS_TPOFF;
2897 else
2899 r_type = R_XTENSA_TLS_TPOFF;
2900 if (! dynamic_symbol)
2902 relocation = tpoff (info, relocation);
2903 break;
2908 if (r_type == R_XTENSA_NONE)
2909 /* Nothing to do here; skip to the next reloc. */
2910 continue;
2912 if (! elf_hash_table (info)->dynamic_sections_created)
2914 error_message =
2915 _("TLS relocation invalid without dynamic sections");
2916 if (!((*info->callbacks->reloc_dangerous)
2917 (info, error_message, input_bfd, input_section,
2918 rel->r_offset)))
2919 return FALSE;
2921 else
2923 Elf_Internal_Rela outrel;
2924 bfd_byte *loc;
2925 asection *srel = htab->srelgot;
2926 int indx;
2928 outrel.r_offset = (input_section->output_section->vma
2929 + input_section->output_offset
2930 + rel->r_offset);
2932 /* Complain if the relocation is in a read-only section
2933 and not in a literal pool. */
2934 if ((input_section->flags & SEC_READONLY) != 0
2935 && ! elf_xtensa_in_literal_pool (lit_table, ltblsize,
2936 outrel.r_offset))
2938 error_message =
2939 _("dynamic relocation in read-only section");
2940 if (!((*info->callbacks->reloc_dangerous)
2941 (info, error_message, input_bfd, input_section,
2942 rel->r_offset)))
2943 return FALSE;
2946 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2947 if (indx == 0)
2948 outrel.r_addend = relocation - dtpoff_base (info);
2949 else
2950 outrel.r_addend = 0;
2951 rel->r_addend = 0;
2953 outrel.r_info = ELF32_R_INFO (indx, r_type);
2954 relocation = 0;
2955 unresolved_reloc = FALSE;
2957 BFD_ASSERT (srel);
2958 loc = (srel->contents
2959 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2960 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2961 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2962 <= srel->size);
2965 break;
2967 case R_XTENSA_TLS_DTPOFF:
2968 if (! info->shared)
2969 /* Switch from LD model to LE model. */
2970 relocation = tpoff (info, relocation);
2971 else
2972 relocation -= dtpoff_base (info);
2973 break;
2975 case R_XTENSA_TLS_FUNC:
2976 case R_XTENSA_TLS_ARG:
2977 case R_XTENSA_TLS_CALL:
2978 /* Check if optimizing to IE or LE model. */
2979 if ((tls_type & GOT_TLS_IE) != 0)
2981 bfd_boolean is_ld_model =
2982 (h && elf_xtensa_hash_entry (h) == htab->tlsbase);
2983 if (! replace_tls_insn (rel, input_bfd, input_section, contents,
2984 is_ld_model, &error_message))
2986 if (!((*info->callbacks->reloc_dangerous)
2987 (info, error_message, input_bfd, input_section,
2988 rel->r_offset)))
2989 return FALSE;
2992 if (r_type != R_XTENSA_TLS_ARG || is_ld_model)
2994 /* Skip subsequent relocations on the same instruction. */
2995 while (rel + 1 < relend && rel[1].r_offset == rel->r_offset)
2996 rel++;
2999 continue;
3001 default:
3002 if (elf_hash_table (info)->dynamic_sections_created
3003 && dynamic_symbol && (is_operand_relocation (r_type)
3004 || r_type == R_XTENSA_32_PCREL))
3006 error_message =
3007 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
3008 strlen (name) + 2, name);
3009 if (!((*info->callbacks->reloc_dangerous)
3010 (info, error_message, input_bfd, input_section,
3011 rel->r_offset)))
3012 return FALSE;
3013 continue;
3015 break;
3018 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3019 because such sections are not SEC_ALLOC and thus ld.so will
3020 not process them. */
3021 if (unresolved_reloc
3022 && !((input_section->flags & SEC_DEBUGGING) != 0
3023 && h->def_dynamic))
3025 (*_bfd_error_handler)
3026 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3027 input_bfd,
3028 input_section,
3029 (long) rel->r_offset,
3030 howto->name,
3031 name);
3032 return FALSE;
3035 /* TLS optimizations may have changed r_type; update "howto". */
3036 howto = &elf_howto_table[r_type];
3038 /* There's no point in calling bfd_perform_relocation here.
3039 Just go directly to our "special function". */
3040 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
3041 relocation + rel->r_addend,
3042 contents, rel->r_offset, is_weak_undef,
3043 &error_message);
3045 if (r != bfd_reloc_ok && !warned)
3047 BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
3048 BFD_ASSERT (error_message != NULL);
3050 if (rel->r_addend == 0)
3051 error_message = vsprint_msg (error_message, ": %s",
3052 strlen (name) + 2, name);
3053 else
3054 error_message = vsprint_msg (error_message, ": (%s+0x%x)",
3055 strlen (name) + 22,
3056 name, (int) rel->r_addend);
3058 if (!((*info->callbacks->reloc_dangerous)
3059 (info, error_message, input_bfd, input_section,
3060 rel->r_offset)))
3061 return FALSE;
3065 if (lit_table)
3066 free (lit_table);
3068 input_section->reloc_done = TRUE;
3070 return TRUE;
3074 /* Finish up dynamic symbol handling. There's not much to do here since
3075 the PLT and GOT entries are all set up by relocate_section. */
3077 static bfd_boolean
3078 elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
3079 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3080 struct elf_link_hash_entry *h,
3081 Elf_Internal_Sym *sym)
3083 if (h->needs_plt && !h->def_regular)
3085 /* Mark the symbol as undefined, rather than as defined in
3086 the .plt section. Leave the value alone. */
3087 sym->st_shndx = SHN_UNDEF;
3088 /* If the symbol is weak, we do need to clear the value.
3089 Otherwise, the PLT entry would provide a definition for
3090 the symbol even if the symbol wasn't defined anywhere,
3091 and so the symbol would never be NULL. */
3092 if (!h->ref_regular_nonweak)
3093 sym->st_value = 0;
3096 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3097 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3098 || h == elf_hash_table (info)->hgot)
3099 sym->st_shndx = SHN_ABS;
3101 return TRUE;
3105 /* Combine adjacent literal table entries in the output. Adjacent
3106 entries within each input section may have been removed during
3107 relaxation, but we repeat the process here, even though it's too late
3108 to shrink the output section, because it's important to minimize the
3109 number of literal table entries to reduce the start-up work for the
3110 runtime linker. Returns the number of remaining table entries or -1
3111 on error. */
3113 static int
3114 elf_xtensa_combine_prop_entries (bfd *output_bfd,
3115 asection *sxtlit,
3116 asection *sgotloc)
3118 bfd_byte *contents;
3119 property_table_entry *table;
3120 bfd_size_type section_size, sgotloc_size;
3121 bfd_vma offset;
3122 int n, m, num;
3124 section_size = sxtlit->size;
3125 BFD_ASSERT (section_size % 8 == 0);
3126 num = section_size / 8;
3128 sgotloc_size = sgotloc->size;
3129 if (sgotloc_size != section_size)
3131 (*_bfd_error_handler)
3132 (_("internal inconsistency in size of .got.loc section"));
3133 return -1;
3136 table = bfd_malloc (num * sizeof (property_table_entry));
3137 if (table == 0)
3138 return -1;
3140 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3141 propagates to the output section, where it doesn't really apply and
3142 where it breaks the following call to bfd_malloc_and_get_section. */
3143 sxtlit->flags &= ~SEC_IN_MEMORY;
3145 if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
3147 if (contents != 0)
3148 free (contents);
3149 free (table);
3150 return -1;
3153 /* There should never be any relocations left at this point, so this
3154 is quite a bit easier than what is done during relaxation. */
3156 /* Copy the raw contents into a property table array and sort it. */
3157 offset = 0;
3158 for (n = 0; n < num; n++)
3160 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
3161 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
3162 offset += 8;
3164 qsort (table, num, sizeof (property_table_entry), property_table_compare);
3166 for (n = 0; n < num; n++)
3168 bfd_boolean remove = FALSE;
3170 if (table[n].size == 0)
3171 remove = TRUE;
3172 else if (n > 0 &&
3173 (table[n-1].address + table[n-1].size == table[n].address))
3175 table[n-1].size += table[n].size;
3176 remove = TRUE;
3179 if (remove)
3181 for (m = n; m < num - 1; m++)
3183 table[m].address = table[m+1].address;
3184 table[m].size = table[m+1].size;
3187 n--;
3188 num--;
3192 /* Copy the data back to the raw contents. */
3193 offset = 0;
3194 for (n = 0; n < num; n++)
3196 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
3197 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
3198 offset += 8;
3201 /* Clear the removed bytes. */
3202 if ((bfd_size_type) (num * 8) < section_size)
3203 memset (&contents[num * 8], 0, section_size - num * 8);
3205 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
3206 section_size))
3207 return -1;
3209 /* Copy the contents to ".got.loc". */
3210 memcpy (sgotloc->contents, contents, section_size);
3212 free (contents);
3213 free (table);
3214 return num;
3218 /* Finish up the dynamic sections. */
3220 static bfd_boolean
3221 elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
3222 struct bfd_link_info *info)
3224 struct elf_xtensa_link_hash_table *htab;
3225 bfd *dynobj;
3226 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
3227 Elf32_External_Dyn *dyncon, *dynconend;
3228 int num_xtlit_entries = 0;
3230 if (! elf_hash_table (info)->dynamic_sections_created)
3231 return TRUE;
3233 htab = elf_xtensa_hash_table (info);
3234 dynobj = elf_hash_table (info)->dynobj;
3235 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3236 BFD_ASSERT (sdyn != NULL);
3238 /* Set the first entry in the global offset table to the address of
3239 the dynamic section. */
3240 sgot = htab->sgot;
3241 if (sgot)
3243 BFD_ASSERT (sgot->size == 4);
3244 if (sdyn == NULL)
3245 bfd_put_32 (output_bfd, 0, sgot->contents);
3246 else
3247 bfd_put_32 (output_bfd,
3248 sdyn->output_section->vma + sdyn->output_offset,
3249 sgot->contents);
3252 srelplt = htab->srelplt;
3253 if (srelplt && srelplt->size != 0)
3255 asection *sgotplt, *srelgot, *spltlittbl;
3256 int chunk, plt_chunks, plt_entries;
3257 Elf_Internal_Rela irela;
3258 bfd_byte *loc;
3259 unsigned rtld_reloc;
3261 srelgot = htab->srelgot;
3262 spltlittbl = htab->spltlittbl;
3263 BFD_ASSERT (srelgot != NULL && spltlittbl != NULL);
3265 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3266 of them follow immediately after.... */
3267 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
3269 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3270 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3271 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
3272 break;
3274 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
3276 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
3277 plt_chunks =
3278 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
3280 for (chunk = 0; chunk < plt_chunks; chunk++)
3282 int chunk_entries = 0;
3284 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
3285 BFD_ASSERT (sgotplt != NULL);
3287 /* Emit special RTLD relocations for the first two entries in
3288 each chunk of the .got.plt section. */
3290 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
3291 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3292 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3293 irela.r_offset = (sgotplt->output_section->vma
3294 + sgotplt->output_offset);
3295 irela.r_addend = 1; /* tell rtld to set value to resolver function */
3296 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3297 rtld_reloc += 1;
3298 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3300 /* Next literal immediately follows the first. */
3301 loc += sizeof (Elf32_External_Rela);
3302 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
3303 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
3304 irela.r_offset = (sgotplt->output_section->vma
3305 + sgotplt->output_offset + 4);
3306 /* Tell rtld to set value to object's link map. */
3307 irela.r_addend = 2;
3308 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
3309 rtld_reloc += 1;
3310 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
3312 /* Fill in the literal table. */
3313 if (chunk < plt_chunks - 1)
3314 chunk_entries = PLT_ENTRIES_PER_CHUNK;
3315 else
3316 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
3318 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
3319 bfd_put_32 (output_bfd,
3320 sgotplt->output_section->vma + sgotplt->output_offset,
3321 spltlittbl->contents + (chunk * 8) + 0);
3322 bfd_put_32 (output_bfd,
3323 8 + (chunk_entries * 4),
3324 spltlittbl->contents + (chunk * 8) + 4);
3327 /* All the dynamic relocations have been emitted at this point.
3328 Make sure the relocation sections are the correct size. */
3329 if (srelgot->size != (sizeof (Elf32_External_Rela)
3330 * srelgot->reloc_count)
3331 || srelplt->size != (sizeof (Elf32_External_Rela)
3332 * srelplt->reloc_count))
3333 abort ();
3335 /* The .xt.lit.plt section has just been modified. This must
3336 happen before the code below which combines adjacent literal
3337 table entries, and the .xt.lit.plt contents have to be forced to
3338 the output here. */
3339 if (! bfd_set_section_contents (output_bfd,
3340 spltlittbl->output_section,
3341 spltlittbl->contents,
3342 spltlittbl->output_offset,
3343 spltlittbl->size))
3344 return FALSE;
3345 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3346 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
3349 /* Combine adjacent literal table entries. */
3350 BFD_ASSERT (! info->relocatable);
3351 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
3352 sgotloc = htab->sgotloc;
3353 BFD_ASSERT (sgotloc);
3354 if (sxtlit)
3356 num_xtlit_entries =
3357 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
3358 if (num_xtlit_entries < 0)
3359 return FALSE;
3362 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3363 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3364 for (; dyncon < dynconend; dyncon++)
3366 Elf_Internal_Dyn dyn;
3368 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3370 switch (dyn.d_tag)
3372 default:
3373 break;
3375 case DT_XTENSA_GOT_LOC_SZ:
3376 dyn.d_un.d_val = num_xtlit_entries;
3377 break;
3379 case DT_XTENSA_GOT_LOC_OFF:
3380 dyn.d_un.d_ptr = htab->sgotloc->output_section->vma;
3381 break;
3383 case DT_PLTGOT:
3384 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3385 break;
3387 case DT_JMPREL:
3388 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3389 break;
3391 case DT_PLTRELSZ:
3392 dyn.d_un.d_val = htab->srelplt->output_section->size;
3393 break;
3395 case DT_RELASZ:
3396 /* Adjust RELASZ to not include JMPREL. This matches what
3397 glibc expects and what is done for several other ELF
3398 targets (e.g., i386, alpha), but the "correct" behavior
3399 seems to be unresolved. Since the linker script arranges
3400 for .rela.plt to follow all other relocation sections, we
3401 don't have to worry about changing the DT_RELA entry. */
3402 if (htab->srelplt)
3403 dyn.d_un.d_val -= htab->srelplt->output_section->size;
3404 break;
3407 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3410 return TRUE;
3414 /* Functions for dealing with the e_flags field. */
3416 /* Merge backend specific data from an object file to the output
3417 object file when linking. */
3419 static bfd_boolean
3420 elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3422 unsigned out_mach, in_mach;
3423 flagword out_flag, in_flag;
3425 /* Check if we have the same endianess. */
3426 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
3427 return FALSE;
3429 /* Don't even pretend to support mixed-format linking. */
3430 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3431 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3432 return FALSE;
3434 out_flag = elf_elfheader (obfd)->e_flags;
3435 in_flag = elf_elfheader (ibfd)->e_flags;
3437 out_mach = out_flag & EF_XTENSA_MACH;
3438 in_mach = in_flag & EF_XTENSA_MACH;
3439 if (out_mach != in_mach)
3441 (*_bfd_error_handler)
3442 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
3443 ibfd, out_mach, in_mach);
3444 bfd_set_error (bfd_error_wrong_format);
3445 return FALSE;
3448 if (! elf_flags_init (obfd))
3450 elf_flags_init (obfd) = TRUE;
3451 elf_elfheader (obfd)->e_flags = in_flag;
3453 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3454 && bfd_get_arch_info (obfd)->the_default)
3455 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3456 bfd_get_mach (ibfd));
3458 return TRUE;
3461 if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
3462 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
3464 if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
3465 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
3467 return TRUE;
3471 static bfd_boolean
3472 elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
3474 BFD_ASSERT (!elf_flags_init (abfd)
3475 || elf_elfheader (abfd)->e_flags == flags);
3477 elf_elfheader (abfd)->e_flags |= flags;
3478 elf_flags_init (abfd) = TRUE;
3480 return TRUE;
3484 static bfd_boolean
3485 elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
3487 FILE *f = (FILE *) farg;
3488 flagword e_flags = elf_elfheader (abfd)->e_flags;
3490 fprintf (f, "\nXtensa header:\n");
3491 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
3492 fprintf (f, "\nMachine = Base\n");
3493 else
3494 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
3496 fprintf (f, "Insn tables = %s\n",
3497 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
3499 fprintf (f, "Literal tables = %s\n",
3500 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
3502 return _bfd_elf_print_private_bfd_data (abfd, farg);
3506 /* Set the right machine number for an Xtensa ELF file. */
3508 static bfd_boolean
3509 elf_xtensa_object_p (bfd *abfd)
3511 int mach;
3512 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
3514 switch (arch)
3516 case E_XTENSA_MACH:
3517 mach = bfd_mach_xtensa;
3518 break;
3519 default:
3520 return FALSE;
3523 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
3524 return TRUE;
3528 /* The final processing done just before writing out an Xtensa ELF object
3529 file. This gets the Xtensa architecture right based on the machine
3530 number. */
3532 static void
3533 elf_xtensa_final_write_processing (bfd *abfd,
3534 bfd_boolean linker ATTRIBUTE_UNUSED)
3536 int mach;
3537 unsigned long val;
3539 switch (mach = bfd_get_mach (abfd))
3541 case bfd_mach_xtensa:
3542 val = E_XTENSA_MACH;
3543 break;
3544 default:
3545 return;
3548 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
3549 elf_elfheader (abfd)->e_flags |= val;
3553 static enum elf_reloc_type_class
3554 elf_xtensa_reloc_type_class (const Elf_Internal_Rela *rela)
3556 switch ((int) ELF32_R_TYPE (rela->r_info))
3558 case R_XTENSA_RELATIVE:
3559 return reloc_class_relative;
3560 case R_XTENSA_JMP_SLOT:
3561 return reloc_class_plt;
3562 default:
3563 return reloc_class_normal;
3568 static bfd_boolean
3569 elf_xtensa_discard_info_for_section (bfd *abfd,
3570 struct elf_reloc_cookie *cookie,
3571 struct bfd_link_info *info,
3572 asection *sec)
3574 bfd_byte *contents;
3575 bfd_vma offset, actual_offset;
3576 bfd_size_type removed_bytes = 0;
3577 bfd_size_type entry_size;
3579 if (sec->output_section
3580 && bfd_is_abs_section (sec->output_section))
3581 return FALSE;
3583 if (xtensa_is_proptable_section (sec))
3584 entry_size = 12;
3585 else
3586 entry_size = 8;
3588 if (sec->size == 0 || sec->size % entry_size != 0)
3589 return FALSE;
3591 contents = retrieve_contents (abfd, sec, info->keep_memory);
3592 if (!contents)
3593 return FALSE;
3595 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
3596 if (!cookie->rels)
3598 release_contents (sec, contents);
3599 return FALSE;
3602 /* Sort the relocations. They should already be in order when
3603 relaxation is enabled, but it might not be. */
3604 qsort (cookie->rels, sec->reloc_count, sizeof (Elf_Internal_Rela),
3605 internal_reloc_compare);
3607 cookie->rel = cookie->rels;
3608 cookie->relend = cookie->rels + sec->reloc_count;
3610 for (offset = 0; offset < sec->size; offset += entry_size)
3612 actual_offset = offset - removed_bytes;
3614 /* The ...symbol_deleted_p function will skip over relocs but it
3615 won't adjust their offsets, so do that here. */
3616 while (cookie->rel < cookie->relend
3617 && cookie->rel->r_offset < offset)
3619 cookie->rel->r_offset -= removed_bytes;
3620 cookie->rel++;
3623 while (cookie->rel < cookie->relend
3624 && cookie->rel->r_offset == offset)
3626 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
3628 /* Remove the table entry. (If the reloc type is NONE, then
3629 the entry has already been merged with another and deleted
3630 during relaxation.) */
3631 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
3633 /* Shift the contents up. */
3634 if (offset + entry_size < sec->size)
3635 memmove (&contents[actual_offset],
3636 &contents[actual_offset + entry_size],
3637 sec->size - offset - entry_size);
3638 removed_bytes += entry_size;
3641 /* Remove this relocation. */
3642 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
3645 /* Adjust the relocation offset for previous removals. This
3646 should not be done before calling ...symbol_deleted_p
3647 because it might mess up the offset comparisons there.
3648 Make sure the offset doesn't underflow in the case where
3649 the first entry is removed. */
3650 if (cookie->rel->r_offset >= removed_bytes)
3651 cookie->rel->r_offset -= removed_bytes;
3652 else
3653 cookie->rel->r_offset = 0;
3655 cookie->rel++;
3659 if (removed_bytes != 0)
3661 /* Adjust any remaining relocs (shouldn't be any). */
3662 for (; cookie->rel < cookie->relend; cookie->rel++)
3664 if (cookie->rel->r_offset >= removed_bytes)
3665 cookie->rel->r_offset -= removed_bytes;
3666 else
3667 cookie->rel->r_offset = 0;
3670 /* Clear the removed bytes. */
3671 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
3673 pin_contents (sec, contents);
3674 pin_internal_relocs (sec, cookie->rels);
3676 /* Shrink size. */
3677 if (sec->rawsize == 0)
3678 sec->rawsize = sec->size;
3679 sec->size -= removed_bytes;
3681 if (xtensa_is_littable_section (sec))
3683 asection *sgotloc = elf_xtensa_hash_table (info)->sgotloc;
3684 if (sgotloc)
3685 sgotloc->size -= removed_bytes;
3688 else
3690 release_contents (sec, contents);
3691 release_internal_relocs (sec, cookie->rels);
3694 return (removed_bytes != 0);
3698 static bfd_boolean
3699 elf_xtensa_discard_info (bfd *abfd,
3700 struct elf_reloc_cookie *cookie,
3701 struct bfd_link_info *info)
3703 asection *sec;
3704 bfd_boolean changed = FALSE;
3706 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3708 if (xtensa_is_property_section (sec))
3710 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
3711 changed = TRUE;
3715 return changed;
3719 static bfd_boolean
3720 elf_xtensa_ignore_discarded_relocs (asection *sec)
3722 return xtensa_is_property_section (sec);
3726 static unsigned int
3727 elf_xtensa_action_discarded (asection *sec)
3729 if (strcmp (".xt_except_table", sec->name) == 0)
3730 return 0;
3732 if (strcmp (".xt_except_desc", sec->name) == 0)
3733 return 0;
3735 return _bfd_elf_default_action_discarded (sec);
3739 /* Support for core dump NOTE sections. */
3741 static bfd_boolean
3742 elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3744 int offset;
3745 unsigned int size;
3747 /* The size for Xtensa is variable, so don't try to recognize the format
3748 based on the size. Just assume this is GNU/Linux. */
3750 /* pr_cursig */
3751 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3753 /* pr_pid */
3754 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
3756 /* pr_reg */
3757 offset = 72;
3758 size = note->descsz - offset - 4;
3760 /* Make a ".reg/999" section. */
3761 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3762 size, note->descpos + offset);
3766 static bfd_boolean
3767 elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3769 switch (note->descsz)
3771 default:
3772 return FALSE;
3774 case 128: /* GNU/Linux elf_prpsinfo */
3775 elf_tdata (abfd)->core_program
3776 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3777 elf_tdata (abfd)->core_command
3778 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3781 /* Note that for some reason, a spurious space is tacked
3782 onto the end of the args in some (at least one anyway)
3783 implementations, so strip it off if it exists. */
3786 char *command = elf_tdata (abfd)->core_command;
3787 int n = strlen (command);
3789 if (0 < n && command[n - 1] == ' ')
3790 command[n - 1] = '\0';
3793 return TRUE;
3797 /* Generic Xtensa configurability stuff. */
3799 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3800 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3801 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3802 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3803 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3804 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3805 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3806 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3808 static void
3809 init_call_opcodes (void)
3811 if (callx0_op == XTENSA_UNDEFINED)
3813 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3814 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3815 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3816 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3817 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3818 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3819 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3820 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3825 static bfd_boolean
3826 is_indirect_call_opcode (xtensa_opcode opcode)
3828 init_call_opcodes ();
3829 return (opcode == callx0_op
3830 || opcode == callx4_op
3831 || opcode == callx8_op
3832 || opcode == callx12_op);
3836 static bfd_boolean
3837 is_direct_call_opcode (xtensa_opcode opcode)
3839 init_call_opcodes ();
3840 return (opcode == call0_op
3841 || opcode == call4_op
3842 || opcode == call8_op
3843 || opcode == call12_op);
3847 static bfd_boolean
3848 is_windowed_call_opcode (xtensa_opcode opcode)
3850 init_call_opcodes ();
3851 return (opcode == call4_op
3852 || opcode == call8_op
3853 || opcode == call12_op
3854 || opcode == callx4_op
3855 || opcode == callx8_op
3856 || opcode == callx12_op);
3860 static bfd_boolean
3861 get_indirect_call_dest_reg (xtensa_opcode opcode, unsigned *pdst)
3863 unsigned dst = (unsigned) -1;
3865 init_call_opcodes ();
3866 if (opcode == callx0_op)
3867 dst = 0;
3868 else if (opcode == callx4_op)
3869 dst = 4;
3870 else if (opcode == callx8_op)
3871 dst = 8;
3872 else if (opcode == callx12_op)
3873 dst = 12;
3875 if (dst == (unsigned) -1)
3876 return FALSE;
3878 *pdst = dst;
3879 return TRUE;
3883 static xtensa_opcode
3884 get_const16_opcode (void)
3886 static bfd_boolean done_lookup = FALSE;
3887 static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3888 if (!done_lookup)
3890 const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3891 done_lookup = TRUE;
3893 return const16_opcode;
3897 static xtensa_opcode
3898 get_l32r_opcode (void)
3900 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
3901 static bfd_boolean done_lookup = FALSE;
3903 if (!done_lookup)
3905 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
3906 done_lookup = TRUE;
3908 return l32r_opcode;
3912 static bfd_vma
3913 l32r_offset (bfd_vma addr, bfd_vma pc)
3915 bfd_vma offset;
3917 offset = addr - ((pc+3) & -4);
3918 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3919 offset = (signed int) offset >> 2;
3920 BFD_ASSERT ((signed int) offset >> 16 == -1);
3921 return offset;
3925 static int
3926 get_relocation_opnd (xtensa_opcode opcode, int r_type)
3928 xtensa_isa isa = xtensa_default_isa;
3929 int last_immed, last_opnd, opi;
3931 if (opcode == XTENSA_UNDEFINED)
3932 return XTENSA_UNDEFINED;
3934 /* Find the last visible PC-relative immediate operand for the opcode.
3935 If there are no PC-relative immediates, then choose the last visible
3936 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3937 last_immed = XTENSA_UNDEFINED;
3938 last_opnd = xtensa_opcode_num_operands (isa, opcode);
3939 for (opi = last_opnd - 1; opi >= 0; opi--)
3941 if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
3942 continue;
3943 if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
3945 last_immed = opi;
3946 break;
3948 if (last_immed == XTENSA_UNDEFINED
3949 && xtensa_operand_is_register (isa, opcode, opi) == 0)
3950 last_immed = opi;
3952 if (last_immed < 0)
3953 return XTENSA_UNDEFINED;
3955 /* If the operand number was specified in an old-style relocation,
3956 check for consistency with the operand computed above. */
3957 if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
3959 int reloc_opnd = r_type - R_XTENSA_OP0;
3960 if (reloc_opnd != last_immed)
3961 return XTENSA_UNDEFINED;
3964 return last_immed;
3969 get_relocation_slot (int r_type)
3971 switch (r_type)
3973 case R_XTENSA_OP0:
3974 case R_XTENSA_OP1:
3975 case R_XTENSA_OP2:
3976 return 0;
3978 default:
3979 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
3980 return r_type - R_XTENSA_SLOT0_OP;
3981 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
3982 return r_type - R_XTENSA_SLOT0_ALT;
3983 break;
3986 return XTENSA_UNDEFINED;
3990 /* Get the opcode for a relocation. */
3992 static xtensa_opcode
3993 get_relocation_opcode (bfd *abfd,
3994 asection *sec,
3995 bfd_byte *contents,
3996 Elf_Internal_Rela *irel)
3998 static xtensa_insnbuf ibuff = NULL;
3999 static xtensa_insnbuf sbuff = NULL;
4000 xtensa_isa isa = xtensa_default_isa;
4001 xtensa_format fmt;
4002 int slot;
4004 if (contents == NULL)
4005 return XTENSA_UNDEFINED;
4007 if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
4008 return XTENSA_UNDEFINED;
4010 if (ibuff == NULL)
4012 ibuff = xtensa_insnbuf_alloc (isa);
4013 sbuff = xtensa_insnbuf_alloc (isa);
4016 /* Decode the instruction. */
4017 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
4018 sec->size - irel->r_offset);
4019 fmt = xtensa_format_decode (isa, ibuff);
4020 slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
4021 if (slot == XTENSA_UNDEFINED)
4022 return XTENSA_UNDEFINED;
4023 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
4024 return xtensa_opcode_decode (isa, fmt, slot, sbuff);
4028 bfd_boolean
4029 is_l32r_relocation (bfd *abfd,
4030 asection *sec,
4031 bfd_byte *contents,
4032 Elf_Internal_Rela *irel)
4034 xtensa_opcode opcode;
4035 if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
4036 return FALSE;
4037 opcode = get_relocation_opcode (abfd, sec, contents, irel);
4038 return (opcode == get_l32r_opcode ());
4042 static bfd_size_type
4043 get_asm_simplify_size (bfd_byte *contents,
4044 bfd_size_type content_len,
4045 bfd_size_type offset)
4047 bfd_size_type insnlen, size = 0;
4049 /* Decode the size of the next two instructions. */
4050 insnlen = insn_decode_len (contents, content_len, offset);
4051 if (insnlen == 0)
4052 return 0;
4054 size += insnlen;
4056 insnlen = insn_decode_len (contents, content_len, offset + size);
4057 if (insnlen == 0)
4058 return 0;
4060 size += insnlen;
4061 return size;
4065 bfd_boolean
4066 is_alt_relocation (int r_type)
4068 return (r_type >= R_XTENSA_SLOT0_ALT
4069 && r_type <= R_XTENSA_SLOT14_ALT);
4073 bfd_boolean
4074 is_operand_relocation (int r_type)
4076 switch (r_type)
4078 case R_XTENSA_OP0:
4079 case R_XTENSA_OP1:
4080 case R_XTENSA_OP2:
4081 return TRUE;
4083 default:
4084 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
4085 return TRUE;
4086 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
4087 return TRUE;
4088 break;
4091 return FALSE;
4095 #define MIN_INSN_LENGTH 2
4097 /* Return 0 if it fails to decode. */
4099 bfd_size_type
4100 insn_decode_len (bfd_byte *contents,
4101 bfd_size_type content_len,
4102 bfd_size_type offset)
4104 int insn_len;
4105 xtensa_isa isa = xtensa_default_isa;
4106 xtensa_format fmt;
4107 static xtensa_insnbuf ibuff = NULL;
4109 if (offset + MIN_INSN_LENGTH > content_len)
4110 return 0;
4112 if (ibuff == NULL)
4113 ibuff = xtensa_insnbuf_alloc (isa);
4114 xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
4115 content_len - offset);
4116 fmt = xtensa_format_decode (isa, ibuff);
4117 if (fmt == XTENSA_UNDEFINED)
4118 return 0;
4119 insn_len = xtensa_format_length (isa, fmt);
4120 if (insn_len == XTENSA_UNDEFINED)
4121 return 0;
4122 return insn_len;
4126 /* Decode the opcode for a single slot instruction.
4127 Return 0 if it fails to decode or the instruction is multi-slot. */
4129 xtensa_opcode
4130 insn_decode_opcode (bfd_byte *contents,
4131 bfd_size_type content_len,
4132 bfd_size_type offset,
4133 int slot)
4135 xtensa_isa isa = xtensa_default_isa;
4136 xtensa_format fmt;
4137 static xtensa_insnbuf insnbuf = NULL;
4138 static xtensa_insnbuf slotbuf = NULL;
4140 if (offset + MIN_INSN_LENGTH > content_len)
4141 return XTENSA_UNDEFINED;
4143 if (insnbuf == NULL)
4145 insnbuf = xtensa_insnbuf_alloc (isa);
4146 slotbuf = xtensa_insnbuf_alloc (isa);
4149 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4150 content_len - offset);
4151 fmt = xtensa_format_decode (isa, insnbuf);
4152 if (fmt == XTENSA_UNDEFINED)
4153 return XTENSA_UNDEFINED;
4155 if (slot >= xtensa_format_num_slots (isa, fmt))
4156 return XTENSA_UNDEFINED;
4158 xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
4159 return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
4163 /* The offset is the offset in the contents.
4164 The address is the address of that offset. */
4166 static bfd_boolean
4167 check_branch_target_aligned (bfd_byte *contents,
4168 bfd_size_type content_length,
4169 bfd_vma offset,
4170 bfd_vma address)
4172 bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
4173 if (insn_len == 0)
4174 return FALSE;
4175 return check_branch_target_aligned_address (address, insn_len);
4179 static bfd_boolean
4180 check_loop_aligned (bfd_byte *contents,
4181 bfd_size_type content_length,
4182 bfd_vma offset,
4183 bfd_vma address)
4185 bfd_size_type loop_len, insn_len;
4186 xtensa_opcode opcode;
4188 opcode = insn_decode_opcode (contents, content_length, offset, 0);
4189 if (opcode == XTENSA_UNDEFINED
4190 || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
4192 BFD_ASSERT (FALSE);
4193 return FALSE;
4196 loop_len = insn_decode_len (contents, content_length, offset);
4197 insn_len = insn_decode_len (contents, content_length, offset + loop_len);
4198 if (loop_len == 0 || insn_len == 0)
4200 BFD_ASSERT (FALSE);
4201 return FALSE;
4204 return check_branch_target_aligned_address (address + loop_len, insn_len);
4208 static bfd_boolean
4209 check_branch_target_aligned_address (bfd_vma addr, int len)
4211 if (len == 8)
4212 return (addr % 8 == 0);
4213 return ((addr >> 2) == ((addr + len - 1) >> 2));
4217 /* Instruction widening and narrowing. */
4219 /* When FLIX is available we need to access certain instructions only
4220 when they are 16-bit or 24-bit instructions. This table caches
4221 information about such instructions by walking through all the
4222 opcodes and finding the smallest single-slot format into which each
4223 can be encoded. */
4225 static xtensa_format *op_single_fmt_table = NULL;
4228 static void
4229 init_op_single_format_table (void)
4231 xtensa_isa isa = xtensa_default_isa;
4232 xtensa_insnbuf ibuf;
4233 xtensa_opcode opcode;
4234 xtensa_format fmt;
4235 int num_opcodes;
4237 if (op_single_fmt_table)
4238 return;
4240 ibuf = xtensa_insnbuf_alloc (isa);
4241 num_opcodes = xtensa_isa_num_opcodes (isa);
4243 op_single_fmt_table = (xtensa_format *)
4244 bfd_malloc (sizeof (xtensa_format) * num_opcodes);
4245 for (opcode = 0; opcode < num_opcodes; opcode++)
4247 op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
4248 for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
4250 if (xtensa_format_num_slots (isa, fmt) == 1
4251 && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
4253 xtensa_opcode old_fmt = op_single_fmt_table[opcode];
4254 int fmt_length = xtensa_format_length (isa, fmt);
4255 if (old_fmt == XTENSA_UNDEFINED
4256 || fmt_length < xtensa_format_length (isa, old_fmt))
4257 op_single_fmt_table[opcode] = fmt;
4261 xtensa_insnbuf_free (isa, ibuf);
4265 static xtensa_format
4266 get_single_format (xtensa_opcode opcode)
4268 init_op_single_format_table ();
4269 return op_single_fmt_table[opcode];
4273 /* For the set of narrowable instructions we do NOT include the
4274 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4275 involved during linker relaxation that may require these to
4276 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4277 requires special case code to ensure it only works when op1 == op2. */
4279 struct string_pair
4281 const char *wide;
4282 const char *narrow;
4285 struct string_pair narrowable[] =
4287 { "add", "add.n" },
4288 { "addi", "addi.n" },
4289 { "addmi", "addi.n" },
4290 { "l32i", "l32i.n" },
4291 { "movi", "movi.n" },
4292 { "ret", "ret.n" },
4293 { "retw", "retw.n" },
4294 { "s32i", "s32i.n" },
4295 { "or", "mov.n" } /* special case only when op1 == op2 */
4298 struct string_pair widenable[] =
4300 { "add", "add.n" },
4301 { "addi", "addi.n" },
4302 { "addmi", "addi.n" },
4303 { "beqz", "beqz.n" },
4304 { "bnez", "bnez.n" },
4305 { "l32i", "l32i.n" },
4306 { "movi", "movi.n" },
4307 { "ret", "ret.n" },
4308 { "retw", "retw.n" },
4309 { "s32i", "s32i.n" },
4310 { "or", "mov.n" } /* special case only when op1 == op2 */
4314 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4315 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4316 return the instruction buffer holding the narrow instruction. Otherwise,
4317 return 0. The set of valid narrowing are specified by a string table
4318 but require some special case operand checks in some cases. */
4320 static xtensa_insnbuf
4321 can_narrow_instruction (xtensa_insnbuf slotbuf,
4322 xtensa_format fmt,
4323 xtensa_opcode opcode)
4325 xtensa_isa isa = xtensa_default_isa;
4326 xtensa_format o_fmt;
4327 unsigned opi;
4329 static xtensa_insnbuf o_insnbuf = NULL;
4330 static xtensa_insnbuf o_slotbuf = NULL;
4332 if (o_insnbuf == NULL)
4334 o_insnbuf = xtensa_insnbuf_alloc (isa);
4335 o_slotbuf = xtensa_insnbuf_alloc (isa);
4338 for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
4340 bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
4342 if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
4344 uint32 value, newval;
4345 int i, operand_count, o_operand_count;
4346 xtensa_opcode o_opcode;
4348 /* Address does not matter in this case. We might need to
4349 fix it to handle branches/jumps. */
4350 bfd_vma self_address = 0;
4352 o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
4353 if (o_opcode == XTENSA_UNDEFINED)
4354 return 0;
4355 o_fmt = get_single_format (o_opcode);
4356 if (o_fmt == XTENSA_UNDEFINED)
4357 return 0;
4359 if (xtensa_format_length (isa, fmt) != 3
4360 || xtensa_format_length (isa, o_fmt) != 2)
4361 return 0;
4363 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4364 operand_count = xtensa_opcode_num_operands (isa, opcode);
4365 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4367 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4368 return 0;
4370 if (!is_or)
4372 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4373 return 0;
4375 else
4377 uint32 rawval0, rawval1, rawval2;
4379 if (o_operand_count + 1 != operand_count
4380 || xtensa_operand_get_field (isa, opcode, 0,
4381 fmt, 0, slotbuf, &rawval0) != 0
4382 || xtensa_operand_get_field (isa, opcode, 1,
4383 fmt, 0, slotbuf, &rawval1) != 0
4384 || xtensa_operand_get_field (isa, opcode, 2,
4385 fmt, 0, slotbuf, &rawval2) != 0
4386 || rawval1 != rawval2
4387 || rawval0 == rawval1 /* it is a nop */)
4388 return 0;
4391 for (i = 0; i < o_operand_count; ++i)
4393 if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
4394 slotbuf, &value)
4395 || xtensa_operand_decode (isa, opcode, i, &value))
4396 return 0;
4398 /* PC-relative branches need adjustment, but
4399 the PC-rel operand will always have a relocation. */
4400 newval = value;
4401 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4402 self_address)
4403 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4404 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4405 o_slotbuf, newval))
4406 return 0;
4409 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4410 return 0;
4412 return o_insnbuf;
4415 return 0;
4419 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4420 the action in-place directly into the contents and return TRUE. Otherwise,
4421 the return value is FALSE and the contents are not modified. */
4423 static bfd_boolean
4424 narrow_instruction (bfd_byte *contents,
4425 bfd_size_type content_length,
4426 bfd_size_type offset)
4428 xtensa_opcode opcode;
4429 bfd_size_type insn_len;
4430 xtensa_isa isa = xtensa_default_isa;
4431 xtensa_format fmt;
4432 xtensa_insnbuf o_insnbuf;
4434 static xtensa_insnbuf insnbuf = NULL;
4435 static xtensa_insnbuf slotbuf = NULL;
4437 if (insnbuf == NULL)
4439 insnbuf = xtensa_insnbuf_alloc (isa);
4440 slotbuf = xtensa_insnbuf_alloc (isa);
4443 BFD_ASSERT (offset < content_length);
4445 if (content_length < 2)
4446 return FALSE;
4448 /* We will hand-code a few of these for a little while.
4449 These have all been specified in the assembler aleady. */
4450 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4451 content_length - offset);
4452 fmt = xtensa_format_decode (isa, insnbuf);
4453 if (xtensa_format_num_slots (isa, fmt) != 1)
4454 return FALSE;
4456 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4457 return FALSE;
4459 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4460 if (opcode == XTENSA_UNDEFINED)
4461 return FALSE;
4462 insn_len = xtensa_format_length (isa, fmt);
4463 if (insn_len > content_length)
4464 return FALSE;
4466 o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
4467 if (o_insnbuf)
4469 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4470 content_length - offset);
4471 return TRUE;
4474 return FALSE;
4478 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4479 "density" instruction to a standard 3-byte instruction. If it is valid,
4480 return the instruction buffer holding the wide instruction. Otherwise,
4481 return 0. The set of valid widenings are specified by a string table
4482 but require some special case operand checks in some cases. */
4484 static xtensa_insnbuf
4485 can_widen_instruction (xtensa_insnbuf slotbuf,
4486 xtensa_format fmt,
4487 xtensa_opcode opcode)
4489 xtensa_isa isa = xtensa_default_isa;
4490 xtensa_format o_fmt;
4491 unsigned opi;
4493 static xtensa_insnbuf o_insnbuf = NULL;
4494 static xtensa_insnbuf o_slotbuf = NULL;
4496 if (o_insnbuf == NULL)
4498 o_insnbuf = xtensa_insnbuf_alloc (isa);
4499 o_slotbuf = xtensa_insnbuf_alloc (isa);
4502 for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
4504 bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
4505 bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
4506 || strcmp ("bnez", widenable[opi].wide) == 0);
4508 if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
4510 uint32 value, newval;
4511 int i, operand_count, o_operand_count, check_operand_count;
4512 xtensa_opcode o_opcode;
4514 /* Address does not matter in this case. We might need to fix it
4515 to handle branches/jumps. */
4516 bfd_vma self_address = 0;
4518 o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
4519 if (o_opcode == XTENSA_UNDEFINED)
4520 return 0;
4521 o_fmt = get_single_format (o_opcode);
4522 if (o_fmt == XTENSA_UNDEFINED)
4523 return 0;
4525 if (xtensa_format_length (isa, fmt) != 2
4526 || xtensa_format_length (isa, o_fmt) != 3)
4527 return 0;
4529 xtensa_format_encode (isa, o_fmt, o_insnbuf);
4530 operand_count = xtensa_opcode_num_operands (isa, opcode);
4531 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
4532 check_operand_count = o_operand_count;
4534 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
4535 return 0;
4537 if (!is_or)
4539 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
4540 return 0;
4542 else
4544 uint32 rawval0, rawval1;
4546 if (o_operand_count != operand_count + 1
4547 || xtensa_operand_get_field (isa, opcode, 0,
4548 fmt, 0, slotbuf, &rawval0) != 0
4549 || xtensa_operand_get_field (isa, opcode, 1,
4550 fmt, 0, slotbuf, &rawval1) != 0
4551 || rawval0 == rawval1 /* it is a nop */)
4552 return 0;
4554 if (is_branch)
4555 check_operand_count--;
4557 for (i = 0; i < check_operand_count; i++)
4559 int new_i = i;
4560 if (is_or && i == o_operand_count - 1)
4561 new_i = i - 1;
4562 if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
4563 slotbuf, &value)
4564 || xtensa_operand_decode (isa, opcode, new_i, &value))
4565 return 0;
4567 /* PC-relative branches need adjustment, but
4568 the PC-rel operand will always have a relocation. */
4569 newval = value;
4570 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
4571 self_address)
4572 || xtensa_operand_encode (isa, o_opcode, i, &newval)
4573 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
4574 o_slotbuf, newval))
4575 return 0;
4578 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
4579 return 0;
4581 return o_insnbuf;
4584 return 0;
4588 /* Attempt to widen an instruction. If the widening is valid, perform
4589 the action in-place directly into the contents and return TRUE. Otherwise,
4590 the return value is FALSE and the contents are not modified. */
4592 static bfd_boolean
4593 widen_instruction (bfd_byte *contents,
4594 bfd_size_type content_length,
4595 bfd_size_type offset)
4597 xtensa_opcode opcode;
4598 bfd_size_type insn_len;
4599 xtensa_isa isa = xtensa_default_isa;
4600 xtensa_format fmt;
4601 xtensa_insnbuf o_insnbuf;
4603 static xtensa_insnbuf insnbuf = NULL;
4604 static xtensa_insnbuf slotbuf = NULL;
4606 if (insnbuf == NULL)
4608 insnbuf = xtensa_insnbuf_alloc (isa);
4609 slotbuf = xtensa_insnbuf_alloc (isa);
4612 BFD_ASSERT (offset < content_length);
4614 if (content_length < 2)
4615 return FALSE;
4617 /* We will hand-code a few of these for a little while.
4618 These have all been specified in the assembler aleady. */
4619 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
4620 content_length - offset);
4621 fmt = xtensa_format_decode (isa, insnbuf);
4622 if (xtensa_format_num_slots (isa, fmt) != 1)
4623 return FALSE;
4625 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
4626 return FALSE;
4628 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4629 if (opcode == XTENSA_UNDEFINED)
4630 return FALSE;
4631 insn_len = xtensa_format_length (isa, fmt);
4632 if (insn_len > content_length)
4633 return FALSE;
4635 o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
4636 if (o_insnbuf)
4638 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
4639 content_length - offset);
4640 return TRUE;
4642 return FALSE;
4646 /* Code for transforming CALLs at link-time. */
4648 static bfd_reloc_status_type
4649 elf_xtensa_do_asm_simplify (bfd_byte *contents,
4650 bfd_vma address,
4651 bfd_vma content_length,
4652 char **error_message)
4654 static xtensa_insnbuf insnbuf = NULL;
4655 static xtensa_insnbuf slotbuf = NULL;
4656 xtensa_format core_format = XTENSA_UNDEFINED;
4657 xtensa_opcode opcode;
4658 xtensa_opcode direct_call_opcode;
4659 xtensa_isa isa = xtensa_default_isa;
4660 bfd_byte *chbuf = contents + address;
4661 int opn;
4663 if (insnbuf == NULL)
4665 insnbuf = xtensa_insnbuf_alloc (isa);
4666 slotbuf = xtensa_insnbuf_alloc (isa);
4669 if (content_length < address)
4671 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4672 return bfd_reloc_other;
4675 opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
4676 direct_call_opcode = swap_callx_for_call_opcode (opcode);
4677 if (direct_call_opcode == XTENSA_UNDEFINED)
4679 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
4680 return bfd_reloc_other;
4683 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4684 core_format = xtensa_format_lookup (isa, "x24");
4685 opcode = xtensa_opcode_lookup (isa, "or");
4686 xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
4687 for (opn = 0; opn < 3; opn++)
4689 uint32 regno = 1;
4690 xtensa_operand_encode (isa, opcode, opn, &regno);
4691 xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
4692 slotbuf, regno);
4694 xtensa_format_encode (isa, core_format, insnbuf);
4695 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4696 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
4698 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4699 xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
4700 xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
4702 xtensa_format_encode (isa, core_format, insnbuf);
4703 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
4704 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
4705 content_length - address - 3);
4707 return bfd_reloc_ok;
4711 static bfd_reloc_status_type
4712 contract_asm_expansion (bfd_byte *contents,
4713 bfd_vma content_length,
4714 Elf_Internal_Rela *irel,
4715 char **error_message)
4717 bfd_reloc_status_type retval =
4718 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
4719 error_message);
4721 if (retval != bfd_reloc_ok)
4722 return bfd_reloc_dangerous;
4724 /* Update the irel->r_offset field so that the right immediate and
4725 the right instruction are modified during the relocation. */
4726 irel->r_offset += 3;
4727 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
4728 return bfd_reloc_ok;
4732 static xtensa_opcode
4733 swap_callx_for_call_opcode (xtensa_opcode opcode)
4735 init_call_opcodes ();
4737 if (opcode == callx0_op) return call0_op;
4738 if (opcode == callx4_op) return call4_op;
4739 if (opcode == callx8_op) return call8_op;
4740 if (opcode == callx12_op) return call12_op;
4742 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4743 return XTENSA_UNDEFINED;
4747 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4748 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4749 If not, return XTENSA_UNDEFINED. */
4751 #define L32R_TARGET_REG_OPERAND 0
4752 #define CONST16_TARGET_REG_OPERAND 0
4753 #define CALLN_SOURCE_OPERAND 0
4755 static xtensa_opcode
4756 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
4758 static xtensa_insnbuf insnbuf = NULL;
4759 static xtensa_insnbuf slotbuf = NULL;
4760 xtensa_format fmt;
4761 xtensa_opcode opcode;
4762 xtensa_isa isa = xtensa_default_isa;
4763 uint32 regno, const16_regno, call_regno;
4764 int offset = 0;
4766 if (insnbuf == NULL)
4768 insnbuf = xtensa_insnbuf_alloc (isa);
4769 slotbuf = xtensa_insnbuf_alloc (isa);
4772 xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4773 fmt = xtensa_format_decode (isa, insnbuf);
4774 if (fmt == XTENSA_UNDEFINED
4775 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4776 return XTENSA_UNDEFINED;
4778 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4779 if (opcode == XTENSA_UNDEFINED)
4780 return XTENSA_UNDEFINED;
4782 if (opcode == get_l32r_opcode ())
4784 if (p_uses_l32r)
4785 *p_uses_l32r = TRUE;
4786 if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4787 fmt, 0, slotbuf, &regno)
4788 || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4789 &regno))
4790 return XTENSA_UNDEFINED;
4792 else if (opcode == get_const16_opcode ())
4794 if (p_uses_l32r)
4795 *p_uses_l32r = FALSE;
4796 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4797 fmt, 0, slotbuf, &regno)
4798 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4799 &regno))
4800 return XTENSA_UNDEFINED;
4802 /* Check that the next instruction is also CONST16. */
4803 offset += xtensa_format_length (isa, fmt);
4804 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4805 fmt = xtensa_format_decode (isa, insnbuf);
4806 if (fmt == XTENSA_UNDEFINED
4807 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4808 return XTENSA_UNDEFINED;
4809 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4810 if (opcode != get_const16_opcode ())
4811 return XTENSA_UNDEFINED;
4813 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4814 fmt, 0, slotbuf, &const16_regno)
4815 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4816 &const16_regno)
4817 || const16_regno != regno)
4818 return XTENSA_UNDEFINED;
4820 else
4821 return XTENSA_UNDEFINED;
4823 /* Next instruction should be an CALLXn with operand 0 == regno. */
4824 offset += xtensa_format_length (isa, fmt);
4825 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4826 fmt = xtensa_format_decode (isa, insnbuf);
4827 if (fmt == XTENSA_UNDEFINED
4828 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4829 return XTENSA_UNDEFINED;
4830 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4831 if (opcode == XTENSA_UNDEFINED
4832 || !is_indirect_call_opcode (opcode))
4833 return XTENSA_UNDEFINED;
4835 if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4836 fmt, 0, slotbuf, &call_regno)
4837 || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4838 &call_regno))
4839 return XTENSA_UNDEFINED;
4841 if (call_regno != regno)
4842 return XTENSA_UNDEFINED;
4844 return opcode;
4848 /* Data structures used during relaxation. */
4850 /* r_reloc: relocation values. */
4852 /* Through the relaxation process, we need to keep track of the values
4853 that will result from evaluating relocations. The standard ELF
4854 relocation structure is not sufficient for this purpose because we're
4855 operating on multiple input files at once, so we need to know which
4856 input file a relocation refers to. The r_reloc structure thus
4857 records both the input file (bfd) and ELF relocation.
4859 For efficiency, an r_reloc also contains a "target_offset" field to
4860 cache the target-section-relative offset value that is represented by
4861 the relocation.
4863 The r_reloc also contains a virtual offset that allows multiple
4864 inserted literals to be placed at the same "address" with
4865 different offsets. */
4867 typedef struct r_reloc_struct r_reloc;
4869 struct r_reloc_struct
4871 bfd *abfd;
4872 Elf_Internal_Rela rela;
4873 bfd_vma target_offset;
4874 bfd_vma virtual_offset;
4878 /* The r_reloc structure is included by value in literal_value, but not
4879 every literal_value has an associated relocation -- some are simple
4880 constants. In such cases, we set all the fields in the r_reloc
4881 struct to zero. The r_reloc_is_const function should be used to
4882 detect this case. */
4884 static bfd_boolean
4885 r_reloc_is_const (const r_reloc *r_rel)
4887 return (r_rel->abfd == NULL);
4891 static bfd_vma
4892 r_reloc_get_target_offset (const r_reloc *r_rel)
4894 bfd_vma target_offset;
4895 unsigned long r_symndx;
4897 BFD_ASSERT (!r_reloc_is_const (r_rel));
4898 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4899 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4900 return (target_offset + r_rel->rela.r_addend);
4904 static struct elf_link_hash_entry *
4905 r_reloc_get_hash_entry (const r_reloc *r_rel)
4907 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4908 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4912 static asection *
4913 r_reloc_get_section (const r_reloc *r_rel)
4915 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4916 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4920 static bfd_boolean
4921 r_reloc_is_defined (const r_reloc *r_rel)
4923 asection *sec;
4924 if (r_rel == NULL)
4925 return FALSE;
4927 sec = r_reloc_get_section (r_rel);
4928 if (sec == bfd_abs_section_ptr
4929 || sec == bfd_com_section_ptr
4930 || sec == bfd_und_section_ptr)
4931 return FALSE;
4932 return TRUE;
4936 static void
4937 r_reloc_init (r_reloc *r_rel,
4938 bfd *abfd,
4939 Elf_Internal_Rela *irel,
4940 bfd_byte *contents,
4941 bfd_size_type content_length)
4943 int r_type;
4944 reloc_howto_type *howto;
4946 if (irel)
4948 r_rel->rela = *irel;
4949 r_rel->abfd = abfd;
4950 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
4951 r_rel->virtual_offset = 0;
4952 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
4953 howto = &elf_howto_table[r_type];
4954 if (howto->partial_inplace)
4956 bfd_vma inplace_val;
4957 BFD_ASSERT (r_rel->rela.r_offset < content_length);
4959 inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
4960 r_rel->target_offset += inplace_val;
4963 else
4964 memset (r_rel, 0, sizeof (r_reloc));
4968 #if DEBUG
4970 static void
4971 print_r_reloc (FILE *fp, const r_reloc *r_rel)
4973 if (r_reloc_is_defined (r_rel))
4975 asection *sec = r_reloc_get_section (r_rel);
4976 fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
4978 else if (r_reloc_get_hash_entry (r_rel))
4979 fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
4980 else
4981 fprintf (fp, " ?? + ");
4983 fprintf_vma (fp, r_rel->target_offset);
4984 if (r_rel->virtual_offset)
4986 fprintf (fp, " + ");
4987 fprintf_vma (fp, r_rel->virtual_offset);
4990 fprintf (fp, ")");
4993 #endif /* DEBUG */
4996 /* source_reloc: relocations that reference literals. */
4998 /* To determine whether literals can be coalesced, we need to first
4999 record all the relocations that reference the literals. The
5000 source_reloc structure below is used for this purpose. The
5001 source_reloc entries are kept in a per-literal-section array, sorted
5002 by offset within the literal section (i.e., target offset).
5004 The source_sec and r_rel.rela.r_offset fields identify the source of
5005 the relocation. The r_rel field records the relocation value, i.e.,
5006 the offset of the literal being referenced. The opnd field is needed
5007 to determine the range of the immediate field to which the relocation
5008 applies, so we can determine whether another literal with the same
5009 value is within range. The is_null field is true when the relocation
5010 is being removed (e.g., when an L32R is being removed due to a CALLX
5011 that is converted to a direct CALL). */
5013 typedef struct source_reloc_struct source_reloc;
5015 struct source_reloc_struct
5017 asection *source_sec;
5018 r_reloc r_rel;
5019 xtensa_opcode opcode;
5020 int opnd;
5021 bfd_boolean is_null;
5022 bfd_boolean is_abs_literal;
5026 static void
5027 init_source_reloc (source_reloc *reloc,
5028 asection *source_sec,
5029 const r_reloc *r_rel,
5030 xtensa_opcode opcode,
5031 int opnd,
5032 bfd_boolean is_abs_literal)
5034 reloc->source_sec = source_sec;
5035 reloc->r_rel = *r_rel;
5036 reloc->opcode = opcode;
5037 reloc->opnd = opnd;
5038 reloc->is_null = FALSE;
5039 reloc->is_abs_literal = is_abs_literal;
5043 /* Find the source_reloc for a particular source offset and relocation
5044 type. Note that the array is sorted by _target_ offset, so this is
5045 just a linear search. */
5047 static source_reloc *
5048 find_source_reloc (source_reloc *src_relocs,
5049 int src_count,
5050 asection *sec,
5051 Elf_Internal_Rela *irel)
5053 int i;
5055 for (i = 0; i < src_count; i++)
5057 if (src_relocs[i].source_sec == sec
5058 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
5059 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
5060 == ELF32_R_TYPE (irel->r_info)))
5061 return &src_relocs[i];
5064 return NULL;
5068 static int
5069 source_reloc_compare (const void *ap, const void *bp)
5071 const source_reloc *a = (const source_reloc *) ap;
5072 const source_reloc *b = (const source_reloc *) bp;
5074 if (a->r_rel.target_offset != b->r_rel.target_offset)
5075 return (a->r_rel.target_offset - b->r_rel.target_offset);
5077 /* We don't need to sort on these criteria for correctness,
5078 but enforcing a more strict ordering prevents unstable qsort
5079 from behaving differently with different implementations.
5080 Without the code below we get correct but different results
5081 on Solaris 2.7 and 2.8. We would like to always produce the
5082 same results no matter the host. */
5084 if ((!a->is_null) - (!b->is_null))
5085 return ((!a->is_null) - (!b->is_null));
5086 return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
5090 /* Literal values and value hash tables. */
5092 /* Literals with the same value can be coalesced. The literal_value
5093 structure records the value of a literal: the "r_rel" field holds the
5094 information from the relocation on the literal (if there is one) and
5095 the "value" field holds the contents of the literal word itself.
5097 The value_map structure records a literal value along with the
5098 location of a literal holding that value. The value_map hash table
5099 is indexed by the literal value, so that we can quickly check if a
5100 particular literal value has been seen before and is thus a candidate
5101 for coalescing. */
5103 typedef struct literal_value_struct literal_value;
5104 typedef struct value_map_struct value_map;
5105 typedef struct value_map_hash_table_struct value_map_hash_table;
5107 struct literal_value_struct
5109 r_reloc r_rel;
5110 unsigned long value;
5111 bfd_boolean is_abs_literal;
5114 struct value_map_struct
5116 literal_value val; /* The literal value. */
5117 r_reloc loc; /* Location of the literal. */
5118 value_map *next;
5121 struct value_map_hash_table_struct
5123 unsigned bucket_count;
5124 value_map **buckets;
5125 unsigned count;
5126 bfd_boolean has_last_loc;
5127 r_reloc last_loc;
5131 static void
5132 init_literal_value (literal_value *lit,
5133 const r_reloc *r_rel,
5134 unsigned long value,
5135 bfd_boolean is_abs_literal)
5137 lit->r_rel = *r_rel;
5138 lit->value = value;
5139 lit->is_abs_literal = is_abs_literal;
5143 static bfd_boolean
5144 literal_value_equal (const literal_value *src1,
5145 const literal_value *src2,
5146 bfd_boolean final_static_link)
5148 struct elf_link_hash_entry *h1, *h2;
5150 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
5151 return FALSE;
5153 if (r_reloc_is_const (&src1->r_rel))
5154 return (src1->value == src2->value);
5156 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
5157 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
5158 return FALSE;
5160 if (src1->r_rel.target_offset != src2->r_rel.target_offset)
5161 return FALSE;
5163 if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
5164 return FALSE;
5166 if (src1->value != src2->value)
5167 return FALSE;
5169 /* Now check for the same section (if defined) or the same elf_hash
5170 (if undefined or weak). */
5171 h1 = r_reloc_get_hash_entry (&src1->r_rel);
5172 h2 = r_reloc_get_hash_entry (&src2->r_rel);
5173 if (r_reloc_is_defined (&src1->r_rel)
5174 && (final_static_link
5175 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
5176 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
5178 if (r_reloc_get_section (&src1->r_rel)
5179 != r_reloc_get_section (&src2->r_rel))
5180 return FALSE;
5182 else
5184 /* Require that the hash entries (i.e., symbols) be identical. */
5185 if (h1 != h2 || h1 == 0)
5186 return FALSE;
5189 if (src1->is_abs_literal != src2->is_abs_literal)
5190 return FALSE;
5192 return TRUE;
5196 /* Must be power of 2. */
5197 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5199 static value_map_hash_table *
5200 value_map_hash_table_init (void)
5202 value_map_hash_table *values;
5204 values = (value_map_hash_table *)
5205 bfd_zmalloc (sizeof (value_map_hash_table));
5206 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
5207 values->count = 0;
5208 values->buckets = (value_map **)
5209 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
5210 if (values->buckets == NULL)
5212 free (values);
5213 return NULL;
5215 values->has_last_loc = FALSE;
5217 return values;
5221 static void
5222 value_map_hash_table_delete (value_map_hash_table *table)
5224 free (table->buckets);
5225 free (table);
5229 static unsigned
5230 hash_bfd_vma (bfd_vma val)
5232 return (val >> 2) + (val >> 10);
5236 static unsigned
5237 literal_value_hash (const literal_value *src)
5239 unsigned hash_val;
5241 hash_val = hash_bfd_vma (src->value);
5242 if (!r_reloc_is_const (&src->r_rel))
5244 void *sec_or_hash;
5246 hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
5247 hash_val += hash_bfd_vma (src->r_rel.target_offset);
5248 hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
5250 /* Now check for the same section and the same elf_hash. */
5251 if (r_reloc_is_defined (&src->r_rel))
5252 sec_or_hash = r_reloc_get_section (&src->r_rel);
5253 else
5254 sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
5255 hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
5257 return hash_val;
5261 /* Check if the specified literal_value has been seen before. */
5263 static value_map *
5264 value_map_get_cached_value (value_map_hash_table *map,
5265 const literal_value *val,
5266 bfd_boolean final_static_link)
5268 value_map *map_e;
5269 value_map *bucket;
5270 unsigned idx;
5272 idx = literal_value_hash (val);
5273 idx = idx & (map->bucket_count - 1);
5274 bucket = map->buckets[idx];
5275 for (map_e = bucket; map_e; map_e = map_e->next)
5277 if (literal_value_equal (&map_e->val, val, final_static_link))
5278 return map_e;
5280 return NULL;
5284 /* Record a new literal value. It is illegal to call this if VALUE
5285 already has an entry here. */
5287 static value_map *
5288 add_value_map (value_map_hash_table *map,
5289 const literal_value *val,
5290 const r_reloc *loc,
5291 bfd_boolean final_static_link)
5293 value_map **bucket_p;
5294 unsigned idx;
5296 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
5297 if (val_e == NULL)
5299 bfd_set_error (bfd_error_no_memory);
5300 return NULL;
5303 BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
5304 val_e->val = *val;
5305 val_e->loc = *loc;
5307 idx = literal_value_hash (val);
5308 idx = idx & (map->bucket_count - 1);
5309 bucket_p = &map->buckets[idx];
5311 val_e->next = *bucket_p;
5312 *bucket_p = val_e;
5313 map->count++;
5314 /* FIXME: Consider resizing the hash table if we get too many entries. */
5316 return val_e;
5320 /* Lists of text actions (ta_) for narrowing, widening, longcall
5321 conversion, space fill, code & literal removal, etc. */
5323 /* The following text actions are generated:
5325 "ta_remove_insn" remove an instruction or instructions
5326 "ta_remove_longcall" convert longcall to call
5327 "ta_convert_longcall" convert longcall to nop/call
5328 "ta_narrow_insn" narrow a wide instruction
5329 "ta_widen" widen a narrow instruction
5330 "ta_fill" add fill or remove fill
5331 removed < 0 is a fill; branches to the fill address will be
5332 changed to address + fill size (e.g., address - removed)
5333 removed >= 0 branches to the fill address will stay unchanged
5334 "ta_remove_literal" remove a literal; this action is
5335 indicated when a literal is removed
5336 or replaced.
5337 "ta_add_literal" insert a new literal; this action is
5338 indicated when a literal has been moved.
5339 It may use a virtual_offset because
5340 multiple literals can be placed at the
5341 same location.
5343 For each of these text actions, we also record the number of bytes
5344 removed by performing the text action. In the case of a "ta_widen"
5345 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5347 typedef struct text_action_struct text_action;
5348 typedef struct text_action_list_struct text_action_list;
5349 typedef enum text_action_enum_t text_action_t;
5351 enum text_action_enum_t
5353 ta_none,
5354 ta_remove_insn, /* removed = -size */
5355 ta_remove_longcall, /* removed = -size */
5356 ta_convert_longcall, /* removed = 0 */
5357 ta_narrow_insn, /* removed = -1 */
5358 ta_widen_insn, /* removed = +1 */
5359 ta_fill, /* removed = +size */
5360 ta_remove_literal,
5361 ta_add_literal
5365 /* Structure for a text action record. */
5366 struct text_action_struct
5368 text_action_t action;
5369 asection *sec; /* Optional */
5370 bfd_vma offset;
5371 bfd_vma virtual_offset; /* Zero except for adding literals. */
5372 int removed_bytes;
5373 literal_value value; /* Only valid when adding literals. */
5375 text_action *next;
5379 /* List of all of the actions taken on a text section. */
5380 struct text_action_list_struct
5382 text_action *head;
5386 static text_action *
5387 find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
5389 text_action **m_p;
5391 /* It is not necessary to fill at the end of a section. */
5392 if (sec->size == offset)
5393 return NULL;
5395 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
5397 text_action *t = *m_p;
5398 /* When the action is another fill at the same address,
5399 just increase the size. */
5400 if (t->offset == offset && t->action == ta_fill)
5401 return t;
5403 return NULL;
5407 static int
5408 compute_removed_action_diff (const text_action *ta,
5409 asection *sec,
5410 bfd_vma offset,
5411 int removed,
5412 int removable_space)
5414 int new_removed;
5415 int current_removed = 0;
5417 if (ta)
5418 current_removed = ta->removed_bytes;
5420 BFD_ASSERT (ta == NULL || ta->offset == offset);
5421 BFD_ASSERT (ta == NULL || ta->action == ta_fill);
5423 /* It is not necessary to fill at the end of a section. Clean this up. */
5424 if (sec->size == offset)
5425 new_removed = removable_space - 0;
5426 else
5428 int space;
5429 int added = -removed - current_removed;
5430 /* Ignore multiples of the section alignment. */
5431 added = ((1 << sec->alignment_power) - 1) & added;
5432 new_removed = (-added);
5434 /* Modify for removable. */
5435 space = removable_space - new_removed;
5436 new_removed = (removable_space
5437 - (((1 << sec->alignment_power) - 1) & space));
5439 return (new_removed - current_removed);
5443 static void
5444 adjust_fill_action (text_action *ta, int fill_diff)
5446 ta->removed_bytes += fill_diff;
5450 /* Add a modification action to the text. For the case of adding or
5451 removing space, modify any current fill and assume that
5452 "unreachable_space" bytes can be freely contracted. Note that a
5453 negative removed value is a fill. */
5455 static void
5456 text_action_add (text_action_list *l,
5457 text_action_t action,
5458 asection *sec,
5459 bfd_vma offset,
5460 int removed)
5462 text_action **m_p;
5463 text_action *ta;
5465 /* It is not necessary to fill at the end of a section. */
5466 if (action == ta_fill && sec->size == offset)
5467 return;
5469 /* It is not necessary to fill 0 bytes. */
5470 if (action == ta_fill && removed == 0)
5471 return;
5473 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
5475 text_action *t = *m_p;
5477 if (action == ta_fill)
5479 /* When the action is another fill at the same address,
5480 just increase the size. */
5481 if (t->offset == offset && t->action == ta_fill)
5483 t->removed_bytes += removed;
5484 return;
5486 /* Fills need to happen before widens so that we don't
5487 insert fill bytes into the instruction stream. */
5488 if (t->offset == offset && t->action == ta_widen_insn)
5489 break;
5493 /* Create a new record and fill it up. */
5494 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5495 ta->action = action;
5496 ta->sec = sec;
5497 ta->offset = offset;
5498 ta->removed_bytes = removed;
5499 ta->next = (*m_p);
5500 *m_p = ta;
5504 static void
5505 text_action_add_literal (text_action_list *l,
5506 text_action_t action,
5507 const r_reloc *loc,
5508 const literal_value *value,
5509 int removed)
5511 text_action **m_p;
5512 text_action *ta;
5513 asection *sec = r_reloc_get_section (loc);
5514 bfd_vma offset = loc->target_offset;
5515 bfd_vma virtual_offset = loc->virtual_offset;
5517 BFD_ASSERT (action == ta_add_literal);
5519 for (m_p = &l->head; *m_p != NULL; m_p = &(*m_p)->next)
5521 if ((*m_p)->offset > offset
5522 && ((*m_p)->offset != offset
5523 || (*m_p)->virtual_offset > virtual_offset))
5524 break;
5527 /* Create a new record and fill it up. */
5528 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
5529 ta->action = action;
5530 ta->sec = sec;
5531 ta->offset = offset;
5532 ta->virtual_offset = virtual_offset;
5533 ta->value = *value;
5534 ta->removed_bytes = removed;
5535 ta->next = (*m_p);
5536 *m_p = ta;
5540 /* Find the total offset adjustment for the relaxations specified by
5541 text_actions, beginning from a particular starting action. This is
5542 typically used from offset_with_removed_text to search an entire list of
5543 actions, but it may also be called directly when adjusting adjacent offsets
5544 so that each search may begin where the previous one left off. */
5546 static int
5547 removed_by_actions (text_action **p_start_action,
5548 bfd_vma offset,
5549 bfd_boolean before_fill)
5551 text_action *r;
5552 int removed = 0;
5554 r = *p_start_action;
5555 while (r)
5557 if (r->offset > offset)
5558 break;
5560 if (r->offset == offset
5561 && (before_fill || r->action != ta_fill || r->removed_bytes >= 0))
5562 break;
5564 removed += r->removed_bytes;
5566 r = r->next;
5569 *p_start_action = r;
5570 return removed;
5574 static bfd_vma
5575 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
5577 text_action *r = action_list->head;
5578 return offset - removed_by_actions (&r, offset, FALSE);
5582 static unsigned
5583 action_list_count (text_action_list *action_list)
5585 text_action *r = action_list->head;
5586 unsigned count = 0;
5587 for (r = action_list->head; r != NULL; r = r->next)
5589 count++;
5591 return count;
5595 /* The find_insn_action routine will only find non-fill actions. */
5597 static text_action *
5598 find_insn_action (text_action_list *action_list, bfd_vma offset)
5600 text_action *t;
5601 for (t = action_list->head; t; t = t->next)
5603 if (t->offset == offset)
5605 switch (t->action)
5607 case ta_none:
5608 case ta_fill:
5609 break;
5610 case ta_remove_insn:
5611 case ta_remove_longcall:
5612 case ta_convert_longcall:
5613 case ta_narrow_insn:
5614 case ta_widen_insn:
5615 return t;
5616 case ta_remove_literal:
5617 case ta_add_literal:
5618 BFD_ASSERT (0);
5619 break;
5623 return NULL;
5627 #if DEBUG
5629 static void
5630 print_action_list (FILE *fp, text_action_list *action_list)
5632 text_action *r;
5634 fprintf (fp, "Text Action\n");
5635 for (r = action_list->head; r != NULL; r = r->next)
5637 const char *t = "unknown";
5638 switch (r->action)
5640 case ta_remove_insn:
5641 t = "remove_insn"; break;
5642 case ta_remove_longcall:
5643 t = "remove_longcall"; break;
5644 case ta_convert_longcall:
5645 t = "convert_longcall"; break;
5646 case ta_narrow_insn:
5647 t = "narrow_insn"; break;
5648 case ta_widen_insn:
5649 t = "widen_insn"; break;
5650 case ta_fill:
5651 t = "fill"; break;
5652 case ta_none:
5653 t = "none"; break;
5654 case ta_remove_literal:
5655 t = "remove_literal"; break;
5656 case ta_add_literal:
5657 t = "add_literal"; break;
5660 fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
5661 r->sec->owner->filename,
5662 r->sec->name, r->offset, t, r->removed_bytes);
5666 #endif /* DEBUG */
5669 /* Lists of literals being coalesced or removed. */
5671 /* In the usual case, the literal identified by "from" is being
5672 coalesced with another literal identified by "to". If the literal is
5673 unused and is being removed altogether, "to.abfd" will be NULL.
5674 The removed_literal entries are kept on a per-section list, sorted
5675 by the "from" offset field. */
5677 typedef struct removed_literal_struct removed_literal;
5678 typedef struct removed_literal_list_struct removed_literal_list;
5680 struct removed_literal_struct
5682 r_reloc from;
5683 r_reloc to;
5684 removed_literal *next;
5687 struct removed_literal_list_struct
5689 removed_literal *head;
5690 removed_literal *tail;
5694 /* Record that the literal at "from" is being removed. If "to" is not
5695 NULL, the "from" literal is being coalesced with the "to" literal. */
5697 static void
5698 add_removed_literal (removed_literal_list *removed_list,
5699 const r_reloc *from,
5700 const r_reloc *to)
5702 removed_literal *r, *new_r, *next_r;
5704 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
5706 new_r->from = *from;
5707 if (to)
5708 new_r->to = *to;
5709 else
5710 new_r->to.abfd = NULL;
5711 new_r->next = NULL;
5713 r = removed_list->head;
5714 if (r == NULL)
5716 removed_list->head = new_r;
5717 removed_list->tail = new_r;
5719 /* Special check for common case of append. */
5720 else if (removed_list->tail->from.target_offset < from->target_offset)
5722 removed_list->tail->next = new_r;
5723 removed_list->tail = new_r;
5725 else
5727 while (r->from.target_offset < from->target_offset && r->next)
5729 r = r->next;
5731 next_r = r->next;
5732 r->next = new_r;
5733 new_r->next = next_r;
5734 if (next_r == NULL)
5735 removed_list->tail = new_r;
5740 /* Check if the list of removed literals contains an entry for the
5741 given address. Return the entry if found. */
5743 static removed_literal *
5744 find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
5746 removed_literal *r = removed_list->head;
5747 while (r && r->from.target_offset < addr)
5748 r = r->next;
5749 if (r && r->from.target_offset == addr)
5750 return r;
5751 return NULL;
5755 #if DEBUG
5757 static void
5758 print_removed_literals (FILE *fp, removed_literal_list *removed_list)
5760 removed_literal *r;
5761 r = removed_list->head;
5762 if (r)
5763 fprintf (fp, "Removed Literals\n");
5764 for (; r != NULL; r = r->next)
5766 print_r_reloc (fp, &r->from);
5767 fprintf (fp, " => ");
5768 if (r->to.abfd == NULL)
5769 fprintf (fp, "REMOVED");
5770 else
5771 print_r_reloc (fp, &r->to);
5772 fprintf (fp, "\n");
5776 #endif /* DEBUG */
5779 /* Per-section data for relaxation. */
5781 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
5783 struct xtensa_relax_info_struct
5785 bfd_boolean is_relaxable_literal_section;
5786 bfd_boolean is_relaxable_asm_section;
5787 int visited; /* Number of times visited. */
5789 source_reloc *src_relocs; /* Array[src_count]. */
5790 int src_count;
5791 int src_next; /* Next src_relocs entry to assign. */
5793 removed_literal_list removed_list;
5794 text_action_list action_list;
5796 reloc_bfd_fix *fix_list;
5797 reloc_bfd_fix *fix_array;
5798 unsigned fix_array_count;
5800 /* Support for expanding the reloc array that is stored
5801 in the section structure. If the relocations have been
5802 reallocated, the newly allocated relocations will be referenced
5803 here along with the actual size allocated. The relocation
5804 count will always be found in the section structure. */
5805 Elf_Internal_Rela *allocated_relocs;
5806 unsigned relocs_count;
5807 unsigned allocated_relocs_count;
5810 struct elf_xtensa_section_data
5812 struct bfd_elf_section_data elf;
5813 xtensa_relax_info relax_info;
5817 static bfd_boolean
5818 elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
5820 if (!sec->used_by_bfd)
5822 struct elf_xtensa_section_data *sdata;
5823 bfd_size_type amt = sizeof (*sdata);
5825 sdata = bfd_zalloc (abfd, amt);
5826 if (sdata == NULL)
5827 return FALSE;
5828 sec->used_by_bfd = sdata;
5831 return _bfd_elf_new_section_hook (abfd, sec);
5835 static xtensa_relax_info *
5836 get_xtensa_relax_info (asection *sec)
5838 struct elf_xtensa_section_data *section_data;
5840 /* No info available if no section or if it is an output section. */
5841 if (!sec || sec == sec->output_section)
5842 return NULL;
5844 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
5845 return &section_data->relax_info;
5849 static void
5850 init_xtensa_relax_info (asection *sec)
5852 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5854 relax_info->is_relaxable_literal_section = FALSE;
5855 relax_info->is_relaxable_asm_section = FALSE;
5856 relax_info->visited = 0;
5858 relax_info->src_relocs = NULL;
5859 relax_info->src_count = 0;
5860 relax_info->src_next = 0;
5862 relax_info->removed_list.head = NULL;
5863 relax_info->removed_list.tail = NULL;
5865 relax_info->action_list.head = NULL;
5867 relax_info->fix_list = NULL;
5868 relax_info->fix_array = NULL;
5869 relax_info->fix_array_count = 0;
5871 relax_info->allocated_relocs = NULL;
5872 relax_info->relocs_count = 0;
5873 relax_info->allocated_relocs_count = 0;
5877 /* Coalescing literals may require a relocation to refer to a section in
5878 a different input file, but the standard relocation information
5879 cannot express that. Instead, the reloc_bfd_fix structures are used
5880 to "fix" the relocations that refer to sections in other input files.
5881 These structures are kept on per-section lists. The "src_type" field
5882 records the relocation type in case there are multiple relocations on
5883 the same location. FIXME: This is ugly; an alternative might be to
5884 add new symbols with the "owner" field to some other input file. */
5886 struct reloc_bfd_fix_struct
5888 asection *src_sec;
5889 bfd_vma src_offset;
5890 unsigned src_type; /* Relocation type. */
5892 asection *target_sec;
5893 bfd_vma target_offset;
5894 bfd_boolean translated;
5896 reloc_bfd_fix *next;
5900 static reloc_bfd_fix *
5901 reloc_bfd_fix_init (asection *src_sec,
5902 bfd_vma src_offset,
5903 unsigned src_type,
5904 asection *target_sec,
5905 bfd_vma target_offset,
5906 bfd_boolean translated)
5908 reloc_bfd_fix *fix;
5910 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
5911 fix->src_sec = src_sec;
5912 fix->src_offset = src_offset;
5913 fix->src_type = src_type;
5914 fix->target_sec = target_sec;
5915 fix->target_offset = target_offset;
5916 fix->translated = translated;
5918 return fix;
5922 static void
5923 add_fix (asection *src_sec, reloc_bfd_fix *fix)
5925 xtensa_relax_info *relax_info;
5927 relax_info = get_xtensa_relax_info (src_sec);
5928 fix->next = relax_info->fix_list;
5929 relax_info->fix_list = fix;
5933 static int
5934 fix_compare (const void *ap, const void *bp)
5936 const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
5937 const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
5939 if (a->src_offset != b->src_offset)
5940 return (a->src_offset - b->src_offset);
5941 return (a->src_type - b->src_type);
5945 static void
5946 cache_fix_array (asection *sec)
5948 unsigned i, count = 0;
5949 reloc_bfd_fix *r;
5950 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5952 if (relax_info == NULL)
5953 return;
5954 if (relax_info->fix_list == NULL)
5955 return;
5957 for (r = relax_info->fix_list; r != NULL; r = r->next)
5958 count++;
5960 relax_info->fix_array =
5961 (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
5962 relax_info->fix_array_count = count;
5964 r = relax_info->fix_list;
5965 for (i = 0; i < count; i++, r = r->next)
5967 relax_info->fix_array[count - 1 - i] = *r;
5968 relax_info->fix_array[count - 1 - i].next = NULL;
5971 qsort (relax_info->fix_array, relax_info->fix_array_count,
5972 sizeof (reloc_bfd_fix), fix_compare);
5976 static reloc_bfd_fix *
5977 get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
5979 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5980 reloc_bfd_fix *rv;
5981 reloc_bfd_fix key;
5983 if (relax_info == NULL)
5984 return NULL;
5985 if (relax_info->fix_list == NULL)
5986 return NULL;
5988 if (relax_info->fix_array == NULL)
5989 cache_fix_array (sec);
5991 key.src_offset = offset;
5992 key.src_type = type;
5993 rv = bsearch (&key, relax_info->fix_array, relax_info->fix_array_count,
5994 sizeof (reloc_bfd_fix), fix_compare);
5995 return rv;
5999 /* Section caching. */
6001 typedef struct section_cache_struct section_cache_t;
6003 struct section_cache_struct
6005 asection *sec;
6007 bfd_byte *contents; /* Cache of the section contents. */
6008 bfd_size_type content_length;
6010 property_table_entry *ptbl; /* Cache of the section property table. */
6011 unsigned pte_count;
6013 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6014 unsigned reloc_count;
6018 static void
6019 init_section_cache (section_cache_t *sec_cache)
6021 memset (sec_cache, 0, sizeof (*sec_cache));
6025 static void
6026 clear_section_cache (section_cache_t *sec_cache)
6028 if (sec_cache->sec)
6030 release_contents (sec_cache->sec, sec_cache->contents);
6031 release_internal_relocs (sec_cache->sec, sec_cache->relocs);
6032 if (sec_cache->ptbl)
6033 free (sec_cache->ptbl);
6034 memset (sec_cache, 0, sizeof (sec_cache));
6039 static bfd_boolean
6040 section_cache_section (section_cache_t *sec_cache,
6041 asection *sec,
6042 struct bfd_link_info *link_info)
6044 bfd *abfd;
6045 property_table_entry *prop_table = NULL;
6046 int ptblsize = 0;
6047 bfd_byte *contents = NULL;
6048 Elf_Internal_Rela *internal_relocs = NULL;
6049 bfd_size_type sec_size;
6051 if (sec == NULL)
6052 return FALSE;
6053 if (sec == sec_cache->sec)
6054 return TRUE;
6056 abfd = sec->owner;
6057 sec_size = bfd_get_section_limit (abfd, sec);
6059 /* Get the contents. */
6060 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6061 if (contents == NULL && sec_size != 0)
6062 goto err;
6064 /* Get the relocations. */
6065 internal_relocs = retrieve_internal_relocs (abfd, sec,
6066 link_info->keep_memory);
6068 /* Get the entry table. */
6069 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6070 XTENSA_PROP_SEC_NAME, FALSE);
6071 if (ptblsize < 0)
6072 goto err;
6074 /* Fill in the new section cache. */
6075 clear_section_cache (sec_cache);
6076 memset (sec_cache, 0, sizeof (sec_cache));
6078 sec_cache->sec = sec;
6079 sec_cache->contents = contents;
6080 sec_cache->content_length = sec_size;
6081 sec_cache->relocs = internal_relocs;
6082 sec_cache->reloc_count = sec->reloc_count;
6083 sec_cache->pte_count = ptblsize;
6084 sec_cache->ptbl = prop_table;
6086 return TRUE;
6088 err:
6089 release_contents (sec, contents);
6090 release_internal_relocs (sec, internal_relocs);
6091 if (prop_table)
6092 free (prop_table);
6093 return FALSE;
6097 /* Extended basic blocks. */
6099 /* An ebb_struct represents an Extended Basic Block. Within this
6100 range, we guarantee that all instructions are decodable, the
6101 property table entries are contiguous, and no property table
6102 specifies a segment that cannot have instructions moved. This
6103 structure contains caches of the contents, property table and
6104 relocations for the specified section for easy use. The range is
6105 specified by ranges of indices for the byte offset, property table
6106 offsets and relocation offsets. These must be consistent. */
6108 typedef struct ebb_struct ebb_t;
6110 struct ebb_struct
6112 asection *sec;
6114 bfd_byte *contents; /* Cache of the section contents. */
6115 bfd_size_type content_length;
6117 property_table_entry *ptbl; /* Cache of the section property table. */
6118 unsigned pte_count;
6120 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
6121 unsigned reloc_count;
6123 bfd_vma start_offset; /* Offset in section. */
6124 unsigned start_ptbl_idx; /* Offset in the property table. */
6125 unsigned start_reloc_idx; /* Offset in the relocations. */
6127 bfd_vma end_offset;
6128 unsigned end_ptbl_idx;
6129 unsigned end_reloc_idx;
6131 bfd_boolean ends_section; /* Is this the last ebb in a section? */
6133 /* The unreachable property table at the end of this set of blocks;
6134 NULL if the end is not an unreachable block. */
6135 property_table_entry *ends_unreachable;
6139 enum ebb_target_enum
6141 EBB_NO_ALIGN = 0,
6142 EBB_DESIRE_TGT_ALIGN,
6143 EBB_REQUIRE_TGT_ALIGN,
6144 EBB_REQUIRE_LOOP_ALIGN,
6145 EBB_REQUIRE_ALIGN
6149 /* proposed_action_struct is similar to the text_action_struct except
6150 that is represents a potential transformation, not one that will
6151 occur. We build a list of these for an extended basic block
6152 and use them to compute the actual actions desired. We must be
6153 careful that the entire set of actual actions we perform do not
6154 break any relocations that would fit if the actions were not
6155 performed. */
6157 typedef struct proposed_action_struct proposed_action;
6159 struct proposed_action_struct
6161 enum ebb_target_enum align_type; /* for the target alignment */
6162 bfd_vma alignment_pow;
6163 text_action_t action;
6164 bfd_vma offset;
6165 int removed_bytes;
6166 bfd_boolean do_action; /* If false, then we will not perform the action. */
6170 /* The ebb_constraint_struct keeps a set of proposed actions for an
6171 extended basic block. */
6173 typedef struct ebb_constraint_struct ebb_constraint;
6175 struct ebb_constraint_struct
6177 ebb_t ebb;
6178 bfd_boolean start_movable;
6180 /* Bytes of extra space at the beginning if movable. */
6181 int start_extra_space;
6183 enum ebb_target_enum start_align;
6185 bfd_boolean end_movable;
6187 /* Bytes of extra space at the end if movable. */
6188 int end_extra_space;
6190 unsigned action_count;
6191 unsigned action_allocated;
6193 /* Array of proposed actions. */
6194 proposed_action *actions;
6196 /* Action alignments -- one for each proposed action. */
6197 enum ebb_target_enum *action_aligns;
6201 static void
6202 init_ebb_constraint (ebb_constraint *c)
6204 memset (c, 0, sizeof (ebb_constraint));
6208 static void
6209 free_ebb_constraint (ebb_constraint *c)
6211 if (c->actions)
6212 free (c->actions);
6216 static void
6217 init_ebb (ebb_t *ebb,
6218 asection *sec,
6219 bfd_byte *contents,
6220 bfd_size_type content_length,
6221 property_table_entry *prop_table,
6222 unsigned ptblsize,
6223 Elf_Internal_Rela *internal_relocs,
6224 unsigned reloc_count)
6226 memset (ebb, 0, sizeof (ebb_t));
6227 ebb->sec = sec;
6228 ebb->contents = contents;
6229 ebb->content_length = content_length;
6230 ebb->ptbl = prop_table;
6231 ebb->pte_count = ptblsize;
6232 ebb->relocs = internal_relocs;
6233 ebb->reloc_count = reloc_count;
6234 ebb->start_offset = 0;
6235 ebb->end_offset = ebb->content_length - 1;
6236 ebb->start_ptbl_idx = 0;
6237 ebb->end_ptbl_idx = ptblsize;
6238 ebb->start_reloc_idx = 0;
6239 ebb->end_reloc_idx = reloc_count;
6243 /* Extend the ebb to all decodable contiguous sections. The algorithm
6244 for building a basic block around an instruction is to push it
6245 forward until we hit the end of a section, an unreachable block or
6246 a block that cannot be transformed. Then we push it backwards
6247 searching for similar conditions. */
6249 static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
6250 static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
6251 static bfd_size_type insn_block_decodable_len
6252 (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
6254 static bfd_boolean
6255 extend_ebb_bounds (ebb_t *ebb)
6257 if (!extend_ebb_bounds_forward (ebb))
6258 return FALSE;
6259 if (!extend_ebb_bounds_backward (ebb))
6260 return FALSE;
6261 return TRUE;
6265 static bfd_boolean
6266 extend_ebb_bounds_forward (ebb_t *ebb)
6268 property_table_entry *the_entry, *new_entry;
6270 the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6272 /* Stop when (1) we cannot decode an instruction, (2) we are at
6273 the end of the property tables, (3) we hit a non-contiguous property
6274 table entry, (4) we hit a NO_TRANSFORM region. */
6276 while (1)
6278 bfd_vma entry_end;
6279 bfd_size_type insn_block_len;
6281 entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
6282 insn_block_len =
6283 insn_block_decodable_len (ebb->contents, ebb->content_length,
6284 ebb->end_offset,
6285 entry_end - ebb->end_offset);
6286 if (insn_block_len != (entry_end - ebb->end_offset))
6288 (*_bfd_error_handler)
6289 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6290 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6291 return FALSE;
6293 ebb->end_offset += insn_block_len;
6295 if (ebb->end_offset == ebb->sec->size)
6296 ebb->ends_section = TRUE;
6298 /* Update the reloc counter. */
6299 while (ebb->end_reloc_idx + 1 < ebb->reloc_count
6300 && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
6301 < ebb->end_offset))
6303 ebb->end_reloc_idx++;
6306 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6307 return TRUE;
6309 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6310 if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
6311 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6312 || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
6313 break;
6315 if (the_entry->address + the_entry->size != new_entry->address)
6316 break;
6318 the_entry = new_entry;
6319 ebb->end_ptbl_idx++;
6322 /* Quick check for an unreachable or end of file just at the end. */
6323 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
6325 if (ebb->end_offset == ebb->content_length)
6326 ebb->ends_section = TRUE;
6328 else
6330 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
6331 if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
6332 && the_entry->address + the_entry->size == new_entry->address)
6333 ebb->ends_unreachable = new_entry;
6336 /* Any other ending requires exact alignment. */
6337 return TRUE;
6341 static bfd_boolean
6342 extend_ebb_bounds_backward (ebb_t *ebb)
6344 property_table_entry *the_entry, *new_entry;
6346 the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6348 /* Stop when (1) we cannot decode the instructions in the current entry.
6349 (2) we are at the beginning of the property tables, (3) we hit a
6350 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6352 while (1)
6354 bfd_vma block_begin;
6355 bfd_size_type insn_block_len;
6357 block_begin = the_entry->address - ebb->sec->vma;
6358 insn_block_len =
6359 insn_block_decodable_len (ebb->contents, ebb->content_length,
6360 block_begin,
6361 ebb->start_offset - block_begin);
6362 if (insn_block_len != ebb->start_offset - block_begin)
6364 (*_bfd_error_handler)
6365 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6366 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
6367 return FALSE;
6369 ebb->start_offset -= insn_block_len;
6371 /* Update the reloc counter. */
6372 while (ebb->start_reloc_idx > 0
6373 && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
6374 >= ebb->start_offset))
6376 ebb->start_reloc_idx--;
6379 if (ebb->start_ptbl_idx == 0)
6380 return TRUE;
6382 new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
6383 if ((new_entry->flags & XTENSA_PROP_INSN) == 0
6384 || ((new_entry->flags & XTENSA_PROP_NO_TRANSFORM) != 0)
6385 || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
6386 return TRUE;
6387 if (new_entry->address + new_entry->size != the_entry->address)
6388 return TRUE;
6390 the_entry = new_entry;
6391 ebb->start_ptbl_idx--;
6393 return TRUE;
6397 static bfd_size_type
6398 insn_block_decodable_len (bfd_byte *contents,
6399 bfd_size_type content_len,
6400 bfd_vma block_offset,
6401 bfd_size_type block_len)
6403 bfd_vma offset = block_offset;
6405 while (offset < block_offset + block_len)
6407 bfd_size_type insn_len = 0;
6409 insn_len = insn_decode_len (contents, content_len, offset);
6410 if (insn_len == 0)
6411 return (offset - block_offset);
6412 offset += insn_len;
6414 return (offset - block_offset);
6418 static void
6419 ebb_propose_action (ebb_constraint *c,
6420 enum ebb_target_enum align_type,
6421 bfd_vma alignment_pow,
6422 text_action_t action,
6423 bfd_vma offset,
6424 int removed_bytes,
6425 bfd_boolean do_action)
6427 proposed_action *act;
6429 if (c->action_allocated <= c->action_count)
6431 unsigned new_allocated, i;
6432 proposed_action *new_actions;
6434 new_allocated = (c->action_count + 2) * 2;
6435 new_actions = (proposed_action *)
6436 bfd_zmalloc (sizeof (proposed_action) * new_allocated);
6438 for (i = 0; i < c->action_count; i++)
6439 new_actions[i] = c->actions[i];
6440 if (c->actions)
6441 free (c->actions);
6442 c->actions = new_actions;
6443 c->action_allocated = new_allocated;
6446 act = &c->actions[c->action_count];
6447 act->align_type = align_type;
6448 act->alignment_pow = alignment_pow;
6449 act->action = action;
6450 act->offset = offset;
6451 act->removed_bytes = removed_bytes;
6452 act->do_action = do_action;
6454 c->action_count++;
6458 /* Access to internal relocations, section contents and symbols. */
6460 /* During relaxation, we need to modify relocations, section contents,
6461 and symbol definitions, and we need to keep the original values from
6462 being reloaded from the input files, i.e., we need to "pin" the
6463 modified values in memory. We also want to continue to observe the
6464 setting of the "keep-memory" flag. The following functions wrap the
6465 standard BFD functions to take care of this for us. */
6467 static Elf_Internal_Rela *
6468 retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6470 Elf_Internal_Rela *internal_relocs;
6472 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6473 return NULL;
6475 internal_relocs = elf_section_data (sec)->relocs;
6476 if (internal_relocs == NULL)
6477 internal_relocs = (_bfd_elf_link_read_relocs
6478 (abfd, sec, NULL, NULL, keep_memory));
6479 return internal_relocs;
6483 static void
6484 pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6486 elf_section_data (sec)->relocs = internal_relocs;
6490 static void
6491 release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
6493 if (internal_relocs
6494 && elf_section_data (sec)->relocs != internal_relocs)
6495 free (internal_relocs);
6499 static bfd_byte *
6500 retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
6502 bfd_byte *contents;
6503 bfd_size_type sec_size;
6505 sec_size = bfd_get_section_limit (abfd, sec);
6506 contents = elf_section_data (sec)->this_hdr.contents;
6508 if (contents == NULL && sec_size != 0)
6510 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
6512 if (contents)
6513 free (contents);
6514 return NULL;
6516 if (keep_memory)
6517 elf_section_data (sec)->this_hdr.contents = contents;
6519 return contents;
6523 static void
6524 pin_contents (asection *sec, bfd_byte *contents)
6526 elf_section_data (sec)->this_hdr.contents = contents;
6530 static void
6531 release_contents (asection *sec, bfd_byte *contents)
6533 if (contents && elf_section_data (sec)->this_hdr.contents != contents)
6534 free (contents);
6538 static Elf_Internal_Sym *
6539 retrieve_local_syms (bfd *input_bfd)
6541 Elf_Internal_Shdr *symtab_hdr;
6542 Elf_Internal_Sym *isymbuf;
6543 size_t locsymcount;
6545 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
6546 locsymcount = symtab_hdr->sh_info;
6548 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
6549 if (isymbuf == NULL && locsymcount != 0)
6550 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
6551 NULL, NULL, NULL);
6553 /* Save the symbols for this input file so they won't be read again. */
6554 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
6555 symtab_hdr->contents = (unsigned char *) isymbuf;
6557 return isymbuf;
6561 /* Code for link-time relaxation. */
6563 /* Initialization for relaxation: */
6564 static bfd_boolean analyze_relocations (struct bfd_link_info *);
6565 static bfd_boolean find_relaxable_sections
6566 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
6567 static bfd_boolean collect_source_relocs
6568 (bfd *, asection *, struct bfd_link_info *);
6569 static bfd_boolean is_resolvable_asm_expansion
6570 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
6571 bfd_boolean *);
6572 static Elf_Internal_Rela *find_associated_l32r_irel
6573 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
6574 static bfd_boolean compute_text_actions
6575 (bfd *, asection *, struct bfd_link_info *);
6576 static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
6577 static bfd_boolean compute_ebb_actions (ebb_constraint *);
6578 static bfd_boolean check_section_ebb_pcrels_fit
6579 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, const ebb_constraint *,
6580 const xtensa_opcode *);
6581 static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
6582 static void text_action_add_proposed
6583 (text_action_list *, const ebb_constraint *, asection *);
6584 static int compute_fill_extra_space (property_table_entry *);
6586 /* First pass: */
6587 static bfd_boolean compute_removed_literals
6588 (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
6589 static Elf_Internal_Rela *get_irel_at_offset
6590 (asection *, Elf_Internal_Rela *, bfd_vma);
6591 static bfd_boolean is_removable_literal
6592 (const source_reloc *, int, const source_reloc *, int, asection *,
6593 property_table_entry *, int);
6594 static bfd_boolean remove_dead_literal
6595 (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
6596 Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
6597 static bfd_boolean identify_literal_placement
6598 (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
6599 value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
6600 source_reloc *, property_table_entry *, int, section_cache_t *,
6601 bfd_boolean);
6602 static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
6603 static bfd_boolean coalesce_shared_literal
6604 (asection *, source_reloc *, property_table_entry *, int, value_map *);
6605 static bfd_boolean move_shared_literal
6606 (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
6607 int, const r_reloc *, const literal_value *, section_cache_t *);
6609 /* Second pass: */
6610 static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
6611 static bfd_boolean translate_section_fixes (asection *);
6612 static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
6613 static asection *translate_reloc (const r_reloc *, r_reloc *, asection *);
6614 static void shrink_dynamic_reloc_sections
6615 (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
6616 static bfd_boolean move_literal
6617 (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
6618 xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
6619 static bfd_boolean relax_property_section
6620 (bfd *, asection *, struct bfd_link_info *);
6622 /* Third pass: */
6623 static bfd_boolean relax_section_symbols (bfd *, asection *);
6626 static bfd_boolean
6627 elf_xtensa_relax_section (bfd *abfd,
6628 asection *sec,
6629 struct bfd_link_info *link_info,
6630 bfd_boolean *again)
6632 static value_map_hash_table *values = NULL;
6633 static bfd_boolean relocations_analyzed = FALSE;
6634 xtensa_relax_info *relax_info;
6636 if (link_info->relocatable)
6637 (*link_info->callbacks->einfo)
6638 (_("%P%F: --relax and -r may not be used together\n"));
6640 if (!relocations_analyzed)
6642 /* Do some overall initialization for relaxation. */
6643 values = value_map_hash_table_init ();
6644 if (values == NULL)
6645 return FALSE;
6646 relaxing_section = TRUE;
6647 if (!analyze_relocations (link_info))
6648 return FALSE;
6649 relocations_analyzed = TRUE;
6651 *again = FALSE;
6653 /* Don't mess with linker-created sections. */
6654 if ((sec->flags & SEC_LINKER_CREATED) != 0)
6655 return TRUE;
6657 relax_info = get_xtensa_relax_info (sec);
6658 BFD_ASSERT (relax_info != NULL);
6660 switch (relax_info->visited)
6662 case 0:
6663 /* Note: It would be nice to fold this pass into
6664 analyze_relocations, but it is important for this step that the
6665 sections be examined in link order. */
6666 if (!compute_removed_literals (abfd, sec, link_info, values))
6667 return FALSE;
6668 *again = TRUE;
6669 break;
6671 case 1:
6672 if (values)
6673 value_map_hash_table_delete (values);
6674 values = NULL;
6675 if (!relax_section (abfd, sec, link_info))
6676 return FALSE;
6677 *again = TRUE;
6678 break;
6680 case 2:
6681 if (!relax_section_symbols (abfd, sec))
6682 return FALSE;
6683 break;
6686 relax_info->visited++;
6687 return TRUE;
6691 /* Initialization for relaxation. */
6693 /* This function is called once at the start of relaxation. It scans
6694 all the input sections and marks the ones that are relaxable (i.e.,
6695 literal sections with L32R relocations against them), and then
6696 collects source_reloc information for all the relocations against
6697 those relaxable sections. During this process, it also detects
6698 longcalls, i.e., calls relaxed by the assembler into indirect
6699 calls, that can be optimized back into direct calls. Within each
6700 extended basic block (ebb) containing an optimized longcall, it
6701 computes a set of "text actions" that can be performed to remove
6702 the L32R associated with the longcall while optionally preserving
6703 branch target alignments. */
6705 static bfd_boolean
6706 analyze_relocations (struct bfd_link_info *link_info)
6708 bfd *abfd;
6709 asection *sec;
6710 bfd_boolean is_relaxable = FALSE;
6712 /* Initialize the per-section relaxation info. */
6713 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6714 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6716 init_xtensa_relax_info (sec);
6719 /* Mark relaxable sections (and count relocations against each one). */
6720 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6721 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6723 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
6724 return FALSE;
6727 /* Bail out if there are no relaxable sections. */
6728 if (!is_relaxable)
6729 return TRUE;
6731 /* Allocate space for source_relocs. */
6732 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6733 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6735 xtensa_relax_info *relax_info;
6737 relax_info = get_xtensa_relax_info (sec);
6738 if (relax_info->is_relaxable_literal_section
6739 || relax_info->is_relaxable_asm_section)
6741 relax_info->src_relocs = (source_reloc *)
6742 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
6744 else
6745 relax_info->src_count = 0;
6748 /* Collect info on relocations against each relaxable section. */
6749 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6750 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6752 if (!collect_source_relocs (abfd, sec, link_info))
6753 return FALSE;
6756 /* Compute the text actions. */
6757 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
6758 for (sec = abfd->sections; sec != NULL; sec = sec->next)
6760 if (!compute_text_actions (abfd, sec, link_info))
6761 return FALSE;
6764 return TRUE;
6768 /* Find all the sections that might be relaxed. The motivation for
6769 this pass is that collect_source_relocs() needs to record _all_ the
6770 relocations that target each relaxable section. That is expensive
6771 and unnecessary unless the target section is actually going to be
6772 relaxed. This pass identifies all such sections by checking if
6773 they have L32Rs pointing to them. In the process, the total number
6774 of relocations targeting each section is also counted so that we
6775 know how much space to allocate for source_relocs against each
6776 relaxable literal section. */
6778 static bfd_boolean
6779 find_relaxable_sections (bfd *abfd,
6780 asection *sec,
6781 struct bfd_link_info *link_info,
6782 bfd_boolean *is_relaxable_p)
6784 Elf_Internal_Rela *internal_relocs;
6785 bfd_byte *contents;
6786 bfd_boolean ok = TRUE;
6787 unsigned i;
6788 xtensa_relax_info *source_relax_info;
6789 bfd_boolean is_l32r_reloc;
6791 internal_relocs = retrieve_internal_relocs (abfd, sec,
6792 link_info->keep_memory);
6793 if (internal_relocs == NULL)
6794 return ok;
6796 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6797 if (contents == NULL && sec->size != 0)
6799 ok = FALSE;
6800 goto error_return;
6803 source_relax_info = get_xtensa_relax_info (sec);
6804 for (i = 0; i < sec->reloc_count; i++)
6806 Elf_Internal_Rela *irel = &internal_relocs[i];
6807 r_reloc r_rel;
6808 asection *target_sec;
6809 xtensa_relax_info *target_relax_info;
6811 /* If this section has not already been marked as "relaxable", and
6812 if it contains any ASM_EXPAND relocations (marking expanded
6813 longcalls) that can be optimized into direct calls, then mark
6814 the section as "relaxable". */
6815 if (source_relax_info
6816 && !source_relax_info->is_relaxable_asm_section
6817 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
6819 bfd_boolean is_reachable = FALSE;
6820 if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
6821 link_info, &is_reachable)
6822 && is_reachable)
6824 source_relax_info->is_relaxable_asm_section = TRUE;
6825 *is_relaxable_p = TRUE;
6829 r_reloc_init (&r_rel, abfd, irel, contents,
6830 bfd_get_section_limit (abfd, sec));
6832 target_sec = r_reloc_get_section (&r_rel);
6833 target_relax_info = get_xtensa_relax_info (target_sec);
6834 if (!target_relax_info)
6835 continue;
6837 /* Count PC-relative operand relocations against the target section.
6838 Note: The conditions tested here must match the conditions under
6839 which init_source_reloc is called in collect_source_relocs(). */
6840 is_l32r_reloc = FALSE;
6841 if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6843 xtensa_opcode opcode =
6844 get_relocation_opcode (abfd, sec, contents, irel);
6845 if (opcode != XTENSA_UNDEFINED)
6847 is_l32r_reloc = (opcode == get_l32r_opcode ());
6848 if (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
6849 || is_l32r_reloc)
6850 target_relax_info->src_count++;
6854 if (is_l32r_reloc && r_reloc_is_defined (&r_rel))
6856 /* Mark the target section as relaxable. */
6857 target_relax_info->is_relaxable_literal_section = TRUE;
6858 *is_relaxable_p = TRUE;
6862 error_return:
6863 release_contents (sec, contents);
6864 release_internal_relocs (sec, internal_relocs);
6865 return ok;
6869 /* Record _all_ the relocations that point to relaxable sections, and
6870 get rid of ASM_EXPAND relocs by either converting them to
6871 ASM_SIMPLIFY or by removing them. */
6873 static bfd_boolean
6874 collect_source_relocs (bfd *abfd,
6875 asection *sec,
6876 struct bfd_link_info *link_info)
6878 Elf_Internal_Rela *internal_relocs;
6879 bfd_byte *contents;
6880 bfd_boolean ok = TRUE;
6881 unsigned i;
6882 bfd_size_type sec_size;
6884 internal_relocs = retrieve_internal_relocs (abfd, sec,
6885 link_info->keep_memory);
6886 if (internal_relocs == NULL)
6887 return ok;
6889 sec_size = bfd_get_section_limit (abfd, sec);
6890 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6891 if (contents == NULL && sec_size != 0)
6893 ok = FALSE;
6894 goto error_return;
6897 /* Record relocations against relaxable literal sections. */
6898 for (i = 0; i < sec->reloc_count; i++)
6900 Elf_Internal_Rela *irel = &internal_relocs[i];
6901 r_reloc r_rel;
6902 asection *target_sec;
6903 xtensa_relax_info *target_relax_info;
6905 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6907 target_sec = r_reloc_get_section (&r_rel);
6908 target_relax_info = get_xtensa_relax_info (target_sec);
6910 if (target_relax_info
6911 && (target_relax_info->is_relaxable_literal_section
6912 || target_relax_info->is_relaxable_asm_section))
6914 xtensa_opcode opcode = XTENSA_UNDEFINED;
6915 int opnd = -1;
6916 bfd_boolean is_abs_literal = FALSE;
6918 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
6920 /* None of the current alternate relocs are PC-relative,
6921 and only PC-relative relocs matter here. However, we
6922 still need to record the opcode for literal
6923 coalescing. */
6924 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6925 if (opcode == get_l32r_opcode ())
6927 is_abs_literal = TRUE;
6928 opnd = 1;
6930 else
6931 opcode = XTENSA_UNDEFINED;
6933 else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6935 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6936 opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
6939 if (opcode != XTENSA_UNDEFINED)
6941 int src_next = target_relax_info->src_next++;
6942 source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
6944 init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
6945 is_abs_literal);
6950 /* Now get rid of ASM_EXPAND relocations. At this point, the
6951 src_relocs array for the target literal section may still be
6952 incomplete, but it must at least contain the entries for the L32R
6953 relocations associated with ASM_EXPANDs because they were just
6954 added in the preceding loop over the relocations. */
6956 for (i = 0; i < sec->reloc_count; i++)
6958 Elf_Internal_Rela *irel = &internal_relocs[i];
6959 bfd_boolean is_reachable;
6961 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
6962 &is_reachable))
6963 continue;
6965 if (is_reachable)
6967 Elf_Internal_Rela *l32r_irel;
6968 r_reloc r_rel;
6969 asection *target_sec;
6970 xtensa_relax_info *target_relax_info;
6972 /* Mark the source_reloc for the L32R so that it will be
6973 removed in compute_removed_literals(), along with the
6974 associated literal. */
6975 l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
6976 irel, internal_relocs);
6977 if (l32r_irel == NULL)
6978 continue;
6980 r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
6982 target_sec = r_reloc_get_section (&r_rel);
6983 target_relax_info = get_xtensa_relax_info (target_sec);
6985 if (target_relax_info
6986 && (target_relax_info->is_relaxable_literal_section
6987 || target_relax_info->is_relaxable_asm_section))
6989 source_reloc *s_reloc;
6991 /* Search the source_relocs for the entry corresponding to
6992 the l32r_irel. Note: The src_relocs array is not yet
6993 sorted, but it wouldn't matter anyway because we're
6994 searching by source offset instead of target offset. */
6995 s_reloc = find_source_reloc (target_relax_info->src_relocs,
6996 target_relax_info->src_next,
6997 sec, l32r_irel);
6998 BFD_ASSERT (s_reloc);
6999 s_reloc->is_null = TRUE;
7002 /* Convert this reloc to ASM_SIMPLIFY. */
7003 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
7004 R_XTENSA_ASM_SIMPLIFY);
7005 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7007 pin_internal_relocs (sec, internal_relocs);
7009 else
7011 /* It is resolvable but doesn't reach. We resolve now
7012 by eliminating the relocation -- the call will remain
7013 expanded into L32R/CALLX. */
7014 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7015 pin_internal_relocs (sec, internal_relocs);
7019 error_return:
7020 release_contents (sec, contents);
7021 release_internal_relocs (sec, internal_relocs);
7022 return ok;
7026 /* Return TRUE if the asm expansion can be resolved. Generally it can
7027 be resolved on a final link or when a partial link locates it in the
7028 same section as the target. Set "is_reachable" flag if the target of
7029 the call is within the range of a direct call, given the current VMA
7030 for this section and the target section. */
7032 bfd_boolean
7033 is_resolvable_asm_expansion (bfd *abfd,
7034 asection *sec,
7035 bfd_byte *contents,
7036 Elf_Internal_Rela *irel,
7037 struct bfd_link_info *link_info,
7038 bfd_boolean *is_reachable_p)
7040 asection *target_sec;
7041 bfd_vma target_offset;
7042 r_reloc r_rel;
7043 xtensa_opcode opcode, direct_call_opcode;
7044 bfd_vma self_address;
7045 bfd_vma dest_address;
7046 bfd_boolean uses_l32r;
7047 bfd_size_type sec_size;
7049 *is_reachable_p = FALSE;
7051 if (contents == NULL)
7052 return FALSE;
7054 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
7055 return FALSE;
7057 sec_size = bfd_get_section_limit (abfd, sec);
7058 opcode = get_expanded_call_opcode (contents + irel->r_offset,
7059 sec_size - irel->r_offset, &uses_l32r);
7060 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7061 if (!uses_l32r)
7062 return FALSE;
7064 direct_call_opcode = swap_callx_for_call_opcode (opcode);
7065 if (direct_call_opcode == XTENSA_UNDEFINED)
7066 return FALSE;
7068 /* Check and see that the target resolves. */
7069 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7070 if (!r_reloc_is_defined (&r_rel))
7071 return FALSE;
7073 target_sec = r_reloc_get_section (&r_rel);
7074 target_offset = r_rel.target_offset;
7076 /* If the target is in a shared library, then it doesn't reach. This
7077 isn't supposed to come up because the compiler should never generate
7078 non-PIC calls on systems that use shared libraries, but the linker
7079 shouldn't crash regardless. */
7080 if (!target_sec->output_section)
7081 return FALSE;
7083 /* For relocatable sections, we can only simplify when the output
7084 section of the target is the same as the output section of the
7085 source. */
7086 if (link_info->relocatable
7087 && (target_sec->output_section != sec->output_section
7088 || is_reloc_sym_weak (abfd, irel)))
7089 return FALSE;
7091 self_address = (sec->output_section->vma
7092 + sec->output_offset + irel->r_offset + 3);
7093 dest_address = (target_sec->output_section->vma
7094 + target_sec->output_offset + target_offset);
7096 *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
7097 self_address, dest_address);
7099 if ((self_address >> CALL_SEGMENT_BITS) !=
7100 (dest_address >> CALL_SEGMENT_BITS))
7101 return FALSE;
7103 return TRUE;
7107 static Elf_Internal_Rela *
7108 find_associated_l32r_irel (bfd *abfd,
7109 asection *sec,
7110 bfd_byte *contents,
7111 Elf_Internal_Rela *other_irel,
7112 Elf_Internal_Rela *internal_relocs)
7114 unsigned i;
7116 for (i = 0; i < sec->reloc_count; i++)
7118 Elf_Internal_Rela *irel = &internal_relocs[i];
7120 if (irel == other_irel)
7121 continue;
7122 if (irel->r_offset != other_irel->r_offset)
7123 continue;
7124 if (is_l32r_relocation (abfd, sec, contents, irel))
7125 return irel;
7128 return NULL;
7132 static xtensa_opcode *
7133 build_reloc_opcodes (bfd *abfd,
7134 asection *sec,
7135 bfd_byte *contents,
7136 Elf_Internal_Rela *internal_relocs)
7138 unsigned i;
7139 xtensa_opcode *reloc_opcodes =
7140 (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
7141 for (i = 0; i < sec->reloc_count; i++)
7143 Elf_Internal_Rela *irel = &internal_relocs[i];
7144 reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
7146 return reloc_opcodes;
7150 /* The compute_text_actions function will build a list of potential
7151 transformation actions for code in the extended basic block of each
7152 longcall that is optimized to a direct call. From this list we
7153 generate a set of actions to actually perform that optimizes for
7154 space and, if not using size_opt, maintains branch target
7155 alignments.
7157 These actions to be performed are placed on a per-section list.
7158 The actual changes are performed by relax_section() in the second
7159 pass. */
7161 bfd_boolean
7162 compute_text_actions (bfd *abfd,
7163 asection *sec,
7164 struct bfd_link_info *link_info)
7166 xtensa_opcode *reloc_opcodes = NULL;
7167 xtensa_relax_info *relax_info;
7168 bfd_byte *contents;
7169 Elf_Internal_Rela *internal_relocs;
7170 bfd_boolean ok = TRUE;
7171 unsigned i;
7172 property_table_entry *prop_table = 0;
7173 int ptblsize = 0;
7174 bfd_size_type sec_size;
7176 relax_info = get_xtensa_relax_info (sec);
7177 BFD_ASSERT (relax_info);
7178 BFD_ASSERT (relax_info->src_next == relax_info->src_count);
7180 /* Do nothing if the section contains no optimized longcalls. */
7181 if (!relax_info->is_relaxable_asm_section)
7182 return ok;
7184 internal_relocs = retrieve_internal_relocs (abfd, sec,
7185 link_info->keep_memory);
7187 if (internal_relocs)
7188 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7189 internal_reloc_compare);
7191 sec_size = bfd_get_section_limit (abfd, sec);
7192 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7193 if (contents == NULL && sec_size != 0)
7195 ok = FALSE;
7196 goto error_return;
7199 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7200 XTENSA_PROP_SEC_NAME, FALSE);
7201 if (ptblsize < 0)
7203 ok = FALSE;
7204 goto error_return;
7207 for (i = 0; i < sec->reloc_count; i++)
7209 Elf_Internal_Rela *irel = &internal_relocs[i];
7210 bfd_vma r_offset;
7211 property_table_entry *the_entry;
7212 int ptbl_idx;
7213 ebb_t *ebb;
7214 ebb_constraint ebb_table;
7215 bfd_size_type simplify_size;
7217 if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
7218 continue;
7219 r_offset = irel->r_offset;
7221 simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
7222 if (simplify_size == 0)
7224 (*_bfd_error_handler)
7225 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
7226 sec->owner, sec, r_offset);
7227 continue;
7230 /* If the instruction table is not around, then don't do this
7231 relaxation. */
7232 the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7233 sec->vma + irel->r_offset);
7234 if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
7236 text_action_add (&relax_info->action_list,
7237 ta_convert_longcall, sec, r_offset,
7239 continue;
7242 /* If the next longcall happens to be at the same address as an
7243 unreachable section of size 0, then skip forward. */
7244 ptbl_idx = the_entry - prop_table;
7245 while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
7246 && the_entry->size == 0
7247 && ptbl_idx + 1 < ptblsize
7248 && (prop_table[ptbl_idx + 1].address
7249 == prop_table[ptbl_idx].address))
7251 ptbl_idx++;
7252 the_entry++;
7255 if (the_entry->flags & XTENSA_PROP_NO_TRANSFORM)
7256 /* NO_REORDER is OK */
7257 continue;
7259 init_ebb_constraint (&ebb_table);
7260 ebb = &ebb_table.ebb;
7261 init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
7262 internal_relocs, sec->reloc_count);
7263 ebb->start_offset = r_offset + simplify_size;
7264 ebb->end_offset = r_offset + simplify_size;
7265 ebb->start_ptbl_idx = ptbl_idx;
7266 ebb->end_ptbl_idx = ptbl_idx;
7267 ebb->start_reloc_idx = i;
7268 ebb->end_reloc_idx = i;
7270 /* Precompute the opcode for each relocation. */
7271 if (reloc_opcodes == NULL)
7272 reloc_opcodes = build_reloc_opcodes (abfd, sec, contents,
7273 internal_relocs);
7275 if (!extend_ebb_bounds (ebb)
7276 || !compute_ebb_proposed_actions (&ebb_table)
7277 || !compute_ebb_actions (&ebb_table)
7278 || !check_section_ebb_pcrels_fit (abfd, sec, contents,
7279 internal_relocs, &ebb_table,
7280 reloc_opcodes)
7281 || !check_section_ebb_reduces (&ebb_table))
7283 /* If anything goes wrong or we get unlucky and something does
7284 not fit, with our plan because of expansion between
7285 critical branches, just convert to a NOP. */
7287 text_action_add (&relax_info->action_list,
7288 ta_convert_longcall, sec, r_offset, 0);
7289 i = ebb_table.ebb.end_reloc_idx;
7290 free_ebb_constraint (&ebb_table);
7291 continue;
7294 text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
7296 /* Update the index so we do not go looking at the relocations
7297 we have already processed. */
7298 i = ebb_table.ebb.end_reloc_idx;
7299 free_ebb_constraint (&ebb_table);
7302 #if DEBUG
7303 if (relax_info->action_list.head)
7304 print_action_list (stderr, &relax_info->action_list);
7305 #endif
7307 error_return:
7308 release_contents (sec, contents);
7309 release_internal_relocs (sec, internal_relocs);
7310 if (prop_table)
7311 free (prop_table);
7312 if (reloc_opcodes)
7313 free (reloc_opcodes);
7315 return ok;
7319 /* Do not widen an instruction if it is preceeded by a
7320 loop opcode. It might cause misalignment. */
7322 static bfd_boolean
7323 prev_instr_is_a_loop (bfd_byte *contents,
7324 bfd_size_type content_length,
7325 bfd_size_type offset)
7327 xtensa_opcode prev_opcode;
7329 if (offset < 3)
7330 return FALSE;
7331 prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
7332 return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
7336 /* Find all of the possible actions for an extended basic block. */
7338 bfd_boolean
7339 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
7341 const ebb_t *ebb = &ebb_table->ebb;
7342 unsigned rel_idx = ebb->start_reloc_idx;
7343 property_table_entry *entry, *start_entry, *end_entry;
7344 bfd_vma offset = 0;
7345 xtensa_isa isa = xtensa_default_isa;
7346 xtensa_format fmt;
7347 static xtensa_insnbuf insnbuf = NULL;
7348 static xtensa_insnbuf slotbuf = NULL;
7350 if (insnbuf == NULL)
7352 insnbuf = xtensa_insnbuf_alloc (isa);
7353 slotbuf = xtensa_insnbuf_alloc (isa);
7356 start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
7357 end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
7359 for (entry = start_entry; entry <= end_entry; entry++)
7361 bfd_vma start_offset, end_offset;
7362 bfd_size_type insn_len;
7364 start_offset = entry->address - ebb->sec->vma;
7365 end_offset = entry->address + entry->size - ebb->sec->vma;
7367 if (entry == start_entry)
7368 start_offset = ebb->start_offset;
7369 if (entry == end_entry)
7370 end_offset = ebb->end_offset;
7371 offset = start_offset;
7373 if (offset == entry->address - ebb->sec->vma
7374 && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
7376 enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
7377 BFD_ASSERT (offset != end_offset);
7378 if (offset == end_offset)
7379 return FALSE;
7381 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
7382 offset);
7383 if (insn_len == 0)
7384 goto decode_error;
7386 if (check_branch_target_aligned_address (offset, insn_len))
7387 align_type = EBB_REQUIRE_TGT_ALIGN;
7389 ebb_propose_action (ebb_table, align_type, 0,
7390 ta_none, offset, 0, TRUE);
7393 while (offset != end_offset)
7395 Elf_Internal_Rela *irel;
7396 xtensa_opcode opcode;
7398 while (rel_idx < ebb->end_reloc_idx
7399 && (ebb->relocs[rel_idx].r_offset < offset
7400 || (ebb->relocs[rel_idx].r_offset == offset
7401 && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
7402 != R_XTENSA_ASM_SIMPLIFY))))
7403 rel_idx++;
7405 /* Check for longcall. */
7406 irel = &ebb->relocs[rel_idx];
7407 if (irel->r_offset == offset
7408 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
7410 bfd_size_type simplify_size;
7412 simplify_size = get_asm_simplify_size (ebb->contents,
7413 ebb->content_length,
7414 irel->r_offset);
7415 if (simplify_size == 0)
7416 goto decode_error;
7418 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7419 ta_convert_longcall, offset, 0, TRUE);
7421 offset += simplify_size;
7422 continue;
7425 if (offset + MIN_INSN_LENGTH > ebb->content_length)
7426 goto decode_error;
7427 xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
7428 ebb->content_length - offset);
7429 fmt = xtensa_format_decode (isa, insnbuf);
7430 if (fmt == XTENSA_UNDEFINED)
7431 goto decode_error;
7432 insn_len = xtensa_format_length (isa, fmt);
7433 if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
7434 goto decode_error;
7436 if (xtensa_format_num_slots (isa, fmt) != 1)
7438 offset += insn_len;
7439 continue;
7442 xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
7443 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
7444 if (opcode == XTENSA_UNDEFINED)
7445 goto decode_error;
7447 if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
7448 && (entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7449 && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
7451 /* Add an instruction narrow action. */
7452 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7453 ta_narrow_insn, offset, 0, FALSE);
7455 else if ((entry->flags & XTENSA_PROP_NO_TRANSFORM) == 0
7456 && can_widen_instruction (slotbuf, fmt, opcode) != 0
7457 && ! prev_instr_is_a_loop (ebb->contents,
7458 ebb->content_length, offset))
7460 /* Add an instruction widen action. */
7461 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7462 ta_widen_insn, offset, 0, FALSE);
7464 else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
7466 /* Check for branch targets. */
7467 ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
7468 ta_none, offset, 0, TRUE);
7471 offset += insn_len;
7475 if (ebb->ends_unreachable)
7477 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
7478 ta_fill, ebb->end_offset, 0, TRUE);
7481 return TRUE;
7483 decode_error:
7484 (*_bfd_error_handler)
7485 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
7486 ebb->sec->owner, ebb->sec, offset);
7487 return FALSE;
7491 /* After all of the information has collected about the
7492 transformations possible in an EBB, compute the appropriate actions
7493 here in compute_ebb_actions. We still must check later to make
7494 sure that the actions do not break any relocations. The algorithm
7495 used here is pretty greedy. Basically, it removes as many no-ops
7496 as possible so that the end of the EBB has the same alignment
7497 characteristics as the original. First, it uses narrowing, then
7498 fill space at the end of the EBB, and finally widenings. If that
7499 does not work, it tries again with one fewer no-op removed. The
7500 optimization will only be performed if all of the branch targets
7501 that were aligned before transformation are also aligned after the
7502 transformation.
7504 When the size_opt flag is set, ignore the branch target alignments,
7505 narrow all wide instructions, and remove all no-ops unless the end
7506 of the EBB prevents it. */
7508 bfd_boolean
7509 compute_ebb_actions (ebb_constraint *ebb_table)
7511 unsigned i = 0;
7512 unsigned j;
7513 int removed_bytes = 0;
7514 ebb_t *ebb = &ebb_table->ebb;
7515 unsigned seg_idx_start = 0;
7516 unsigned seg_idx_end = 0;
7518 /* We perform this like the assembler relaxation algorithm: Start by
7519 assuming all instructions are narrow and all no-ops removed; then
7520 walk through.... */
7522 /* For each segment of this that has a solid constraint, check to
7523 see if there are any combinations that will keep the constraint.
7524 If so, use it. */
7525 for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
7527 bfd_boolean requires_text_end_align = FALSE;
7528 unsigned longcall_count = 0;
7529 unsigned longcall_convert_count = 0;
7530 unsigned narrowable_count = 0;
7531 unsigned narrowable_convert_count = 0;
7532 unsigned widenable_count = 0;
7533 unsigned widenable_convert_count = 0;
7535 proposed_action *action = NULL;
7536 int align = (1 << ebb_table->ebb.sec->alignment_power);
7538 seg_idx_start = seg_idx_end;
7540 for (i = seg_idx_start; i < ebb_table->action_count; i++)
7542 action = &ebb_table->actions[i];
7543 if (action->action == ta_convert_longcall)
7544 longcall_count++;
7545 if (action->action == ta_narrow_insn)
7546 narrowable_count++;
7547 if (action->action == ta_widen_insn)
7548 widenable_count++;
7549 if (action->action == ta_fill)
7550 break;
7551 if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
7552 break;
7553 if (action->align_type == EBB_REQUIRE_TGT_ALIGN
7554 && !elf32xtensa_size_opt)
7555 break;
7557 seg_idx_end = i;
7559 if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
7560 requires_text_end_align = TRUE;
7562 if (elf32xtensa_size_opt && !requires_text_end_align
7563 && action->align_type != EBB_REQUIRE_LOOP_ALIGN
7564 && action->align_type != EBB_REQUIRE_TGT_ALIGN)
7566 longcall_convert_count = longcall_count;
7567 narrowable_convert_count = narrowable_count;
7568 widenable_convert_count = 0;
7570 else
7572 /* There is a constraint. Convert the max number of longcalls. */
7573 narrowable_convert_count = 0;
7574 longcall_convert_count = 0;
7575 widenable_convert_count = 0;
7577 for (j = 0; j < longcall_count; j++)
7579 int removed = (longcall_count - j) * 3 & (align - 1);
7580 unsigned desire_narrow = (align - removed) & (align - 1);
7581 unsigned desire_widen = removed;
7582 if (desire_narrow <= narrowable_count)
7584 narrowable_convert_count = desire_narrow;
7585 narrowable_convert_count +=
7586 (align * ((narrowable_count - narrowable_convert_count)
7587 / align));
7588 longcall_convert_count = (longcall_count - j);
7589 widenable_convert_count = 0;
7590 break;
7592 if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
7594 narrowable_convert_count = 0;
7595 longcall_convert_count = longcall_count - j;
7596 widenable_convert_count = desire_widen;
7597 break;
7602 /* Now the number of conversions are saved. Do them. */
7603 for (i = seg_idx_start; i < seg_idx_end; i++)
7605 action = &ebb_table->actions[i];
7606 switch (action->action)
7608 case ta_convert_longcall:
7609 if (longcall_convert_count != 0)
7611 action->action = ta_remove_longcall;
7612 action->do_action = TRUE;
7613 action->removed_bytes += 3;
7614 longcall_convert_count--;
7616 break;
7617 case ta_narrow_insn:
7618 if (narrowable_convert_count != 0)
7620 action->do_action = TRUE;
7621 action->removed_bytes += 1;
7622 narrowable_convert_count--;
7624 break;
7625 case ta_widen_insn:
7626 if (widenable_convert_count != 0)
7628 action->do_action = TRUE;
7629 action->removed_bytes -= 1;
7630 widenable_convert_count--;
7632 break;
7633 default:
7634 break;
7639 /* Now we move on to some local opts. Try to remove each of the
7640 remaining longcalls. */
7642 if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
7644 removed_bytes = 0;
7645 for (i = 0; i < ebb_table->action_count; i++)
7647 int old_removed_bytes = removed_bytes;
7648 proposed_action *action = &ebb_table->actions[i];
7650 if (action->do_action && action->action == ta_convert_longcall)
7652 bfd_boolean bad_alignment = FALSE;
7653 removed_bytes += 3;
7654 for (j = i + 1; j < ebb_table->action_count; j++)
7656 proposed_action *new_action = &ebb_table->actions[j];
7657 bfd_vma offset = new_action->offset;
7658 if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
7660 if (!check_branch_target_aligned
7661 (ebb_table->ebb.contents,
7662 ebb_table->ebb.content_length,
7663 offset, offset - removed_bytes))
7665 bad_alignment = TRUE;
7666 break;
7669 if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
7671 if (!check_loop_aligned (ebb_table->ebb.contents,
7672 ebb_table->ebb.content_length,
7673 offset,
7674 offset - removed_bytes))
7676 bad_alignment = TRUE;
7677 break;
7680 if (new_action->action == ta_narrow_insn
7681 && !new_action->do_action
7682 && ebb_table->ebb.sec->alignment_power == 2)
7684 /* Narrow an instruction and we are done. */
7685 new_action->do_action = TRUE;
7686 new_action->removed_bytes += 1;
7687 bad_alignment = FALSE;
7688 break;
7690 if (new_action->action == ta_widen_insn
7691 && new_action->do_action
7692 && ebb_table->ebb.sec->alignment_power == 2)
7694 /* Narrow an instruction and we are done. */
7695 new_action->do_action = FALSE;
7696 new_action->removed_bytes += 1;
7697 bad_alignment = FALSE;
7698 break;
7700 if (new_action->do_action)
7701 removed_bytes += new_action->removed_bytes;
7703 if (!bad_alignment)
7705 action->removed_bytes += 3;
7706 action->action = ta_remove_longcall;
7707 action->do_action = TRUE;
7710 removed_bytes = old_removed_bytes;
7711 if (action->do_action)
7712 removed_bytes += action->removed_bytes;
7716 removed_bytes = 0;
7717 for (i = 0; i < ebb_table->action_count; ++i)
7719 proposed_action *action = &ebb_table->actions[i];
7720 if (action->do_action)
7721 removed_bytes += action->removed_bytes;
7724 if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
7725 && ebb->ends_unreachable)
7727 proposed_action *action;
7728 int br;
7729 int extra_space;
7731 BFD_ASSERT (ebb_table->action_count != 0);
7732 action = &ebb_table->actions[ebb_table->action_count - 1];
7733 BFD_ASSERT (action->action == ta_fill);
7734 BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
7736 extra_space = compute_fill_extra_space (ebb->ends_unreachable);
7737 br = action->removed_bytes + removed_bytes + extra_space;
7738 br = br & ((1 << ebb->sec->alignment_power ) - 1);
7740 action->removed_bytes = extra_space - br;
7742 return TRUE;
7746 /* The xlate_map is a sorted array of address mappings designed to
7747 answer the offset_with_removed_text() query with a binary search instead
7748 of a linear search through the section's action_list. */
7750 typedef struct xlate_map_entry xlate_map_entry_t;
7751 typedef struct xlate_map xlate_map_t;
7753 struct xlate_map_entry
7755 unsigned orig_address;
7756 unsigned new_address;
7757 unsigned size;
7760 struct xlate_map
7762 unsigned entry_count;
7763 xlate_map_entry_t *entry;
7767 static int
7768 xlate_compare (const void *a_v, const void *b_v)
7770 const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
7771 const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
7772 if (a->orig_address < b->orig_address)
7773 return -1;
7774 if (a->orig_address > (b->orig_address + b->size - 1))
7775 return 1;
7776 return 0;
7780 static bfd_vma
7781 xlate_offset_with_removed_text (const xlate_map_t *map,
7782 text_action_list *action_list,
7783 bfd_vma offset)
7785 xlate_map_entry_t tmp;
7786 void *r;
7787 xlate_map_entry_t *e;
7789 if (map == NULL)
7790 return offset_with_removed_text (action_list, offset);
7792 if (map->entry_count == 0)
7793 return offset;
7795 tmp.orig_address = offset;
7796 tmp.new_address = offset;
7797 tmp.size = 1;
7799 r = bsearch (&offset, map->entry, map->entry_count,
7800 sizeof (xlate_map_entry_t), &xlate_compare);
7801 e = (xlate_map_entry_t *) r;
7803 BFD_ASSERT (e != NULL);
7804 if (e == NULL)
7805 return offset;
7806 return e->new_address - e->orig_address + offset;
7810 /* Build a binary searchable offset translation map from a section's
7811 action list. */
7813 static xlate_map_t *
7814 build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
7816 xlate_map_t *map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
7817 text_action_list *action_list = &relax_info->action_list;
7818 unsigned num_actions = 0;
7819 text_action *r;
7820 int removed;
7821 xlate_map_entry_t *current_entry;
7823 if (map == NULL)
7824 return NULL;
7826 num_actions = action_list_count (action_list);
7827 map->entry = (xlate_map_entry_t *)
7828 bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
7829 if (map->entry == NULL)
7831 free (map);
7832 return NULL;
7834 map->entry_count = 0;
7836 removed = 0;
7837 current_entry = &map->entry[0];
7839 current_entry->orig_address = 0;
7840 current_entry->new_address = 0;
7841 current_entry->size = 0;
7843 for (r = action_list->head; r != NULL; r = r->next)
7845 unsigned orig_size = 0;
7846 switch (r->action)
7848 case ta_none:
7849 case ta_remove_insn:
7850 case ta_convert_longcall:
7851 case ta_remove_literal:
7852 case ta_add_literal:
7853 break;
7854 case ta_remove_longcall:
7855 orig_size = 6;
7856 break;
7857 case ta_narrow_insn:
7858 orig_size = 3;
7859 break;
7860 case ta_widen_insn:
7861 orig_size = 2;
7862 break;
7863 case ta_fill:
7864 break;
7866 current_entry->size =
7867 r->offset + orig_size - current_entry->orig_address;
7868 if (current_entry->size != 0)
7870 current_entry++;
7871 map->entry_count++;
7873 current_entry->orig_address = r->offset + orig_size;
7874 removed += r->removed_bytes;
7875 current_entry->new_address = r->offset + orig_size - removed;
7876 current_entry->size = 0;
7879 current_entry->size = (bfd_get_section_limit (sec->owner, sec)
7880 - current_entry->orig_address);
7881 if (current_entry->size != 0)
7882 map->entry_count++;
7884 return map;
7888 /* Free an offset translation map. */
7890 static void
7891 free_xlate_map (xlate_map_t *map)
7893 if (map && map->entry)
7894 free (map->entry);
7895 if (map)
7896 free (map);
7900 /* Use check_section_ebb_pcrels_fit to make sure that all of the
7901 relocations in a section will fit if a proposed set of actions
7902 are performed. */
7904 static bfd_boolean
7905 check_section_ebb_pcrels_fit (bfd *abfd,
7906 asection *sec,
7907 bfd_byte *contents,
7908 Elf_Internal_Rela *internal_relocs,
7909 const ebb_constraint *constraint,
7910 const xtensa_opcode *reloc_opcodes)
7912 unsigned i, j;
7913 Elf_Internal_Rela *irel;
7914 xlate_map_t *xmap = NULL;
7915 bfd_boolean ok = TRUE;
7916 xtensa_relax_info *relax_info;
7918 relax_info = get_xtensa_relax_info (sec);
7920 if (relax_info && sec->reloc_count > 100)
7922 xmap = build_xlate_map (sec, relax_info);
7923 /* NULL indicates out of memory, but the slow version
7924 can still be used. */
7927 for (i = 0; i < sec->reloc_count; i++)
7929 r_reloc r_rel;
7930 bfd_vma orig_self_offset, orig_target_offset;
7931 bfd_vma self_offset, target_offset;
7932 int r_type;
7933 reloc_howto_type *howto;
7934 int self_removed_bytes, target_removed_bytes;
7936 irel = &internal_relocs[i];
7937 r_type = ELF32_R_TYPE (irel->r_info);
7939 howto = &elf_howto_table[r_type];
7940 /* We maintain the required invariant: PC-relative relocations
7941 that fit before linking must fit after linking. Thus we only
7942 need to deal with relocations to the same section that are
7943 PC-relative. */
7944 if (r_type == R_XTENSA_ASM_SIMPLIFY
7945 || r_type == R_XTENSA_32_PCREL
7946 || !howto->pc_relative)
7947 continue;
7949 r_reloc_init (&r_rel, abfd, irel, contents,
7950 bfd_get_section_limit (abfd, sec));
7952 if (r_reloc_get_section (&r_rel) != sec)
7953 continue;
7955 orig_self_offset = irel->r_offset;
7956 orig_target_offset = r_rel.target_offset;
7958 self_offset = orig_self_offset;
7959 target_offset = orig_target_offset;
7961 if (relax_info)
7963 self_offset =
7964 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
7965 orig_self_offset);
7966 target_offset =
7967 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
7968 orig_target_offset);
7971 self_removed_bytes = 0;
7972 target_removed_bytes = 0;
7974 for (j = 0; j < constraint->action_count; ++j)
7976 proposed_action *action = &constraint->actions[j];
7977 bfd_vma offset = action->offset;
7978 int removed_bytes = action->removed_bytes;
7979 if (offset < orig_self_offset
7980 || (offset == orig_self_offset && action->action == ta_fill
7981 && action->removed_bytes < 0))
7982 self_removed_bytes += removed_bytes;
7983 if (offset < orig_target_offset
7984 || (offset == orig_target_offset && action->action == ta_fill
7985 && action->removed_bytes < 0))
7986 target_removed_bytes += removed_bytes;
7988 self_offset -= self_removed_bytes;
7989 target_offset -= target_removed_bytes;
7991 /* Try to encode it. Get the operand and check. */
7992 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7994 /* None of the current alternate relocs are PC-relative,
7995 and only PC-relative relocs matter here. */
7997 else
7999 xtensa_opcode opcode;
8000 int opnum;
8002 if (reloc_opcodes)
8003 opcode = reloc_opcodes[i];
8004 else
8005 opcode = get_relocation_opcode (abfd, sec, contents, irel);
8006 if (opcode == XTENSA_UNDEFINED)
8008 ok = FALSE;
8009 break;
8012 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
8013 if (opnum == XTENSA_UNDEFINED)
8015 ok = FALSE;
8016 break;
8019 if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
8021 ok = FALSE;
8022 break;
8027 if (xmap)
8028 free_xlate_map (xmap);
8030 return ok;
8034 static bfd_boolean
8035 check_section_ebb_reduces (const ebb_constraint *constraint)
8037 int removed = 0;
8038 unsigned i;
8040 for (i = 0; i < constraint->action_count; i++)
8042 const proposed_action *action = &constraint->actions[i];
8043 if (action->do_action)
8044 removed += action->removed_bytes;
8046 if (removed < 0)
8047 return FALSE;
8049 return TRUE;
8053 void
8054 text_action_add_proposed (text_action_list *l,
8055 const ebb_constraint *ebb_table,
8056 asection *sec)
8058 unsigned i;
8060 for (i = 0; i < ebb_table->action_count; i++)
8062 proposed_action *action = &ebb_table->actions[i];
8064 if (!action->do_action)
8065 continue;
8066 switch (action->action)
8068 case ta_remove_insn:
8069 case ta_remove_longcall:
8070 case ta_convert_longcall:
8071 case ta_narrow_insn:
8072 case ta_widen_insn:
8073 case ta_fill:
8074 case ta_remove_literal:
8075 text_action_add (l, action->action, sec, action->offset,
8076 action->removed_bytes);
8077 break;
8078 case ta_none:
8079 break;
8080 default:
8081 BFD_ASSERT (0);
8082 break;
8089 compute_fill_extra_space (property_table_entry *entry)
8091 int fill_extra_space;
8093 if (!entry)
8094 return 0;
8096 if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
8097 return 0;
8099 fill_extra_space = entry->size;
8100 if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
8102 /* Fill bytes for alignment:
8103 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8104 int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
8105 int nsm = (1 << pow) - 1;
8106 bfd_vma addr = entry->address + entry->size;
8107 bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
8108 fill_extra_space += align_fill;
8110 return fill_extra_space;
8114 /* First relaxation pass. */
8116 /* If the section contains relaxable literals, check each literal to
8117 see if it has the same value as another literal that has already
8118 been seen, either in the current section or a previous one. If so,
8119 add an entry to the per-section list of removed literals. The
8120 actual changes are deferred until the next pass. */
8122 static bfd_boolean
8123 compute_removed_literals (bfd *abfd,
8124 asection *sec,
8125 struct bfd_link_info *link_info,
8126 value_map_hash_table *values)
8128 xtensa_relax_info *relax_info;
8129 bfd_byte *contents;
8130 Elf_Internal_Rela *internal_relocs;
8131 source_reloc *src_relocs, *rel;
8132 bfd_boolean ok = TRUE;
8133 property_table_entry *prop_table = NULL;
8134 int ptblsize;
8135 int i, prev_i;
8136 bfd_boolean last_loc_is_prev = FALSE;
8137 bfd_vma last_target_offset = 0;
8138 section_cache_t target_sec_cache;
8139 bfd_size_type sec_size;
8141 init_section_cache (&target_sec_cache);
8143 /* Do nothing if it is not a relaxable literal section. */
8144 relax_info = get_xtensa_relax_info (sec);
8145 BFD_ASSERT (relax_info);
8146 if (!relax_info->is_relaxable_literal_section)
8147 return ok;
8149 internal_relocs = retrieve_internal_relocs (abfd, sec,
8150 link_info->keep_memory);
8152 sec_size = bfd_get_section_limit (abfd, sec);
8153 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8154 if (contents == NULL && sec_size != 0)
8156 ok = FALSE;
8157 goto error_return;
8160 /* Sort the source_relocs by target offset. */
8161 src_relocs = relax_info->src_relocs;
8162 qsort (src_relocs, relax_info->src_count,
8163 sizeof (source_reloc), source_reloc_compare);
8164 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8165 internal_reloc_compare);
8167 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
8168 XTENSA_PROP_SEC_NAME, FALSE);
8169 if (ptblsize < 0)
8171 ok = FALSE;
8172 goto error_return;
8175 prev_i = -1;
8176 for (i = 0; i < relax_info->src_count; i++)
8178 Elf_Internal_Rela *irel = NULL;
8180 rel = &src_relocs[i];
8181 if (get_l32r_opcode () != rel->opcode)
8182 continue;
8183 irel = get_irel_at_offset (sec, internal_relocs,
8184 rel->r_rel.target_offset);
8186 /* If the relocation on this is not a simple R_XTENSA_32 or
8187 R_XTENSA_PLT then do not consider it. This may happen when
8188 the difference of two symbols is used in a literal. */
8189 if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
8190 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
8191 continue;
8193 /* If the target_offset for this relocation is the same as the
8194 previous relocation, then we've already considered whether the
8195 literal can be coalesced. Skip to the next one.... */
8196 if (i != 0 && prev_i != -1
8197 && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
8198 continue;
8199 prev_i = i;
8201 if (last_loc_is_prev &&
8202 last_target_offset + 4 != rel->r_rel.target_offset)
8203 last_loc_is_prev = FALSE;
8205 /* Check if the relocation was from an L32R that is being removed
8206 because a CALLX was converted to a direct CALL, and check if
8207 there are no other relocations to the literal. */
8208 if (is_removable_literal (rel, i, src_relocs, relax_info->src_count,
8209 sec, prop_table, ptblsize))
8211 if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
8212 irel, rel, prop_table, ptblsize))
8214 ok = FALSE;
8215 goto error_return;
8217 last_target_offset = rel->r_rel.target_offset;
8218 continue;
8221 if (!identify_literal_placement (abfd, sec, contents, link_info,
8222 values,
8223 &last_loc_is_prev, irel,
8224 relax_info->src_count - i, rel,
8225 prop_table, ptblsize,
8226 &target_sec_cache, rel->is_abs_literal))
8228 ok = FALSE;
8229 goto error_return;
8231 last_target_offset = rel->r_rel.target_offset;
8234 #if DEBUG
8235 print_removed_literals (stderr, &relax_info->removed_list);
8236 print_action_list (stderr, &relax_info->action_list);
8237 #endif /* DEBUG */
8239 error_return:
8240 if (prop_table) free (prop_table);
8241 clear_section_cache (&target_sec_cache);
8243 release_contents (sec, contents);
8244 release_internal_relocs (sec, internal_relocs);
8245 return ok;
8249 static Elf_Internal_Rela *
8250 get_irel_at_offset (asection *sec,
8251 Elf_Internal_Rela *internal_relocs,
8252 bfd_vma offset)
8254 unsigned i;
8255 Elf_Internal_Rela *irel;
8256 unsigned r_type;
8257 Elf_Internal_Rela key;
8259 if (!internal_relocs)
8260 return NULL;
8262 key.r_offset = offset;
8263 irel = bsearch (&key, internal_relocs, sec->reloc_count,
8264 sizeof (Elf_Internal_Rela), internal_reloc_matches);
8265 if (!irel)
8266 return NULL;
8268 /* bsearch does not guarantee which will be returned if there are
8269 multiple matches. We need the first that is not an alignment. */
8270 i = irel - internal_relocs;
8271 while (i > 0)
8273 if (internal_relocs[i-1].r_offset != offset)
8274 break;
8275 i--;
8277 for ( ; i < sec->reloc_count; i++)
8279 irel = &internal_relocs[i];
8280 r_type = ELF32_R_TYPE (irel->r_info);
8281 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
8282 return irel;
8285 return NULL;
8289 bfd_boolean
8290 is_removable_literal (const source_reloc *rel,
8291 int i,
8292 const source_reloc *src_relocs,
8293 int src_count,
8294 asection *sec,
8295 property_table_entry *prop_table,
8296 int ptblsize)
8298 const source_reloc *curr_rel;
8299 property_table_entry *entry;
8301 if (!rel->is_null)
8302 return FALSE;
8304 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8305 sec->vma + rel->r_rel.target_offset);
8306 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8307 return FALSE;
8309 for (++i; i < src_count; ++i)
8311 curr_rel = &src_relocs[i];
8312 /* If all others have the same target offset.... */
8313 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
8314 return TRUE;
8316 if (!curr_rel->is_null
8317 && !xtensa_is_property_section (curr_rel->source_sec)
8318 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
8319 return FALSE;
8321 return TRUE;
8325 bfd_boolean
8326 remove_dead_literal (bfd *abfd,
8327 asection *sec,
8328 struct bfd_link_info *link_info,
8329 Elf_Internal_Rela *internal_relocs,
8330 Elf_Internal_Rela *irel,
8331 source_reloc *rel,
8332 property_table_entry *prop_table,
8333 int ptblsize)
8335 property_table_entry *entry;
8336 xtensa_relax_info *relax_info;
8338 relax_info = get_xtensa_relax_info (sec);
8339 if (!relax_info)
8340 return FALSE;
8342 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8343 sec->vma + rel->r_rel.target_offset);
8345 /* Mark the unused literal so that it will be removed. */
8346 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
8348 text_action_add (&relax_info->action_list,
8349 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8351 /* If the section is 4-byte aligned, do not add fill. */
8352 if (sec->alignment_power > 2)
8354 int fill_extra_space;
8355 bfd_vma entry_sec_offset;
8356 text_action *fa;
8357 property_table_entry *the_add_entry;
8358 int removed_diff;
8360 if (entry)
8361 entry_sec_offset = entry->address - sec->vma + entry->size;
8362 else
8363 entry_sec_offset = rel->r_rel.target_offset + 4;
8365 /* If the literal range is at the end of the section,
8366 do not add fill. */
8367 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8368 entry_sec_offset);
8369 fill_extra_space = compute_fill_extra_space (the_add_entry);
8371 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8372 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8373 -4, fill_extra_space);
8374 if (fa)
8375 adjust_fill_action (fa, removed_diff);
8376 else
8377 text_action_add (&relax_info->action_list,
8378 ta_fill, sec, entry_sec_offset, removed_diff);
8381 /* Zero out the relocation on this literal location. */
8382 if (irel)
8384 if (elf_hash_table (link_info)->dynamic_sections_created)
8385 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8387 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8388 pin_internal_relocs (sec, internal_relocs);
8391 /* Do not modify "last_loc_is_prev". */
8392 return TRUE;
8396 bfd_boolean
8397 identify_literal_placement (bfd *abfd,
8398 asection *sec,
8399 bfd_byte *contents,
8400 struct bfd_link_info *link_info,
8401 value_map_hash_table *values,
8402 bfd_boolean *last_loc_is_prev_p,
8403 Elf_Internal_Rela *irel,
8404 int remaining_src_rels,
8405 source_reloc *rel,
8406 property_table_entry *prop_table,
8407 int ptblsize,
8408 section_cache_t *target_sec_cache,
8409 bfd_boolean is_abs_literal)
8411 literal_value val;
8412 value_map *val_map;
8413 xtensa_relax_info *relax_info;
8414 bfd_boolean literal_placed = FALSE;
8415 r_reloc r_rel;
8416 unsigned long value;
8417 bfd_boolean final_static_link;
8418 bfd_size_type sec_size;
8420 relax_info = get_xtensa_relax_info (sec);
8421 if (!relax_info)
8422 return FALSE;
8424 sec_size = bfd_get_section_limit (abfd, sec);
8426 final_static_link =
8427 (!link_info->relocatable
8428 && !elf_hash_table (link_info)->dynamic_sections_created);
8430 /* The placement algorithm first checks to see if the literal is
8431 already in the value map. If so and the value map is reachable
8432 from all uses, then the literal is moved to that location. If
8433 not, then we identify the last location where a fresh literal was
8434 placed. If the literal can be safely moved there, then we do so.
8435 If not, then we assume that the literal is not to move and leave
8436 the literal where it is, marking it as the last literal
8437 location. */
8439 /* Find the literal value. */
8440 value = 0;
8441 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8442 if (!irel)
8444 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
8445 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
8447 init_literal_value (&val, &r_rel, value, is_abs_literal);
8449 /* Check if we've seen another literal with the same value that
8450 is in the same output section. */
8451 val_map = value_map_get_cached_value (values, &val, final_static_link);
8453 if (val_map
8454 && (r_reloc_get_section (&val_map->loc)->output_section
8455 == sec->output_section)
8456 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
8457 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
8459 /* No change to last_loc_is_prev. */
8460 literal_placed = TRUE;
8463 /* For relocatable links, do not try to move literals. To do it
8464 correctly might increase the number of relocations in an input
8465 section making the default relocatable linking fail. */
8466 if (!link_info->relocatable && !literal_placed
8467 && values->has_last_loc && !(*last_loc_is_prev_p))
8469 asection *target_sec = r_reloc_get_section (&values->last_loc);
8470 if (target_sec && target_sec->output_section == sec->output_section)
8472 /* Increment the virtual offset. */
8473 r_reloc try_loc = values->last_loc;
8474 try_loc.virtual_offset += 4;
8476 /* There is a last loc that was in the same output section. */
8477 if (relocations_reach (rel, remaining_src_rels, &try_loc)
8478 && move_shared_literal (sec, link_info, rel,
8479 prop_table, ptblsize,
8480 &try_loc, &val, target_sec_cache))
8482 values->last_loc.virtual_offset += 4;
8483 literal_placed = TRUE;
8484 if (!val_map)
8485 val_map = add_value_map (values, &val, &try_loc,
8486 final_static_link);
8487 else
8488 val_map->loc = try_loc;
8493 if (!literal_placed)
8495 /* Nothing worked, leave the literal alone but update the last loc. */
8496 values->has_last_loc = TRUE;
8497 values->last_loc = rel->r_rel;
8498 if (!val_map)
8499 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
8500 else
8501 val_map->loc = rel->r_rel;
8502 *last_loc_is_prev_p = TRUE;
8505 return TRUE;
8509 /* Check if the original relocations (presumably on L32R instructions)
8510 identified by reloc[0..N] can be changed to reference the literal
8511 identified by r_rel. If r_rel is out of range for any of the
8512 original relocations, then we don't want to coalesce the original
8513 literal with the one at r_rel. We only check reloc[0..N], where the
8514 offsets are all the same as for reloc[0] (i.e., they're all
8515 referencing the same literal) and where N is also bounded by the
8516 number of remaining entries in the "reloc" array. The "reloc" array
8517 is sorted by target offset so we know all the entries for the same
8518 literal will be contiguous. */
8520 static bfd_boolean
8521 relocations_reach (source_reloc *reloc,
8522 int remaining_relocs,
8523 const r_reloc *r_rel)
8525 bfd_vma from_offset, source_address, dest_address;
8526 asection *sec;
8527 int i;
8529 if (!r_reloc_is_defined (r_rel))
8530 return FALSE;
8532 sec = r_reloc_get_section (r_rel);
8533 from_offset = reloc[0].r_rel.target_offset;
8535 for (i = 0; i < remaining_relocs; i++)
8537 if (reloc[i].r_rel.target_offset != from_offset)
8538 break;
8540 /* Ignore relocations that have been removed. */
8541 if (reloc[i].is_null)
8542 continue;
8544 /* The original and new output section for these must be the same
8545 in order to coalesce. */
8546 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
8547 != sec->output_section)
8548 return FALSE;
8550 /* Absolute literals in the same output section can always be
8551 combined. */
8552 if (reloc[i].is_abs_literal)
8553 continue;
8555 /* A literal with no PC-relative relocations can be moved anywhere. */
8556 if (reloc[i].opnd != -1)
8558 /* Otherwise, check to see that it fits. */
8559 source_address = (reloc[i].source_sec->output_section->vma
8560 + reloc[i].source_sec->output_offset
8561 + reloc[i].r_rel.rela.r_offset);
8562 dest_address = (sec->output_section->vma
8563 + sec->output_offset
8564 + r_rel->target_offset);
8566 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
8567 source_address, dest_address))
8568 return FALSE;
8572 return TRUE;
8576 /* Move a literal to another literal location because it is
8577 the same as the other literal value. */
8579 static bfd_boolean
8580 coalesce_shared_literal (asection *sec,
8581 source_reloc *rel,
8582 property_table_entry *prop_table,
8583 int ptblsize,
8584 value_map *val_map)
8586 property_table_entry *entry;
8587 text_action *fa;
8588 property_table_entry *the_add_entry;
8589 int removed_diff;
8590 xtensa_relax_info *relax_info;
8592 relax_info = get_xtensa_relax_info (sec);
8593 if (!relax_info)
8594 return FALSE;
8596 entry = elf_xtensa_find_property_entry
8597 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
8598 if (entry && (entry->flags & XTENSA_PROP_NO_TRANSFORM))
8599 return TRUE;
8601 /* Mark that the literal will be coalesced. */
8602 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
8604 text_action_add (&relax_info->action_list,
8605 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8607 /* If the section is 4-byte aligned, do not add fill. */
8608 if (sec->alignment_power > 2)
8610 int fill_extra_space;
8611 bfd_vma entry_sec_offset;
8613 if (entry)
8614 entry_sec_offset = entry->address - sec->vma + entry->size;
8615 else
8616 entry_sec_offset = rel->r_rel.target_offset + 4;
8618 /* If the literal range is at the end of the section,
8619 do not add fill. */
8620 fill_extra_space = 0;
8621 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8622 entry_sec_offset);
8623 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8624 fill_extra_space = the_add_entry->size;
8626 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8627 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8628 -4, fill_extra_space);
8629 if (fa)
8630 adjust_fill_action (fa, removed_diff);
8631 else
8632 text_action_add (&relax_info->action_list,
8633 ta_fill, sec, entry_sec_offset, removed_diff);
8636 return TRUE;
8640 /* Move a literal to another location. This may actually increase the
8641 total amount of space used because of alignments so we need to do
8642 this carefully. Also, it may make a branch go out of range. */
8644 static bfd_boolean
8645 move_shared_literal (asection *sec,
8646 struct bfd_link_info *link_info,
8647 source_reloc *rel,
8648 property_table_entry *prop_table,
8649 int ptblsize,
8650 const r_reloc *target_loc,
8651 const literal_value *lit_value,
8652 section_cache_t *target_sec_cache)
8654 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
8655 text_action *fa, *target_fa;
8656 int removed_diff;
8657 xtensa_relax_info *relax_info, *target_relax_info;
8658 asection *target_sec;
8659 ebb_t *ebb;
8660 ebb_constraint ebb_table;
8661 bfd_boolean relocs_fit;
8663 /* If this routine always returns FALSE, the literals that cannot be
8664 coalesced will not be moved. */
8665 if (elf32xtensa_no_literal_movement)
8666 return FALSE;
8668 relax_info = get_xtensa_relax_info (sec);
8669 if (!relax_info)
8670 return FALSE;
8672 target_sec = r_reloc_get_section (target_loc);
8673 target_relax_info = get_xtensa_relax_info (target_sec);
8675 /* Literals to undefined sections may not be moved because they
8676 must report an error. */
8677 if (bfd_is_und_section (target_sec))
8678 return FALSE;
8680 src_entry = elf_xtensa_find_property_entry
8681 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
8683 if (!section_cache_section (target_sec_cache, target_sec, link_info))
8684 return FALSE;
8686 target_entry = elf_xtensa_find_property_entry
8687 (target_sec_cache->ptbl, target_sec_cache->pte_count,
8688 target_sec->vma + target_loc->target_offset);
8690 if (!target_entry)
8691 return FALSE;
8693 /* Make sure that we have not broken any branches. */
8694 relocs_fit = FALSE;
8696 init_ebb_constraint (&ebb_table);
8697 ebb = &ebb_table.ebb;
8698 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
8699 target_sec_cache->content_length,
8700 target_sec_cache->ptbl, target_sec_cache->pte_count,
8701 target_sec_cache->relocs, target_sec_cache->reloc_count);
8703 /* Propose to add 4 bytes + worst-case alignment size increase to
8704 destination. */
8705 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
8706 ta_fill, target_loc->target_offset,
8707 -4 - (1 << target_sec->alignment_power), TRUE);
8709 /* Check all of the PC-relative relocations to make sure they still fit. */
8710 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
8711 target_sec_cache->contents,
8712 target_sec_cache->relocs,
8713 &ebb_table, NULL);
8715 if (!relocs_fit)
8716 return FALSE;
8718 text_action_add_literal (&target_relax_info->action_list,
8719 ta_add_literal, target_loc, lit_value, -4);
8721 if (target_sec->alignment_power > 2 && target_entry != src_entry)
8723 /* May need to add or remove some fill to maintain alignment. */
8724 int fill_extra_space;
8725 bfd_vma entry_sec_offset;
8727 entry_sec_offset =
8728 target_entry->address - target_sec->vma + target_entry->size;
8730 /* If the literal range is at the end of the section,
8731 do not add fill. */
8732 fill_extra_space = 0;
8733 the_add_entry =
8734 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
8735 target_sec_cache->pte_count,
8736 entry_sec_offset);
8737 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8738 fill_extra_space = the_add_entry->size;
8740 target_fa = find_fill_action (&target_relax_info->action_list,
8741 target_sec, entry_sec_offset);
8742 removed_diff = compute_removed_action_diff (target_fa, target_sec,
8743 entry_sec_offset, 4,
8744 fill_extra_space);
8745 if (target_fa)
8746 adjust_fill_action (target_fa, removed_diff);
8747 else
8748 text_action_add (&target_relax_info->action_list,
8749 ta_fill, target_sec, entry_sec_offset, removed_diff);
8752 /* Mark that the literal will be moved to the new location. */
8753 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
8755 /* Remove the literal. */
8756 text_action_add (&relax_info->action_list,
8757 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
8759 /* If the section is 4-byte aligned, do not add fill. */
8760 if (sec->alignment_power > 2 && target_entry != src_entry)
8762 int fill_extra_space;
8763 bfd_vma entry_sec_offset;
8765 if (src_entry)
8766 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
8767 else
8768 entry_sec_offset = rel->r_rel.target_offset+4;
8770 /* If the literal range is at the end of the section,
8771 do not add fill. */
8772 fill_extra_space = 0;
8773 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
8774 entry_sec_offset);
8775 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
8776 fill_extra_space = the_add_entry->size;
8778 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
8779 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
8780 -4, fill_extra_space);
8781 if (fa)
8782 adjust_fill_action (fa, removed_diff);
8783 else
8784 text_action_add (&relax_info->action_list,
8785 ta_fill, sec, entry_sec_offset, removed_diff);
8788 return TRUE;
8792 /* Second relaxation pass. */
8794 /* Modify all of the relocations to point to the right spot, and if this
8795 is a relaxable section, delete the unwanted literals and fix the
8796 section size. */
8798 bfd_boolean
8799 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
8801 Elf_Internal_Rela *internal_relocs;
8802 xtensa_relax_info *relax_info;
8803 bfd_byte *contents;
8804 bfd_boolean ok = TRUE;
8805 unsigned i;
8806 bfd_boolean rv = FALSE;
8807 bfd_boolean virtual_action;
8808 bfd_size_type sec_size;
8810 sec_size = bfd_get_section_limit (abfd, sec);
8811 relax_info = get_xtensa_relax_info (sec);
8812 BFD_ASSERT (relax_info);
8814 /* First translate any of the fixes that have been added already. */
8815 translate_section_fixes (sec);
8817 /* Handle property sections (e.g., literal tables) specially. */
8818 if (xtensa_is_property_section (sec))
8820 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
8821 return relax_property_section (abfd, sec, link_info);
8824 internal_relocs = retrieve_internal_relocs (abfd, sec,
8825 link_info->keep_memory);
8826 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8827 if (contents == NULL && sec_size != 0)
8829 ok = FALSE;
8830 goto error_return;
8833 if (internal_relocs)
8835 for (i = 0; i < sec->reloc_count; i++)
8837 Elf_Internal_Rela *irel;
8838 xtensa_relax_info *target_relax_info;
8839 bfd_vma source_offset, old_source_offset;
8840 r_reloc r_rel;
8841 unsigned r_type;
8842 asection *target_sec;
8844 /* Locally change the source address.
8845 Translate the target to the new target address.
8846 If it points to this section and has been removed,
8847 NULLify it.
8848 Write it back. */
8850 irel = &internal_relocs[i];
8851 source_offset = irel->r_offset;
8852 old_source_offset = source_offset;
8854 r_type = ELF32_R_TYPE (irel->r_info);
8855 r_reloc_init (&r_rel, abfd, irel, contents,
8856 bfd_get_section_limit (abfd, sec));
8858 /* If this section could have changed then we may need to
8859 change the relocation's offset. */
8861 if (relax_info->is_relaxable_literal_section
8862 || relax_info->is_relaxable_asm_section)
8864 pin_internal_relocs (sec, internal_relocs);
8866 if (r_type != R_XTENSA_NONE
8867 && find_removed_literal (&relax_info->removed_list,
8868 irel->r_offset))
8870 /* Remove this relocation. */
8871 if (elf_hash_table (link_info)->dynamic_sections_created)
8872 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8873 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8874 irel->r_offset = offset_with_removed_text
8875 (&relax_info->action_list, irel->r_offset);
8876 continue;
8879 if (r_type == R_XTENSA_ASM_SIMPLIFY)
8881 text_action *action =
8882 find_insn_action (&relax_info->action_list,
8883 irel->r_offset);
8884 if (action && (action->action == ta_convert_longcall
8885 || action->action == ta_remove_longcall))
8887 bfd_reloc_status_type retval;
8888 char *error_message = NULL;
8890 retval = contract_asm_expansion (contents, sec_size,
8891 irel, &error_message);
8892 if (retval != bfd_reloc_ok)
8894 (*link_info->callbacks->reloc_dangerous)
8895 (link_info, error_message, abfd, sec,
8896 irel->r_offset);
8897 goto error_return;
8899 /* Update the action so that the code that moves
8900 the contents will do the right thing. */
8901 if (action->action == ta_remove_longcall)
8902 action->action = ta_remove_insn;
8903 else
8904 action->action = ta_none;
8905 /* Refresh the info in the r_rel. */
8906 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8907 r_type = ELF32_R_TYPE (irel->r_info);
8911 source_offset = offset_with_removed_text
8912 (&relax_info->action_list, irel->r_offset);
8913 irel->r_offset = source_offset;
8916 /* If the target section could have changed then
8917 we may need to change the relocation's target offset. */
8919 target_sec = r_reloc_get_section (&r_rel);
8921 /* For a reference to a discarded section from a DWARF section,
8922 i.e., where action_discarded is PRETEND, the symbol will
8923 eventually be modified to refer to the kept section (at least if
8924 the kept and discarded sections are the same size). Anticipate
8925 that here and adjust things accordingly. */
8926 if (! elf_xtensa_ignore_discarded_relocs (sec)
8927 && elf_xtensa_action_discarded (sec) == PRETEND
8928 && sec->sec_info_type != ELF_INFO_TYPE_STABS
8929 && target_sec != NULL
8930 && elf_discarded_section (target_sec))
8932 /* It would be natural to call _bfd_elf_check_kept_section
8933 here, but it's not exported from elflink.c. It's also a
8934 fairly expensive check. Adjusting the relocations to the
8935 discarded section is fairly harmless; it will only adjust
8936 some addends and difference values. If it turns out that
8937 _bfd_elf_check_kept_section fails later, it won't matter,
8938 so just compare the section names to find the right group
8939 member. */
8940 asection *kept = target_sec->kept_section;
8941 if (kept != NULL)
8943 if ((kept->flags & SEC_GROUP) != 0)
8945 asection *first = elf_next_in_group (kept);
8946 asection *s = first;
8948 kept = NULL;
8949 while (s != NULL)
8951 if (strcmp (s->name, target_sec->name) == 0)
8953 kept = s;
8954 break;
8956 s = elf_next_in_group (s);
8957 if (s == first)
8958 break;
8962 if (kept != NULL
8963 && ((target_sec->rawsize != 0
8964 ? target_sec->rawsize : target_sec->size)
8965 == (kept->rawsize != 0 ? kept->rawsize : kept->size)))
8966 target_sec = kept;
8969 target_relax_info = get_xtensa_relax_info (target_sec);
8970 if (target_relax_info
8971 && (target_relax_info->is_relaxable_literal_section
8972 || target_relax_info->is_relaxable_asm_section))
8974 r_reloc new_reloc;
8975 target_sec = translate_reloc (&r_rel, &new_reloc, target_sec);
8977 if (r_type == R_XTENSA_DIFF8
8978 || r_type == R_XTENSA_DIFF16
8979 || r_type == R_XTENSA_DIFF32)
8981 bfd_vma diff_value = 0, new_end_offset, diff_mask = 0;
8983 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
8985 (*link_info->callbacks->reloc_dangerous)
8986 (link_info, _("invalid relocation address"),
8987 abfd, sec, old_source_offset);
8988 goto error_return;
8991 switch (r_type)
8993 case R_XTENSA_DIFF8:
8994 diff_value =
8995 bfd_get_8 (abfd, &contents[old_source_offset]);
8996 break;
8997 case R_XTENSA_DIFF16:
8998 diff_value =
8999 bfd_get_16 (abfd, &contents[old_source_offset]);
9000 break;
9001 case R_XTENSA_DIFF32:
9002 diff_value =
9003 bfd_get_32 (abfd, &contents[old_source_offset]);
9004 break;
9007 new_end_offset = offset_with_removed_text
9008 (&target_relax_info->action_list,
9009 r_rel.target_offset + diff_value);
9010 diff_value = new_end_offset - new_reloc.target_offset;
9012 switch (r_type)
9014 case R_XTENSA_DIFF8:
9015 diff_mask = 0xff;
9016 bfd_put_8 (abfd, diff_value,
9017 &contents[old_source_offset]);
9018 break;
9019 case R_XTENSA_DIFF16:
9020 diff_mask = 0xffff;
9021 bfd_put_16 (abfd, diff_value,
9022 &contents[old_source_offset]);
9023 break;
9024 case R_XTENSA_DIFF32:
9025 diff_mask = 0xffffffff;
9026 bfd_put_32 (abfd, diff_value,
9027 &contents[old_source_offset]);
9028 break;
9031 /* Check for overflow. */
9032 if ((diff_value & ~diff_mask) != 0)
9034 (*link_info->callbacks->reloc_dangerous)
9035 (link_info, _("overflow after relaxation"),
9036 abfd, sec, old_source_offset);
9037 goto error_return;
9040 pin_contents (sec, contents);
9043 /* If the relocation still references a section in the same
9044 input file, modify the relocation directly instead of
9045 adding a "fix" record. */
9046 if (target_sec->owner == abfd)
9048 unsigned r_symndx = ELF32_R_SYM (new_reloc.rela.r_info);
9049 irel->r_info = ELF32_R_INFO (r_symndx, r_type);
9050 irel->r_addend = new_reloc.rela.r_addend;
9051 pin_internal_relocs (sec, internal_relocs);
9053 else
9055 bfd_vma addend_displacement;
9056 reloc_bfd_fix *fix;
9058 addend_displacement =
9059 new_reloc.target_offset + new_reloc.virtual_offset;
9060 fix = reloc_bfd_fix_init (sec, source_offset, r_type,
9061 target_sec,
9062 addend_displacement, TRUE);
9063 add_fix (sec, fix);
9069 if ((relax_info->is_relaxable_literal_section
9070 || relax_info->is_relaxable_asm_section)
9071 && relax_info->action_list.head)
9073 /* Walk through the planned actions and build up a table
9074 of move, copy and fill records. Use the move, copy and
9075 fill records to perform the actions once. */
9077 int removed = 0;
9078 bfd_size_type final_size, copy_size, orig_insn_size;
9079 bfd_byte *scratch = NULL;
9080 bfd_byte *dup_contents = NULL;
9081 bfd_size_type orig_size = sec->size;
9082 bfd_vma orig_dot = 0;
9083 bfd_vma orig_dot_copied = 0; /* Byte copied already from
9084 orig dot in physical memory. */
9085 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
9086 bfd_vma dup_dot = 0;
9088 text_action *action = relax_info->action_list.head;
9090 final_size = sec->size;
9091 for (action = relax_info->action_list.head; action;
9092 action = action->next)
9094 final_size -= action->removed_bytes;
9097 scratch = (bfd_byte *) bfd_zmalloc (final_size);
9098 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
9100 /* The dot is the current fill location. */
9101 #if DEBUG
9102 print_action_list (stderr, &relax_info->action_list);
9103 #endif
9105 for (action = relax_info->action_list.head; action;
9106 action = action->next)
9108 virtual_action = FALSE;
9109 if (action->offset > orig_dot)
9111 orig_dot += orig_dot_copied;
9112 orig_dot_copied = 0;
9113 orig_dot_vo = 0;
9114 /* Out of the virtual world. */
9117 if (action->offset > orig_dot)
9119 copy_size = action->offset - orig_dot;
9120 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9121 orig_dot += copy_size;
9122 dup_dot += copy_size;
9123 BFD_ASSERT (action->offset == orig_dot);
9125 else if (action->offset < orig_dot)
9127 if (action->action == ta_fill
9128 && action->offset - action->removed_bytes == orig_dot)
9130 /* This is OK because the fill only effects the dup_dot. */
9132 else if (action->action == ta_add_literal)
9134 /* TBD. Might need to handle this. */
9137 if (action->offset == orig_dot)
9139 if (action->virtual_offset > orig_dot_vo)
9141 if (orig_dot_vo == 0)
9143 /* Need to copy virtual_offset bytes. Probably four. */
9144 copy_size = action->virtual_offset - orig_dot_vo;
9145 memmove (&dup_contents[dup_dot],
9146 &contents[orig_dot], copy_size);
9147 orig_dot_copied = copy_size;
9148 dup_dot += copy_size;
9150 virtual_action = TRUE;
9152 else
9153 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
9155 switch (action->action)
9157 case ta_remove_literal:
9158 case ta_remove_insn:
9159 BFD_ASSERT (action->removed_bytes >= 0);
9160 orig_dot += action->removed_bytes;
9161 break;
9163 case ta_narrow_insn:
9164 orig_insn_size = 3;
9165 copy_size = 2;
9166 memmove (scratch, &contents[orig_dot], orig_insn_size);
9167 BFD_ASSERT (action->removed_bytes == 1);
9168 rv = narrow_instruction (scratch, final_size, 0);
9169 BFD_ASSERT (rv);
9170 memmove (&dup_contents[dup_dot], scratch, copy_size);
9171 orig_dot += orig_insn_size;
9172 dup_dot += copy_size;
9173 break;
9175 case ta_fill:
9176 if (action->removed_bytes >= 0)
9177 orig_dot += action->removed_bytes;
9178 else
9180 /* Already zeroed in dup_contents. Just bump the
9181 counters. */
9182 dup_dot += (-action->removed_bytes);
9184 break;
9186 case ta_none:
9187 BFD_ASSERT (action->removed_bytes == 0);
9188 break;
9190 case ta_convert_longcall:
9191 case ta_remove_longcall:
9192 /* These will be removed or converted before we get here. */
9193 BFD_ASSERT (0);
9194 break;
9196 case ta_widen_insn:
9197 orig_insn_size = 2;
9198 copy_size = 3;
9199 memmove (scratch, &contents[orig_dot], orig_insn_size);
9200 BFD_ASSERT (action->removed_bytes == -1);
9201 rv = widen_instruction (scratch, final_size, 0);
9202 BFD_ASSERT (rv);
9203 memmove (&dup_contents[dup_dot], scratch, copy_size);
9204 orig_dot += orig_insn_size;
9205 dup_dot += copy_size;
9206 break;
9208 case ta_add_literal:
9209 orig_insn_size = 0;
9210 copy_size = 4;
9211 BFD_ASSERT (action->removed_bytes == -4);
9212 /* TBD -- place the literal value here and insert
9213 into the table. */
9214 memset (&dup_contents[dup_dot], 0, 4);
9215 pin_internal_relocs (sec, internal_relocs);
9216 pin_contents (sec, contents);
9218 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
9219 relax_info, &internal_relocs, &action->value))
9220 goto error_return;
9222 if (virtual_action)
9223 orig_dot_vo += copy_size;
9225 orig_dot += orig_insn_size;
9226 dup_dot += copy_size;
9227 break;
9229 default:
9230 /* Not implemented yet. */
9231 BFD_ASSERT (0);
9232 break;
9235 removed += action->removed_bytes;
9236 BFD_ASSERT (dup_dot <= final_size);
9237 BFD_ASSERT (orig_dot <= orig_size);
9240 orig_dot += orig_dot_copied;
9241 orig_dot_copied = 0;
9243 if (orig_dot != orig_size)
9245 copy_size = orig_size - orig_dot;
9246 BFD_ASSERT (orig_size > orig_dot);
9247 BFD_ASSERT (dup_dot + copy_size == final_size);
9248 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
9249 orig_dot += copy_size;
9250 dup_dot += copy_size;
9252 BFD_ASSERT (orig_size == orig_dot);
9253 BFD_ASSERT (final_size == dup_dot);
9255 /* Move the dup_contents back. */
9256 if (final_size > orig_size)
9258 /* Contents need to be reallocated. Swap the dup_contents into
9259 contents. */
9260 sec->contents = dup_contents;
9261 free (contents);
9262 contents = dup_contents;
9263 pin_contents (sec, contents);
9265 else
9267 BFD_ASSERT (final_size <= orig_size);
9268 memset (contents, 0, orig_size);
9269 memcpy (contents, dup_contents, final_size);
9270 free (dup_contents);
9272 free (scratch);
9273 pin_contents (sec, contents);
9275 if (sec->rawsize == 0)
9276 sec->rawsize = sec->size;
9277 sec->size = final_size;
9280 error_return:
9281 release_internal_relocs (sec, internal_relocs);
9282 release_contents (sec, contents);
9283 return ok;
9287 static bfd_boolean
9288 translate_section_fixes (asection *sec)
9290 xtensa_relax_info *relax_info;
9291 reloc_bfd_fix *r;
9293 relax_info = get_xtensa_relax_info (sec);
9294 if (!relax_info)
9295 return TRUE;
9297 for (r = relax_info->fix_list; r != NULL; r = r->next)
9298 if (!translate_reloc_bfd_fix (r))
9299 return FALSE;
9301 return TRUE;
9305 /* Translate a fix given the mapping in the relax info for the target
9306 section. If it has already been translated, no work is required. */
9308 static bfd_boolean
9309 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
9311 reloc_bfd_fix new_fix;
9312 asection *sec;
9313 xtensa_relax_info *relax_info;
9314 removed_literal *removed;
9315 bfd_vma new_offset, target_offset;
9317 if (fix->translated)
9318 return TRUE;
9320 sec = fix->target_sec;
9321 target_offset = fix->target_offset;
9323 relax_info = get_xtensa_relax_info (sec);
9324 if (!relax_info)
9326 fix->translated = TRUE;
9327 return TRUE;
9330 new_fix = *fix;
9332 /* The fix does not need to be translated if the section cannot change. */
9333 if (!relax_info->is_relaxable_literal_section
9334 && !relax_info->is_relaxable_asm_section)
9336 fix->translated = TRUE;
9337 return TRUE;
9340 /* If the literal has been moved and this relocation was on an
9341 opcode, then the relocation should move to the new literal
9342 location. Otherwise, the relocation should move within the
9343 section. */
9345 removed = FALSE;
9346 if (is_operand_relocation (fix->src_type))
9348 /* Check if the original relocation is against a literal being
9349 removed. */
9350 removed = find_removed_literal (&relax_info->removed_list,
9351 target_offset);
9354 if (removed)
9356 asection *new_sec;
9358 /* The fact that there is still a relocation to this literal indicates
9359 that the literal is being coalesced, not simply removed. */
9360 BFD_ASSERT (removed->to.abfd != NULL);
9362 /* This was moved to some other address (possibly another section). */
9363 new_sec = r_reloc_get_section (&removed->to);
9364 if (new_sec != sec)
9366 sec = new_sec;
9367 relax_info = get_xtensa_relax_info (sec);
9368 if (!relax_info ||
9369 (!relax_info->is_relaxable_literal_section
9370 && !relax_info->is_relaxable_asm_section))
9372 target_offset = removed->to.target_offset;
9373 new_fix.target_sec = new_sec;
9374 new_fix.target_offset = target_offset;
9375 new_fix.translated = TRUE;
9376 *fix = new_fix;
9377 return TRUE;
9380 target_offset = removed->to.target_offset;
9381 new_fix.target_sec = new_sec;
9384 /* The target address may have been moved within its section. */
9385 new_offset = offset_with_removed_text (&relax_info->action_list,
9386 target_offset);
9388 new_fix.target_offset = new_offset;
9389 new_fix.target_offset = new_offset;
9390 new_fix.translated = TRUE;
9391 *fix = new_fix;
9392 return TRUE;
9396 /* Fix up a relocation to take account of removed literals. */
9398 static asection *
9399 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec)
9401 xtensa_relax_info *relax_info;
9402 removed_literal *removed;
9403 bfd_vma target_offset, base_offset;
9404 text_action *act;
9406 *new_rel = *orig_rel;
9408 if (!r_reloc_is_defined (orig_rel))
9409 return sec ;
9411 relax_info = get_xtensa_relax_info (sec);
9412 BFD_ASSERT (relax_info && (relax_info->is_relaxable_literal_section
9413 || relax_info->is_relaxable_asm_section));
9415 target_offset = orig_rel->target_offset;
9417 removed = FALSE;
9418 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
9420 /* Check if the original relocation is against a literal being
9421 removed. */
9422 removed = find_removed_literal (&relax_info->removed_list,
9423 target_offset);
9425 if (removed && removed->to.abfd)
9427 asection *new_sec;
9429 /* The fact that there is still a relocation to this literal indicates
9430 that the literal is being coalesced, not simply removed. */
9431 BFD_ASSERT (removed->to.abfd != NULL);
9433 /* This was moved to some other address
9434 (possibly in another section). */
9435 *new_rel = removed->to;
9436 new_sec = r_reloc_get_section (new_rel);
9437 if (new_sec != sec)
9439 sec = new_sec;
9440 relax_info = get_xtensa_relax_info (sec);
9441 if (!relax_info
9442 || (!relax_info->is_relaxable_literal_section
9443 && !relax_info->is_relaxable_asm_section))
9444 return sec;
9446 target_offset = new_rel->target_offset;
9449 /* Find the base offset of the reloc symbol, excluding any addend from the
9450 reloc or from the section contents (for a partial_inplace reloc). Then
9451 find the adjusted values of the offsets due to relaxation. The base
9452 offset is needed to determine the change to the reloc's addend; the reloc
9453 addend should not be adjusted due to relaxations located before the base
9454 offset. */
9456 base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend;
9457 act = relax_info->action_list.head;
9458 if (base_offset <= target_offset)
9460 int base_removed = removed_by_actions (&act, base_offset, FALSE);
9461 int addend_removed = removed_by_actions (&act, target_offset, FALSE);
9462 new_rel->target_offset = target_offset - base_removed - addend_removed;
9463 new_rel->rela.r_addend -= addend_removed;
9465 else
9467 /* Handle a negative addend. The base offset comes first. */
9468 int tgt_removed = removed_by_actions (&act, target_offset, FALSE);
9469 int addend_removed = removed_by_actions (&act, base_offset, FALSE);
9470 new_rel->target_offset = target_offset - tgt_removed;
9471 new_rel->rela.r_addend += addend_removed;
9474 return sec;
9478 /* For dynamic links, there may be a dynamic relocation for each
9479 literal. The number of dynamic relocations must be computed in
9480 size_dynamic_sections, which occurs before relaxation. When a
9481 literal is removed, this function checks if there is a corresponding
9482 dynamic relocation and shrinks the size of the appropriate dynamic
9483 relocation section accordingly. At this point, the contents of the
9484 dynamic relocation sections have not yet been filled in, so there's
9485 nothing else that needs to be done. */
9487 static void
9488 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
9489 bfd *abfd,
9490 asection *input_section,
9491 Elf_Internal_Rela *rel)
9493 struct elf_xtensa_link_hash_table *htab;
9494 Elf_Internal_Shdr *symtab_hdr;
9495 struct elf_link_hash_entry **sym_hashes;
9496 unsigned long r_symndx;
9497 int r_type;
9498 struct elf_link_hash_entry *h;
9499 bfd_boolean dynamic_symbol;
9501 htab = elf_xtensa_hash_table (info);
9502 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9503 sym_hashes = elf_sym_hashes (abfd);
9505 r_type = ELF32_R_TYPE (rel->r_info);
9506 r_symndx = ELF32_R_SYM (rel->r_info);
9508 if (r_symndx < symtab_hdr->sh_info)
9509 h = NULL;
9510 else
9511 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
9513 dynamic_symbol = elf_xtensa_dynamic_symbol_p (h, info);
9515 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
9516 && (input_section->flags & SEC_ALLOC) != 0
9517 && (dynamic_symbol || info->shared))
9519 asection *srel;
9520 bfd_boolean is_plt = FALSE;
9522 if (dynamic_symbol && r_type == R_XTENSA_PLT)
9524 srel = htab->srelplt;
9525 is_plt = TRUE;
9527 else
9528 srel = htab->srelgot;
9530 /* Reduce size of the .rela.* section by one reloc. */
9531 BFD_ASSERT (srel != NULL);
9532 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
9533 srel->size -= sizeof (Elf32_External_Rela);
9535 if (is_plt)
9537 asection *splt, *sgotplt, *srelgot;
9538 int reloc_index, chunk;
9540 /* Find the PLT reloc index of the entry being removed. This
9541 is computed from the size of ".rela.plt". It is needed to
9542 figure out which PLT chunk to resize. Usually "last index
9543 = size - 1" since the index starts at zero, but in this
9544 context, the size has just been decremented so there's no
9545 need to subtract one. */
9546 reloc_index = srel->size / sizeof (Elf32_External_Rela);
9548 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
9549 splt = elf_xtensa_get_plt_section (info, chunk);
9550 sgotplt = elf_xtensa_get_gotplt_section (info, chunk);
9551 BFD_ASSERT (splt != NULL && sgotplt != NULL);
9553 /* Check if an entire PLT chunk has just been eliminated. */
9554 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
9556 /* The two magic GOT entries for that chunk can go away. */
9557 srelgot = htab->srelgot;
9558 BFD_ASSERT (srelgot != NULL);
9559 srelgot->reloc_count -= 2;
9560 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
9561 sgotplt->size -= 8;
9563 /* There should be only one entry left (and it will be
9564 removed below). */
9565 BFD_ASSERT (sgotplt->size == 4);
9566 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
9569 BFD_ASSERT (sgotplt->size >= 4);
9570 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
9572 sgotplt->size -= 4;
9573 splt->size -= PLT_ENTRY_SIZE;
9579 /* Take an r_rel and move it to another section. This usually
9580 requires extending the interal_relocation array and pinning it. If
9581 the original r_rel is from the same BFD, we can complete this here.
9582 Otherwise, we add a fix record to let the final link fix the
9583 appropriate address. Contents and internal relocations for the
9584 section must be pinned after calling this routine. */
9586 static bfd_boolean
9587 move_literal (bfd *abfd,
9588 struct bfd_link_info *link_info,
9589 asection *sec,
9590 bfd_vma offset,
9591 bfd_byte *contents,
9592 xtensa_relax_info *relax_info,
9593 Elf_Internal_Rela **internal_relocs_p,
9594 const literal_value *lit)
9596 Elf_Internal_Rela *new_relocs = NULL;
9597 size_t new_relocs_count = 0;
9598 Elf_Internal_Rela this_rela;
9599 const r_reloc *r_rel;
9601 r_rel = &lit->r_rel;
9602 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
9604 if (r_reloc_is_const (r_rel))
9605 bfd_put_32 (abfd, lit->value, contents + offset);
9606 else
9608 int r_type;
9609 unsigned i;
9610 asection *target_sec;
9611 reloc_bfd_fix *fix;
9612 unsigned insert_at;
9614 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
9615 target_sec = r_reloc_get_section (r_rel);
9617 /* This is the difficult case. We have to create a fix up. */
9618 this_rela.r_offset = offset;
9619 this_rela.r_info = ELF32_R_INFO (0, r_type);
9620 this_rela.r_addend =
9621 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
9622 bfd_put_32 (abfd, lit->value, contents + offset);
9624 /* Currently, we cannot move relocations during a relocatable link. */
9625 BFD_ASSERT (!link_info->relocatable);
9626 fix = reloc_bfd_fix_init (sec, offset, r_type,
9627 r_reloc_get_section (r_rel),
9628 r_rel->target_offset + r_rel->virtual_offset,
9629 FALSE);
9630 /* We also need to mark that relocations are needed here. */
9631 sec->flags |= SEC_RELOC;
9633 translate_reloc_bfd_fix (fix);
9634 /* This fix has not yet been translated. */
9635 add_fix (sec, fix);
9637 /* Add the relocation. If we have already allocated our own
9638 space for the relocations and we have room for more, then use
9639 it. Otherwise, allocate new space and move the literals. */
9640 insert_at = sec->reloc_count;
9641 for (i = 0; i < sec->reloc_count; ++i)
9643 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
9645 insert_at = i;
9646 break;
9650 if (*internal_relocs_p != relax_info->allocated_relocs
9651 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
9653 BFD_ASSERT (relax_info->allocated_relocs == NULL
9654 || sec->reloc_count == relax_info->relocs_count);
9656 if (relax_info->allocated_relocs_count == 0)
9657 new_relocs_count = (sec->reloc_count + 2) * 2;
9658 else
9659 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
9661 new_relocs = (Elf_Internal_Rela *)
9662 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
9663 if (!new_relocs)
9664 return FALSE;
9666 /* We could handle this more quickly by finding the split point. */
9667 if (insert_at != 0)
9668 memcpy (new_relocs, *internal_relocs_p,
9669 insert_at * sizeof (Elf_Internal_Rela));
9671 new_relocs[insert_at] = this_rela;
9673 if (insert_at != sec->reloc_count)
9674 memcpy (new_relocs + insert_at + 1,
9675 (*internal_relocs_p) + insert_at,
9676 (sec->reloc_count - insert_at)
9677 * sizeof (Elf_Internal_Rela));
9679 if (*internal_relocs_p != relax_info->allocated_relocs)
9681 /* The first time we re-allocate, we can only free the
9682 old relocs if they were allocated with bfd_malloc.
9683 This is not true when keep_memory is in effect. */
9684 if (!link_info->keep_memory)
9685 free (*internal_relocs_p);
9687 else
9688 free (*internal_relocs_p);
9689 relax_info->allocated_relocs = new_relocs;
9690 relax_info->allocated_relocs_count = new_relocs_count;
9691 elf_section_data (sec)->relocs = new_relocs;
9692 sec->reloc_count++;
9693 relax_info->relocs_count = sec->reloc_count;
9694 *internal_relocs_p = new_relocs;
9696 else
9698 if (insert_at != sec->reloc_count)
9700 unsigned idx;
9701 for (idx = sec->reloc_count; idx > insert_at; idx--)
9702 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
9704 (*internal_relocs_p)[insert_at] = this_rela;
9705 sec->reloc_count++;
9706 if (relax_info->allocated_relocs)
9707 relax_info->relocs_count = sec->reloc_count;
9710 return TRUE;
9714 /* This is similar to relax_section except that when a target is moved,
9715 we shift addresses up. We also need to modify the size. This
9716 algorithm does NOT allow for relocations into the middle of the
9717 property sections. */
9719 static bfd_boolean
9720 relax_property_section (bfd *abfd,
9721 asection *sec,
9722 struct bfd_link_info *link_info)
9724 Elf_Internal_Rela *internal_relocs;
9725 bfd_byte *contents;
9726 unsigned i;
9727 bfd_boolean ok = TRUE;
9728 bfd_boolean is_full_prop_section;
9729 size_t last_zfill_target_offset = 0;
9730 asection *last_zfill_target_sec = NULL;
9731 bfd_size_type sec_size;
9732 bfd_size_type entry_size;
9734 sec_size = bfd_get_section_limit (abfd, sec);
9735 internal_relocs = retrieve_internal_relocs (abfd, sec,
9736 link_info->keep_memory);
9737 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9738 if (contents == NULL && sec_size != 0)
9740 ok = FALSE;
9741 goto error_return;
9744 is_full_prop_section = xtensa_is_proptable_section (sec);
9745 if (is_full_prop_section)
9746 entry_size = 12;
9747 else
9748 entry_size = 8;
9750 if (internal_relocs)
9752 for (i = 0; i < sec->reloc_count; i++)
9754 Elf_Internal_Rela *irel;
9755 xtensa_relax_info *target_relax_info;
9756 unsigned r_type;
9757 asection *target_sec;
9758 literal_value val;
9759 bfd_byte *size_p, *flags_p;
9761 /* Locally change the source address.
9762 Translate the target to the new target address.
9763 If it points to this section and has been removed, MOVE IT.
9764 Also, don't forget to modify the associated SIZE at
9765 (offset + 4). */
9767 irel = &internal_relocs[i];
9768 r_type = ELF32_R_TYPE (irel->r_info);
9769 if (r_type == R_XTENSA_NONE)
9770 continue;
9772 /* Find the literal value. */
9773 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
9774 size_p = &contents[irel->r_offset + 4];
9775 flags_p = NULL;
9776 if (is_full_prop_section)
9777 flags_p = &contents[irel->r_offset + 8];
9778 BFD_ASSERT (irel->r_offset + entry_size <= sec_size);
9780 target_sec = r_reloc_get_section (&val.r_rel);
9781 target_relax_info = get_xtensa_relax_info (target_sec);
9783 if (target_relax_info
9784 && (target_relax_info->is_relaxable_literal_section
9785 || target_relax_info->is_relaxable_asm_section ))
9787 /* Translate the relocation's destination. */
9788 bfd_vma old_offset = val.r_rel.target_offset;
9789 bfd_vma new_offset;
9790 long old_size, new_size;
9791 text_action *act = target_relax_info->action_list.head;
9792 new_offset = old_offset -
9793 removed_by_actions (&act, old_offset, FALSE);
9795 /* Assert that we are not out of bounds. */
9796 old_size = bfd_get_32 (abfd, size_p);
9797 new_size = old_size;
9799 if (old_size == 0)
9801 /* Only the first zero-sized unreachable entry is
9802 allowed to expand. In this case the new offset
9803 should be the offset before the fill and the new
9804 size is the expansion size. For other zero-sized
9805 entries the resulting size should be zero with an
9806 offset before or after the fill address depending
9807 on whether the expanding unreachable entry
9808 preceeds it. */
9809 if (last_zfill_target_sec == 0
9810 || last_zfill_target_sec != target_sec
9811 || last_zfill_target_offset != old_offset)
9813 bfd_vma new_end_offset = new_offset;
9815 /* Recompute the new_offset, but this time don't
9816 include any fill inserted by relaxation. */
9817 act = target_relax_info->action_list.head;
9818 new_offset = old_offset -
9819 removed_by_actions (&act, old_offset, TRUE);
9821 /* If it is not unreachable and we have not yet
9822 seen an unreachable at this address, place it
9823 before the fill address. */
9824 if (flags_p && (bfd_get_32 (abfd, flags_p)
9825 & XTENSA_PROP_UNREACHABLE) != 0)
9827 new_size = new_end_offset - new_offset;
9829 last_zfill_target_sec = target_sec;
9830 last_zfill_target_offset = old_offset;
9834 else
9835 new_size -=
9836 removed_by_actions (&act, old_offset + old_size, TRUE);
9838 if (new_size != old_size)
9840 bfd_put_32 (abfd, new_size, size_p);
9841 pin_contents (sec, contents);
9844 if (new_offset != old_offset)
9846 bfd_vma diff = new_offset - old_offset;
9847 irel->r_addend += diff;
9848 pin_internal_relocs (sec, internal_relocs);
9854 /* Combine adjacent property table entries. This is also done in
9855 finish_dynamic_sections() but at that point it's too late to
9856 reclaim the space in the output section, so we do this twice. */
9858 if (internal_relocs && (!link_info->relocatable
9859 || xtensa_is_littable_section (sec)))
9861 Elf_Internal_Rela *last_irel = NULL;
9862 Elf_Internal_Rela *irel, *next_rel, *rel_end;
9863 int removed_bytes = 0;
9864 bfd_vma offset;
9865 flagword predef_flags;
9867 predef_flags = xtensa_get_property_predef_flags (sec);
9869 /* Walk over memory and relocations at the same time.
9870 This REQUIRES that the internal_relocs be sorted by offset. */
9871 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
9872 internal_reloc_compare);
9874 pin_internal_relocs (sec, internal_relocs);
9875 pin_contents (sec, contents);
9877 next_rel = internal_relocs;
9878 rel_end = internal_relocs + sec->reloc_count;
9880 BFD_ASSERT (sec->size % entry_size == 0);
9882 for (offset = 0; offset < sec->size; offset += entry_size)
9884 Elf_Internal_Rela *offset_rel, *extra_rel;
9885 bfd_vma bytes_to_remove, size, actual_offset;
9886 bfd_boolean remove_this_rel;
9887 flagword flags;
9889 /* Find the first relocation for the entry at the current offset.
9890 Adjust the offsets of any extra relocations for the previous
9891 entry. */
9892 offset_rel = NULL;
9893 if (next_rel)
9895 for (irel = next_rel; irel < rel_end; irel++)
9897 if ((irel->r_offset == offset
9898 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9899 || irel->r_offset > offset)
9901 offset_rel = irel;
9902 break;
9904 irel->r_offset -= removed_bytes;
9908 /* Find the next relocation (if there are any left). */
9909 extra_rel = NULL;
9910 if (offset_rel)
9912 for (irel = offset_rel + 1; irel < rel_end; irel++)
9914 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
9916 extra_rel = irel;
9917 break;
9922 /* Check if there are relocations on the current entry. There
9923 should usually be a relocation on the offset field. If there
9924 are relocations on the size or flags, then we can't optimize
9925 this entry. Also, find the next relocation to examine on the
9926 next iteration. */
9927 if (offset_rel)
9929 if (offset_rel->r_offset >= offset + entry_size)
9931 next_rel = offset_rel;
9932 /* There are no relocations on the current entry, but we
9933 might still be able to remove it if the size is zero. */
9934 offset_rel = NULL;
9936 else if (offset_rel->r_offset > offset
9937 || (extra_rel
9938 && extra_rel->r_offset < offset + entry_size))
9940 /* There is a relocation on the size or flags, so we can't
9941 do anything with this entry. Continue with the next. */
9942 next_rel = offset_rel;
9943 continue;
9945 else
9947 BFD_ASSERT (offset_rel->r_offset == offset);
9948 offset_rel->r_offset -= removed_bytes;
9949 next_rel = offset_rel + 1;
9952 else
9953 next_rel = NULL;
9955 remove_this_rel = FALSE;
9956 bytes_to_remove = 0;
9957 actual_offset = offset - removed_bytes;
9958 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
9960 if (is_full_prop_section)
9961 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
9962 else
9963 flags = predef_flags;
9965 if (size == 0
9966 && (flags & XTENSA_PROP_ALIGN) == 0
9967 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
9969 /* Always remove entries with zero size and no alignment. */
9970 bytes_to_remove = entry_size;
9971 if (offset_rel)
9972 remove_this_rel = TRUE;
9974 else if (offset_rel
9975 && ELF32_R_TYPE (offset_rel->r_info) == R_XTENSA_32)
9977 if (last_irel)
9979 flagword old_flags;
9980 bfd_vma old_size =
9981 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
9982 bfd_vma old_address =
9983 (last_irel->r_addend
9984 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
9985 bfd_vma new_address =
9986 (offset_rel->r_addend
9987 + bfd_get_32 (abfd, &contents[actual_offset]));
9988 if (is_full_prop_section)
9989 old_flags = bfd_get_32
9990 (abfd, &contents[last_irel->r_offset + 8]);
9991 else
9992 old_flags = predef_flags;
9994 if ((ELF32_R_SYM (offset_rel->r_info)
9995 == ELF32_R_SYM (last_irel->r_info))
9996 && old_address + old_size == new_address
9997 && old_flags == flags
9998 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
9999 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
10001 /* Fix the old size. */
10002 bfd_put_32 (abfd, old_size + size,
10003 &contents[last_irel->r_offset + 4]);
10004 bytes_to_remove = entry_size;
10005 remove_this_rel = TRUE;
10007 else
10008 last_irel = offset_rel;
10010 else
10011 last_irel = offset_rel;
10014 if (remove_this_rel)
10016 offset_rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
10017 offset_rel->r_offset = 0;
10020 if (bytes_to_remove != 0)
10022 removed_bytes += bytes_to_remove;
10023 if (offset + bytes_to_remove < sec->size)
10024 memmove (&contents[actual_offset],
10025 &contents[actual_offset + bytes_to_remove],
10026 sec->size - offset - bytes_to_remove);
10030 if (removed_bytes)
10032 /* Fix up any extra relocations on the last entry. */
10033 for (irel = next_rel; irel < rel_end; irel++)
10034 irel->r_offset -= removed_bytes;
10036 /* Clear the removed bytes. */
10037 memset (&contents[sec->size - removed_bytes], 0, removed_bytes);
10039 if (sec->rawsize == 0)
10040 sec->rawsize = sec->size;
10041 sec->size -= removed_bytes;
10043 if (xtensa_is_littable_section (sec))
10045 asection *sgotloc = elf_xtensa_hash_table (link_info)->sgotloc;
10046 if (sgotloc)
10047 sgotloc->size -= removed_bytes;
10052 error_return:
10053 release_internal_relocs (sec, internal_relocs);
10054 release_contents (sec, contents);
10055 return ok;
10059 /* Third relaxation pass. */
10061 /* Change symbol values to account for removed literals. */
10063 bfd_boolean
10064 relax_section_symbols (bfd *abfd, asection *sec)
10066 xtensa_relax_info *relax_info;
10067 unsigned int sec_shndx;
10068 Elf_Internal_Shdr *symtab_hdr;
10069 Elf_Internal_Sym *isymbuf;
10070 unsigned i, num_syms, num_locals;
10072 relax_info = get_xtensa_relax_info (sec);
10073 BFD_ASSERT (relax_info);
10075 if (!relax_info->is_relaxable_literal_section
10076 && !relax_info->is_relaxable_asm_section)
10077 return TRUE;
10079 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
10081 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10082 isymbuf = retrieve_local_syms (abfd);
10084 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
10085 num_locals = symtab_hdr->sh_info;
10087 /* Adjust the local symbols defined in this section. */
10088 for (i = 0; i < num_locals; i++)
10090 Elf_Internal_Sym *isym = &isymbuf[i];
10092 if (isym->st_shndx == sec_shndx)
10094 text_action *act = relax_info->action_list.head;
10095 bfd_vma orig_addr = isym->st_value;
10097 isym->st_value -= removed_by_actions (&act, orig_addr, FALSE);
10099 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
10100 isym->st_size -=
10101 removed_by_actions (&act, orig_addr + isym->st_size, FALSE);
10105 /* Now adjust the global symbols defined in this section. */
10106 for (i = 0; i < (num_syms - num_locals); i++)
10108 struct elf_link_hash_entry *sym_hash;
10110 sym_hash = elf_sym_hashes (abfd)[i];
10112 if (sym_hash->root.type == bfd_link_hash_warning)
10113 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
10115 if ((sym_hash->root.type == bfd_link_hash_defined
10116 || sym_hash->root.type == bfd_link_hash_defweak)
10117 && sym_hash->root.u.def.section == sec)
10119 text_action *act = relax_info->action_list.head;
10120 bfd_vma orig_addr = sym_hash->root.u.def.value;
10122 sym_hash->root.u.def.value -=
10123 removed_by_actions (&act, orig_addr, FALSE);
10125 if (sym_hash->type == STT_FUNC)
10126 sym_hash->size -=
10127 removed_by_actions (&act, orig_addr + sym_hash->size, FALSE);
10131 return TRUE;
10135 /* "Fix" handling functions, called while performing relocations. */
10137 static bfd_boolean
10138 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
10139 bfd *input_bfd,
10140 asection *input_section,
10141 bfd_byte *contents)
10143 r_reloc r_rel;
10144 asection *sec, *old_sec;
10145 bfd_vma old_offset;
10146 int r_type = ELF32_R_TYPE (rel->r_info);
10147 reloc_bfd_fix *fix;
10149 if (r_type == R_XTENSA_NONE)
10150 return TRUE;
10152 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10153 if (!fix)
10154 return TRUE;
10156 r_reloc_init (&r_rel, input_bfd, rel, contents,
10157 bfd_get_section_limit (input_bfd, input_section));
10158 old_sec = r_reloc_get_section (&r_rel);
10159 old_offset = r_rel.target_offset;
10161 if (!old_sec || !r_reloc_is_defined (&r_rel))
10163 if (r_type != R_XTENSA_ASM_EXPAND)
10165 (*_bfd_error_handler)
10166 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
10167 input_bfd, input_section, rel->r_offset,
10168 elf_howto_table[r_type].name);
10169 return FALSE;
10171 /* Leave it be. Resolution will happen in a later stage. */
10173 else
10175 sec = fix->target_sec;
10176 rel->r_addend += ((sec->output_offset + fix->target_offset)
10177 - (old_sec->output_offset + old_offset));
10179 return TRUE;
10183 static void
10184 do_fix_for_final_link (Elf_Internal_Rela *rel,
10185 bfd *input_bfd,
10186 asection *input_section,
10187 bfd_byte *contents,
10188 bfd_vma *relocationp)
10190 asection *sec;
10191 int r_type = ELF32_R_TYPE (rel->r_info);
10192 reloc_bfd_fix *fix;
10193 bfd_vma fixup_diff;
10195 if (r_type == R_XTENSA_NONE)
10196 return;
10198 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
10199 if (!fix)
10200 return;
10202 sec = fix->target_sec;
10204 fixup_diff = rel->r_addend;
10205 if (elf_howto_table[fix->src_type].partial_inplace)
10207 bfd_vma inplace_val;
10208 BFD_ASSERT (fix->src_offset
10209 < bfd_get_section_limit (input_bfd, input_section));
10210 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
10211 fixup_diff += inplace_val;
10214 *relocationp = (sec->output_section->vma
10215 + sec->output_offset
10216 + fix->target_offset - fixup_diff);
10220 /* Miscellaneous utility functions.... */
10222 static asection *
10223 elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk)
10225 struct elf_xtensa_link_hash_table *htab;
10226 bfd *dynobj;
10227 char plt_name[10];
10229 if (chunk == 0)
10231 htab = elf_xtensa_hash_table (info);
10232 return htab->splt;
10235 dynobj = elf_hash_table (info)->dynobj;
10236 sprintf (plt_name, ".plt.%u", chunk);
10237 return bfd_get_section_by_name (dynobj, plt_name);
10241 static asection *
10242 elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk)
10244 struct elf_xtensa_link_hash_table *htab;
10245 bfd *dynobj;
10246 char got_name[14];
10248 if (chunk == 0)
10250 htab = elf_xtensa_hash_table (info);
10251 return htab->sgotplt;
10254 dynobj = elf_hash_table (info)->dynobj;
10255 sprintf (got_name, ".got.plt.%u", chunk);
10256 return bfd_get_section_by_name (dynobj, got_name);
10260 /* Get the input section for a given symbol index.
10261 If the symbol is:
10262 . a section symbol, return the section;
10263 . a common symbol, return the common section;
10264 . an undefined symbol, return the undefined section;
10265 . an indirect symbol, follow the links;
10266 . an absolute value, return the absolute section. */
10268 static asection *
10269 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
10271 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10272 asection *target_sec = NULL;
10273 if (r_symndx < symtab_hdr->sh_info)
10275 Elf_Internal_Sym *isymbuf;
10276 unsigned int section_index;
10278 isymbuf = retrieve_local_syms (abfd);
10279 section_index = isymbuf[r_symndx].st_shndx;
10281 if (section_index == SHN_UNDEF)
10282 target_sec = bfd_und_section_ptr;
10283 else if (section_index == SHN_ABS)
10284 target_sec = bfd_abs_section_ptr;
10285 else if (section_index == SHN_COMMON)
10286 target_sec = bfd_com_section_ptr;
10287 else
10288 target_sec = bfd_section_from_elf_index (abfd, section_index);
10290 else
10292 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10293 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
10295 while (h->root.type == bfd_link_hash_indirect
10296 || h->root.type == bfd_link_hash_warning)
10297 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10299 switch (h->root.type)
10301 case bfd_link_hash_defined:
10302 case bfd_link_hash_defweak:
10303 target_sec = h->root.u.def.section;
10304 break;
10305 case bfd_link_hash_common:
10306 target_sec = bfd_com_section_ptr;
10307 break;
10308 case bfd_link_hash_undefined:
10309 case bfd_link_hash_undefweak:
10310 target_sec = bfd_und_section_ptr;
10311 break;
10312 default: /* New indirect warning. */
10313 target_sec = bfd_und_section_ptr;
10314 break;
10317 return target_sec;
10321 static struct elf_link_hash_entry *
10322 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
10324 unsigned long indx;
10325 struct elf_link_hash_entry *h;
10326 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10328 if (r_symndx < symtab_hdr->sh_info)
10329 return NULL;
10331 indx = r_symndx - symtab_hdr->sh_info;
10332 h = elf_sym_hashes (abfd)[indx];
10333 while (h->root.type == bfd_link_hash_indirect
10334 || h->root.type == bfd_link_hash_warning)
10335 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10336 return h;
10340 /* Get the section-relative offset for a symbol number. */
10342 static bfd_vma
10343 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
10345 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
10346 bfd_vma offset = 0;
10348 if (r_symndx < symtab_hdr->sh_info)
10350 Elf_Internal_Sym *isymbuf;
10351 isymbuf = retrieve_local_syms (abfd);
10352 offset = isymbuf[r_symndx].st_value;
10354 else
10356 unsigned long indx = r_symndx - symtab_hdr->sh_info;
10357 struct elf_link_hash_entry *h =
10358 elf_sym_hashes (abfd)[indx];
10360 while (h->root.type == bfd_link_hash_indirect
10361 || h->root.type == bfd_link_hash_warning)
10362 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10363 if (h->root.type == bfd_link_hash_defined
10364 || h->root.type == bfd_link_hash_defweak)
10365 offset = h->root.u.def.value;
10367 return offset;
10371 static bfd_boolean
10372 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
10374 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
10375 struct elf_link_hash_entry *h;
10377 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
10378 if (h && h->root.type == bfd_link_hash_defweak)
10379 return TRUE;
10380 return FALSE;
10384 static bfd_boolean
10385 pcrel_reloc_fits (xtensa_opcode opc,
10386 int opnd,
10387 bfd_vma self_address,
10388 bfd_vma dest_address)
10390 xtensa_isa isa = xtensa_default_isa;
10391 uint32 valp = dest_address;
10392 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
10393 || xtensa_operand_encode (isa, opc, opnd, &valp))
10394 return FALSE;
10395 return TRUE;
10399 static bfd_boolean
10400 xtensa_is_property_section (asection *sec)
10402 if (xtensa_is_insntable_section (sec)
10403 || xtensa_is_littable_section (sec)
10404 || xtensa_is_proptable_section (sec))
10405 return TRUE;
10407 return FALSE;
10411 static bfd_boolean
10412 xtensa_is_insntable_section (asection *sec)
10414 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
10415 || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
10416 return TRUE;
10418 return FALSE;
10422 static bfd_boolean
10423 xtensa_is_littable_section (asection *sec)
10425 if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
10426 || CONST_STRNEQ (sec->name, ".gnu.linkonce.p."))
10427 return TRUE;
10429 return FALSE;
10433 static bfd_boolean
10434 xtensa_is_proptable_section (asection *sec)
10436 if (CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
10437 || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."))
10438 return TRUE;
10440 return FALSE;
10444 static int
10445 internal_reloc_compare (const void *ap, const void *bp)
10447 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10448 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10450 if (a->r_offset != b->r_offset)
10451 return (a->r_offset - b->r_offset);
10453 /* We don't need to sort on these criteria for correctness,
10454 but enforcing a more strict ordering prevents unstable qsort
10455 from behaving differently with different implementations.
10456 Without the code below we get correct but different results
10457 on Solaris 2.7 and 2.8. We would like to always produce the
10458 same results no matter the host. */
10460 if (a->r_info != b->r_info)
10461 return (a->r_info - b->r_info);
10463 return (a->r_addend - b->r_addend);
10467 static int
10468 internal_reloc_matches (const void *ap, const void *bp)
10470 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
10471 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
10473 /* Check if one entry overlaps with the other; this shouldn't happen
10474 except when searching for a match. */
10475 return (a->r_offset - b->r_offset);
10479 /* Predicate function used to look up a section in a particular group. */
10481 static bfd_boolean
10482 match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
10484 const char *gname = inf;
10485 const char *group_name = elf_group_name (sec);
10487 return (group_name == gname
10488 || (group_name != NULL
10489 && gname != NULL
10490 && strcmp (group_name, gname) == 0));
10494 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
10496 static char *
10497 xtensa_property_section_name (asection *sec, const char *base_name)
10499 const char *suffix, *group_name;
10500 char *prop_sec_name;
10502 group_name = elf_group_name (sec);
10503 if (group_name)
10505 suffix = strrchr (sec->name, '.');
10506 if (suffix == sec->name)
10507 suffix = 0;
10508 prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
10509 + (suffix ? strlen (suffix) : 0));
10510 strcpy (prop_sec_name, base_name);
10511 if (suffix)
10512 strcat (prop_sec_name, suffix);
10514 else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
10516 char *linkonce_kind = 0;
10518 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
10519 linkonce_kind = "x.";
10520 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
10521 linkonce_kind = "p.";
10522 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
10523 linkonce_kind = "prop.";
10524 else
10525 abort ();
10527 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
10528 + strlen (linkonce_kind) + 1);
10529 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
10530 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
10532 suffix = sec->name + linkonce_len;
10533 /* For backward compatibility, replace "t." instead of inserting
10534 the new linkonce_kind (but not for "prop" sections). */
10535 if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
10536 suffix += 2;
10537 strcat (prop_sec_name + linkonce_len, suffix);
10539 else
10540 prop_sec_name = strdup (base_name);
10542 return prop_sec_name;
10546 static asection *
10547 xtensa_get_property_section (asection *sec, const char *base_name)
10549 char *prop_sec_name;
10550 asection *prop_sec;
10552 prop_sec_name = xtensa_property_section_name (sec, base_name);
10553 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10554 match_section_group,
10555 (void *) elf_group_name (sec));
10556 free (prop_sec_name);
10557 return prop_sec;
10561 asection *
10562 xtensa_make_property_section (asection *sec, const char *base_name)
10564 char *prop_sec_name;
10565 asection *prop_sec;
10567 /* Check if the section already exists. */
10568 prop_sec_name = xtensa_property_section_name (sec, base_name);
10569 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
10570 match_section_group,
10571 (void *) elf_group_name (sec));
10572 /* If not, create it. */
10573 if (! prop_sec)
10575 flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
10576 flags |= (bfd_get_section_flags (sec->owner, sec)
10577 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
10579 prop_sec = bfd_make_section_anyway_with_flags
10580 (sec->owner, strdup (prop_sec_name), flags);
10581 if (! prop_sec)
10582 return 0;
10584 elf_group_name (prop_sec) = elf_group_name (sec);
10587 free (prop_sec_name);
10588 return prop_sec;
10592 flagword
10593 xtensa_get_property_predef_flags (asection *sec)
10595 if (xtensa_is_insntable_section (sec))
10596 return (XTENSA_PROP_INSN
10597 | XTENSA_PROP_NO_TRANSFORM
10598 | XTENSA_PROP_INSN_NO_REORDER);
10600 if (xtensa_is_littable_section (sec))
10601 return (XTENSA_PROP_LITERAL
10602 | XTENSA_PROP_NO_TRANSFORM
10603 | XTENSA_PROP_INSN_NO_REORDER);
10605 return 0;
10609 /* Other functions called directly by the linker. */
10611 bfd_boolean
10612 xtensa_callback_required_dependence (bfd *abfd,
10613 asection *sec,
10614 struct bfd_link_info *link_info,
10615 deps_callback_t callback,
10616 void *closure)
10618 Elf_Internal_Rela *internal_relocs;
10619 bfd_byte *contents;
10620 unsigned i;
10621 bfd_boolean ok = TRUE;
10622 bfd_size_type sec_size;
10624 sec_size = bfd_get_section_limit (abfd, sec);
10626 /* ".plt*" sections have no explicit relocations but they contain L32R
10627 instructions that reference the corresponding ".got.plt*" sections. */
10628 if ((sec->flags & SEC_LINKER_CREATED) != 0
10629 && CONST_STRNEQ (sec->name, ".plt"))
10631 asection *sgotplt;
10633 /* Find the corresponding ".got.plt*" section. */
10634 if (sec->name[4] == '\0')
10635 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
10636 else
10638 char got_name[14];
10639 int chunk = 0;
10641 BFD_ASSERT (sec->name[4] == '.');
10642 chunk = strtol (&sec->name[5], NULL, 10);
10644 sprintf (got_name, ".got.plt.%u", chunk);
10645 sgotplt = bfd_get_section_by_name (sec->owner, got_name);
10647 BFD_ASSERT (sgotplt);
10649 /* Assume worst-case offsets: L32R at the very end of the ".plt"
10650 section referencing a literal at the very beginning of
10651 ".got.plt". This is very close to the real dependence, anyway. */
10652 (*callback) (sec, sec_size, sgotplt, 0, closure);
10655 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
10656 when building uclibc, which runs "ld -b binary /dev/null". */
10657 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
10658 return ok;
10660 internal_relocs = retrieve_internal_relocs (abfd, sec,
10661 link_info->keep_memory);
10662 if (internal_relocs == NULL
10663 || sec->reloc_count == 0)
10664 return ok;
10666 /* Cache the contents for the duration of this scan. */
10667 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
10668 if (contents == NULL && sec_size != 0)
10670 ok = FALSE;
10671 goto error_return;
10674 if (!xtensa_default_isa)
10675 xtensa_default_isa = xtensa_isa_init (0, 0);
10677 for (i = 0; i < sec->reloc_count; i++)
10679 Elf_Internal_Rela *irel = &internal_relocs[i];
10680 if (is_l32r_relocation (abfd, sec, contents, irel))
10682 r_reloc l32r_rel;
10683 asection *target_sec;
10684 bfd_vma target_offset;
10686 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
10687 target_sec = NULL;
10688 target_offset = 0;
10689 /* L32Rs must be local to the input file. */
10690 if (r_reloc_is_defined (&l32r_rel))
10692 target_sec = r_reloc_get_section (&l32r_rel);
10693 target_offset = l32r_rel.target_offset;
10695 (*callback) (sec, irel->r_offset, target_sec, target_offset,
10696 closure);
10700 error_return:
10701 release_internal_relocs (sec, internal_relocs);
10702 release_contents (sec, contents);
10703 return ok;
10706 /* The default literal sections should always be marked as "code" (i.e.,
10707 SHF_EXECINSTR). This is particularly important for the Linux kernel
10708 module loader so that the literals are not placed after the text. */
10709 static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
10711 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10712 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10713 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
10714 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 },
10715 { NULL, 0, 0, 0, 0 }
10718 #ifndef ELF_ARCH
10719 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
10720 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
10721 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
10722 #define TARGET_BIG_NAME "elf32-xtensa-be"
10723 #define ELF_ARCH bfd_arch_xtensa
10725 #define ELF_MACHINE_CODE EM_XTENSA
10726 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
10728 #if XCHAL_HAVE_MMU
10729 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
10730 #else /* !XCHAL_HAVE_MMU */
10731 #define ELF_MAXPAGESIZE 1
10732 #endif /* !XCHAL_HAVE_MMU */
10733 #endif /* ELF_ARCH */
10735 #define elf_backend_can_gc_sections 1
10736 #define elf_backend_can_refcount 1
10737 #define elf_backend_plt_readonly 1
10738 #define elf_backend_got_header_size 4
10739 #define elf_backend_want_dynbss 0
10740 #define elf_backend_want_got_plt 1
10742 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
10744 #define bfd_elf32_mkobject elf_xtensa_mkobject
10746 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
10747 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
10748 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
10749 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
10750 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
10751 #define bfd_elf32_bfd_reloc_name_lookup \
10752 elf_xtensa_reloc_name_lookup
10753 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
10754 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
10756 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
10757 #define elf_backend_check_relocs elf_xtensa_check_relocs
10758 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
10759 #define elf_backend_discard_info elf_xtensa_discard_info
10760 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
10761 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
10762 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
10763 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
10764 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
10765 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
10766 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
10767 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
10768 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
10769 #define elf_backend_object_p elf_xtensa_object_p
10770 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
10771 #define elf_backend_relocate_section elf_xtensa_relocate_section
10772 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
10773 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
10774 #define elf_backend_omit_section_dynsym \
10775 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
10776 #define elf_backend_special_sections elf_xtensa_special_sections
10777 #define elf_backend_action_discarded elf_xtensa_action_discarded
10778 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
10780 #include "elf32-target.h"