1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright 2003, 2004 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 2 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., 59 Temple Place - Suite 330, Boston, MA
24 #ifdef ANSI_PROTOTYPES
34 #include "elf/xtensa.h"
35 #include "xtensa-isa.h"
36 #include "xtensa-config.h"
38 #define XTENSA_NO_NOP_REMOVAL 0
40 /* Local helper functions. */
42 static bfd_boolean add_extra_plt_sections (bfd *, int);
43 static char *build_encoding_error_message (xtensa_opcode, bfd_vma);
44 static bfd_reloc_status_type bfd_elf_xtensa_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_boolean do_fix_for_relocatable_link
47 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *);
48 static void do_fix_for_final_link
49 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *, bfd_vma *);
51 /* Local functions to handle Xtensa configurability. */
53 static bfd_boolean is_indirect_call_opcode (xtensa_opcode);
54 static bfd_boolean is_direct_call_opcode (xtensa_opcode);
55 static bfd_boolean is_windowed_call_opcode (xtensa_opcode);
56 static xtensa_opcode get_const16_opcode (void);
57 static xtensa_opcode get_l32r_opcode (void);
58 static bfd_vma l32r_offset (bfd_vma, bfd_vma);
59 static int get_relocation_opnd (xtensa_opcode, int);
60 static int get_relocation_slot (int);
61 static xtensa_opcode get_relocation_opcode
62 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
63 static bfd_boolean is_l32r_relocation
64 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
65 static bfd_boolean is_alt_relocation (int);
66 static bfd_boolean is_operand_relocation (int);
67 static bfd_size_type insn_decode_len
68 (bfd_byte *, bfd_size_type, bfd_size_type);
69 static xtensa_opcode insn_decode_opcode
70 (bfd_byte *, bfd_size_type, bfd_size_type, int);
71 static bfd_boolean check_branch_target_aligned
72 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
73 static bfd_boolean check_loop_aligned
74 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
75 static bfd_boolean check_branch_target_aligned_address (bfd_vma, int);
76 static bfd_size_type get_asm_simplify_size
77 (bfd_byte *, bfd_size_type, bfd_size_type);
79 /* Functions for link-time code simplifications. */
81 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
82 (bfd_byte *, bfd_vma, bfd_vma, char **);
83 static bfd_reloc_status_type contract_asm_expansion
84 (bfd_byte *, bfd_vma, Elf_Internal_Rela *, char **);
85 static xtensa_opcode swap_callx_for_call_opcode (xtensa_opcode);
86 static xtensa_opcode get_expanded_call_opcode (bfd_byte *, int, bfd_boolean *);
88 /* Access to internal relocations, section contents and symbols. */
90 static Elf_Internal_Rela *retrieve_internal_relocs
91 (bfd *, asection *, bfd_boolean);
92 static void pin_internal_relocs (asection *, Elf_Internal_Rela *);
93 static void release_internal_relocs (asection *, Elf_Internal_Rela *);
94 static bfd_byte *retrieve_contents (bfd *, asection *, bfd_boolean);
95 static void pin_contents (asection *, bfd_byte *);
96 static void release_contents (asection *, bfd_byte *);
97 static Elf_Internal_Sym *retrieve_local_syms (bfd *);
99 /* Miscellaneous utility functions. */
101 static asection *elf_xtensa_get_plt_section (bfd *, int);
102 static asection *elf_xtensa_get_gotplt_section (bfd *, int);
103 static asection *get_elf_r_symndx_section (bfd *, unsigned long);
104 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
105 (bfd *, unsigned long);
106 static bfd_vma get_elf_r_symndx_offset (bfd *, unsigned long);
107 static bfd_boolean is_reloc_sym_weak (bfd *, Elf_Internal_Rela *);
108 static bfd_boolean pcrel_reloc_fits (xtensa_opcode, int, bfd_vma, bfd_vma);
109 static bfd_boolean xtensa_is_property_section (asection *);
110 static bfd_boolean xtensa_is_littable_section (asection *);
111 static int internal_reloc_compare (const void *, const void *);
112 static int internal_reloc_matches (const void *, const void *);
113 extern char *xtensa_get_property_section_name (asection *, const char *);
114 static flagword xtensa_get_property_predef_flags (asection *);
116 /* Other functions called directly by the linker. */
118 typedef void (*deps_callback_t)
119 (asection *, bfd_vma, asection *, bfd_vma, void *);
120 extern bfd_boolean xtensa_callback_required_dependence
121 (bfd *, asection *, struct bfd_link_info *, deps_callback_t, void *);
124 /* Globally visible flag for choosing size optimization of NOP removal
125 instead of branch-target-aware minimization for NOP removal.
126 When nonzero, narrow all instructions and remove all NOPs possible
127 around longcall expansions. */
129 int elf32xtensa_size_opt;
132 /* The "new_section_hook" is used to set up a per-section
133 "xtensa_relax_info" data structure with additional information used
134 during relaxation. */
136 typedef struct xtensa_relax_info_struct xtensa_relax_info;
139 /* Total count of PLT relocations seen during check_relocs.
140 The actual PLT code must be split into multiple sections and all
141 the sections have to be created before size_dynamic_sections,
142 where we figure out the exact number of PLT entries that will be
143 needed. It is OK if this count is an overestimate, e.g., some
144 relocations may be removed by GC. */
146 static int plt_reloc_count = 0;
149 /* The GNU tools do not easily allow extending interfaces to pass around
150 the pointer to the Xtensa ISA information, so instead we add a global
151 variable here (in BFD) that can be used by any of the tools that need
154 xtensa_isa xtensa_default_isa;
157 /* When this is true, relocations may have been modified to refer to
158 symbols from other input files. The per-section list of "fix"
159 records needs to be checked when resolving relocations. */
161 static bfd_boolean relaxing_section = FALSE;
163 /* When this is true, during final links, literals that cannot be
164 coalesced and their relocations may be moved to other sections. */
166 int elf32xtensa_no_literal_movement = 1;
169 static reloc_howto_type elf_howto_table[] =
171 HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
172 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
173 FALSE, 0x00000000, 0x00000000, FALSE),
174 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
175 bfd_elf_xtensa_reloc, "R_XTENSA_32",
176 TRUE, 0xffffffff, 0xffffffff, FALSE),
177 /* Replace a 32-bit value with a value from the runtime linker (only
178 used by linker-generated stub functions). The r_addend value is
179 special: 1 means to substitute a pointer to the runtime linker's
180 dynamic resolver function; 2 means to substitute the link map for
181 the shared object. */
182 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
183 NULL, "R_XTENSA_RTLD",
184 FALSE, 0x00000000, 0x00000000, FALSE),
185 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
186 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
187 FALSE, 0xffffffff, 0xffffffff, FALSE),
188 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
189 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
190 FALSE, 0xffffffff, 0xffffffff, FALSE),
191 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
192 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
193 FALSE, 0xffffffff, 0xffffffff, FALSE),
194 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
195 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
196 FALSE, 0xffffffff, 0xffffffff, FALSE),
198 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
199 bfd_elf_xtensa_reloc, "R_XTENSA_OP0",
200 FALSE, 0x00000000, 0x00000000, TRUE),
201 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
202 bfd_elf_xtensa_reloc, "R_XTENSA_OP1",
203 FALSE, 0x00000000, 0x00000000, TRUE),
204 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
205 bfd_elf_xtensa_reloc, "R_XTENSA_OP2",
206 FALSE, 0x00000000, 0x00000000, TRUE),
207 /* Assembly auto-expansion. */
208 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
209 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND",
210 FALSE, 0x00000000, 0x00000000, FALSE),
211 /* Relax assembly auto-expansion. */
212 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
213 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY",
214 FALSE, 0x00000000, 0x00000000, TRUE),
217 /* GNU extension to record C++ vtable hierarchy. */
218 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
219 NULL, "R_XTENSA_GNU_VTINHERIT",
220 FALSE, 0x00000000, 0x00000000, FALSE),
221 /* GNU extension to record C++ vtable member usage. */
222 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
223 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
224 FALSE, 0x00000000, 0x00000000, FALSE),
226 /* Relocations for supporting difference of symbols. */
227 HOWTO (R_XTENSA_DIFF8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
228 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF8",
229 FALSE, 0xffffffff, 0xffffffff, FALSE),
230 HOWTO (R_XTENSA_DIFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
231 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF16",
232 FALSE, 0xffffffff, 0xffffffff, FALSE),
233 HOWTO (R_XTENSA_DIFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
234 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF32",
235 FALSE, 0xffffffff, 0xffffffff, FALSE),
237 /* General immediate operand relocations. */
238 HOWTO (R_XTENSA_SLOT0_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
239 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_OP",
240 FALSE, 0x00000000, 0x00000000, TRUE),
241 HOWTO (R_XTENSA_SLOT1_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
242 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_OP",
243 FALSE, 0x00000000, 0x00000000, TRUE),
244 HOWTO (R_XTENSA_SLOT2_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
245 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_OP",
246 FALSE, 0x00000000, 0x00000000, TRUE),
247 HOWTO (R_XTENSA_SLOT3_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
248 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_OP",
249 FALSE, 0x00000000, 0x00000000, TRUE),
250 HOWTO (R_XTENSA_SLOT4_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
251 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_OP",
252 FALSE, 0x00000000, 0x00000000, TRUE),
253 HOWTO (R_XTENSA_SLOT5_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
254 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_OP",
255 FALSE, 0x00000000, 0x00000000, TRUE),
256 HOWTO (R_XTENSA_SLOT6_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
257 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_OP",
258 FALSE, 0x00000000, 0x00000000, TRUE),
259 HOWTO (R_XTENSA_SLOT7_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
260 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_OP",
261 FALSE, 0x00000000, 0x00000000, TRUE),
262 HOWTO (R_XTENSA_SLOT8_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
263 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_OP",
264 FALSE, 0x00000000, 0x00000000, TRUE),
265 HOWTO (R_XTENSA_SLOT9_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
266 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_OP",
267 FALSE, 0x00000000, 0x00000000, TRUE),
268 HOWTO (R_XTENSA_SLOT10_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
269 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_OP",
270 FALSE, 0x00000000, 0x00000000, TRUE),
271 HOWTO (R_XTENSA_SLOT11_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
272 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_OP",
273 FALSE, 0x00000000, 0x00000000, TRUE),
274 HOWTO (R_XTENSA_SLOT12_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
275 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_OP",
276 FALSE, 0x00000000, 0x00000000, TRUE),
277 HOWTO (R_XTENSA_SLOT13_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
278 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_OP",
279 FALSE, 0x00000000, 0x00000000, TRUE),
280 HOWTO (R_XTENSA_SLOT14_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
281 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_OP",
282 FALSE, 0x00000000, 0x00000000, TRUE),
284 /* "Alternate" relocations. The meaning of these is opcode-specific. */
285 HOWTO (R_XTENSA_SLOT0_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
286 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_ALT",
287 FALSE, 0x00000000, 0x00000000, TRUE),
288 HOWTO (R_XTENSA_SLOT1_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
289 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_ALT",
290 FALSE, 0x00000000, 0x00000000, TRUE),
291 HOWTO (R_XTENSA_SLOT2_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
292 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_ALT",
293 FALSE, 0x00000000, 0x00000000, TRUE),
294 HOWTO (R_XTENSA_SLOT3_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
295 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_ALT",
296 FALSE, 0x00000000, 0x00000000, TRUE),
297 HOWTO (R_XTENSA_SLOT4_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
298 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_ALT",
299 FALSE, 0x00000000, 0x00000000, TRUE),
300 HOWTO (R_XTENSA_SLOT5_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
301 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_ALT",
302 FALSE, 0x00000000, 0x00000000, TRUE),
303 HOWTO (R_XTENSA_SLOT6_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
304 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_ALT",
305 FALSE, 0x00000000, 0x00000000, TRUE),
306 HOWTO (R_XTENSA_SLOT7_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
307 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_ALT",
308 FALSE, 0x00000000, 0x00000000, TRUE),
309 HOWTO (R_XTENSA_SLOT8_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
310 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_ALT",
311 FALSE, 0x00000000, 0x00000000, TRUE),
312 HOWTO (R_XTENSA_SLOT9_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
313 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_ALT",
314 FALSE, 0x00000000, 0x00000000, TRUE),
315 HOWTO (R_XTENSA_SLOT10_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
316 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_ALT",
317 FALSE, 0x00000000, 0x00000000, TRUE),
318 HOWTO (R_XTENSA_SLOT11_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
319 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_ALT",
320 FALSE, 0x00000000, 0x00000000, TRUE),
321 HOWTO (R_XTENSA_SLOT12_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
322 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_ALT",
323 FALSE, 0x00000000, 0x00000000, TRUE),
324 HOWTO (R_XTENSA_SLOT13_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
325 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_ALT",
326 FALSE, 0x00000000, 0x00000000, TRUE),
327 HOWTO (R_XTENSA_SLOT14_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
328 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_ALT",
329 FALSE, 0x00000000, 0x00000000, TRUE)
334 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
339 static reloc_howto_type *
340 elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
341 bfd_reloc_code_real_type code)
346 TRACE ("BFD_RELOC_NONE");
347 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
350 TRACE ("BFD_RELOC_32");
351 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
353 case BFD_RELOC_XTENSA_DIFF8:
354 TRACE ("BFD_RELOC_XTENSA_DIFF8");
355 return &elf_howto_table[(unsigned) R_XTENSA_DIFF8 ];
357 case BFD_RELOC_XTENSA_DIFF16:
358 TRACE ("BFD_RELOC_XTENSA_DIFF16");
359 return &elf_howto_table[(unsigned) R_XTENSA_DIFF16 ];
361 case BFD_RELOC_XTENSA_DIFF32:
362 TRACE ("BFD_RELOC_XTENSA_DIFF32");
363 return &elf_howto_table[(unsigned) R_XTENSA_DIFF32 ];
365 case BFD_RELOC_XTENSA_RTLD:
366 TRACE ("BFD_RELOC_XTENSA_RTLD");
367 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
369 case BFD_RELOC_XTENSA_GLOB_DAT:
370 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
371 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
373 case BFD_RELOC_XTENSA_JMP_SLOT:
374 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
375 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
377 case BFD_RELOC_XTENSA_RELATIVE:
378 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
379 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
381 case BFD_RELOC_XTENSA_PLT:
382 TRACE ("BFD_RELOC_XTENSA_PLT");
383 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
385 case BFD_RELOC_XTENSA_OP0:
386 TRACE ("BFD_RELOC_XTENSA_OP0");
387 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
389 case BFD_RELOC_XTENSA_OP1:
390 TRACE ("BFD_RELOC_XTENSA_OP1");
391 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
393 case BFD_RELOC_XTENSA_OP2:
394 TRACE ("BFD_RELOC_XTENSA_OP2");
395 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
397 case BFD_RELOC_XTENSA_ASM_EXPAND:
398 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
399 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
401 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
402 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
403 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
405 case BFD_RELOC_VTABLE_INHERIT:
406 TRACE ("BFD_RELOC_VTABLE_INHERIT");
407 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
409 case BFD_RELOC_VTABLE_ENTRY:
410 TRACE ("BFD_RELOC_VTABLE_ENTRY");
411 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
414 if (code >= BFD_RELOC_XTENSA_SLOT0_OP
415 && code <= BFD_RELOC_XTENSA_SLOT14_OP)
417 unsigned n = (R_XTENSA_SLOT0_OP +
418 (code - BFD_RELOC_XTENSA_SLOT0_OP));
419 return &elf_howto_table[n];
422 if (code >= BFD_RELOC_XTENSA_SLOT0_ALT
423 && code <= BFD_RELOC_XTENSA_SLOT14_ALT)
425 unsigned n = (R_XTENSA_SLOT0_ALT +
426 (code - BFD_RELOC_XTENSA_SLOT0_ALT));
427 return &elf_howto_table[n];
438 /* Given an ELF "rela" relocation, find the corresponding howto and record
439 it in the BFD internal arelent representation of the relocation. */
442 elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
444 Elf_Internal_Rela *dst)
446 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
448 BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max);
449 cache_ptr->howto = &elf_howto_table[r_type];
453 /* Functions for the Xtensa ELF linker. */
455 /* The name of the dynamic interpreter. This is put in the .interp
458 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
460 /* The size in bytes of an entry in the procedure linkage table.
461 (This does _not_ include the space for the literals associated with
464 #define PLT_ENTRY_SIZE 16
466 /* For _really_ large PLTs, we may need to alternate between literals
467 and code to keep the literals within the 256K range of the L32R
468 instructions in the code. It's unlikely that anyone would ever need
469 such a big PLT, but an arbitrary limit on the PLT size would be bad.
470 Thus, we split the PLT into chunks. Since there's very little
471 overhead (2 extra literals) for each chunk, the chunk size is kept
472 small so that the code for handling multiple chunks get used and
473 tested regularly. With 254 entries, there are 1K of literals for
474 each chunk, and that seems like a nice round number. */
476 #define PLT_ENTRIES_PER_CHUNK 254
478 /* PLT entries are actually used as stub functions for lazy symbol
479 resolution. Once the symbol is resolved, the stub function is never
480 invoked. Note: the 32-byte frame size used here cannot be changed
481 without a corresponding change in the runtime linker. */
483 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
485 0x6c, 0x10, 0x04, /* entry sp, 32 */
486 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
487 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
488 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
489 0x0a, 0x80, 0x00, /* jx a8 */
493 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
495 0x36, 0x41, 0x00, /* entry sp, 32 */
496 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
497 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
498 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
499 0xa0, 0x08, 0x00, /* jx a8 */
504 static inline bfd_boolean
505 xtensa_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
506 struct bfd_link_info *info)
508 /* Check if we should do dynamic things to this symbol. The
509 "ignore_protected" argument need not be set, because Xtensa code
510 does not require special handling of STV_PROTECTED to make function
511 pointer comparisons work properly. The PLT addresses are never
512 used for function pointers. */
514 return _bfd_elf_dynamic_symbol_p (h, info, 0);
519 property_table_compare (const void *ap, const void *bp)
521 const property_table_entry *a = (const property_table_entry *) ap;
522 const property_table_entry *b = (const property_table_entry *) bp;
524 if (a->address == b->address)
526 /* The only circumstance where two entries may legitimately have the
527 same address is when one of them is a zero-size placeholder to
528 mark a place where fill can be inserted. The zero-size entry should
530 BFD_ASSERT ((a->size == 0 || b->size == 0));
532 if (a->size != b->size)
533 return (a->size - b->size);
535 if ((a->flags & XTENSA_PROP_ALIGN) != (b->flags & XTENSA_PROP_ALIGN))
536 return ((b->flags & XTENSA_PROP_ALIGN)
537 - (a->flags & XTENSA_PROP_ALIGN));
539 if ((a->flags & XTENSA_PROP_ALIGN)
540 && (GET_XTENSA_PROP_ALIGNMENT (a->flags)
541 != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
542 return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
543 - GET_XTENSA_PROP_ALIGNMENT (b->flags));
545 if ((a->flags & XTENSA_PROP_UNREACHABLE)
546 != (b->flags & XTENSA_PROP_UNREACHABLE))
547 return ((b->flags & XTENSA_PROP_UNREACHABLE)
548 - (a->flags & XTENSA_PROP_UNREACHABLE));
550 return (a->flags - b->flags);
553 return (a->address - b->address);
558 property_table_matches (const void *ap, const void *bp)
560 const property_table_entry *a = (const property_table_entry *) ap;
561 const property_table_entry *b = (const property_table_entry *) bp;
563 /* Check if one entry overlaps with the other. */
564 if ((b->address >= a->address && b->address < (a->address + a->size))
565 || (a->address >= b->address && a->address < (b->address + b->size)))
568 return (a->address - b->address);
572 /* Get the literal table or property table entries for the given
573 section. Sets TABLE_P and returns the number of entries. On
574 error, returns a negative value. */
577 xtensa_read_table_entries (bfd *abfd,
579 property_table_entry **table_p,
580 const char *sec_name,
581 bfd_boolean output_addr)
583 asection *table_section;
584 char *table_section_name;
585 bfd_size_type table_size = 0;
586 bfd_byte *table_data;
587 property_table_entry *blocks;
589 bfd_size_type num_records;
590 Elf_Internal_Rela *internal_relocs;
591 bfd_vma section_addr;
592 flagword predef_flags;
593 bfd_size_type table_entry_size;
596 || !(section->flags & SEC_ALLOC)
597 || (section->flags & SEC_DEBUGGING))
603 table_section_name = xtensa_get_property_section_name (section, sec_name);
604 table_section = bfd_get_section_by_name (abfd, table_section_name);
605 free (table_section_name);
607 table_size = table_section->size;
615 predef_flags = xtensa_get_property_predef_flags (table_section);
616 table_entry_size = 12;
618 table_entry_size -= 4;
620 num_records = table_size / table_entry_size;
621 table_data = retrieve_contents (abfd, table_section, TRUE);
622 blocks = (property_table_entry *)
623 bfd_malloc (num_records * sizeof (property_table_entry));
627 section_addr = section->output_section->vma + section->output_offset;
629 section_addr = section->vma;
631 /* If the file has not yet been relocated, process the relocations
632 and sort out the table entries that apply to the specified section. */
633 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
634 if (internal_relocs && !table_section->reloc_done)
638 for (i = 0; i < table_section->reloc_count; i++)
640 Elf_Internal_Rela *rel = &internal_relocs[i];
641 unsigned long r_symndx;
643 if (ELF32_R_TYPE (rel->r_info) == R_XTENSA_NONE)
646 BFD_ASSERT (ELF32_R_TYPE (rel->r_info) == R_XTENSA_32);
647 r_symndx = ELF32_R_SYM (rel->r_info);
649 if (get_elf_r_symndx_section (abfd, r_symndx) == section)
651 bfd_vma sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
652 BFD_ASSERT (sym_off == 0);
653 BFD_ASSERT (rel->r_addend == 0);
654 blocks[block_count].address =
655 (section_addr + sym_off + rel->r_addend
656 + bfd_get_32 (abfd, table_data + rel->r_offset));
657 blocks[block_count].size =
658 bfd_get_32 (abfd, table_data + rel->r_offset + 4);
660 blocks[block_count].flags = predef_flags;
662 blocks[block_count].flags =
663 bfd_get_32 (abfd, table_data + rel->r_offset + 8);
670 /* The file has already been relocated and the addresses are
671 already in the table. */
673 bfd_size_type section_limit = bfd_get_section_limit (abfd, section);
675 for (off = 0; off < table_size; off += table_entry_size)
677 bfd_vma address = bfd_get_32 (abfd, table_data + off);
679 if (address >= section_addr
680 && address < section_addr + section_limit)
682 blocks[block_count].address = address;
683 blocks[block_count].size =
684 bfd_get_32 (abfd, table_data + off + 4);
686 blocks[block_count].flags = predef_flags;
688 blocks[block_count].flags =
689 bfd_get_32 (abfd, table_data + off + 8);
695 release_contents (table_section, table_data);
696 release_internal_relocs (table_section, internal_relocs);
700 /* Now sort them into address order for easy reference. */
701 qsort (blocks, block_count, sizeof (property_table_entry),
702 property_table_compare);
710 static property_table_entry *
711 elf_xtensa_find_property_entry (property_table_entry *property_table,
712 int property_table_size,
715 property_table_entry entry;
716 property_table_entry *rv;
718 if (property_table_size == 0)
721 entry.address = addr;
725 rv = bsearch (&entry, property_table, property_table_size,
726 sizeof (property_table_entry), property_table_matches);
732 elf_xtensa_in_literal_pool (property_table_entry *lit_table,
736 if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
743 /* Look through the relocs for a section during the first phase, and
744 calculate needed space in the dynamic reloc sections. */
747 elf_xtensa_check_relocs (bfd *abfd,
748 struct bfd_link_info *info,
750 const Elf_Internal_Rela *relocs)
752 Elf_Internal_Shdr *symtab_hdr;
753 struct elf_link_hash_entry **sym_hashes;
754 const Elf_Internal_Rela *rel;
755 const Elf_Internal_Rela *rel_end;
757 if (info->relocatable)
760 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
761 sym_hashes = elf_sym_hashes (abfd);
763 rel_end = relocs + sec->reloc_count;
764 for (rel = relocs; rel < rel_end; rel++)
767 unsigned long r_symndx;
768 struct elf_link_hash_entry *h;
770 r_symndx = ELF32_R_SYM (rel->r_info);
771 r_type = ELF32_R_TYPE (rel->r_info);
773 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
775 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
780 if (r_symndx < symtab_hdr->sh_info)
784 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
785 while (h->root.type == bfd_link_hash_indirect
786 || h->root.type == bfd_link_hash_warning)
787 h = (struct elf_link_hash_entry *) h->root.u.i.link;
796 if ((sec->flags & SEC_ALLOC) != 0)
798 if (h->got.refcount <= 0)
801 h->got.refcount += 1;
806 /* If this relocation is against a local symbol, then it's
807 exactly the same as a normal local GOT entry. */
811 if ((sec->flags & SEC_ALLOC) != 0)
813 if (h->plt.refcount <= 0)
819 h->plt.refcount += 1;
821 /* Keep track of the total PLT relocation count even if we
822 don't yet know whether the dynamic sections will be
824 plt_reloc_count += 1;
826 if (elf_hash_table (info)->dynamic_sections_created)
828 if (!add_extra_plt_sections (elf_hash_table (info)->dynobj,
836 if ((sec->flags & SEC_ALLOC) != 0)
838 bfd_signed_vma *local_got_refcounts;
840 /* This is a global offset table entry for a local symbol. */
841 local_got_refcounts = elf_local_got_refcounts (abfd);
842 if (local_got_refcounts == NULL)
846 size = symtab_hdr->sh_info;
847 size *= sizeof (bfd_signed_vma);
848 local_got_refcounts =
849 (bfd_signed_vma *) bfd_zalloc (abfd, size);
850 if (local_got_refcounts == NULL)
852 elf_local_got_refcounts (abfd) = local_got_refcounts;
854 local_got_refcounts[r_symndx] += 1;
861 case R_XTENSA_SLOT0_OP:
862 case R_XTENSA_SLOT1_OP:
863 case R_XTENSA_SLOT2_OP:
864 case R_XTENSA_SLOT3_OP:
865 case R_XTENSA_SLOT4_OP:
866 case R_XTENSA_SLOT5_OP:
867 case R_XTENSA_SLOT6_OP:
868 case R_XTENSA_SLOT7_OP:
869 case R_XTENSA_SLOT8_OP:
870 case R_XTENSA_SLOT9_OP:
871 case R_XTENSA_SLOT10_OP:
872 case R_XTENSA_SLOT11_OP:
873 case R_XTENSA_SLOT12_OP:
874 case R_XTENSA_SLOT13_OP:
875 case R_XTENSA_SLOT14_OP:
876 case R_XTENSA_SLOT0_ALT:
877 case R_XTENSA_SLOT1_ALT:
878 case R_XTENSA_SLOT2_ALT:
879 case R_XTENSA_SLOT3_ALT:
880 case R_XTENSA_SLOT4_ALT:
881 case R_XTENSA_SLOT5_ALT:
882 case R_XTENSA_SLOT6_ALT:
883 case R_XTENSA_SLOT7_ALT:
884 case R_XTENSA_SLOT8_ALT:
885 case R_XTENSA_SLOT9_ALT:
886 case R_XTENSA_SLOT10_ALT:
887 case R_XTENSA_SLOT11_ALT:
888 case R_XTENSA_SLOT12_ALT:
889 case R_XTENSA_SLOT13_ALT:
890 case R_XTENSA_SLOT14_ALT:
891 case R_XTENSA_ASM_EXPAND:
892 case R_XTENSA_ASM_SIMPLIFY:
894 case R_XTENSA_DIFF16:
895 case R_XTENSA_DIFF32:
896 /* Nothing to do for these. */
899 case R_XTENSA_GNU_VTINHERIT:
900 /* This relocation describes the C++ object vtable hierarchy.
901 Reconstruct it for later use during GC. */
902 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
906 case R_XTENSA_GNU_VTENTRY:
907 /* This relocation describes which C++ vtable entries are actually
908 used. Record for later use during GC. */
909 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
923 elf_xtensa_make_sym_local (struct bfd_link_info *info,
924 struct elf_link_hash_entry *h)
928 if (h->plt.refcount > 0)
930 /* Will use RELATIVE relocs instead of JMP_SLOT relocs. */
931 if (h->got.refcount < 0)
933 h->got.refcount += h->plt.refcount;
939 /* Don't need any dynamic relocations at all. */
947 elf_xtensa_hide_symbol (struct bfd_link_info *info,
948 struct elf_link_hash_entry *h,
949 bfd_boolean force_local)
951 /* For a shared link, move the plt refcount to the got refcount to leave
952 space for RELATIVE relocs. */
953 elf_xtensa_make_sym_local (info, h);
955 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
959 /* Return the section that should be marked against GC for a given
963 elf_xtensa_gc_mark_hook (asection *sec,
964 struct bfd_link_info *info ATTRIBUTE_UNUSED,
965 Elf_Internal_Rela *rel,
966 struct elf_link_hash_entry *h,
967 Elf_Internal_Sym *sym)
971 switch (ELF32_R_TYPE (rel->r_info))
973 case R_XTENSA_GNU_VTINHERIT:
974 case R_XTENSA_GNU_VTENTRY:
978 switch (h->root.type)
980 case bfd_link_hash_defined:
981 case bfd_link_hash_defweak:
982 return h->root.u.def.section;
984 case bfd_link_hash_common:
985 return h->root.u.c.p->section;
993 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
999 /* Update the GOT & PLT entry reference counts
1000 for the section being removed. */
1003 elf_xtensa_gc_sweep_hook (bfd *abfd,
1004 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1006 const Elf_Internal_Rela *relocs)
1008 Elf_Internal_Shdr *symtab_hdr;
1009 struct elf_link_hash_entry **sym_hashes;
1010 bfd_signed_vma *local_got_refcounts;
1011 const Elf_Internal_Rela *rel, *relend;
1013 if ((sec->flags & SEC_ALLOC) == 0)
1016 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1017 sym_hashes = elf_sym_hashes (abfd);
1018 local_got_refcounts = elf_local_got_refcounts (abfd);
1020 relend = relocs + sec->reloc_count;
1021 for (rel = relocs; rel < relend; rel++)
1023 unsigned long r_symndx;
1024 unsigned int r_type;
1025 struct elf_link_hash_entry *h = NULL;
1027 r_symndx = ELF32_R_SYM (rel->r_info);
1028 if (r_symndx >= symtab_hdr->sh_info)
1029 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1031 r_type = ELF32_R_TYPE (rel->r_info);
1037 if (h->got.refcount > 0)
1044 if (h->plt.refcount > 0)
1049 if (local_got_refcounts[r_symndx] > 0)
1050 local_got_refcounts[r_symndx] -= 1;
1062 /* Create all the dynamic sections. */
1065 elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1067 flagword flags, noalloc_flags;
1070 /* First do all the standard stuff. */
1071 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
1074 /* Create any extra PLT sections in case check_relocs has already
1075 been called on all the non-dynamic input files. */
1076 if (!add_extra_plt_sections (dynobj, plt_reloc_count))
1079 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
1080 | SEC_LINKER_CREATED | SEC_READONLY);
1081 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
1083 /* Mark the ".got.plt" section READONLY. */
1084 s = bfd_get_section_by_name (dynobj, ".got.plt");
1086 || ! bfd_set_section_flags (dynobj, s, flags))
1089 /* Create ".rela.got". */
1090 s = bfd_make_section (dynobj, ".rela.got");
1092 || ! bfd_set_section_flags (dynobj, s, flags)
1093 || ! bfd_set_section_alignment (dynobj, s, 2))
1096 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1097 s = bfd_make_section (dynobj, ".got.loc");
1099 || ! bfd_set_section_flags (dynobj, s, flags)
1100 || ! bfd_set_section_alignment (dynobj, s, 2))
1103 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1104 s = bfd_make_section (dynobj, ".xt.lit.plt");
1106 || ! bfd_set_section_flags (dynobj, s, noalloc_flags)
1107 || ! bfd_set_section_alignment (dynobj, s, 2))
1115 add_extra_plt_sections (bfd *dynobj, int count)
1119 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1120 ".got.plt" sections. */
1121 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1127 /* Stop when we find a section has already been created. */
1128 if (elf_xtensa_get_plt_section (dynobj, chunk))
1131 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1132 | SEC_LINKER_CREATED | SEC_READONLY);
1134 sname = (char *) bfd_malloc (10);
1135 sprintf (sname, ".plt.%u", chunk);
1136 s = bfd_make_section (dynobj, sname);
1138 || ! bfd_set_section_flags (dynobj, s, flags | SEC_CODE)
1139 || ! bfd_set_section_alignment (dynobj, s, 2))
1142 sname = (char *) bfd_malloc (14);
1143 sprintf (sname, ".got.plt.%u", chunk);
1144 s = bfd_make_section (dynobj, sname);
1146 || ! bfd_set_section_flags (dynobj, s, flags)
1147 || ! bfd_set_section_alignment (dynobj, s, 2))
1155 /* Adjust a symbol defined by a dynamic object and referenced by a
1156 regular object. The current definition is in some section of the
1157 dynamic object, but we're not including those sections. We have to
1158 change the definition to something the rest of the link can
1162 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1163 struct elf_link_hash_entry *h)
1165 /* If this is a weak symbol, and there is a real definition, the
1166 processor independent code will have arranged for us to see the
1167 real definition first, and we can just use the same value. */
1170 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1171 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1172 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1173 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1177 /* This is a reference to a symbol defined by a dynamic object. The
1178 reference must go through the GOT, so there's no need for COPY relocs,
1186 elf_xtensa_fix_refcounts (struct elf_link_hash_entry *h, void *arg)
1188 struct bfd_link_info *info = (struct bfd_link_info *) arg;
1190 if (h->root.type == bfd_link_hash_warning)
1191 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1193 if (! xtensa_elf_dynamic_symbol_p (h, info))
1194 elf_xtensa_make_sym_local (info, h);
1201 elf_xtensa_allocate_plt_size (struct elf_link_hash_entry *h, void *arg)
1203 asection *srelplt = (asection *) arg;
1205 if (h->root.type == bfd_link_hash_warning)
1206 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1208 if (h->plt.refcount > 0)
1209 srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1216 elf_xtensa_allocate_got_size (struct elf_link_hash_entry *h, void *arg)
1218 asection *srelgot = (asection *) arg;
1220 if (h->root.type == bfd_link_hash_warning)
1221 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1223 if (h->got.refcount > 0)
1224 srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
1231 elf_xtensa_allocate_local_got_size (struct bfd_link_info *info,
1236 for (i = info->input_bfds; i; i = i->link_next)
1238 bfd_signed_vma *local_got_refcounts;
1239 bfd_size_type j, cnt;
1240 Elf_Internal_Shdr *symtab_hdr;
1242 local_got_refcounts = elf_local_got_refcounts (i);
1243 if (!local_got_refcounts)
1246 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1247 cnt = symtab_hdr->sh_info;
1249 for (j = 0; j < cnt; ++j)
1251 if (local_got_refcounts[j] > 0)
1252 srelgot->size += (local_got_refcounts[j]
1253 * sizeof (Elf32_External_Rela));
1259 /* Set the sizes of the dynamic sections. */
1262 elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1263 struct bfd_link_info *info)
1266 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1267 bfd_boolean relplt, relgot;
1268 int plt_entries, plt_chunks, chunk;
1274 dynobj = elf_hash_table (info)->dynobj;
1278 if (elf_hash_table (info)->dynamic_sections_created)
1280 /* Set the contents of the .interp section to the interpreter. */
1281 if (info->executable)
1283 s = bfd_get_section_by_name (dynobj, ".interp");
1286 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1287 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1290 /* Allocate room for one word in ".got". */
1291 s = bfd_get_section_by_name (dynobj, ".got");
1296 /* Adjust refcounts for symbols that we now know are not "dynamic". */
1297 elf_link_hash_traverse (elf_hash_table (info),
1298 elf_xtensa_fix_refcounts,
1301 /* Allocate space in ".rela.got" for literals that reference
1303 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1304 if (srelgot == NULL)
1306 elf_link_hash_traverse (elf_hash_table (info),
1307 elf_xtensa_allocate_got_size,
1310 /* If we are generating a shared object, we also need space in
1311 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1312 reference local symbols. */
1314 elf_xtensa_allocate_local_got_size (info, srelgot);
1316 /* Allocate space in ".rela.plt" for literals that have PLT entries. */
1317 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1318 if (srelplt == NULL)
1320 elf_link_hash_traverse (elf_hash_table (info),
1321 elf_xtensa_allocate_plt_size,
1324 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1325 each PLT entry, we need the PLT code plus a 4-byte literal.
1326 For each chunk of ".plt", we also need two more 4-byte
1327 literals, two corresponding entries in ".rela.got", and an
1328 8-byte entry in ".xt.lit.plt". */
1329 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
1330 if (spltlittbl == NULL)
1333 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
1335 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1337 /* Iterate over all the PLT chunks, including any extra sections
1338 created earlier because the initial count of PLT relocations
1339 was an overestimate. */
1341 (splt = elf_xtensa_get_plt_section (dynobj, chunk)) != NULL;
1346 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1347 if (sgotplt == NULL)
1350 if (chunk < plt_chunks - 1)
1351 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1352 else if (chunk == plt_chunks - 1)
1353 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1357 if (chunk_entries != 0)
1359 sgotplt->size = 4 * (chunk_entries + 2);
1360 splt->size = PLT_ENTRY_SIZE * chunk_entries;
1361 srelgot->size += 2 * sizeof (Elf32_External_Rela);
1362 spltlittbl->size += 8;
1371 /* Allocate space in ".got.loc" to match the total size of all the
1373 sgotloc = bfd_get_section_by_name (dynobj, ".got.loc");
1374 if (sgotloc == NULL)
1376 sgotloc->size = spltlittbl->size;
1377 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1379 if (abfd->flags & DYNAMIC)
1381 for (s = abfd->sections; s != NULL; s = s->next)
1383 if (! elf_discarded_section (s)
1384 && xtensa_is_littable_section (s)
1386 sgotloc->size += s->size;
1391 /* Allocate memory for dynamic sections. */
1394 for (s = dynobj->sections; s != NULL; s = s->next)
1399 if ((s->flags & SEC_LINKER_CREATED) == 0)
1402 /* It's OK to base decisions on the section name, because none
1403 of the dynobj section names depend upon the input files. */
1404 name = bfd_get_section_name (dynobj, s);
1408 if (strncmp (name, ".rela", 5) == 0)
1410 if (strcmp (name, ".rela.plt") == 0)
1412 else if (strcmp (name, ".rela.got") == 0)
1415 /* We use the reloc_count field as a counter if we need
1416 to copy relocs into the output file. */
1419 else if (strncmp (name, ".plt.", 5) == 0
1420 || strncmp (name, ".got.plt.", 9) == 0)
1424 /* If we don't need this section, strip it from the output
1425 file. We must create the ".plt*" and ".got.plt*"
1426 sections in create_dynamic_sections and/or check_relocs
1427 based on a conservative estimate of the PLT relocation
1428 count, because the sections must be created before the
1429 linker maps input sections to output sections. The
1430 linker does that before size_dynamic_sections, where we
1431 compute the exact size of the PLT, so there may be more
1432 of these sections than are actually needed. */
1436 else if (strcmp (name, ".got") != 0
1437 && strcmp (name, ".plt") != 0
1438 && strcmp (name, ".got.plt") != 0
1439 && strcmp (name, ".xt.lit.plt") != 0
1440 && strcmp (name, ".got.loc") != 0)
1442 /* It's not one of our sections, so don't allocate space. */
1447 _bfd_strip_section_from_output (info, s);
1450 /* Allocate memory for the section contents. */
1451 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1452 if (s->contents == NULL && s->size != 0)
1457 if (elf_hash_table (info)->dynamic_sections_created)
1459 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1460 known until finish_dynamic_sections, but we need to get the relocs
1461 in place before they are sorted. */
1462 if (srelgot == NULL)
1464 for (chunk = 0; chunk < plt_chunks; chunk++)
1466 Elf_Internal_Rela irela;
1470 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1473 loc = (srelgot->contents
1474 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1475 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1476 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1477 loc + sizeof (Elf32_External_Rela));
1478 srelgot->reloc_count += 2;
1481 /* Add some entries to the .dynamic section. We fill in the
1482 values later, in elf_xtensa_finish_dynamic_sections, but we
1483 must add the entries now so that we get the correct size for
1484 the .dynamic section. The DT_DEBUG entry is filled in by the
1485 dynamic linker and used by the debugger. */
1486 #define add_dynamic_entry(TAG, VAL) \
1487 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1491 if (!add_dynamic_entry (DT_DEBUG, 0))
1497 if (!add_dynamic_entry (DT_PLTGOT, 0)
1498 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1499 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1500 || !add_dynamic_entry (DT_JMPREL, 0))
1506 if (!add_dynamic_entry (DT_RELA, 0)
1507 || !add_dynamic_entry (DT_RELASZ, 0)
1508 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1512 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1513 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1516 #undef add_dynamic_entry
1522 /* Remove any PT_LOAD segments with no allocated sections. Prior to
1523 binutils 2.13, this function used to remove the non-SEC_ALLOC
1524 sections from PT_LOAD segments, but that task has now been moved
1525 into elf.c. We still need this function to remove any empty
1526 segments that result, but there's nothing Xtensa-specific about
1527 this and it probably ought to be moved into elf.c as well. */
1530 elf_xtensa_modify_segment_map (bfd *abfd,
1531 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1533 struct elf_segment_map **m_p;
1535 m_p = &elf_tdata (abfd)->segment_map;
1538 if ((*m_p)->p_type == PT_LOAD && (*m_p)->count == 0)
1539 *m_p = (*m_p)->next;
1541 m_p = &(*m_p)->next;
1547 /* Perform the specified relocation. The instruction at (contents + address)
1548 is modified to set one operand to represent the value in "relocation". The
1549 operand position is determined by the relocation type recorded in the
1552 #define CALL_SEGMENT_BITS (30)
1553 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1555 static bfd_reloc_status_type
1556 elf_xtensa_do_reloc (reloc_howto_type *howto,
1558 asection *input_section,
1562 bfd_boolean is_weak_undef,
1563 char **error_message)
1566 xtensa_opcode opcode;
1567 xtensa_isa isa = xtensa_default_isa;
1568 static xtensa_insnbuf ibuff = NULL;
1569 static xtensa_insnbuf sbuff = NULL;
1570 bfd_vma self_address = 0;
1571 bfd_size_type input_size;
1577 ibuff = xtensa_insnbuf_alloc (isa);
1578 sbuff = xtensa_insnbuf_alloc (isa);
1581 input_size = bfd_get_section_limit (abfd, input_section);
1583 switch (howto->type)
1586 case R_XTENSA_DIFF8:
1587 case R_XTENSA_DIFF16:
1588 case R_XTENSA_DIFF32:
1589 return bfd_reloc_ok;
1591 case R_XTENSA_ASM_EXPAND:
1594 /* Check for windowed CALL across a 1GB boundary. */
1595 xtensa_opcode opcode =
1596 get_expanded_call_opcode (contents + address,
1597 input_size - address, 0);
1598 if (is_windowed_call_opcode (opcode))
1600 self_address = (input_section->output_section->vma
1601 + input_section->output_offset
1603 if ((self_address >> CALL_SEGMENT_BITS)
1604 != (relocation >> CALL_SEGMENT_BITS))
1606 *error_message = "windowed longcall crosses 1GB boundary; "
1608 return bfd_reloc_dangerous;
1612 return bfd_reloc_ok;
1614 case R_XTENSA_ASM_SIMPLIFY:
1616 /* Convert the L32R/CALLX to CALL. */
1617 bfd_reloc_status_type retval =
1618 elf_xtensa_do_asm_simplify (contents, address, input_size,
1620 if (retval != bfd_reloc_ok)
1621 return bfd_reloc_dangerous;
1623 /* The CALL needs to be relocated. Continue below for that part. */
1625 howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
1633 x = bfd_get_32 (abfd, contents + address);
1635 bfd_put_32 (abfd, x, contents + address);
1637 return bfd_reloc_ok;
1640 /* Only instruction slot-specific relocations handled below.... */
1641 slot = get_relocation_slot (howto->type);
1642 if (slot == XTENSA_UNDEFINED)
1644 *error_message = "unexpected relocation";
1645 return bfd_reloc_dangerous;
1648 /* Read the instruction into a buffer and decode the opcode. */
1649 xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
1650 input_size - address);
1651 fmt = xtensa_format_decode (isa, ibuff);
1652 if (fmt == XTENSA_UNDEFINED)
1654 *error_message = "cannot decode instruction format";
1655 return bfd_reloc_dangerous;
1658 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
1660 opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
1661 if (opcode == XTENSA_UNDEFINED)
1663 *error_message = "cannot decode instruction opcode";
1664 return bfd_reloc_dangerous;
1667 /* Check for opcode-specific "alternate" relocations. */
1668 if (is_alt_relocation (howto->type))
1670 if (opcode == get_l32r_opcode ())
1672 /* Handle the special-case of non-PC-relative L32R instructions. */
1673 bfd *output_bfd = input_section->output_section->owner;
1674 asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
1677 *error_message = "relocation references missing .lit4 section";
1678 return bfd_reloc_dangerous;
1680 self_address = ((lit4_sec->vma & ~0xfff)
1681 + 0x40000 - 3); /* -3 to compensate for do_reloc */
1682 newval = relocation;
1685 else if (opcode == get_const16_opcode ())
1687 /* ALT used for high 16 bits. */
1688 newval = relocation >> 16;
1693 /* No other "alternate" relocations currently defined. */
1694 *error_message = "unexpected relocation";
1695 return bfd_reloc_dangerous;
1698 else /* Not an "alternate" relocation.... */
1700 if (opcode == get_const16_opcode ())
1702 newval = relocation & 0xffff;
1707 /* ...normal PC-relative relocation.... */
1709 /* Determine which operand is being relocated. */
1710 opnd = get_relocation_opnd (opcode, howto->type);
1711 if (opnd == XTENSA_UNDEFINED)
1713 *error_message = "unexpected relocation";
1714 return bfd_reloc_dangerous;
1717 if (!howto->pc_relative)
1719 *error_message = "expected PC-relative relocation";
1720 return bfd_reloc_dangerous;
1723 /* Calculate the PC address for this instruction. */
1724 self_address = (input_section->output_section->vma
1725 + input_section->output_offset
1728 newval = relocation;
1732 /* Apply the relocation. */
1733 if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
1734 || xtensa_operand_encode (isa, opcode, opnd, &newval)
1735 || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
1738 *error_message = build_encoding_error_message (opcode, relocation);
1739 return bfd_reloc_dangerous;
1742 /* Check for calls across 1GB boundaries. */
1743 if (is_direct_call_opcode (opcode)
1744 && is_windowed_call_opcode (opcode))
1746 if ((self_address >> CALL_SEGMENT_BITS)
1747 != (relocation >> CALL_SEGMENT_BITS))
1750 "windowed call crosses 1GB boundary; return may fail";
1751 return bfd_reloc_dangerous;
1755 /* Write the modified instruction back out of the buffer. */
1756 xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
1757 xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
1758 input_size - address);
1759 return bfd_reloc_ok;
1764 vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
1766 /* To reduce the size of the memory leak,
1767 we only use a single message buffer. */
1768 static bfd_size_type alloc_size = 0;
1769 static char *message = NULL;
1770 bfd_size_type orig_len, len = 0;
1771 bfd_boolean is_append;
1773 VA_OPEN (ap, arglen);
1774 VA_FIXEDARG (ap, const char *, origmsg);
1776 is_append = (origmsg == message);
1778 orig_len = strlen (origmsg);
1779 len = orig_len + strlen (fmt) + arglen + 20;
1780 if (len > alloc_size)
1782 message = (char *) bfd_realloc (message, len);
1786 memcpy (message, origmsg, orig_len);
1787 vsprintf (message + orig_len, fmt, ap);
1794 build_encoding_error_message (xtensa_opcode opcode, bfd_vma target_address)
1796 const char *opname = xtensa_opcode_name (xtensa_default_isa, opcode);
1799 msg = "cannot encode";
1800 if (is_direct_call_opcode (opcode))
1802 if ((target_address & 0x3) != 0)
1803 msg = "misaligned call target";
1805 msg = "call target out of range";
1807 else if (opcode == get_l32r_opcode ())
1809 if ((target_address & 0x3) != 0)
1810 msg = "misaligned literal target";
1812 msg = "literal target out of range";
1815 return vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
1819 /* This function is registered as the "special_function" in the
1820 Xtensa howto for handling simplify operations.
1821 bfd_perform_relocation / bfd_install_relocation use it to
1822 perform (install) the specified relocation. Since this replaces the code
1823 in bfd_perform_relocation, it is basically an Xtensa-specific,
1824 stripped-down version of bfd_perform_relocation. */
1826 static bfd_reloc_status_type
1827 bfd_elf_xtensa_reloc (bfd *abfd,
1828 arelent *reloc_entry,
1831 asection *input_section,
1833 char **error_message)
1836 bfd_reloc_status_type flag;
1837 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1838 bfd_vma output_base = 0;
1839 reloc_howto_type *howto = reloc_entry->howto;
1840 asection *reloc_target_output_section;
1841 bfd_boolean is_weak_undef;
1843 /* ELF relocs are against symbols. If we are producing relocatable
1844 output, and the reloc is against an external symbol, the resulting
1845 reloc will also be against the same symbol. In such a case, we
1846 don't want to change anything about the way the reloc is handled,
1847 since it will all be done at final link time. This test is similar
1848 to what bfd_elf_generic_reloc does except that it lets relocs with
1849 howto->partial_inplace go through even if the addend is non-zero.
1850 (The real problem is that partial_inplace is set for XTENSA_32
1851 relocs to begin with, but that's a long story and there's little we
1852 can do about it now....) */
1854 if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
1856 reloc_entry->address += input_section->output_offset;
1857 return bfd_reloc_ok;
1860 /* Is the address of the relocation really within the section? */
1861 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1862 return bfd_reloc_outofrange;
1864 /* Work out which section the relocation is targeted at and the
1865 initial relocation command value. */
1867 /* Get symbol value. (Common symbols are special.) */
1868 if (bfd_is_com_section (symbol->section))
1871 relocation = symbol->value;
1873 reloc_target_output_section = symbol->section->output_section;
1875 /* Convert input-section-relative symbol value to absolute. */
1876 if ((output_bfd && !howto->partial_inplace)
1877 || reloc_target_output_section == NULL)
1880 output_base = reloc_target_output_section->vma;
1882 relocation += output_base + symbol->section->output_offset;
1884 /* Add in supplied addend. */
1885 relocation += reloc_entry->addend;
1887 /* Here the variable relocation holds the final address of the
1888 symbol we are relocating against, plus any addend. */
1891 if (!howto->partial_inplace)
1893 /* This is a partial relocation, and we want to apply the relocation
1894 to the reloc entry rather than the raw data. Everything except
1895 relocations against section symbols has already been handled
1898 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
1899 reloc_entry->addend = relocation;
1900 reloc_entry->address += input_section->output_offset;
1901 return bfd_reloc_ok;
1905 reloc_entry->address += input_section->output_offset;
1906 reloc_entry->addend = 0;
1910 is_weak_undef = (bfd_is_und_section (symbol->section)
1911 && (symbol->flags & BSF_WEAK) != 0);
1912 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
1913 (bfd_byte *) data, (bfd_vma) octets,
1914 is_weak_undef, error_message);
1916 if (flag == bfd_reloc_dangerous)
1918 /* Add the symbol name to the error message. */
1919 if (! *error_message)
1920 *error_message = "";
1921 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
1922 strlen (symbol->name) + 17,
1923 symbol->name, reloc_entry->addend);
1930 /* Set up an entry in the procedure linkage table. */
1933 elf_xtensa_create_plt_entry (bfd *dynobj,
1935 unsigned reloc_index)
1937 asection *splt, *sgotplt;
1938 bfd_vma plt_base, got_base;
1939 bfd_vma code_offset, lit_offset;
1942 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
1943 splt = elf_xtensa_get_plt_section (dynobj, chunk);
1944 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1945 BFD_ASSERT (splt != NULL && sgotplt != NULL);
1947 plt_base = splt->output_section->vma + splt->output_offset;
1948 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1950 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
1951 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
1953 /* Fill in the literal entry. This is the offset of the dynamic
1954 relocation entry. */
1955 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
1956 sgotplt->contents + lit_offset);
1958 /* Fill in the entry in the procedure linkage table. */
1959 memcpy (splt->contents + code_offset,
1960 (bfd_big_endian (output_bfd)
1961 ? elf_xtensa_be_plt_entry
1962 : elf_xtensa_le_plt_entry),
1964 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
1965 plt_base + code_offset + 3),
1966 splt->contents + code_offset + 4);
1967 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
1968 plt_base + code_offset + 6),
1969 splt->contents + code_offset + 7);
1970 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
1971 plt_base + code_offset + 9),
1972 splt->contents + code_offset + 10);
1974 return plt_base + code_offset;
1978 /* Relocate an Xtensa ELF section. This is invoked by the linker for
1979 both relocatable and final links. */
1982 elf_xtensa_relocate_section (bfd *output_bfd,
1983 struct bfd_link_info *info,
1985 asection *input_section,
1987 Elf_Internal_Rela *relocs,
1988 Elf_Internal_Sym *local_syms,
1989 asection **local_sections)
1991 Elf_Internal_Shdr *symtab_hdr;
1992 Elf_Internal_Rela *rel;
1993 Elf_Internal_Rela *relend;
1994 struct elf_link_hash_entry **sym_hashes;
1995 asection *srelgot, *srelplt;
1997 property_table_entry *lit_table = 0;
1999 char *error_message = NULL;
2000 bfd_size_type input_size;
2002 if (!xtensa_default_isa)
2003 xtensa_default_isa = xtensa_isa_init (0, 0);
2005 dynobj = elf_hash_table (info)->dynobj;
2006 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2007 sym_hashes = elf_sym_hashes (input_bfd);
2013 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
2014 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
2017 if (elf_hash_table (info)->dynamic_sections_created)
2019 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
2020 &lit_table, XTENSA_LIT_SEC_NAME,
2026 input_size = bfd_get_section_limit (input_bfd, input_section);
2029 relend = relocs + input_section->reloc_count;
2030 for (; rel < relend; rel++)
2033 reloc_howto_type *howto;
2034 unsigned long r_symndx;
2035 struct elf_link_hash_entry *h;
2036 Elf_Internal_Sym *sym;
2039 bfd_reloc_status_type r;
2040 bfd_boolean is_weak_undef;
2041 bfd_boolean unresolved_reloc;
2044 r_type = ELF32_R_TYPE (rel->r_info);
2045 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2046 || r_type == (int) R_XTENSA_GNU_VTENTRY)
2049 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2051 bfd_set_error (bfd_error_bad_value);
2054 howto = &elf_howto_table[r_type];
2056 r_symndx = ELF32_R_SYM (rel->r_info);
2058 if (info->relocatable)
2060 /* This is a relocatable link.
2061 1) If the reloc is against a section symbol, adjust
2062 according to the output section.
2063 2) If there is a new target for this relocation,
2064 the new target will be in the same output section.
2065 We adjust the relocation by the output section
2068 if (relaxing_section)
2070 /* Check if this references a section in another input file. */
2071 if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2074 r_type = ELF32_R_TYPE (rel->r_info);
2077 if (r_type == R_XTENSA_ASM_SIMPLIFY)
2079 char *error_message = NULL;
2080 /* Convert ASM_SIMPLIFY into the simpler relocation
2081 so that they never escape a relaxing link. */
2082 r = contract_asm_expansion (contents, input_size, rel,
2084 if (r != bfd_reloc_ok)
2086 if (!((*info->callbacks->reloc_dangerous)
2087 (info, error_message, input_bfd, input_section,
2091 r_type = ELF32_R_TYPE (rel->r_info);
2094 /* This is a relocatable link, so we don't have to change
2095 anything unless the reloc is against a section symbol,
2096 in which case we have to adjust according to where the
2097 section symbol winds up in the output section. */
2098 if (r_symndx < symtab_hdr->sh_info)
2100 sym = local_syms + r_symndx;
2101 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2103 sec = local_sections[r_symndx];
2104 rel->r_addend += sec->output_offset + sym->st_value;
2108 /* If there is an addend with a partial_inplace howto,
2109 then move the addend to the contents. This is a hack
2110 to work around problems with DWARF in relocatable links
2111 with some previous version of BFD. Now we can't easily get
2112 rid of the hack without breaking backward compatibility.... */
2115 howto = &elf_howto_table[r_type];
2116 if (howto->partial_inplace)
2118 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2119 rel->r_addend, contents,
2120 rel->r_offset, FALSE,
2122 if (r != bfd_reloc_ok)
2124 if (!((*info->callbacks->reloc_dangerous)
2125 (info, error_message, input_bfd, input_section,
2133 /* Done with work for relocatable link; continue with next reloc. */
2137 /* This is a final link. */
2142 is_weak_undef = FALSE;
2143 unresolved_reloc = FALSE;
2146 if (howto->partial_inplace)
2148 /* Because R_XTENSA_32 was made partial_inplace to fix some
2149 problems with DWARF info in partial links, there may be
2150 an addend stored in the contents. Take it out of there
2151 and move it back into the addend field of the reloc. */
2152 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2153 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2156 if (r_symndx < symtab_hdr->sh_info)
2158 sym = local_syms + r_symndx;
2159 sec = local_sections[r_symndx];
2160 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2164 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2165 r_symndx, symtab_hdr, sym_hashes,
2167 unresolved_reloc, warned);
2170 && !unresolved_reloc
2171 && h->root.type == bfd_link_hash_undefweak)
2172 is_weak_undef = TRUE;
2175 if (relaxing_section)
2177 /* Check if this references a section in another input file. */
2178 do_fix_for_final_link (rel, input_bfd, input_section, contents,
2181 /* Update some already cached values. */
2182 r_type = ELF32_R_TYPE (rel->r_info);
2183 howto = &elf_howto_table[r_type];
2186 /* Sanity check the address. */
2187 if (rel->r_offset >= input_size
2188 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2190 (*_bfd_error_handler)
2191 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2192 input_bfd, input_section, rel->r_offset, input_size);
2193 bfd_set_error (bfd_error_bad_value);
2197 /* Generate dynamic relocations. */
2198 if (elf_hash_table (info)->dynamic_sections_created)
2200 bfd_boolean dynamic_symbol = xtensa_elf_dynamic_symbol_p (h, info);
2202 if (dynamic_symbol && is_operand_relocation (r_type))
2204 /* This is an error. The symbol's real value won't be known
2205 until runtime and it's likely to be out of range anyway. */
2206 const char *name = h->root.root.string;
2207 error_message = vsprint_msg ("invalid relocation for dynamic "
2209 strlen (name) + 2, name);
2210 if (!((*info->callbacks->reloc_dangerous)
2211 (info, error_message, input_bfd, input_section,
2215 else if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
2216 && (input_section->flags & SEC_ALLOC) != 0
2217 && (dynamic_symbol || info->shared))
2219 Elf_Internal_Rela outrel;
2223 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2228 BFD_ASSERT (srel != NULL);
2231 _bfd_elf_section_offset (output_bfd, info,
2232 input_section, rel->r_offset);
2234 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2235 memset (&outrel, 0, sizeof outrel);
2238 outrel.r_offset += (input_section->output_section->vma
2239 + input_section->output_offset);
2241 /* Complain if the relocation is in a read-only section
2242 and not in a literal pool. */
2243 if ((input_section->flags & SEC_READONLY) != 0
2244 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
2248 _("dynamic relocation in read-only section");
2249 if (!((*info->callbacks->reloc_dangerous)
2250 (info, error_message, input_bfd, input_section,
2257 outrel.r_addend = rel->r_addend;
2260 if (r_type == R_XTENSA_32)
2263 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2266 else /* r_type == R_XTENSA_PLT */
2269 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2271 /* Create the PLT entry and set the initial
2272 contents of the literal entry to the address of
2275 elf_xtensa_create_plt_entry (dynobj, output_bfd,
2278 unresolved_reloc = FALSE;
2282 /* Generate a RELATIVE relocation. */
2283 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2284 outrel.r_addend = 0;
2288 loc = (srel->contents
2289 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2290 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2291 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2296 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2297 because such sections are not SEC_ALLOC and thus ld.so will
2298 not process them. */
2299 if (unresolved_reloc
2300 && !((input_section->flags & SEC_DEBUGGING) != 0
2302 (*_bfd_error_handler)
2303 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
2306 (long) rel->r_offset,
2307 h->root.root.string);
2309 /* There's no point in calling bfd_perform_relocation here.
2310 Just go directly to our "special function". */
2311 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2312 relocation + rel->r_addend,
2313 contents, rel->r_offset, is_weak_undef,
2316 if (r != bfd_reloc_ok && !warned)
2320 BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
2321 BFD_ASSERT (error_message != NULL);
2324 name = h->root.root.string;
2327 name = bfd_elf_string_from_elf_section
2328 (input_bfd, symtab_hdr->sh_link, sym->st_name);
2329 if (name && *name == '\0')
2330 name = bfd_section_name (input_bfd, sec);
2334 if (rel->r_addend == 0)
2335 error_message = vsprint_msg (error_message, ": %s",
2336 strlen (name) + 2, name);
2338 error_message = vsprint_msg (error_message, ": (%s+0x%x)",
2340 name, rel->r_addend);
2343 if (!((*info->callbacks->reloc_dangerous)
2344 (info, error_message, input_bfd, input_section,
2353 input_section->reloc_done = TRUE;
2359 /* Finish up dynamic symbol handling. There's not much to do here since
2360 the PLT and GOT entries are all set up by relocate_section. */
2363 elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
2364 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2365 struct elf_link_hash_entry *h,
2366 Elf_Internal_Sym *sym)
2371 /* Mark the symbol as undefined, rather than as defined in
2372 the .plt section. Leave the value alone. */
2373 sym->st_shndx = SHN_UNDEF;
2376 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2377 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2378 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2379 sym->st_shndx = SHN_ABS;
2385 /* Combine adjacent literal table entries in the output. Adjacent
2386 entries within each input section may have been removed during
2387 relaxation, but we repeat the process here, even though it's too late
2388 to shrink the output section, because it's important to minimize the
2389 number of literal table entries to reduce the start-up work for the
2390 runtime linker. Returns the number of remaining table entries or -1
2394 elf_xtensa_combine_prop_entries (bfd *output_bfd,
2399 property_table_entry *table;
2400 bfd_size_type section_size, sgotloc_size;
2404 section_size = sxtlit->size;
2405 BFD_ASSERT (section_size % 8 == 0);
2406 num = section_size / 8;
2408 sgotloc_size = sgotloc->size;
2409 if (sgotloc_size != section_size)
2411 (*_bfd_error_handler)
2412 (_("internal inconsistency in size of .got.loc section"));
2416 table = bfd_malloc (num * sizeof (property_table_entry));
2420 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
2421 propagates to the output section, where it doesn't really apply and
2422 where it breaks the following call to bfd_malloc_and_get_section. */
2423 sxtlit->flags &= ~SEC_IN_MEMORY;
2425 if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
2433 /* There should never be any relocations left at this point, so this
2434 is quite a bit easier than what is done during relaxation. */
2436 /* Copy the raw contents into a property table array and sort it. */
2438 for (n = 0; n < num; n++)
2440 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
2441 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
2444 qsort (table, num, sizeof (property_table_entry), property_table_compare);
2446 for (n = 0; n < num; n++)
2448 bfd_boolean remove = FALSE;
2450 if (table[n].size == 0)
2453 (table[n-1].address + table[n-1].size == table[n].address))
2455 table[n-1].size += table[n].size;
2461 for (m = n; m < num - 1; m++)
2463 table[m].address = table[m+1].address;
2464 table[m].size = table[m+1].size;
2472 /* Copy the data back to the raw contents. */
2474 for (n = 0; n < num; n++)
2476 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
2477 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
2481 /* Clear the removed bytes. */
2482 if ((bfd_size_type) (num * 8) < section_size)
2483 memset (&contents[num * 8], 0, section_size - num * 8);
2485 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
2489 /* Copy the contents to ".got.loc". */
2490 memcpy (sgotloc->contents, contents, section_size);
2498 /* Finish up the dynamic sections. */
2501 elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
2502 struct bfd_link_info *info)
2505 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
2506 Elf32_External_Dyn *dyncon, *dynconend;
2507 int num_xtlit_entries;
2509 if (! elf_hash_table (info)->dynamic_sections_created)
2512 dynobj = elf_hash_table (info)->dynobj;
2513 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2514 BFD_ASSERT (sdyn != NULL);
2516 /* Set the first entry in the global offset table to the address of
2517 the dynamic section. */
2518 sgot = bfd_get_section_by_name (dynobj, ".got");
2521 BFD_ASSERT (sgot->size == 4);
2523 bfd_put_32 (output_bfd, 0, sgot->contents);
2525 bfd_put_32 (output_bfd,
2526 sdyn->output_section->vma + sdyn->output_offset,
2530 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
2531 if (srelplt && srelplt->size != 0)
2533 asection *sgotplt, *srelgot, *spltlittbl;
2534 int chunk, plt_chunks, plt_entries;
2535 Elf_Internal_Rela irela;
2537 unsigned rtld_reloc;
2539 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
2540 BFD_ASSERT (srelgot != NULL);
2542 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
2543 BFD_ASSERT (spltlittbl != NULL);
2545 /* Find the first XTENSA_RTLD relocation. Presumably the rest
2546 of them follow immediately after.... */
2547 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
2549 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2550 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2551 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
2554 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
2556 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
2558 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
2560 for (chunk = 0; chunk < plt_chunks; chunk++)
2562 int chunk_entries = 0;
2564 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
2565 BFD_ASSERT (sgotplt != NULL);
2567 /* Emit special RTLD relocations for the first two entries in
2568 each chunk of the .got.plt section. */
2570 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2571 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2572 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2573 irela.r_offset = (sgotplt->output_section->vma
2574 + sgotplt->output_offset);
2575 irela.r_addend = 1; /* tell rtld to set value to resolver function */
2576 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2578 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2580 /* Next literal immediately follows the first. */
2581 loc += sizeof (Elf32_External_Rela);
2582 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2583 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2584 irela.r_offset = (sgotplt->output_section->vma
2585 + sgotplt->output_offset + 4);
2586 /* Tell rtld to set value to object's link map. */
2588 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2590 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2592 /* Fill in the literal table. */
2593 if (chunk < plt_chunks - 1)
2594 chunk_entries = PLT_ENTRIES_PER_CHUNK;
2596 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
2598 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
2599 bfd_put_32 (output_bfd,
2600 sgotplt->output_section->vma + sgotplt->output_offset,
2601 spltlittbl->contents + (chunk * 8) + 0);
2602 bfd_put_32 (output_bfd,
2603 8 + (chunk_entries * 4),
2604 spltlittbl->contents + (chunk * 8) + 4);
2607 /* All the dynamic relocations have been emitted at this point.
2608 Make sure the relocation sections are the correct size. */
2609 if (srelgot->size != (sizeof (Elf32_External_Rela)
2610 * srelgot->reloc_count)
2611 || srelplt->size != (sizeof (Elf32_External_Rela)
2612 * srelplt->reloc_count))
2615 /* The .xt.lit.plt section has just been modified. This must
2616 happen before the code below which combines adjacent literal
2617 table entries, and the .xt.lit.plt contents have to be forced to
2619 if (! bfd_set_section_contents (output_bfd,
2620 spltlittbl->output_section,
2621 spltlittbl->contents,
2622 spltlittbl->output_offset,
2625 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
2626 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
2629 /* Combine adjacent literal table entries. */
2630 BFD_ASSERT (! info->relocatable);
2631 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
2632 sgotloc = bfd_get_section_by_name (dynobj, ".got.loc");
2633 BFD_ASSERT (sxtlit && sgotloc);
2635 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
2636 if (num_xtlit_entries < 0)
2639 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2640 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2641 for (; dyncon < dynconend; dyncon++)
2643 Elf_Internal_Dyn dyn;
2647 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2654 case DT_XTENSA_GOT_LOC_SZ:
2655 dyn.d_un.d_val = num_xtlit_entries;
2658 case DT_XTENSA_GOT_LOC_OFF:
2667 s = bfd_get_section_by_name (output_bfd, name);
2669 dyn.d_un.d_ptr = s->vma;
2673 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2675 dyn.d_un.d_val = s->size;
2679 /* Adjust RELASZ to not include JMPREL. This matches what
2680 glibc expects and what is done for several other ELF
2681 targets (e.g., i386, alpha), but the "correct" behavior
2682 seems to be unresolved. Since the linker script arranges
2683 for .rela.plt to follow all other relocation sections, we
2684 don't have to worry about changing the DT_RELA entry. */
2685 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2687 dyn.d_un.d_val -= s->size;
2691 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2698 /* Functions for dealing with the e_flags field. */
2700 /* Merge backend specific data from an object file to the output
2701 object file when linking. */
2704 elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2706 unsigned out_mach, in_mach;
2707 flagword out_flag, in_flag;
2709 /* Check if we have the same endianess. */
2710 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
2713 /* Don't even pretend to support mixed-format linking. */
2714 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2715 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2718 out_flag = elf_elfheader (obfd)->e_flags;
2719 in_flag = elf_elfheader (ibfd)->e_flags;
2721 out_mach = out_flag & EF_XTENSA_MACH;
2722 in_mach = in_flag & EF_XTENSA_MACH;
2723 if (out_mach != in_mach)
2725 (*_bfd_error_handler)
2726 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
2727 ibfd, out_mach, in_mach);
2728 bfd_set_error (bfd_error_wrong_format);
2732 if (! elf_flags_init (obfd))
2734 elf_flags_init (obfd) = TRUE;
2735 elf_elfheader (obfd)->e_flags = in_flag;
2737 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2738 && bfd_get_arch_info (obfd)->the_default)
2739 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2740 bfd_get_mach (ibfd));
2745 if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
2746 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
2748 if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
2749 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
2756 elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
2758 BFD_ASSERT (!elf_flags_init (abfd)
2759 || elf_elfheader (abfd)->e_flags == flags);
2761 elf_elfheader (abfd)->e_flags |= flags;
2762 elf_flags_init (abfd) = TRUE;
2769 elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
2771 FILE *f = (FILE *) farg;
2772 flagword e_flags = elf_elfheader (abfd)->e_flags;
2774 fprintf (f, "\nXtensa header:\n");
2775 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
2776 fprintf (f, "\nMachine = Base\n");
2778 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
2780 fprintf (f, "Insn tables = %s\n",
2781 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
2783 fprintf (f, "Literal tables = %s\n",
2784 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
2786 return _bfd_elf_print_private_bfd_data (abfd, farg);
2790 /* Set the right machine number for an Xtensa ELF file. */
2793 elf_xtensa_object_p (bfd *abfd)
2796 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
2801 mach = bfd_mach_xtensa;
2807 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
2812 /* The final processing done just before writing out an Xtensa ELF object
2813 file. This gets the Xtensa architecture right based on the machine
2817 elf_xtensa_final_write_processing (bfd *abfd,
2818 bfd_boolean linker ATTRIBUTE_UNUSED)
2823 switch (mach = bfd_get_mach (abfd))
2825 case bfd_mach_xtensa:
2826 val = E_XTENSA_MACH;
2832 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
2833 elf_elfheader (abfd)->e_flags |= val;
2837 static enum elf_reloc_type_class
2838 elf_xtensa_reloc_type_class (const Elf_Internal_Rela *rela)
2840 switch ((int) ELF32_R_TYPE (rela->r_info))
2842 case R_XTENSA_RELATIVE:
2843 return reloc_class_relative;
2844 case R_XTENSA_JMP_SLOT:
2845 return reloc_class_plt;
2847 return reloc_class_normal;
2853 elf_xtensa_discard_info_for_section (bfd *abfd,
2854 struct elf_reloc_cookie *cookie,
2855 struct bfd_link_info *info,
2859 bfd_vma section_size;
2860 bfd_vma offset, actual_offset;
2861 size_t removed_bytes = 0;
2863 section_size = sec->size;
2864 if (section_size == 0 || section_size % 8 != 0)
2867 if (sec->output_section
2868 && bfd_is_abs_section (sec->output_section))
2871 contents = retrieve_contents (abfd, sec, info->keep_memory);
2875 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
2878 release_contents (sec, contents);
2882 cookie->rel = cookie->rels;
2883 cookie->relend = cookie->rels + sec->reloc_count;
2885 for (offset = 0; offset < section_size; offset += 8)
2887 actual_offset = offset - removed_bytes;
2889 /* The ...symbol_deleted_p function will skip over relocs but it
2890 won't adjust their offsets, so do that here. */
2891 while (cookie->rel < cookie->relend
2892 && cookie->rel->r_offset < offset)
2894 cookie->rel->r_offset -= removed_bytes;
2898 while (cookie->rel < cookie->relend
2899 && cookie->rel->r_offset == offset)
2901 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
2903 /* Remove the table entry. (If the reloc type is NONE, then
2904 the entry has already been merged with another and deleted
2905 during relaxation.) */
2906 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
2908 /* Shift the contents up. */
2909 if (offset + 8 < section_size)
2910 memmove (&contents[actual_offset],
2911 &contents[actual_offset+8],
2912 section_size - offset - 8);
2916 /* Remove this relocation. */
2917 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
2920 /* Adjust the relocation offset for previous removals. This
2921 should not be done before calling ...symbol_deleted_p
2922 because it might mess up the offset comparisons there.
2923 Make sure the offset doesn't underflow in the case where
2924 the first entry is removed. */
2925 if (cookie->rel->r_offset >= removed_bytes)
2926 cookie->rel->r_offset -= removed_bytes;
2928 cookie->rel->r_offset = 0;
2934 if (removed_bytes != 0)
2936 /* Adjust any remaining relocs (shouldn't be any). */
2937 for (; cookie->rel < cookie->relend; cookie->rel++)
2939 if (cookie->rel->r_offset >= removed_bytes)
2940 cookie->rel->r_offset -= removed_bytes;
2942 cookie->rel->r_offset = 0;
2945 /* Clear the removed bytes. */
2946 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
2948 pin_contents (sec, contents);
2949 pin_internal_relocs (sec, cookie->rels);
2952 sec->size = section_size - removed_bytes;
2954 if (xtensa_is_littable_section (sec))
2956 bfd *dynobj = elf_hash_table (info)->dynobj;
2960 bfd_get_section_by_name (dynobj, ".got.loc");
2962 sgotloc->size -= removed_bytes;
2968 release_contents (sec, contents);
2969 release_internal_relocs (sec, cookie->rels);
2972 return (removed_bytes != 0);
2977 elf_xtensa_discard_info (bfd *abfd,
2978 struct elf_reloc_cookie *cookie,
2979 struct bfd_link_info *info)
2982 bfd_boolean changed = FALSE;
2984 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2986 if (xtensa_is_property_section (sec))
2988 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
2998 elf_xtensa_ignore_discarded_relocs (asection *sec)
3000 return xtensa_is_property_section (sec);
3004 /* Support for core dump NOTE sections. */
3007 elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3012 /* The size for Xtensa is variable, so don't try to recognize the format
3013 based on the size. Just assume this is GNU/Linux. */
3016 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3019 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
3023 size = note->descsz - offset - 4;
3025 /* Make a ".reg/999" section. */
3026 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3027 size, note->descpos + offset);
3032 elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3034 switch (note->descsz)
3039 case 128: /* GNU/Linux elf_prpsinfo */
3040 elf_tdata (abfd)->core_program
3041 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3042 elf_tdata (abfd)->core_command
3043 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3046 /* Note that for some reason, a spurious space is tacked
3047 onto the end of the args in some (at least one anyway)
3048 implementations, so strip it off if it exists. */
3051 char *command = elf_tdata (abfd)->core_command;
3052 int n = strlen (command);
3054 if (0 < n && command[n - 1] == ' ')
3055 command[n - 1] = '\0';
3062 /* Generic Xtensa configurability stuff. */
3064 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3065 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3066 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3067 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3068 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3069 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3070 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3071 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3074 init_call_opcodes (void)
3076 if (callx0_op == XTENSA_UNDEFINED)
3078 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3079 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3080 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3081 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3082 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3083 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3084 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3085 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3091 is_indirect_call_opcode (xtensa_opcode opcode)
3093 init_call_opcodes ();
3094 return (opcode == callx0_op
3095 || opcode == callx4_op
3096 || opcode == callx8_op
3097 || opcode == callx12_op);
3102 is_direct_call_opcode (xtensa_opcode opcode)
3104 init_call_opcodes ();
3105 return (opcode == call0_op
3106 || opcode == call4_op
3107 || opcode == call8_op
3108 || opcode == call12_op);
3113 is_windowed_call_opcode (xtensa_opcode opcode)
3115 init_call_opcodes ();
3116 return (opcode == call4_op
3117 || opcode == call8_op
3118 || opcode == call12_op
3119 || opcode == callx4_op
3120 || opcode == callx8_op
3121 || opcode == callx12_op);
3125 static xtensa_opcode
3126 get_const16_opcode (void)
3128 static bfd_boolean done_lookup = FALSE;
3129 static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3132 const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3135 return const16_opcode;
3139 static xtensa_opcode
3140 get_l32r_opcode (void)
3142 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
3143 static bfd_boolean done_lookup = FALSE;
3147 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
3155 l32r_offset (bfd_vma addr, bfd_vma pc)
3159 offset = addr - ((pc+3) & -4);
3160 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3161 offset = (signed int) offset >> 2;
3162 BFD_ASSERT ((signed int) offset >> 16 == -1);
3168 get_relocation_opnd (xtensa_opcode opcode, int r_type)
3170 xtensa_isa isa = xtensa_default_isa;
3171 int last_immed, last_opnd, opi;
3173 if (opcode == XTENSA_UNDEFINED)
3174 return XTENSA_UNDEFINED;
3176 /* Find the last visible PC-relative immediate operand for the opcode.
3177 If there are no PC-relative immediates, then choose the last visible
3178 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3179 last_immed = XTENSA_UNDEFINED;
3180 last_opnd = xtensa_opcode_num_operands (isa, opcode);
3181 for (opi = last_opnd - 1; opi >= 0; opi--)
3183 if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
3185 if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
3190 if (last_immed == XTENSA_UNDEFINED
3191 && xtensa_operand_is_register (isa, opcode, opi) == 0)
3195 return XTENSA_UNDEFINED;
3197 /* If the operand number was specified in an old-style relocation,
3198 check for consistency with the operand computed above. */
3199 if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
3201 int reloc_opnd = r_type - R_XTENSA_OP0;
3202 if (reloc_opnd != last_immed)
3203 return XTENSA_UNDEFINED;
3211 get_relocation_slot (int r_type)
3221 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
3222 return r_type - R_XTENSA_SLOT0_OP;
3223 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
3224 return r_type - R_XTENSA_SLOT0_ALT;
3228 return XTENSA_UNDEFINED;
3232 /* Get the opcode for a relocation. */
3234 static xtensa_opcode
3235 get_relocation_opcode (bfd *abfd,
3238 Elf_Internal_Rela *irel)
3240 static xtensa_insnbuf ibuff = NULL;
3241 static xtensa_insnbuf sbuff = NULL;
3242 xtensa_isa isa = xtensa_default_isa;
3246 if (contents == NULL)
3247 return XTENSA_UNDEFINED;
3249 if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
3250 return XTENSA_UNDEFINED;
3254 ibuff = xtensa_insnbuf_alloc (isa);
3255 sbuff = xtensa_insnbuf_alloc (isa);
3258 /* Decode the instruction. */
3259 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
3260 sec->size - irel->r_offset);
3261 fmt = xtensa_format_decode (isa, ibuff);
3262 slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
3263 if (slot == XTENSA_UNDEFINED)
3264 return XTENSA_UNDEFINED;
3265 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
3266 return xtensa_opcode_decode (isa, fmt, slot, sbuff);
3271 is_l32r_relocation (bfd *abfd,
3274 Elf_Internal_Rela *irel)
3276 xtensa_opcode opcode;
3277 if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
3279 opcode = get_relocation_opcode (abfd, sec, contents, irel);
3280 return (opcode == get_l32r_opcode ());
3284 static bfd_size_type
3285 get_asm_simplify_size (bfd_byte *contents,
3286 bfd_size_type content_len,
3287 bfd_size_type offset)
3289 bfd_size_type insnlen, size = 0;
3291 /* Decode the size of the next two instructions. */
3292 insnlen = insn_decode_len (contents, content_len, offset);
3298 insnlen = insn_decode_len (contents, content_len, offset + size);
3308 is_alt_relocation (int r_type)
3310 return (r_type >= R_XTENSA_SLOT0_ALT
3311 && r_type <= R_XTENSA_SLOT14_ALT);
3316 is_operand_relocation (int r_type)
3326 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
3328 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
3337 #define MIN_INSN_LENGTH 2
3339 /* Return 0 if it fails to decode. */
3342 insn_decode_len (bfd_byte *contents,
3343 bfd_size_type content_len,
3344 bfd_size_type offset)
3347 xtensa_isa isa = xtensa_default_isa;
3349 static xtensa_insnbuf ibuff = NULL;
3351 if (offset + MIN_INSN_LENGTH > content_len)
3355 ibuff = xtensa_insnbuf_alloc (isa);
3356 xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
3357 content_len - offset);
3358 fmt = xtensa_format_decode (isa, ibuff);
3359 if (fmt == XTENSA_UNDEFINED)
3361 insn_len = xtensa_format_length (isa, fmt);
3362 if (insn_len == XTENSA_UNDEFINED)
3368 /* Decode the opcode for a single slot instruction.
3369 Return 0 if it fails to decode or the instruction is multi-slot. */
3372 insn_decode_opcode (bfd_byte *contents,
3373 bfd_size_type content_len,
3374 bfd_size_type offset,
3377 xtensa_isa isa = xtensa_default_isa;
3379 static xtensa_insnbuf insnbuf = NULL;
3380 static xtensa_insnbuf slotbuf = NULL;
3382 if (offset + MIN_INSN_LENGTH > content_len)
3383 return XTENSA_UNDEFINED;
3385 if (insnbuf == NULL)
3387 insnbuf = xtensa_insnbuf_alloc (isa);
3388 slotbuf = xtensa_insnbuf_alloc (isa);
3391 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
3392 content_len - offset);
3393 fmt = xtensa_format_decode (isa, insnbuf);
3394 if (fmt == XTENSA_UNDEFINED)
3395 return XTENSA_UNDEFINED;
3397 if (slot >= xtensa_format_num_slots (isa, fmt))
3398 return XTENSA_UNDEFINED;
3400 xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
3401 return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
3405 /* The offset is the offset in the contents.
3406 The address is the address of that offset. */
3409 check_branch_target_aligned (bfd_byte *contents,
3410 bfd_size_type content_length,
3414 bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
3417 return check_branch_target_aligned_address (address, insn_len);
3422 check_loop_aligned (bfd_byte *contents,
3423 bfd_size_type content_length,
3427 bfd_size_type loop_len, insn_len;
3428 xtensa_opcode opcode =
3429 insn_decode_opcode (contents, content_length, offset, 0);
3430 BFD_ASSERT (opcode != XTENSA_UNDEFINED);
3431 if (opcode != XTENSA_UNDEFINED)
3433 BFD_ASSERT (xtensa_opcode_is_loop (xtensa_default_isa, opcode));
3434 if (!xtensa_opcode_is_loop (xtensa_default_isa, opcode))
3437 loop_len = insn_decode_len (contents, content_length, offset);
3438 BFD_ASSERT (loop_len != 0);
3442 insn_len = insn_decode_len (contents, content_length, offset + loop_len);
3443 BFD_ASSERT (insn_len != 0);
3447 return check_branch_target_aligned_address (address + loop_len, insn_len);
3452 check_branch_target_aligned_address (bfd_vma addr, int len)
3455 return (addr % 8 == 0);
3456 return ((addr >> 2) == ((addr + len - 1) >> 2));
3460 /* Instruction widening and narrowing. */
3462 /* When FLIX is available we need to access certain instructions only
3463 when they are 16-bit or 24-bit instructions. This table caches
3464 information about such instructions by walking through all the
3465 opcodes and finding the smallest single-slot format into which each
3468 static xtensa_format *op_single_fmt_table = NULL;
3472 init_op_single_format_table (void)
3474 xtensa_isa isa = xtensa_default_isa;
3475 xtensa_insnbuf ibuf;
3476 xtensa_opcode opcode;
3480 if (op_single_fmt_table)
3483 ibuf = xtensa_insnbuf_alloc (isa);
3484 num_opcodes = xtensa_isa_num_opcodes (isa);
3486 op_single_fmt_table = (xtensa_format *)
3487 bfd_malloc (sizeof (xtensa_format) * num_opcodes);
3488 for (opcode = 0; opcode < num_opcodes; opcode++)
3490 op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
3491 for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
3493 if (xtensa_format_num_slots (isa, fmt) == 1
3494 && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
3496 xtensa_opcode old_fmt = op_single_fmt_table[opcode];
3497 int fmt_length = xtensa_format_length (isa, fmt);
3498 if (old_fmt == XTENSA_UNDEFINED
3499 || fmt_length < xtensa_format_length (isa, old_fmt))
3500 op_single_fmt_table[opcode] = fmt;
3504 xtensa_insnbuf_free (isa, ibuf);
3508 static xtensa_format
3509 get_single_format (xtensa_opcode opcode)
3511 init_op_single_format_table ();
3512 return op_single_fmt_table[opcode];
3516 /* For the set of narrowable instructions we do NOT include the
3517 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
3518 involved during linker relaxation that may require these to
3519 re-expand in some conditions. Also, the narrowing "or" -> mov.n
3520 requires special case code to ensure it only works when op1 == op2. */
3528 struct string_pair narrowable[] =
3531 { "addi", "addi.n" },
3532 { "addmi", "addi.n" },
3533 { "l32i", "l32i.n" },
3534 { "movi", "movi.n" },
3536 { "retw", "retw.n" },
3537 { "s32i", "s32i.n" },
3538 { "or", "mov.n" } /* special case only when op1 == op2 */
3541 struct string_pair widenable[] =
3544 { "addi", "addi.n" },
3545 { "addmi", "addi.n" },
3546 { "beqz", "beqz.n" },
3547 { "bnez", "bnez.n" },
3548 { "l32i", "l32i.n" },
3549 { "movi", "movi.n" },
3551 { "retw", "retw.n" },
3552 { "s32i", "s32i.n" },
3553 { "or", "mov.n" } /* special case only when op1 == op2 */
3557 /* Attempt to narrow an instruction. Return true if the narrowing is
3558 valid. If the do_it parameter is non-zero, then perform the action
3559 in-place directly into the contents. Otherwise, do not modify the
3560 contents. The set of valid narrowing are specified by a string table
3561 but require some special case operand checks in some cases. */
3564 narrow_instruction (bfd_byte *contents,
3565 bfd_size_type content_length,
3566 bfd_size_type offset,
3569 xtensa_opcode opcode;
3570 bfd_size_type insn_len, opi;
3571 xtensa_isa isa = xtensa_default_isa;
3572 xtensa_format fmt, o_fmt;
3574 static xtensa_insnbuf insnbuf = NULL;
3575 static xtensa_insnbuf slotbuf = NULL;
3576 static xtensa_insnbuf o_insnbuf = NULL;
3577 static xtensa_insnbuf o_slotbuf = NULL;
3579 if (insnbuf == NULL)
3581 insnbuf = xtensa_insnbuf_alloc (isa);
3582 slotbuf = xtensa_insnbuf_alloc (isa);
3583 o_insnbuf = xtensa_insnbuf_alloc (isa);
3584 o_slotbuf = xtensa_insnbuf_alloc (isa);
3587 BFD_ASSERT (offset < content_length);
3589 if (content_length < 2)
3592 /* We will hand-code a few of these for a little while.
3593 These have all been specified in the assembler aleady. */
3594 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
3595 content_length - offset);
3596 fmt = xtensa_format_decode (isa, insnbuf);
3597 if (xtensa_format_num_slots (isa, fmt) != 1)
3600 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
3603 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
3604 if (opcode == XTENSA_UNDEFINED)
3606 insn_len = xtensa_format_length (isa, fmt);
3607 if (insn_len > content_length)
3610 for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); ++opi)
3612 bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
3614 if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
3616 uint32 value, newval;
3617 int i, operand_count, o_operand_count;
3618 xtensa_opcode o_opcode;
3620 /* Address does not matter in this case. We might need to
3621 fix it to handle branches/jumps. */
3622 bfd_vma self_address = 0;
3624 o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
3625 if (o_opcode == XTENSA_UNDEFINED)
3627 o_fmt = get_single_format (o_opcode);
3628 if (o_fmt == XTENSA_UNDEFINED)
3631 if (xtensa_format_length (isa, fmt) != 3
3632 || xtensa_format_length (isa, o_fmt) != 2)
3635 xtensa_format_encode (isa, o_fmt, o_insnbuf);
3636 operand_count = xtensa_opcode_num_operands (isa, opcode);
3637 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
3639 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
3644 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
3649 uint32 rawval0, rawval1, rawval2;
3651 if (o_operand_count + 1 != operand_count)
3653 if (xtensa_operand_get_field (isa, opcode, 0,
3654 fmt, 0, slotbuf, &rawval0) != 0)
3656 if (xtensa_operand_get_field (isa, opcode, 1,
3657 fmt, 0, slotbuf, &rawval1) != 0)
3659 if (xtensa_operand_get_field (isa, opcode, 2,
3660 fmt, 0, slotbuf, &rawval2) != 0)
3663 if (rawval1 != rawval2)
3665 if (rawval0 == rawval1) /* it is a nop */
3669 for (i = 0; i < o_operand_count; ++i)
3671 if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
3673 || xtensa_operand_decode (isa, opcode, i, &value))
3676 /* PC-relative branches need adjustment, but
3677 the PC-rel operand will always have a relocation. */
3679 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
3681 || xtensa_operand_encode (isa, o_opcode, i, &newval)
3682 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
3687 if (xtensa_format_set_slot (isa, o_fmt, 0,
3688 o_insnbuf, o_slotbuf) != 0)
3692 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
3693 content_length - offset);
3701 /* Attempt to widen an instruction. Return true if the widening is
3702 valid. If the do_it parameter is non-zero, then the action should
3703 be performed inplace into the contents. Otherwise, do not modify
3704 the contents. The set of valid widenings are specified by a string
3705 table but require some special case operand checks in some
3709 widen_instruction (bfd_byte *contents,
3710 bfd_size_type content_length,
3711 bfd_size_type offset,
3714 xtensa_opcode opcode;
3715 bfd_size_type insn_len, opi;
3716 xtensa_isa isa = xtensa_default_isa;
3717 xtensa_format fmt, o_fmt;
3719 static xtensa_insnbuf insnbuf = NULL;
3720 static xtensa_insnbuf slotbuf = NULL;
3721 static xtensa_insnbuf o_insnbuf = NULL;
3722 static xtensa_insnbuf o_slotbuf = NULL;
3724 if (insnbuf == NULL)
3726 insnbuf = xtensa_insnbuf_alloc (isa);
3727 slotbuf = xtensa_insnbuf_alloc (isa);
3728 o_insnbuf = xtensa_insnbuf_alloc (isa);
3729 o_slotbuf = xtensa_insnbuf_alloc (isa);
3732 BFD_ASSERT (offset < content_length);
3734 if (content_length < 2)
3737 /* We will hand code a few of these for a little while.
3738 These have all been specified in the assembler aleady. */
3739 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
3740 content_length - offset);
3741 fmt = xtensa_format_decode (isa, insnbuf);
3742 if (xtensa_format_num_slots (isa, fmt) != 1)
3745 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
3748 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
3749 if (opcode == XTENSA_UNDEFINED)
3751 insn_len = xtensa_format_length (isa, fmt);
3752 if (insn_len > content_length)
3755 for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); ++opi)
3757 bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
3758 bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
3759 || strcmp ("bnez", widenable[opi].wide) == 0);
3761 if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
3763 uint32 value, newval;
3764 int i, operand_count, o_operand_count, check_operand_count;
3765 xtensa_opcode o_opcode;
3767 /* Address does not matter in this case. We might need to fix it
3768 to handle branches/jumps. */
3769 bfd_vma self_address = 0;
3771 o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
3772 if (o_opcode == XTENSA_UNDEFINED)
3774 o_fmt = get_single_format (o_opcode);
3775 if (o_fmt == XTENSA_UNDEFINED)
3778 if (xtensa_format_length (isa, fmt) != 2
3779 || xtensa_format_length (isa, o_fmt) != 3)
3782 xtensa_format_encode (isa, o_fmt, o_insnbuf);
3783 operand_count = xtensa_opcode_num_operands (isa, opcode);
3784 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
3785 check_operand_count = o_operand_count;
3787 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
3792 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
3797 uint32 rawval0, rawval1;
3799 if (o_operand_count != operand_count + 1)
3801 if (xtensa_operand_get_field (isa, opcode, 0,
3802 fmt, 0, slotbuf, &rawval0) != 0)
3804 if (xtensa_operand_get_field (isa, opcode, 1,
3805 fmt, 0, slotbuf, &rawval1) != 0)
3807 if (rawval0 == rawval1) /* it is a nop */
3811 check_operand_count--;
3813 for (i = 0; i < check_operand_count; ++i)
3816 if (is_or && i == o_operand_count - 1)
3818 if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
3820 || xtensa_operand_decode (isa, opcode, new_i, &value))
3823 /* PC-relative branches need adjustment, but
3824 the PC-rel operand will always have a relocation. */
3826 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
3828 || xtensa_operand_encode (isa, o_opcode, i, &newval)
3829 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
3834 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
3838 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
3839 content_length - offset);
3847 /* Code for transforming CALLs at link-time. */
3849 static bfd_reloc_status_type
3850 elf_xtensa_do_asm_simplify (bfd_byte *contents,
3852 bfd_vma content_length,
3853 char **error_message)
3855 static xtensa_insnbuf insnbuf = NULL;
3856 static xtensa_insnbuf slotbuf = NULL;
3857 xtensa_format core_format = XTENSA_UNDEFINED;
3858 xtensa_opcode opcode;
3859 xtensa_opcode direct_call_opcode;
3860 xtensa_isa isa = xtensa_default_isa;
3861 bfd_byte *chbuf = contents + address;
3864 if (insnbuf == NULL)
3866 insnbuf = xtensa_insnbuf_alloc (isa);
3867 slotbuf = xtensa_insnbuf_alloc (isa);
3870 if (content_length < address)
3872 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
3873 return bfd_reloc_other;
3876 opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
3877 direct_call_opcode = swap_callx_for_call_opcode (opcode);
3878 if (direct_call_opcode == XTENSA_UNDEFINED)
3880 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
3881 return bfd_reloc_other;
3884 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
3885 core_format = xtensa_format_lookup (isa, "x24");
3886 opcode = xtensa_opcode_lookup (isa, "or");
3887 xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
3888 for (opn = 0; opn < 3; opn++)
3891 xtensa_operand_encode (isa, opcode, opn, ®no);
3892 xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
3895 xtensa_format_encode (isa, core_format, insnbuf);
3896 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
3897 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
3899 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
3900 xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
3901 xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
3903 xtensa_format_encode (isa, core_format, insnbuf);
3904 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
3905 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
3906 content_length - address - 3);
3908 return bfd_reloc_ok;
3912 static bfd_reloc_status_type
3913 contract_asm_expansion (bfd_byte *contents,
3914 bfd_vma content_length,
3915 Elf_Internal_Rela *irel,
3916 char **error_message)
3918 bfd_reloc_status_type retval =
3919 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
3922 if (retval != bfd_reloc_ok)
3923 return bfd_reloc_dangerous;
3925 /* Update the irel->r_offset field so that the right immediate and
3926 the right instruction are modified during the relocation. */
3927 irel->r_offset += 3;
3928 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
3929 return bfd_reloc_ok;
3933 static xtensa_opcode
3934 swap_callx_for_call_opcode (xtensa_opcode opcode)
3936 init_call_opcodes ();
3938 if (opcode == callx0_op) return call0_op;
3939 if (opcode == callx4_op) return call4_op;
3940 if (opcode == callx8_op) return call8_op;
3941 if (opcode == callx12_op) return call12_op;
3943 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
3944 return XTENSA_UNDEFINED;
3948 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
3949 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
3950 If not, return XTENSA_UNDEFINED. */
3952 #define L32R_TARGET_REG_OPERAND 0
3953 #define CONST16_TARGET_REG_OPERAND 0
3954 #define CALLN_SOURCE_OPERAND 0
3956 static xtensa_opcode
3957 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
3959 static xtensa_insnbuf insnbuf = NULL;
3960 static xtensa_insnbuf slotbuf = NULL;
3962 xtensa_opcode opcode;
3963 xtensa_isa isa = xtensa_default_isa;
3964 uint32 regno, const16_regno, call_regno;
3967 if (insnbuf == NULL)
3969 insnbuf = xtensa_insnbuf_alloc (isa);
3970 slotbuf = xtensa_insnbuf_alloc (isa);
3973 xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
3974 fmt = xtensa_format_decode (isa, insnbuf);
3975 if (fmt == XTENSA_UNDEFINED
3976 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
3977 return XTENSA_UNDEFINED;
3979 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
3980 if (opcode == XTENSA_UNDEFINED)
3981 return XTENSA_UNDEFINED;
3983 if (opcode == get_l32r_opcode ())
3986 *p_uses_l32r = TRUE;
3987 if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
3988 fmt, 0, slotbuf, ®no)
3989 || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
3991 return XTENSA_UNDEFINED;
3993 else if (opcode == get_const16_opcode ())
3996 *p_uses_l32r = FALSE;
3997 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
3998 fmt, 0, slotbuf, ®no)
3999 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4001 return XTENSA_UNDEFINED;
4003 /* Check that the next instruction is also CONST16. */
4004 offset += xtensa_format_length (isa, fmt);
4005 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4006 fmt = xtensa_format_decode (isa, insnbuf);
4007 if (fmt == XTENSA_UNDEFINED
4008 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4009 return XTENSA_UNDEFINED;
4010 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4011 if (opcode != get_const16_opcode ())
4012 return XTENSA_UNDEFINED;
4014 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4015 fmt, 0, slotbuf, &const16_regno)
4016 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4018 || const16_regno != regno)
4019 return XTENSA_UNDEFINED;
4022 return XTENSA_UNDEFINED;
4024 /* Next instruction should be an CALLXn with operand 0 == regno. */
4025 offset += xtensa_format_length (isa, fmt);
4026 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4027 fmt = xtensa_format_decode (isa, insnbuf);
4028 if (fmt == XTENSA_UNDEFINED
4029 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4030 return XTENSA_UNDEFINED;
4031 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4032 if (opcode == XTENSA_UNDEFINED
4033 || !is_indirect_call_opcode (opcode))
4034 return XTENSA_UNDEFINED;
4036 if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4037 fmt, 0, slotbuf, &call_regno)
4038 || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4040 return XTENSA_UNDEFINED;
4042 if (call_regno != regno)
4043 return XTENSA_UNDEFINED;
4049 /* Data structures used during relaxation. */
4051 /* r_reloc: relocation values. */
4053 /* Through the relaxation process, we need to keep track of the values
4054 that will result from evaluating relocations. The standard ELF
4055 relocation structure is not sufficient for this purpose because we're
4056 operating on multiple input files at once, so we need to know which
4057 input file a relocation refers to. The r_reloc structure thus
4058 records both the input file (bfd) and ELF relocation.
4060 For efficiency, an r_reloc also contains a "target_offset" field to
4061 cache the target-section-relative offset value that is represented by
4064 The r_reloc also contains a virtual offset that allows multiple
4065 inserted literals to be placed at the same "address" with
4066 different offsets. */
4068 typedef struct r_reloc_struct r_reloc;
4070 struct r_reloc_struct
4073 Elf_Internal_Rela rela;
4074 bfd_vma target_offset;
4075 bfd_vma virtual_offset;
4079 /* The r_reloc structure is included by value in literal_value, but not
4080 every literal_value has an associated relocation -- some are simple
4081 constants. In such cases, we set all the fields in the r_reloc
4082 struct to zero. The r_reloc_is_const function should be used to
4083 detect this case. */
4086 r_reloc_is_const (const r_reloc *r_rel)
4088 return (r_rel->abfd == NULL);
4093 r_reloc_get_target_offset (const r_reloc *r_rel)
4095 bfd_vma target_offset;
4096 unsigned long r_symndx;
4098 BFD_ASSERT (!r_reloc_is_const (r_rel));
4099 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4100 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4101 return (target_offset + r_rel->rela.r_addend);
4105 static struct elf_link_hash_entry *
4106 r_reloc_get_hash_entry (const r_reloc *r_rel)
4108 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4109 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4114 r_reloc_get_section (const r_reloc *r_rel)
4116 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4117 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4122 r_reloc_is_defined (const r_reloc *r_rel)
4128 sec = r_reloc_get_section (r_rel);
4129 if (sec == bfd_abs_section_ptr
4130 || sec == bfd_com_section_ptr
4131 || sec == bfd_und_section_ptr)
4138 r_reloc_init (r_reloc *r_rel,
4140 Elf_Internal_Rela *irel,
4142 bfd_size_type content_length)
4145 reloc_howto_type *howto;
4149 r_rel->rela = *irel;
4151 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
4152 r_rel->virtual_offset = 0;
4153 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
4154 howto = &elf_howto_table[r_type];
4155 if (howto->partial_inplace)
4157 bfd_vma inplace_val;
4158 BFD_ASSERT (r_rel->rela.r_offset < content_length);
4160 inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
4161 r_rel->target_offset += inplace_val;
4165 memset (r_rel, 0, sizeof (r_reloc));
4172 print_r_reloc (FILE *fp, const r_reloc *r_rel)
4174 if (r_reloc_is_defined (r_rel))
4176 asection *sec = r_reloc_get_section (r_rel);
4177 fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
4179 else if (r_reloc_get_hash_entry (r_rel))
4180 fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
4182 fprintf (fp, " ?? + ");
4184 fprintf_vma (fp, r_rel->target_offset);
4185 if (r_rel->virtual_offset)
4187 fprintf (fp, " + ");
4188 fprintf_vma (fp, r_rel->virtual_offset);
4197 /* source_reloc: relocations that reference literals. */
4199 /* To determine whether literals can be coalesced, we need to first
4200 record all the relocations that reference the literals. The
4201 source_reloc structure below is used for this purpose. The
4202 source_reloc entries are kept in a per-literal-section array, sorted
4203 by offset within the literal section (i.e., target offset).
4205 The source_sec and r_rel.rela.r_offset fields identify the source of
4206 the relocation. The r_rel field records the relocation value, i.e.,
4207 the offset of the literal being referenced. The opnd field is needed
4208 to determine the range of the immediate field to which the relocation
4209 applies, so we can determine whether another literal with the same
4210 value is within range. The is_null field is true when the relocation
4211 is being removed (e.g., when an L32R is being removed due to a CALLX
4212 that is converted to a direct CALL). */
4214 typedef struct source_reloc_struct source_reloc;
4216 struct source_reloc_struct
4218 asection *source_sec;
4220 xtensa_opcode opcode;
4222 bfd_boolean is_null;
4223 bfd_boolean is_abs_literal;
4228 init_source_reloc (source_reloc *reloc,
4229 asection *source_sec,
4230 const r_reloc *r_rel,
4231 xtensa_opcode opcode,
4233 bfd_boolean is_abs_literal)
4235 reloc->source_sec = source_sec;
4236 reloc->r_rel = *r_rel;
4237 reloc->opcode = opcode;
4239 reloc->is_null = FALSE;
4240 reloc->is_abs_literal = is_abs_literal;
4244 /* Find the source_reloc for a particular source offset and relocation
4245 type. Note that the array is sorted by _target_ offset, so this is
4246 just a linear search. */
4248 static source_reloc *
4249 find_source_reloc (source_reloc *src_relocs,
4252 Elf_Internal_Rela *irel)
4256 for (i = 0; i < src_count; i++)
4258 if (src_relocs[i].source_sec == sec
4259 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
4260 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
4261 == ELF32_R_TYPE (irel->r_info)))
4262 return &src_relocs[i];
4270 source_reloc_compare (const void *ap, const void *bp)
4272 const source_reloc *a = (const source_reloc *) ap;
4273 const source_reloc *b = (const source_reloc *) bp;
4275 if (a->r_rel.target_offset != b->r_rel.target_offset)
4276 return (a->r_rel.target_offset - b->r_rel.target_offset);
4278 /* We don't need to sort on these criteria for correctness,
4279 but enforcing a more strict ordering prevents unstable qsort
4280 from behaving differently with different implementations.
4281 Without the code below we get correct but different results
4282 on Solaris 2.7 and 2.8. We would like to always produce the
4283 same results no matter the host. */
4285 if ((!a->is_null) - (!b->is_null))
4286 return ((!a->is_null) - (!b->is_null));
4287 return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
4291 /* Literal values and value hash tables. */
4293 /* Literals with the same value can be coalesced. The literal_value
4294 structure records the value of a literal: the "r_rel" field holds the
4295 information from the relocation on the literal (if there is one) and
4296 the "value" field holds the contents of the literal word itself.
4298 The value_map structure records a literal value along with the
4299 location of a literal holding that value. The value_map hash table
4300 is indexed by the literal value, so that we can quickly check if a
4301 particular literal value has been seen before and is thus a candidate
4304 typedef struct literal_value_struct literal_value;
4305 typedef struct value_map_struct value_map;
4306 typedef struct value_map_hash_table_struct value_map_hash_table;
4308 struct literal_value_struct
4311 unsigned long value;
4312 bfd_boolean is_abs_literal;
4315 struct value_map_struct
4317 literal_value val; /* The literal value. */
4318 r_reloc loc; /* Location of the literal. */
4322 struct value_map_hash_table_struct
4324 unsigned bucket_count;
4325 value_map **buckets;
4327 bfd_boolean has_last_loc;
4333 init_literal_value (literal_value *lit,
4334 const r_reloc *r_rel,
4335 unsigned long value,
4336 bfd_boolean is_abs_literal)
4338 lit->r_rel = *r_rel;
4340 lit->is_abs_literal = is_abs_literal;
4345 literal_value_equal (const literal_value *src1,
4346 const literal_value *src2,
4347 bfd_boolean final_static_link)
4349 struct elf_link_hash_entry *h1, *h2;
4351 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
4354 if (r_reloc_is_const (&src1->r_rel))
4355 return (src1->value == src2->value);
4357 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
4358 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
4361 if (src1->r_rel.target_offset != src2->r_rel.target_offset)
4364 if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
4367 if (src1->value != src2->value)
4370 /* Now check for the same section (if defined) or the same elf_hash
4371 (if undefined or weak). */
4372 h1 = r_reloc_get_hash_entry (&src1->r_rel);
4373 h2 = r_reloc_get_hash_entry (&src2->r_rel);
4374 if (r_reloc_is_defined (&src1->r_rel)
4375 && (final_static_link
4376 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
4377 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
4379 if (r_reloc_get_section (&src1->r_rel)
4380 != r_reloc_get_section (&src2->r_rel))
4385 /* Require that the hash entries (i.e., symbols) be identical. */
4386 if (h1 != h2 || h1 == 0)
4390 if (src1->is_abs_literal != src2->is_abs_literal)
4397 /* Must be power of 2. */
4398 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
4400 static value_map_hash_table *
4401 value_map_hash_table_init (void)
4403 value_map_hash_table *values;
4405 values = (value_map_hash_table *)
4406 bfd_zmalloc (sizeof (value_map_hash_table));
4407 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
4409 values->buckets = (value_map **)
4410 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
4411 if (values->buckets == NULL)
4416 values->has_last_loc = FALSE;
4423 value_map_hash_table_delete (value_map_hash_table *table)
4425 free (table->buckets);
4431 hash_bfd_vma (bfd_vma val)
4433 return (val >> 2) + (val >> 10);
4438 literal_value_hash (const literal_value *src)
4442 hash_val = hash_bfd_vma (src->value);
4443 if (!r_reloc_is_const (&src->r_rel))
4447 hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
4448 hash_val += hash_bfd_vma (src->r_rel.target_offset);
4449 hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
4451 /* Now check for the same section and the same elf_hash. */
4452 if (r_reloc_is_defined (&src->r_rel))
4453 sec_or_hash = r_reloc_get_section (&src->r_rel);
4455 sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
4456 hash_val += hash_bfd_vma ((bfd_vma) (unsigned) sec_or_hash);
4462 /* Check if the specified literal_value has been seen before. */
4465 value_map_get_cached_value (value_map_hash_table *map,
4466 const literal_value *val,
4467 bfd_boolean final_static_link)
4473 idx = literal_value_hash (val);
4474 idx = idx & (map->bucket_count - 1);
4475 bucket = map->buckets[idx];
4476 for (map_e = bucket; map_e; map_e = map_e->next)
4478 if (literal_value_equal (&map_e->val, val, final_static_link))
4485 /* Record a new literal value. It is illegal to call this if VALUE
4486 already has an entry here. */
4489 add_value_map (value_map_hash_table *map,
4490 const literal_value *val,
4492 bfd_boolean final_static_link)
4494 value_map **bucket_p;
4497 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
4500 bfd_set_error (bfd_error_no_memory);
4504 BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
4508 idx = literal_value_hash (val);
4509 idx = idx & (map->bucket_count - 1);
4510 bucket_p = &map->buckets[idx];
4512 val_e->next = *bucket_p;
4515 /* FIXME: Consider resizing the hash table if we get too many entries. */
4521 /* Lists of text actions (ta_) for narrowing, widening, longcall
4522 conversion, space fill, code & literal removal, etc. */
4524 /* The following text actions are generated:
4526 "ta_remove_insn" remove an instruction or instructions
4527 "ta_remove_longcall" convert longcall to call
4528 "ta_convert_longcall" convert longcall to nop/call
4529 "ta_narrow_insn" narrow a wide instruction
4530 "ta_widen" widen a narrow instruction
4531 "ta_fill" add fill or remove fill
4532 removed < 0 is a fill; branches to the fill address will be
4533 changed to address + fill size (e.g., address - removed)
4534 removed >= 0 branches to the fill address will stay unchanged
4535 "ta_remove_literal" remove a literal; this action is
4536 indicated when a literal is removed
4538 "ta_add_literal" insert a new literal; this action is
4539 indicated when a literal has been moved.
4540 It may use a virtual_offset because
4541 multiple literals can be placed at the
4544 For each of these text actions, we also record the number of bytes
4545 removed by performing the text action. In the case of a "ta_widen"
4546 or a "ta_fill" that adds space, the removed_bytes will be negative. */
4548 typedef struct text_action_struct text_action;
4549 typedef struct text_action_list_struct text_action_list;
4550 typedef enum text_action_enum_t text_action_t;
4552 enum text_action_enum_t
4555 ta_remove_insn, /* removed = -size */
4556 ta_remove_longcall, /* removed = -size */
4557 ta_convert_longcall, /* removed = 0 */
4558 ta_narrow_insn, /* removed = -1 */
4559 ta_widen_insn, /* removed = +1 */
4560 ta_fill, /* removed = +size */
4566 /* Structure for a text action record. */
4567 struct text_action_struct
4569 text_action_t action;
4570 asection *sec; /* Optional */
4572 bfd_vma virtual_offset; /* Zero except for adding literals. */
4574 literal_value value; /* Only valid when adding literals. */
4580 /* List of all of the actions taken on a text section. */
4581 struct text_action_list_struct
4587 static text_action *
4588 find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
4592 /* It is not necessary to fill at the end of a section. */
4593 if (sec->size == offset)
4596 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
4598 text_action *t = *m_p;
4599 /* When the action is another fill at the same address,
4600 just increase the size. */
4601 if (t->offset == offset && t->action == ta_fill)
4609 compute_removed_action_diff (const text_action *ta,
4613 int removable_space)
4616 int current_removed = 0;
4619 current_removed = ta->removed_bytes;
4621 BFD_ASSERT (ta == NULL || ta->offset == offset);
4622 BFD_ASSERT (ta == NULL || ta->action == ta_fill);
4624 /* It is not necessary to fill at the end of a section. Clean this up. */
4625 if (sec->size == offset)
4626 new_removed = removable_space - 0;
4630 int added = -removed - current_removed;
4631 /* Ignore multiples of the section alignment. */
4632 added = ((1 << sec->alignment_power) - 1) & added;
4633 new_removed = (-added);
4635 /* Modify for removable. */
4636 space = removable_space - new_removed;
4637 new_removed = (removable_space
4638 - (((1 << sec->alignment_power) - 1) & space));
4640 return (new_removed - current_removed);
4645 adjust_fill_action (text_action *ta, int fill_diff)
4647 ta->removed_bytes += fill_diff;
4651 /* Add a modification action to the text. For the case of adding or
4652 removing space, modify any current fill and assume that
4653 "unreachable_space" bytes can be freely contracted. Note that a
4654 negative removed value is a fill. */
4657 text_action_add (text_action_list *l,
4658 text_action_t action,
4666 /* It is not necessary to fill at the end of a section. */
4667 if (action == ta_fill && sec->size == offset)
4670 /* It is not necessary to fill 0 bytes. */
4671 if (action == ta_fill && removed == 0)
4674 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
4676 text_action *t = *m_p;
4677 /* When the action is another fill at the same address,
4678 just increase the size. */
4679 if (t->offset == offset && t->action == ta_fill && action == ta_fill)
4681 t->removed_bytes += removed;
4686 /* Create a new record and fill it up. */
4687 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
4688 ta->action = action;
4690 ta->offset = offset;
4691 ta->removed_bytes = removed;
4698 text_action_add_literal (text_action_list *l,
4699 text_action_t action,
4701 const literal_value *value,
4706 asection *sec = r_reloc_get_section (loc);
4707 bfd_vma offset = loc->target_offset;
4708 bfd_vma virtual_offset = loc->virtual_offset;
4710 BFD_ASSERT (action == ta_add_literal);
4712 for (m_p = &l->head; *m_p != NULL; m_p = &(*m_p)->next)
4714 if ((*m_p)->offset > offset
4715 && ((*m_p)->offset != offset
4716 || (*m_p)->virtual_offset > virtual_offset))
4720 /* Create a new record and fill it up. */
4721 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
4722 ta->action = action;
4724 ta->offset = offset;
4725 ta->virtual_offset = virtual_offset;
4727 ta->removed_bytes = removed;
4734 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
4739 for (r = action_list->head; r && r->offset <= offset; r = r->next)
4741 if (r->offset < offset
4742 || (r->action == ta_fill && r->removed_bytes < 0))
4743 removed += r->removed_bytes;
4746 return (offset - removed);
4751 offset_with_removed_text_before_fill (text_action_list *action_list,
4757 for (r = action_list->head; r && r->offset < offset; r = r->next)
4758 removed += r->removed_bytes;
4760 return (offset - removed);
4764 /* The find_insn_action routine will only find non-fill actions. */
4766 static text_action *
4767 find_insn_action (text_action_list *action_list, bfd_vma offset)
4770 for (t = action_list->head; t; t = t->next)
4772 if (t->offset == offset)
4779 case ta_remove_insn:
4780 case ta_remove_longcall:
4781 case ta_convert_longcall:
4782 case ta_narrow_insn:
4785 case ta_remove_literal:
4786 case ta_add_literal:
4799 print_action_list (FILE *fp, text_action_list *action_list)
4803 fprintf (fp, "Text Action\n");
4804 for (r = action_list->head; r != NULL; r = r->next)
4806 const char *t = "unknown";
4809 case ta_remove_insn:
4810 t = "remove_insn"; break;
4811 case ta_remove_longcall:
4812 t = "remove_longcall"; break;
4813 case ta_convert_longcall:
4814 t = "remove_longcall"; break;
4815 case ta_narrow_insn:
4816 t = "narrow_insn"; break;
4818 t = "widen_insn"; break;
4823 case ta_remove_literal:
4824 t = "remove_literal"; break;
4825 case ta_add_literal:
4826 t = "add_literal"; break;
4829 fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
4830 r->sec->owner->filename,
4831 r->sec->name, r->offset, t, r->removed_bytes);
4838 /* Lists of literals being coalesced or removed. */
4840 /* In the usual case, the literal identified by "from" is being
4841 coalesced with another literal identified by "to". If the literal is
4842 unused and is being removed altogether, "to.abfd" will be NULL.
4843 The removed_literal entries are kept on a per-section list, sorted
4844 by the "from" offset field. */
4846 typedef struct removed_literal_struct removed_literal;
4847 typedef struct removed_literal_list_struct removed_literal_list;
4849 struct removed_literal_struct
4853 removed_literal *next;
4856 struct removed_literal_list_struct
4858 removed_literal *head;
4859 removed_literal *tail;
4863 /* Record that the literal at "from" is being removed. If "to" is not
4864 NULL, the "from" literal is being coalesced with the "to" literal. */
4867 add_removed_literal (removed_literal_list *removed_list,
4868 const r_reloc *from,
4871 removed_literal *r, *new_r, *next_r;
4873 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
4875 new_r->from = *from;
4879 new_r->to.abfd = NULL;
4882 r = removed_list->head;
4885 removed_list->head = new_r;
4886 removed_list->tail = new_r;
4888 /* Special check for common case of append. */
4889 else if (removed_list->tail->from.target_offset < from->target_offset)
4891 removed_list->tail->next = new_r;
4892 removed_list->tail = new_r;
4896 while (r->from.target_offset < from->target_offset && r->next)
4902 new_r->next = next_r;
4904 removed_list->tail = new_r;
4909 /* Check if the list of removed literals contains an entry for the
4910 given address. Return the entry if found. */
4912 static removed_literal *
4913 find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
4915 removed_literal *r = removed_list->head;
4916 while (r && r->from.target_offset < addr)
4918 if (r && r->from.target_offset == addr)
4927 print_removed_literals (FILE *fp, removed_literal_list *removed_list)
4930 r = removed_list->head;
4932 fprintf (fp, "Removed Literals\n");
4933 for (; r != NULL; r = r->next)
4935 print_r_reloc (fp, &r->from);
4936 fprintf (fp, " => ");
4937 if (r->to.abfd == NULL)
4938 fprintf (fp, "REMOVED");
4940 print_r_reloc (fp, &r->to);
4948 /* Per-section data for relaxation. */
4950 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
4952 struct xtensa_relax_info_struct
4954 bfd_boolean is_relaxable_literal_section;
4955 bfd_boolean is_relaxable_asm_section;
4956 int visited; /* Number of times visited. */
4958 source_reloc *src_relocs; /* Array[src_count]. */
4960 int src_next; /* Next src_relocs entry to assign. */
4962 removed_literal_list removed_list;
4963 text_action_list action_list;
4965 reloc_bfd_fix *fix_list;
4966 reloc_bfd_fix *fix_array;
4967 unsigned fix_array_count;
4969 /* Support for expanding the reloc array that is stored
4970 in the section structure. If the relocations have been
4971 reallocated, the newly allocated relocations will be referenced
4972 here along with the actual size allocated. The relocation
4973 count will always be found in the section structure. */
4974 Elf_Internal_Rela *allocated_relocs;
4975 unsigned relocs_count;
4976 unsigned allocated_relocs_count;
4979 struct elf_xtensa_section_data
4981 struct bfd_elf_section_data elf;
4982 xtensa_relax_info relax_info;
4987 elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
4989 struct elf_xtensa_section_data *sdata;
4990 bfd_size_type amt = sizeof (*sdata);
4992 sdata = (struct elf_xtensa_section_data *) bfd_zalloc (abfd, amt);
4995 sec->used_by_bfd = (void *) sdata;
4997 return _bfd_elf_new_section_hook (abfd, sec);
5001 static xtensa_relax_info *
5002 get_xtensa_relax_info (asection *sec)
5004 struct elf_xtensa_section_data *section_data;
5006 /* No info available if no section or if it is an output section. */
5007 if (!sec || sec == sec->output_section)
5010 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
5011 return §ion_data->relax_info;
5016 init_xtensa_relax_info (asection *sec)
5018 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5020 relax_info->is_relaxable_literal_section = FALSE;
5021 relax_info->is_relaxable_asm_section = FALSE;
5022 relax_info->visited = 0;
5024 relax_info->src_relocs = NULL;
5025 relax_info->src_count = 0;
5026 relax_info->src_next = 0;
5028 relax_info->removed_list.head = NULL;
5029 relax_info->removed_list.tail = NULL;
5031 relax_info->action_list.head = NULL;
5033 relax_info->fix_list = NULL;
5034 relax_info->fix_array = NULL;
5035 relax_info->fix_array_count = 0;
5037 relax_info->allocated_relocs = NULL;
5038 relax_info->relocs_count = 0;
5039 relax_info->allocated_relocs_count = 0;
5043 /* Coalescing literals may require a relocation to refer to a section in
5044 a different input file, but the standard relocation information
5045 cannot express that. Instead, the reloc_bfd_fix structures are used
5046 to "fix" the relocations that refer to sections in other input files.
5047 These structures are kept on per-section lists. The "src_type" field
5048 records the relocation type in case there are multiple relocations on
5049 the same location. FIXME: This is ugly; an alternative might be to
5050 add new symbols with the "owner" field to some other input file. */
5052 struct reloc_bfd_fix_struct
5056 unsigned src_type; /* Relocation type. */
5059 asection *target_sec;
5060 bfd_vma target_offset;
5061 bfd_boolean translated;
5063 reloc_bfd_fix *next;
5067 static reloc_bfd_fix *
5068 reloc_bfd_fix_init (asection *src_sec,
5072 asection *target_sec,
5073 bfd_vma target_offset,
5074 bfd_boolean translated)
5078 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
5079 fix->src_sec = src_sec;
5080 fix->src_offset = src_offset;
5081 fix->src_type = src_type;
5082 fix->target_abfd = target_abfd;
5083 fix->target_sec = target_sec;
5084 fix->target_offset = target_offset;
5085 fix->translated = translated;
5092 add_fix (asection *src_sec, reloc_bfd_fix *fix)
5094 xtensa_relax_info *relax_info;
5096 relax_info = get_xtensa_relax_info (src_sec);
5097 fix->next = relax_info->fix_list;
5098 relax_info->fix_list = fix;
5103 fix_compare (const void *ap, const void *bp)
5105 const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
5106 const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
5108 if (a->src_offset != b->src_offset)
5109 return (a->src_offset - b->src_offset);
5110 return (a->src_type - b->src_type);
5115 cache_fix_array (asection *sec)
5117 unsigned i, count = 0;
5119 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5121 if (relax_info == NULL)
5123 if (relax_info->fix_list == NULL)
5126 for (r = relax_info->fix_list; r != NULL; r = r->next)
5129 relax_info->fix_array =
5130 (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
5131 relax_info->fix_array_count = count;
5133 r = relax_info->fix_list;
5134 for (i = 0; i < count; i++, r = r->next)
5136 relax_info->fix_array[count - 1 - i] = *r;
5137 relax_info->fix_array[count - 1 - i].next = NULL;
5140 qsort (relax_info->fix_array, relax_info->fix_array_count,
5141 sizeof (reloc_bfd_fix), fix_compare);
5145 static reloc_bfd_fix *
5146 get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
5148 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5152 if (relax_info == NULL)
5154 if (relax_info->fix_list == NULL)
5157 if (relax_info->fix_array == NULL)
5158 cache_fix_array (sec);
5160 key.src_offset = offset;
5161 key.src_type = type;
5162 rv = bsearch (&key, relax_info->fix_array, relax_info->fix_array_count,
5163 sizeof (reloc_bfd_fix), fix_compare);
5168 /* Section caching. */
5170 typedef struct section_cache_struct section_cache_t;
5172 struct section_cache_struct
5176 bfd_byte *contents; /* Cache of the section contents. */
5177 bfd_size_type content_length;
5179 property_table_entry *ptbl; /* Cache of the section property table. */
5182 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
5183 unsigned reloc_count;
5188 init_section_cache (section_cache_t *sec_cache)
5190 memset (sec_cache, 0, sizeof (*sec_cache));
5195 clear_section_cache (section_cache_t *sec_cache)
5199 release_contents (sec_cache->sec, sec_cache->contents);
5200 release_internal_relocs (sec_cache->sec, sec_cache->relocs);
5201 if (sec_cache->ptbl)
5202 free (sec_cache->ptbl);
5203 memset (sec_cache, 0, sizeof (sec_cache));
5209 section_cache_section (section_cache_t *sec_cache,
5211 struct bfd_link_info *link_info)
5214 property_table_entry *prop_table = NULL;
5216 bfd_byte *contents = NULL;
5217 Elf_Internal_Rela *internal_relocs = NULL;
5218 bfd_size_type sec_size;
5222 if (sec == sec_cache->sec)
5226 sec_size = bfd_get_section_limit (abfd, sec);
5228 /* Get the contents. */
5229 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5230 if (contents == NULL && sec_size != 0)
5233 /* Get the relocations. */
5234 internal_relocs = retrieve_internal_relocs (abfd, sec,
5235 link_info->keep_memory);
5237 /* Get the entry table. */
5238 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
5239 XTENSA_PROP_SEC_NAME, FALSE);
5243 /* Fill in the new section cache. */
5244 clear_section_cache (sec_cache);
5245 memset (sec_cache, 0, sizeof (sec_cache));
5247 sec_cache->sec = sec;
5248 sec_cache->contents = contents;
5249 sec_cache->content_length = sec_size;
5250 sec_cache->relocs = internal_relocs;
5251 sec_cache->reloc_count = sec->reloc_count;
5252 sec_cache->pte_count = ptblsize;
5253 sec_cache->ptbl = prop_table;
5258 release_contents (sec, contents);
5259 release_internal_relocs (sec, internal_relocs);
5266 /* Extended basic blocks. */
5268 /* An ebb_struct represents an Extended Basic Block. Within this
5269 range, we guarantee that all instructions are decodable, the
5270 property table entries are contiguous, and no property table
5271 specifies a segment that cannot have instructions moved. This
5272 structure contains caches of the contents, property table and
5273 relocations for the specified section for easy use. The range is
5274 specified by ranges of indices for the byte offset, property table
5275 offsets and relocation offsets. These must be consistent. */
5277 typedef struct ebb_struct ebb_t;
5283 bfd_byte *contents; /* Cache of the section contents. */
5284 bfd_size_type content_length;
5286 property_table_entry *ptbl; /* Cache of the section property table. */
5289 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
5290 unsigned reloc_count;
5292 bfd_vma start_offset; /* Offset in section. */
5293 unsigned start_ptbl_idx; /* Offset in the property table. */
5294 unsigned start_reloc_idx; /* Offset in the relocations. */
5297 unsigned end_ptbl_idx;
5298 unsigned end_reloc_idx;
5300 bfd_boolean ends_section; /* Is this the last ebb in a section? */
5302 /* The unreachable property table at the end of this set of blocks;
5303 NULL if the end is not an unreachable block. */
5304 property_table_entry *ends_unreachable;
5308 enum ebb_target_enum
5311 EBB_DESIRE_TGT_ALIGN,
5312 EBB_REQUIRE_TGT_ALIGN,
5313 EBB_REQUIRE_LOOP_ALIGN,
5318 /* proposed_action_struct is similar to the text_action_struct except
5319 that is represents a potential transformation, not one that will
5320 occur. We build a list of these for an extended basic block
5321 and use them to compute the actual actions desired. We must be
5322 careful that the entire set of actual actions we perform do not
5323 break any relocations that would fit if the actions were not
5326 typedef struct proposed_action_struct proposed_action;
5328 struct proposed_action_struct
5330 enum ebb_target_enum align_type; /* for the target alignment */
5331 bfd_vma alignment_pow;
5332 text_action_t action;
5335 bfd_boolean do_action; /* If false, then we will not perform the action. */
5339 /* The ebb_constraint_struct keeps a set of proposed actions for an
5340 extended basic block. */
5342 typedef struct ebb_constraint_struct ebb_constraint;
5344 struct ebb_constraint_struct
5347 bfd_boolean start_movable;
5349 /* Bytes of extra space at the beginning if movable. */
5350 int start_extra_space;
5352 enum ebb_target_enum start_align;
5354 bfd_boolean end_movable;
5356 /* Bytes of extra space at the end if movable. */
5357 int end_extra_space;
5359 unsigned action_count;
5360 unsigned action_allocated;
5362 /* Array of proposed actions. */
5363 proposed_action *actions;
5365 /* Action alignments -- one for each proposed action. */
5366 enum ebb_target_enum *action_aligns;
5371 init_ebb_constraint (ebb_constraint *c)
5373 memset (c, 0, sizeof (ebb_constraint));
5378 free_ebb_constraint (ebb_constraint *c)
5386 init_ebb (ebb_t *ebb,
5389 bfd_size_type content_length,
5390 property_table_entry *prop_table,
5392 Elf_Internal_Rela *internal_relocs,
5393 unsigned reloc_count)
5395 memset (ebb, 0, sizeof (ebb_t));
5397 ebb->contents = contents;
5398 ebb->content_length = content_length;
5399 ebb->ptbl = prop_table;
5400 ebb->pte_count = ptblsize;
5401 ebb->relocs = internal_relocs;
5402 ebb->reloc_count = reloc_count;
5403 ebb->start_offset = 0;
5404 ebb->end_offset = ebb->content_length - 1;
5405 ebb->start_ptbl_idx = 0;
5406 ebb->end_ptbl_idx = ptblsize;
5407 ebb->start_reloc_idx = 0;
5408 ebb->end_reloc_idx = reloc_count;
5412 /* Extend the ebb to all decodable contiguous sections. The algorithm
5413 for building a basic block around an instruction is to push it
5414 forward until we hit the end of a section, an unreachable block or
5415 a block that cannot be transformed. Then we push it backwards
5416 searching for similar conditions. */
5418 static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
5419 static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
5420 static bfd_size_type insn_block_decodable_len
5421 (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
5424 extend_ebb_bounds (ebb_t *ebb)
5426 if (!extend_ebb_bounds_forward (ebb))
5428 if (!extend_ebb_bounds_backward (ebb))
5435 extend_ebb_bounds_forward (ebb_t *ebb)
5437 property_table_entry *the_entry, *new_entry;
5439 the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
5441 /* Stop when (1) we cannot decode an instruction, (2) we are at
5442 the end of the property tables, (3) we hit a non-contiguous property
5443 table entry, (4) we hit a NO_TRANSFORM region. */
5448 bfd_size_type insn_block_len;
5450 entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
5452 insn_block_decodable_len (ebb->contents, ebb->content_length,
5454 entry_end - ebb->end_offset);
5455 if (insn_block_len != (entry_end - ebb->end_offset))
5457 (*_bfd_error_handler)
5458 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
5459 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
5462 ebb->end_offset += insn_block_len;
5464 if (ebb->end_offset == ebb->sec->size)
5465 ebb->ends_section = TRUE;
5467 /* Update the reloc counter. */
5468 while (ebb->end_reloc_idx + 1 < ebb->reloc_count
5469 && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
5472 ebb->end_reloc_idx++;
5475 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
5478 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
5479 if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
5480 || ((new_entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) != 0)
5481 || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
5484 if (the_entry->address + the_entry->size != new_entry->address)
5487 the_entry = new_entry;
5488 ebb->end_ptbl_idx++;
5491 /* Quick check for an unreachable or end of file just at the end. */
5492 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
5494 if (ebb->end_offset == ebb->content_length)
5495 ebb->ends_section = TRUE;
5499 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
5500 if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
5501 && the_entry->address + the_entry->size == new_entry->address)
5502 ebb->ends_unreachable = new_entry;
5505 /* Any other ending requires exact alignment. */
5511 extend_ebb_bounds_backward (ebb_t *ebb)
5513 property_table_entry *the_entry, *new_entry;
5515 the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
5517 /* Stop when (1) we cannot decode the instructions in the current entry.
5518 (2) we are at the beginning of the property tables, (3) we hit a
5519 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
5523 bfd_vma block_begin;
5524 bfd_size_type insn_block_len;
5526 block_begin = the_entry->address - ebb->sec->vma;
5528 insn_block_decodable_len (ebb->contents, ebb->content_length,
5530 ebb->start_offset - block_begin);
5531 if (insn_block_len != ebb->start_offset - block_begin)
5533 (*_bfd_error_handler)
5534 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
5535 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
5538 ebb->start_offset -= insn_block_len;
5540 /* Update the reloc counter. */
5541 while (ebb->start_reloc_idx > 0
5542 && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
5543 >= ebb->start_offset))
5545 ebb->start_reloc_idx--;
5548 if (ebb->start_ptbl_idx == 0)
5551 new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
5552 if ((new_entry->flags & XTENSA_PROP_INSN) == 0
5553 || ((new_entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) != 0)
5554 || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
5556 if (new_entry->address + new_entry->size != the_entry->address)
5559 the_entry = new_entry;
5560 ebb->start_ptbl_idx--;
5566 static bfd_size_type
5567 insn_block_decodable_len (bfd_byte *contents,
5568 bfd_size_type content_len,
5569 bfd_vma block_offset,
5570 bfd_size_type block_len)
5572 bfd_vma offset = block_offset;
5574 while (offset < block_offset + block_len)
5576 bfd_size_type insn_len = 0;
5578 insn_len = insn_decode_len (contents, content_len, offset);
5580 return (offset - block_offset);
5583 return (offset - block_offset);
5588 ebb_propose_action (ebb_constraint *c,
5589 bfd_vma alignment_pow,
5590 enum ebb_target_enum align_type,
5591 text_action_t action,
5594 bfd_boolean do_action)
5596 proposed_action *act;
5598 if (c->action_allocated <= c->action_count)
5600 unsigned new_allocated, i;
5602 new_allocated = (c->action_count + 2) * 2;
5603 proposed_action *new_actions = (proposed_action *)
5604 bfd_zmalloc (sizeof (proposed_action) * new_allocated);
5606 for (i = 0; i < c->action_count; i++)
5607 new_actions[i] = c->actions[i];
5610 c->actions = new_actions;
5611 c->action_allocated = new_allocated;
5614 act = &c->actions[c->action_count];
5615 act->align_type = align_type;
5616 act->alignment_pow = alignment_pow;
5617 act->action = action;
5618 act->offset = offset;
5619 act->removed_bytes = removed_bytes;
5620 act->do_action = do_action;
5626 /* Access to internal relocations, section contents and symbols. */
5628 /* During relaxation, we need to modify relocations, section contents,
5629 and symbol definitions, and we need to keep the original values from
5630 being reloaded from the input files, i.e., we need to "pin" the
5631 modified values in memory. We also want to continue to observe the
5632 setting of the "keep-memory" flag. The following functions wrap the
5633 standard BFD functions to take care of this for us. */
5635 static Elf_Internal_Rela *
5636 retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
5638 Elf_Internal_Rela *internal_relocs;
5640 if ((sec->flags & SEC_LINKER_CREATED) != 0)
5643 internal_relocs = elf_section_data (sec)->relocs;
5644 if (internal_relocs == NULL)
5645 internal_relocs = (_bfd_elf_link_read_relocs
5646 (abfd, sec, NULL, NULL, keep_memory));
5647 return internal_relocs;
5652 pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
5654 elf_section_data (sec)->relocs = internal_relocs;
5659 release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
5662 && elf_section_data (sec)->relocs != internal_relocs)
5663 free (internal_relocs);
5668 retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
5671 bfd_size_type sec_size;
5673 sec_size = bfd_get_section_limit (abfd, sec);
5674 contents = elf_section_data (sec)->this_hdr.contents;
5676 if (contents == NULL && sec_size != 0)
5678 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
5685 elf_section_data (sec)->this_hdr.contents = contents;
5692 pin_contents (asection *sec, bfd_byte *contents)
5694 elf_section_data (sec)->this_hdr.contents = contents;
5699 release_contents (asection *sec, bfd_byte *contents)
5701 if (contents && elf_section_data (sec)->this_hdr.contents != contents)
5706 static Elf_Internal_Sym *
5707 retrieve_local_syms (bfd *input_bfd)
5709 Elf_Internal_Shdr *symtab_hdr;
5710 Elf_Internal_Sym *isymbuf;
5713 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5714 locsymcount = symtab_hdr->sh_info;
5716 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5717 if (isymbuf == NULL && locsymcount != 0)
5718 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
5721 /* Save the symbols for this input file so they won't be read again. */
5722 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
5723 symtab_hdr->contents = (unsigned char *) isymbuf;
5729 /* Code for link-time relaxation. */
5731 /* Initialization for relaxation: */
5732 static bfd_boolean analyze_relocations (struct bfd_link_info *);
5733 static bfd_boolean find_relaxable_sections
5734 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
5735 static bfd_boolean collect_source_relocs
5736 (bfd *, asection *, struct bfd_link_info *);
5737 static bfd_boolean is_resolvable_asm_expansion
5738 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
5740 static Elf_Internal_Rela *find_associated_l32r_irel
5741 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
5742 static bfd_boolean compute_text_actions
5743 (bfd *, asection *, struct bfd_link_info *);
5744 static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
5745 static bfd_boolean compute_ebb_actions (ebb_constraint *);
5746 static bfd_boolean check_section_ebb_pcrels_fit
5747 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, const ebb_constraint *);
5748 static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
5749 static void text_action_add_proposed
5750 (text_action_list *, const ebb_constraint *, asection *);
5751 static int compute_fill_extra_space (property_table_entry *);
5754 static bfd_boolean compute_removed_literals
5755 (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
5756 static Elf_Internal_Rela *get_irel_at_offset
5757 (asection *, Elf_Internal_Rela *, bfd_vma);
5758 static bfd_boolean is_removable_literal
5759 (const source_reloc *, int, const source_reloc *, int);
5760 static bfd_boolean remove_dead_literal
5761 (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
5762 Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
5763 static bfd_boolean identify_literal_placement
5764 (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
5765 value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
5766 source_reloc *, property_table_entry *, int, section_cache_t *,
5768 static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
5769 static bfd_boolean coalesce_shared_literal
5770 (asection *, source_reloc *, property_table_entry *, int, value_map *);
5771 static bfd_boolean move_shared_literal
5772 (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
5773 int, const r_reloc *, const literal_value *, section_cache_t *);
5776 static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
5777 static bfd_boolean translate_section_fixes (asection *);
5778 static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
5779 static void translate_reloc (const r_reloc *, r_reloc *);
5780 static void shrink_dynamic_reloc_sections
5781 (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
5782 static bfd_boolean move_literal
5783 (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
5784 xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
5785 static bfd_boolean relax_property_section
5786 (bfd *, asection *, struct bfd_link_info *);
5789 static bfd_boolean relax_section_symbols (bfd *, asection *);
5793 elf_xtensa_relax_section (bfd *abfd,
5795 struct bfd_link_info *link_info,
5798 static value_map_hash_table *values = NULL;
5799 static bfd_boolean relocations_analyzed = FALSE;
5800 xtensa_relax_info *relax_info;
5802 if (!relocations_analyzed)
5804 /* Do some overall initialization for relaxation. */
5805 values = value_map_hash_table_init ();
5808 relaxing_section = TRUE;
5809 if (!analyze_relocations (link_info))
5811 relocations_analyzed = TRUE;
5815 /* Don't mess with linker-created sections. */
5816 if ((sec->flags & SEC_LINKER_CREATED) != 0)
5819 relax_info = get_xtensa_relax_info (sec);
5820 BFD_ASSERT (relax_info != NULL);
5822 switch (relax_info->visited)
5825 /* Note: It would be nice to fold this pass into
5826 analyze_relocations, but it is important for this step that the
5827 sections be examined in link order. */
5828 if (!compute_removed_literals (abfd, sec, link_info, values))
5835 value_map_hash_table_delete (values);
5837 if (!relax_section (abfd, sec, link_info))
5843 if (!relax_section_symbols (abfd, sec))
5848 relax_info->visited++;
5853 /* Initialization for relaxation. */
5855 /* This function is called once at the start of relaxation. It scans
5856 all the input sections and marks the ones that are relaxable (i.e.,
5857 literal sections with L32R relocations against them), and then
5858 collects source_reloc information for all the relocations against
5859 those relaxable sections. During this process, it also detects
5860 longcalls, i.e., calls relaxed by the assembler into indirect
5861 calls, that can be optimized back into direct calls. Within each
5862 extended basic block (ebb) containing an optimized longcall, it
5863 computes a set of "text actions" that can be performed to remove
5864 the L32R associated with the longcall while optionally preserving
5865 branch target alignments. */
5868 analyze_relocations (struct bfd_link_info *link_info)
5872 bfd_boolean is_relaxable = FALSE;
5874 /* Initialize the per-section relaxation info. */
5875 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5876 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5878 init_xtensa_relax_info (sec);
5881 /* Mark relaxable sections (and count relocations against each one). */
5882 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5883 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5885 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
5889 /* Bail out if there are no relaxable sections. */
5893 /* Allocate space for source_relocs. */
5894 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5895 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5897 xtensa_relax_info *relax_info;
5899 relax_info = get_xtensa_relax_info (sec);
5900 if (relax_info->is_relaxable_literal_section
5901 || relax_info->is_relaxable_asm_section)
5903 relax_info->src_relocs = (source_reloc *)
5904 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
5908 /* Collect info on relocations against each relaxable section. */
5909 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5910 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5912 if (!collect_source_relocs (abfd, sec, link_info))
5916 /* Compute the text actions. */
5917 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5918 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5920 if (!compute_text_actions (abfd, sec, link_info))
5928 /* Find all the sections that might be relaxed. The motivation for
5929 this pass is that collect_source_relocs() needs to record _all_ the
5930 relocations that target each relaxable section. That is expensive
5931 and unnecessary unless the target section is actually going to be
5932 relaxed. This pass identifies all such sections by checking if
5933 they have L32Rs pointing to them. In the process, the total number
5934 of relocations targeting each section is also counted so that we
5935 know how much space to allocate for source_relocs against each
5936 relaxable literal section. */
5939 find_relaxable_sections (bfd *abfd,
5941 struct bfd_link_info *link_info,
5942 bfd_boolean *is_relaxable_p)
5944 Elf_Internal_Rela *internal_relocs;
5946 bfd_boolean ok = TRUE;
5948 xtensa_relax_info *source_relax_info;
5950 internal_relocs = retrieve_internal_relocs (abfd, sec,
5951 link_info->keep_memory);
5952 if (internal_relocs == NULL)
5955 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5956 if (contents == NULL && sec->size != 0)
5962 source_relax_info = get_xtensa_relax_info (sec);
5963 for (i = 0; i < sec->reloc_count; i++)
5965 Elf_Internal_Rela *irel = &internal_relocs[i];
5967 asection *target_sec;
5968 xtensa_relax_info *target_relax_info;
5970 /* If this section has not already been marked as "relaxable", and
5971 if it contains any ASM_EXPAND relocations (marking expanded
5972 longcalls) that can be optimized into direct calls, then mark
5973 the section as "relaxable". */
5974 if (source_relax_info
5975 && !source_relax_info->is_relaxable_asm_section
5976 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
5978 bfd_boolean is_reachable = FALSE;
5979 if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
5980 link_info, &is_reachable)
5983 source_relax_info->is_relaxable_asm_section = TRUE;
5984 *is_relaxable_p = TRUE;
5988 r_reloc_init (&r_rel, abfd, irel, contents,
5989 bfd_get_section_limit (abfd, sec));
5991 target_sec = r_reloc_get_section (&r_rel);
5992 target_relax_info = get_xtensa_relax_info (target_sec);
5993 if (!target_relax_info)
5996 /* Count PC-relative operand relocations against the target section.
5997 Note: The conditions tested here must match the conditions under
5998 which init_source_reloc is called in collect_source_relocs(). */
5999 if (is_operand_relocation (ELF32_R_TYPE (irel->r_info))
6000 && (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
6001 || is_l32r_relocation (abfd, sec, contents, irel)))
6002 target_relax_info->src_count++;
6004 if (is_l32r_relocation (abfd, sec, contents, irel)
6005 && r_reloc_is_defined (&r_rel))
6007 /* Mark the target section as relaxable. */
6008 target_relax_info->is_relaxable_literal_section = TRUE;
6009 *is_relaxable_p = TRUE;
6014 release_contents (sec, contents);
6015 release_internal_relocs (sec, internal_relocs);
6020 /* Record _all_ the relocations that point to relaxable sections, and
6021 get rid of ASM_EXPAND relocs by either converting them to
6022 ASM_SIMPLIFY or by removing them. */
6025 collect_source_relocs (bfd *abfd,
6027 struct bfd_link_info *link_info)
6029 Elf_Internal_Rela *internal_relocs;
6031 bfd_boolean ok = TRUE;
6033 bfd_size_type sec_size;
6035 internal_relocs = retrieve_internal_relocs (abfd, sec,
6036 link_info->keep_memory);
6037 if (internal_relocs == NULL)
6040 sec_size = bfd_get_section_limit (abfd, sec);
6041 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6042 if (contents == NULL && sec_size != 0)
6048 /* Record relocations against relaxable literal sections. */
6049 for (i = 0; i < sec->reloc_count; i++)
6051 Elf_Internal_Rela *irel = &internal_relocs[i];
6053 asection *target_sec;
6054 xtensa_relax_info *target_relax_info;
6056 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6058 target_sec = r_reloc_get_section (&r_rel);
6059 target_relax_info = get_xtensa_relax_info (target_sec);
6061 if (target_relax_info
6062 && (target_relax_info->is_relaxable_literal_section
6063 || target_relax_info->is_relaxable_asm_section))
6065 xtensa_opcode opcode = XTENSA_UNDEFINED;
6067 bfd_boolean is_abs_literal = FALSE;
6069 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
6071 /* None of the current alternate relocs are PC-relative,
6072 and only PC-relative relocs matter here. However, we
6073 still need to record the opcode for literal
6075 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6076 if (opcode == get_l32r_opcode ())
6078 is_abs_literal = TRUE;
6082 opcode = XTENSA_UNDEFINED;
6084 else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6086 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6087 opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
6090 if (opcode != XTENSA_UNDEFINED)
6092 int src_next = target_relax_info->src_next++;
6093 source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
6095 init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
6101 /* Now get rid of ASM_EXPAND relocations. At this point, the
6102 src_relocs array for the target literal section may still be
6103 incomplete, but it must at least contain the entries for the L32R
6104 relocations associated with ASM_EXPANDs because they were just
6105 added in the preceding loop over the relocations. */
6107 for (i = 0; i < sec->reloc_count; i++)
6109 Elf_Internal_Rela *irel = &internal_relocs[i];
6110 bfd_boolean is_reachable;
6112 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
6118 Elf_Internal_Rela *l32r_irel;
6120 asection *target_sec;
6121 xtensa_relax_info *target_relax_info;
6123 /* Mark the source_reloc for the L32R so that it will be
6124 removed in compute_removed_literals(), along with the
6125 associated literal. */
6126 l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
6127 irel, internal_relocs);
6128 if (l32r_irel == NULL)
6131 r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
6133 target_sec = r_reloc_get_section (&r_rel);
6134 target_relax_info = get_xtensa_relax_info (target_sec);
6136 if (target_relax_info
6137 && (target_relax_info->is_relaxable_literal_section
6138 || target_relax_info->is_relaxable_asm_section))
6140 source_reloc *s_reloc;
6142 /* Search the source_relocs for the entry corresponding to
6143 the l32r_irel. Note: The src_relocs array is not yet
6144 sorted, but it wouldn't matter anyway because we're
6145 searching by source offset instead of target offset. */
6146 s_reloc = find_source_reloc (target_relax_info->src_relocs,
6147 target_relax_info->src_next,
6149 BFD_ASSERT (s_reloc);
6150 s_reloc->is_null = TRUE;
6153 /* Convert this reloc to ASM_SIMPLIFY. */
6154 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
6155 R_XTENSA_ASM_SIMPLIFY);
6156 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
6158 pin_internal_relocs (sec, internal_relocs);
6162 /* It is resolvable but doesn't reach. We resolve now
6163 by eliminating the relocation -- the call will remain
6164 expanded into L32R/CALLX. */
6165 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
6166 pin_internal_relocs (sec, internal_relocs);
6171 release_contents (sec, contents);
6172 release_internal_relocs (sec, internal_relocs);
6177 /* Return TRUE if the asm expansion can be resolved. Generally it can
6178 be resolved on a final link or when a partial link locates it in the
6179 same section as the target. Set "is_reachable" flag if the target of
6180 the call is within the range of a direct call, given the current VMA
6181 for this section and the target section. */
6184 is_resolvable_asm_expansion (bfd *abfd,
6187 Elf_Internal_Rela *irel,
6188 struct bfd_link_info *link_info,
6189 bfd_boolean *is_reachable_p)
6191 asection *target_sec;
6192 bfd_vma target_offset;
6194 xtensa_opcode opcode, direct_call_opcode;
6195 bfd_vma self_address;
6196 bfd_vma dest_address;
6197 bfd_boolean uses_l32r;
6198 bfd_size_type sec_size;
6200 *is_reachable_p = FALSE;
6202 if (contents == NULL)
6205 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
6208 sec_size = bfd_get_section_limit (abfd, sec);
6209 opcode = get_expanded_call_opcode (contents + irel->r_offset,
6210 sec_size - irel->r_offset, &uses_l32r);
6211 /* Optimization of longcalls that use CONST16 is not yet implemented. */
6215 direct_call_opcode = swap_callx_for_call_opcode (opcode);
6216 if (direct_call_opcode == XTENSA_UNDEFINED)
6219 /* Check and see that the target resolves. */
6220 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6221 if (!r_reloc_is_defined (&r_rel))
6224 target_sec = r_reloc_get_section (&r_rel);
6225 target_offset = r_rel.target_offset;
6227 /* If the target is in a shared library, then it doesn't reach. This
6228 isn't supposed to come up because the compiler should never generate
6229 non-PIC calls on systems that use shared libraries, but the linker
6230 shouldn't crash regardless. */
6231 if (!target_sec->output_section)
6234 /* For relocatable sections, we can only simplify when the output
6235 section of the target is the same as the output section of the
6237 if (link_info->relocatable
6238 && (target_sec->output_section != sec->output_section
6239 || is_reloc_sym_weak (abfd, irel)))
6242 self_address = (sec->output_section->vma
6243 + sec->output_offset + irel->r_offset + 3);
6244 dest_address = (target_sec->output_section->vma
6245 + target_sec->output_offset + target_offset);
6247 *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
6248 self_address, dest_address);
6250 if ((self_address >> CALL_SEGMENT_BITS) !=
6251 (dest_address >> CALL_SEGMENT_BITS))
6258 static Elf_Internal_Rela *
6259 find_associated_l32r_irel (bfd *abfd,
6262 Elf_Internal_Rela *other_irel,
6263 Elf_Internal_Rela *internal_relocs)
6267 for (i = 0; i < sec->reloc_count; i++)
6269 Elf_Internal_Rela *irel = &internal_relocs[i];
6271 if (irel == other_irel)
6273 if (irel->r_offset != other_irel->r_offset)
6275 if (is_l32r_relocation (abfd, sec, contents, irel))
6283 /* The compute_text_actions function will build a list of potential
6284 transformation actions for code in the extended basic block of each
6285 longcall that is optimized to a direct call. From this list we
6286 generate a set of actions to actually perform that optimizes for
6287 space and, if not using size_opt, maintains branch target
6290 These actions to be performed are placed on a per-section list.
6291 The actual changes are performed by relax_section() in the second
6295 compute_text_actions (bfd *abfd,
6297 struct bfd_link_info *link_info)
6299 xtensa_relax_info *relax_info;
6301 Elf_Internal_Rela *internal_relocs;
6302 bfd_boolean ok = TRUE;
6304 property_table_entry *prop_table = 0;
6306 bfd_size_type sec_size;
6307 static bfd_boolean no_insn_move = FALSE;
6312 /* Do nothing if the section contains no optimized longcalls. */
6313 relax_info = get_xtensa_relax_info (sec);
6314 BFD_ASSERT (relax_info);
6315 if (!relax_info->is_relaxable_asm_section)
6318 internal_relocs = retrieve_internal_relocs (abfd, sec,
6319 link_info->keep_memory);
6321 if (internal_relocs)
6322 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
6323 internal_reloc_compare);
6325 sec_size = bfd_get_section_limit (abfd, sec);
6326 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6327 if (contents == NULL && sec_size != 0)
6333 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6334 XTENSA_PROP_SEC_NAME, FALSE);
6341 for (i = 0; i < sec->reloc_count; i++)
6343 Elf_Internal_Rela *irel = &internal_relocs[i];
6345 property_table_entry *the_entry;
6348 ebb_constraint ebb_table;
6349 bfd_size_type simplify_size;
6351 if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
6353 r_offset = irel->r_offset;
6355 simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
6356 if (simplify_size == 0)
6358 (*_bfd_error_handler)
6359 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
6360 sec->owner, sec, r_offset);
6364 /* If the instruction table is not around, then don't do this
6366 the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
6367 sec->vma + irel->r_offset);
6368 if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
6370 text_action_add (&relax_info->action_list,
6371 ta_convert_longcall, sec, r_offset,
6376 /* If the next longcall happens to be at the same address as an
6377 unreachable section of size 0, then skip forward. */
6378 ptbl_idx = the_entry - prop_table;
6379 while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
6380 && the_entry->size == 0
6381 && ptbl_idx + 1 < ptblsize
6382 && (prop_table[ptbl_idx + 1].address
6383 == prop_table[ptbl_idx].address))
6389 if (the_entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM)
6390 /* NO_REORDER is OK */
6393 init_ebb_constraint (&ebb_table);
6394 ebb = &ebb_table.ebb;
6395 init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
6396 internal_relocs, sec->reloc_count);
6397 ebb->start_offset = r_offset + simplify_size;
6398 ebb->end_offset = r_offset + simplify_size;
6399 ebb->start_ptbl_idx = ptbl_idx;
6400 ebb->end_ptbl_idx = ptbl_idx;
6401 ebb->start_reloc_idx = i;
6402 ebb->end_reloc_idx = i;
6404 if (!extend_ebb_bounds (ebb)
6405 || !compute_ebb_proposed_actions (&ebb_table)
6406 || !compute_ebb_actions (&ebb_table)
6407 || !check_section_ebb_pcrels_fit (abfd, sec, contents,
6408 internal_relocs, &ebb_table)
6409 || !check_section_ebb_reduces (&ebb_table))
6411 /* If anything goes wrong or we get unlucky and something does
6412 not fit, with our plan because of expansion between
6413 critical branches, just convert to a NOP. */
6415 text_action_add (&relax_info->action_list,
6416 ta_convert_longcall, sec, r_offset, 0);
6417 i = ebb_table.ebb.end_reloc_idx;
6418 free_ebb_constraint (&ebb_table);
6422 text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
6424 /* Update the index so we do not go looking at the relocations
6425 we have already processed. */
6426 i = ebb_table.ebb.end_reloc_idx;
6427 free_ebb_constraint (&ebb_table);
6431 if (relax_info->action_list.head)
6432 print_action_list (stderr, &relax_info->action_list);
6436 release_contents (sec, contents);
6437 release_internal_relocs (sec, internal_relocs);
6445 /* Find all of the possible actions for an extended basic block. */
6448 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
6450 const ebb_t *ebb = &ebb_table->ebb;
6451 unsigned rel_idx = ebb->start_reloc_idx;
6452 property_table_entry *entry, *start_entry, *end_entry;
6454 start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6455 end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6457 for (entry = start_entry; entry <= end_entry; entry++)
6459 bfd_vma offset, start_offset, end_offset;
6460 bfd_size_type insn_len;
6462 start_offset = entry->address - ebb->sec->vma;
6463 end_offset = entry->address + entry->size - ebb->sec->vma;
6465 if (entry == start_entry)
6466 start_offset = ebb->start_offset;
6467 if (entry == end_entry)
6468 end_offset = ebb->end_offset;
6469 offset = start_offset;
6471 if (offset == entry->address - ebb->sec->vma
6472 && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
6474 enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
6475 BFD_ASSERT (offset != end_offset);
6476 if (offset == end_offset)
6479 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
6482 /* Propose no actions for a section with an undecodable offset. */
6485 (*_bfd_error_handler)
6486 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6487 ebb->sec->owner, ebb->sec, offset);
6490 if (check_branch_target_aligned_address (offset, insn_len))
6491 align_type = EBB_REQUIRE_TGT_ALIGN;
6493 ebb_propose_action (ebb_table, align_type, 0,
6494 ta_none, offset, 0, TRUE);
6497 while (offset != end_offset)
6499 Elf_Internal_Rela *irel;
6500 xtensa_opcode opcode;
6502 while (rel_idx < ebb->end_reloc_idx
6503 && (ebb->relocs[rel_idx].r_offset < offset
6504 || (ebb->relocs[rel_idx].r_offset == offset
6505 && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
6506 != R_XTENSA_ASM_SIMPLIFY))))
6509 /* Check for longcall. */
6510 irel = &ebb->relocs[rel_idx];
6511 if (irel->r_offset == offset
6512 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
6514 bfd_size_type simplify_size;
6516 simplify_size = get_asm_simplify_size (ebb->contents,
6517 ebb->content_length,
6519 if (simplify_size == 0)
6521 (*_bfd_error_handler)
6522 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
6523 ebb->sec->owner, ebb->sec, offset);
6527 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6528 ta_convert_longcall, offset, 0, TRUE);
6530 offset += simplify_size;
6534 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
6536 /* If the instruction is undecodable, then report an error. */
6539 (*_bfd_error_handler)
6540 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6541 ebb->sec->owner, ebb->sec, offset);
6545 if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
6546 && (entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) == 0
6547 && narrow_instruction (ebb->contents, ebb->content_length,
6550 /* Add an instruction narrow action. */
6551 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6552 ta_narrow_insn, offset, 0, FALSE);
6556 if ((entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) == 0
6557 && widen_instruction (ebb->contents, ebb->content_length,
6560 /* Add an instruction widen action. */
6561 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6562 ta_widen_insn, offset, 0, FALSE);
6566 opcode = insn_decode_opcode (ebb->contents, ebb->content_length,
6568 if (xtensa_opcode_is_loop (xtensa_default_isa, opcode))
6570 /* Check for branch targets. */
6571 ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
6572 ta_none, offset, 0, TRUE);
6581 if (ebb->ends_unreachable)
6583 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6584 ta_fill, ebb->end_offset, 0, TRUE);
6591 /* After all of the information has collected about the
6592 transformations possible in an EBB, compute the appropriate actions
6593 here in compute_ebb_actions. We still must check later to make
6594 sure that the actions do not break any relocations. The algorithm
6595 used here is pretty greedy. Basically, it removes as many no-ops
6596 as possible so that the end of the EBB has the same alignment
6597 characteristics as the original. First, it uses narrowing, then
6598 fill space at the end of the EBB, and finally widenings. If that
6599 does not work, it tries again with one fewer no-op removed. The
6600 optimization will only be performed if all of the branch targets
6601 that were aligned before transformation are also aligned after the
6604 When the size_opt flag is set, ignore the branch target alignments,
6605 narrow all wide instructions, and remove all no-ops unless the end
6606 of the EBB prevents it. */
6609 compute_ebb_actions (ebb_constraint *ebb_table)
6613 int removed_bytes = 0;
6614 ebb_t *ebb = &ebb_table->ebb;
6615 unsigned seg_idx_start = 0;
6616 unsigned seg_idx_end = 0;
6618 /* We perform this like the assembler relaxation algorithm: Start by
6619 assuming all instructions are narrow and all no-ops removed; then
6622 /* For each segment of this that has a solid constraint, check to
6623 see if there are any combinations that will keep the constraint.
6625 for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
6627 bfd_boolean requires_text_end_align = FALSE;
6628 unsigned longcall_count = 0;
6629 unsigned longcall_convert_count = 0;
6630 unsigned narrowable_count = 0;
6631 unsigned narrowable_convert_count = 0;
6632 unsigned widenable_count = 0;
6633 unsigned widenable_convert_count = 0;
6635 proposed_action *action = NULL;
6636 int align = (1 << ebb_table->ebb.sec->alignment_power);
6638 seg_idx_start = seg_idx_end;
6640 for (i = seg_idx_start; i < ebb_table->action_count; i++)
6642 action = &ebb_table->actions[i];
6643 if (action->action == ta_convert_longcall)
6645 if (action->action == ta_narrow_insn)
6647 if (action->action == ta_widen_insn)
6649 if (action->action == ta_fill)
6651 if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
6653 if (action->align_type == EBB_REQUIRE_TGT_ALIGN
6654 && !elf32xtensa_size_opt)
6659 if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
6660 requires_text_end_align = TRUE;
6662 if (elf32xtensa_size_opt && !requires_text_end_align
6663 && action->align_type != EBB_REQUIRE_LOOP_ALIGN
6664 && action->align_type != EBB_REQUIRE_TGT_ALIGN)
6666 longcall_convert_count = longcall_count;
6667 narrowable_convert_count = narrowable_count;
6668 widenable_convert_count = 0;
6672 /* There is a constraint. Convert the max number of longcalls. */
6673 narrowable_convert_count = 0;
6674 longcall_convert_count = 0;
6675 widenable_convert_count = 0;
6677 for (j = 0; j < longcall_count; j++)
6679 int removed = (longcall_count - j) * 3 & (align - 1);
6680 unsigned desire_narrow = (align - removed) & (align - 1);
6681 unsigned desire_widen = removed;
6682 if (desire_narrow <= narrowable_count)
6684 narrowable_convert_count = desire_narrow;
6685 narrowable_convert_count +=
6686 (align * ((narrowable_count - narrowable_convert_count)
6688 longcall_convert_count = (longcall_count - j);
6689 widenable_convert_count = 0;
6692 if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
6694 narrowable_convert_count = 0;
6695 longcall_convert_count = longcall_count - j;
6696 widenable_convert_count = desire_widen;
6702 /* Now the number of conversions are saved. Do them. */
6703 for (i = seg_idx_start; i < seg_idx_end; i++)
6705 action = &ebb_table->actions[i];
6706 switch (action->action)
6708 case ta_convert_longcall:
6709 if (longcall_convert_count != 0)
6711 action->action = ta_remove_longcall;
6712 action->do_action = TRUE;
6713 action->removed_bytes += 3;
6714 longcall_convert_count--;
6717 case ta_narrow_insn:
6718 if (narrowable_convert_count != 0)
6720 action->do_action = TRUE;
6721 action->removed_bytes += 1;
6722 narrowable_convert_count--;
6726 if (widenable_convert_count != 0)
6728 action->do_action = TRUE;
6729 action->removed_bytes -= 1;
6730 widenable_convert_count--;
6739 /* Now we move on to some local opts. Try to remove each of the
6740 remaining longcalls. */
6742 if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
6745 for (i = 0; i < ebb_table->action_count; i++)
6747 int old_removed_bytes = removed_bytes;
6748 proposed_action *action = &ebb_table->actions[i];
6750 if (action->do_action && action->action == ta_convert_longcall)
6752 bfd_boolean bad_alignment = FALSE;
6754 for (j = i + 1; j < ebb_table->action_count; j++)
6756 proposed_action *new_action = &ebb_table->actions[j];
6757 bfd_vma offset = new_action->offset;
6758 if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
6760 if (!check_branch_target_aligned
6761 (ebb_table->ebb.contents,
6762 ebb_table->ebb.content_length,
6763 offset, offset - removed_bytes))
6765 bad_alignment = TRUE;
6769 if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
6771 if (!check_loop_aligned (ebb_table->ebb.contents,
6772 ebb_table->ebb.content_length,
6774 offset - removed_bytes))
6776 bad_alignment = TRUE;
6780 if (new_action->action == ta_narrow_insn
6781 && !new_action->do_action
6782 && ebb_table->ebb.sec->alignment_power == 2)
6784 /* Narrow an instruction and we are done. */
6785 new_action->do_action = TRUE;
6786 new_action->removed_bytes += 1;
6787 bad_alignment = FALSE;
6790 if (new_action->action == ta_widen_insn
6791 && new_action->do_action
6792 && ebb_table->ebb.sec->alignment_power == 2)
6794 /* Narrow an instruction and we are done. */
6795 new_action->do_action = FALSE;
6796 new_action->removed_bytes += 1;
6797 bad_alignment = FALSE;
6803 action->removed_bytes += 3;
6804 action->action = ta_remove_longcall;
6805 action->do_action = TRUE;
6808 removed_bytes = old_removed_bytes;
6809 if (action->do_action)
6810 removed_bytes += action->removed_bytes;
6815 for (i = 0; i < ebb_table->action_count; ++i)
6817 proposed_action *action = &ebb_table->actions[i];
6818 if (action->do_action)
6819 removed_bytes += action->removed_bytes;
6822 if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
6823 && ebb->ends_unreachable)
6825 proposed_action *action;
6829 BFD_ASSERT (ebb_table->action_count != 0);
6830 action = &ebb_table->actions[ebb_table->action_count - 1];
6831 BFD_ASSERT (action->action == ta_fill);
6832 BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
6834 extra_space = compute_fill_extra_space (ebb->ends_unreachable);
6835 br = action->removed_bytes + removed_bytes + extra_space;
6836 br = br & ((1 << ebb->sec->alignment_power ) - 1);
6838 action->removed_bytes = extra_space - br;
6844 /* Use check_section_ebb_pcrels_fit to make sure that all of the
6845 relocations in a section will fit if a proposed set of actions
6849 check_section_ebb_pcrels_fit (bfd *abfd,
6852 Elf_Internal_Rela *internal_relocs,
6853 const ebb_constraint *constraint)
6856 Elf_Internal_Rela *irel;
6857 xtensa_relax_info *relax_info;
6859 relax_info = get_xtensa_relax_info (sec);
6861 for (i = 0; i < sec->reloc_count; i++)
6864 bfd_vma orig_self_offset, orig_target_offset;
6865 bfd_vma self_offset, target_offset;
6867 reloc_howto_type *howto;
6868 int self_removed_bytes, target_removed_bytes;
6870 irel = &internal_relocs[i];
6871 r_type = ELF32_R_TYPE (irel->r_info);
6873 howto = &elf_howto_table[r_type];
6874 /* We maintain the required invariant: PC-relative relocations
6875 that fit before linking must fit after linking. Thus we only
6876 need to deal with relocations to the same section that are
6878 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY
6879 || !howto->pc_relative)
6882 r_reloc_init (&r_rel, abfd, irel, contents,
6883 bfd_get_section_limit (abfd, sec));
6885 if (r_reloc_get_section (&r_rel) != sec)
6888 orig_self_offset = irel->r_offset;
6889 orig_target_offset = r_rel.target_offset;
6891 self_offset = orig_self_offset;
6892 target_offset = orig_target_offset;
6896 self_offset = offset_with_removed_text (&relax_info->action_list,
6898 target_offset = offset_with_removed_text (&relax_info->action_list,
6899 orig_target_offset);
6902 self_removed_bytes = 0;
6903 target_removed_bytes = 0;
6905 for (j = 0; j < constraint->action_count; ++j)
6907 proposed_action *action = &constraint->actions[j];
6908 bfd_vma offset = action->offset;
6909 int removed_bytes = action->removed_bytes;
6910 if (offset < orig_self_offset
6911 || (offset == orig_self_offset && action->action == ta_fill
6912 && action->removed_bytes < 0))
6913 self_removed_bytes += removed_bytes;
6914 if (offset < orig_target_offset
6915 || (offset == orig_target_offset && action->action == ta_fill
6916 && action->removed_bytes < 0))
6917 target_removed_bytes += removed_bytes;
6919 self_offset -= self_removed_bytes;
6920 target_offset -= target_removed_bytes;
6922 /* Try to encode it. Get the operand and check. */
6923 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
6925 /* None of the current alternate relocs are PC-relative,
6926 and only PC-relative relocs matter here. */
6930 xtensa_opcode opcode;
6933 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6934 if (opcode == XTENSA_UNDEFINED)
6937 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
6938 if (opnum == XTENSA_UNDEFINED)
6941 if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
6951 check_section_ebb_reduces (const ebb_constraint *constraint)
6956 for (i = 0; i < constraint->action_count; i++)
6958 const proposed_action *action = &constraint->actions[i];
6959 if (action->do_action)
6960 removed += action->removed_bytes;
6970 text_action_add_proposed (text_action_list *l,
6971 const ebb_constraint *ebb_table,
6976 for (i = 0; i < ebb_table->action_count; i++)
6978 proposed_action *action = &ebb_table->actions[i];
6980 if (!action->do_action)
6982 switch (action->action)
6984 case ta_remove_insn:
6985 case ta_remove_longcall:
6986 case ta_convert_longcall:
6987 case ta_narrow_insn:
6990 case ta_remove_literal:
6991 text_action_add (l, action->action, sec, action->offset,
6992 action->removed_bytes);
7005 compute_fill_extra_space (property_table_entry *entry)
7007 int fill_extra_space;
7012 if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
7015 fill_extra_space = entry->size;
7016 if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
7018 /* Fill bytes for alignment:
7019 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
7020 int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
7021 int nsm = (1 << pow) - 1;
7022 bfd_vma addr = entry->address + entry->size;
7023 bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
7024 fill_extra_space += align_fill;
7026 return fill_extra_space;
7030 /* First relaxation pass. */
7032 /* If the section contains relaxable literals, check each literal to
7033 see if it has the same value as another literal that has already
7034 been seen, either in the current section or a previous one. If so,
7035 add an entry to the per-section list of removed literals. The
7036 actual changes are deferred until the next pass. */
7039 compute_removed_literals (bfd *abfd,
7041 struct bfd_link_info *link_info,
7042 value_map_hash_table *values)
7044 xtensa_relax_info *relax_info;
7046 Elf_Internal_Rela *internal_relocs;
7047 source_reloc *src_relocs, *rel;
7048 bfd_boolean ok = TRUE;
7049 property_table_entry *prop_table = NULL;
7052 bfd_boolean last_loc_is_prev = FALSE;
7053 bfd_vma last_target_offset = 0;
7054 section_cache_t target_sec_cache;
7055 bfd_size_type sec_size;
7057 init_section_cache (&target_sec_cache);
7059 /* Do nothing if it is not a relaxable literal section. */
7060 relax_info = get_xtensa_relax_info (sec);
7061 BFD_ASSERT (relax_info);
7062 if (!relax_info->is_relaxable_literal_section)
7065 internal_relocs = retrieve_internal_relocs (abfd, sec,
7066 link_info->keep_memory);
7068 sec_size = bfd_get_section_limit (abfd, sec);
7069 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7070 if (contents == NULL && sec_size != 0)
7076 /* Sort the source_relocs by target offset. */
7077 src_relocs = relax_info->src_relocs;
7078 qsort (src_relocs, relax_info->src_count,
7079 sizeof (source_reloc), source_reloc_compare);
7080 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7081 internal_reloc_compare);
7083 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7084 XTENSA_PROP_SEC_NAME, FALSE);
7092 for (i = 0; i < relax_info->src_count; i++)
7094 Elf_Internal_Rela *irel = NULL;
7096 rel = &src_relocs[i];
7097 if (get_l32r_opcode () != rel->opcode)
7099 irel = get_irel_at_offset (sec, internal_relocs,
7100 rel->r_rel.target_offset);
7102 /* If the relocation on this is not a simple R_XTENSA_32 or
7103 R_XTENSA_PLT then do not consider it. This may happen when
7104 the difference of two symbols is used in a literal. */
7105 if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
7106 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
7109 /* If the target_offset for this relocation is the same as the
7110 previous relocation, then we've already considered whether the
7111 literal can be coalesced. Skip to the next one.... */
7112 if (i != 0 && prev_i != -1
7113 && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
7117 if (last_loc_is_prev &&
7118 last_target_offset + 4 != rel->r_rel.target_offset)
7119 last_loc_is_prev = FALSE;
7121 /* Check if the relocation was from an L32R that is being removed
7122 because a CALLX was converted to a direct CALL, and check if
7123 there are no other relocations to the literal. */
7124 if (is_removable_literal (rel, i, src_relocs, relax_info->src_count))
7126 if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
7127 irel, rel, prop_table, ptblsize))
7132 last_target_offset = rel->r_rel.target_offset;
7136 if (!identify_literal_placement (abfd, sec, contents, link_info,
7138 &last_loc_is_prev, irel,
7139 relax_info->src_count - i, rel,
7140 prop_table, ptblsize,
7141 &target_sec_cache, rel->is_abs_literal))
7146 last_target_offset = rel->r_rel.target_offset;
7150 print_removed_literals (stderr, &relax_info->removed_list);
7151 print_action_list (stderr, &relax_info->action_list);
7155 if (prop_table) free (prop_table);
7156 clear_section_cache (&target_sec_cache);
7158 release_contents (sec, contents);
7159 release_internal_relocs (sec, internal_relocs);
7164 static Elf_Internal_Rela *
7165 get_irel_at_offset (asection *sec,
7166 Elf_Internal_Rela *internal_relocs,
7170 Elf_Internal_Rela *irel;
7172 Elf_Internal_Rela key;
7174 if (!internal_relocs)
7177 key.r_offset = offset;
7178 irel = bsearch (&key, internal_relocs, sec->reloc_count,
7179 sizeof (Elf_Internal_Rela), internal_reloc_matches);
7183 /* bsearch does not guarantee which will be returned if there are
7184 multiple matches. We need the first that is not an alignment. */
7185 i = irel - internal_relocs;
7188 if (internal_relocs[i-1].r_offset != offset)
7192 for ( ; i < sec->reloc_count; i++)
7194 irel = &internal_relocs[i];
7195 r_type = ELF32_R_TYPE (irel->r_info);
7196 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
7205 is_removable_literal (const source_reloc *rel,
7207 const source_reloc *src_relocs,
7210 const source_reloc *curr_rel;
7214 for (++i; i < src_count; ++i)
7216 curr_rel = &src_relocs[i];
7217 /* If all others have the same target offset.... */
7218 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
7221 if (!curr_rel->is_null
7222 && !xtensa_is_property_section (curr_rel->source_sec)
7223 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
7231 remove_dead_literal (bfd *abfd,
7233 struct bfd_link_info *link_info,
7234 Elf_Internal_Rela *internal_relocs,
7235 Elf_Internal_Rela *irel,
7237 property_table_entry *prop_table,
7240 property_table_entry *entry;
7241 xtensa_relax_info *relax_info;
7243 relax_info = get_xtensa_relax_info (sec);
7247 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7248 sec->vma + rel->r_rel.target_offset);
7250 /* Mark the unused literal so that it will be removed. */
7251 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
7253 text_action_add (&relax_info->action_list,
7254 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7256 /* If the section is 4-byte aligned, do not add fill. */
7257 if (sec->alignment_power > 2)
7259 int fill_extra_space;
7260 bfd_vma entry_sec_offset;
7262 property_table_entry *the_add_entry;
7266 entry_sec_offset = entry->address - sec->vma + entry->size;
7268 entry_sec_offset = rel->r_rel.target_offset + 4;
7270 /* If the literal range is at the end of the section,
7272 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7274 fill_extra_space = compute_fill_extra_space (the_add_entry);
7276 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7277 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7278 -4, fill_extra_space);
7280 adjust_fill_action (fa, removed_diff);
7282 text_action_add (&relax_info->action_list,
7283 ta_fill, sec, entry_sec_offset, removed_diff);
7286 /* Zero out the relocation on this literal location. */
7289 if (elf_hash_table (link_info)->dynamic_sections_created)
7290 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
7292 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7293 pin_internal_relocs (sec, internal_relocs);
7296 /* Do not modify "last_loc_is_prev". */
7302 identify_literal_placement (bfd *abfd,
7305 struct bfd_link_info *link_info,
7306 value_map_hash_table *values,
7307 bfd_boolean *last_loc_is_prev_p,
7308 Elf_Internal_Rela *irel,
7309 int remaining_src_rels,
7311 property_table_entry *prop_table,
7313 section_cache_t *target_sec_cache,
7314 bfd_boolean is_abs_literal)
7318 xtensa_relax_info *relax_info;
7319 bfd_boolean literal_placed = FALSE;
7321 unsigned long value;
7322 bfd_boolean final_static_link;
7323 bfd_size_type sec_size;
7325 relax_info = get_xtensa_relax_info (sec);
7329 sec_size = bfd_get_section_limit (abfd, sec);
7332 (!link_info->relocatable
7333 && !elf_hash_table (link_info)->dynamic_sections_created);
7335 /* The placement algorithm first checks to see if the literal is
7336 already in the value map. If so and the value map is reachable
7337 from all uses, then the literal is moved to that location. If
7338 not, then we identify the last location where a fresh literal was
7339 placed. If the literal can be safely moved there, then we do so.
7340 If not, then we assume that the literal is not to move and leave
7341 the literal where it is, marking it as the last literal
7344 /* Find the literal value. */
7346 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7349 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
7350 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
7352 init_literal_value (&val, &r_rel, value, is_abs_literal);
7354 /* Check if we've seen another literal with the same value that
7355 is in the same output section. */
7356 val_map = value_map_get_cached_value (values, &val, final_static_link);
7359 && (r_reloc_get_section (&val_map->loc)->output_section
7360 == sec->output_section)
7361 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
7362 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
7364 /* No change to last_loc_is_prev. */
7365 literal_placed = TRUE;
7368 /* For relocatable links, do not try to move literals. To do it
7369 correctly might increase the number of relocations in an input
7370 section making the default relocatable linking fail. */
7371 if (!link_info->relocatable && !literal_placed
7372 && values->has_last_loc && !(*last_loc_is_prev_p))
7374 asection *target_sec = r_reloc_get_section (&values->last_loc);
7375 if (target_sec && target_sec->output_section == sec->output_section)
7377 /* Increment the virtual offset. */
7378 r_reloc try_loc = values->last_loc;
7379 try_loc.virtual_offset += 4;
7381 /* There is a last loc that was in the same output section. */
7382 if (relocations_reach (rel, remaining_src_rels, &try_loc)
7383 && move_shared_literal (sec, link_info, rel,
7384 prop_table, ptblsize,
7385 &try_loc, &val, target_sec_cache))
7387 values->last_loc.virtual_offset += 4;
7388 literal_placed = TRUE;
7390 val_map = add_value_map (values, &val, &try_loc,
7393 val_map->loc = try_loc;
7398 if (!literal_placed)
7400 /* Nothing worked, leave the literal alone but update the last loc. */
7401 values->has_last_loc = TRUE;
7402 values->last_loc = rel->r_rel;
7404 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
7406 val_map->loc = rel->r_rel;
7407 *last_loc_is_prev_p = TRUE;
7414 /* Check if the original relocations (presumably on L32R instructions)
7415 identified by reloc[0..N] can be changed to reference the literal
7416 identified by r_rel. If r_rel is out of range for any of the
7417 original relocations, then we don't want to coalesce the original
7418 literal with the one at r_rel. We only check reloc[0..N], where the
7419 offsets are all the same as for reloc[0] (i.e., they're all
7420 referencing the same literal) and where N is also bounded by the
7421 number of remaining entries in the "reloc" array. The "reloc" array
7422 is sorted by target offset so we know all the entries for the same
7423 literal will be contiguous. */
7426 relocations_reach (source_reloc *reloc,
7427 int remaining_relocs,
7428 const r_reloc *r_rel)
7430 bfd_vma from_offset, source_address, dest_address;
7434 if (!r_reloc_is_defined (r_rel))
7437 sec = r_reloc_get_section (r_rel);
7438 from_offset = reloc[0].r_rel.target_offset;
7440 for (i = 0; i < remaining_relocs; i++)
7442 if (reloc[i].r_rel.target_offset != from_offset)
7445 /* Ignore relocations that have been removed. */
7446 if (reloc[i].is_null)
7449 /* The original and new output section for these must be the same
7450 in order to coalesce. */
7451 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
7452 != sec->output_section)
7455 /* A literal with no PC-relative relocations can be moved anywhere. */
7456 if (reloc[i].opnd != -1)
7458 /* Otherwise, check to see that it fits. */
7459 source_address = (reloc[i].source_sec->output_section->vma
7460 + reloc[i].source_sec->output_offset
7461 + reloc[i].r_rel.rela.r_offset);
7462 dest_address = (sec->output_section->vma
7463 + sec->output_offset
7464 + r_rel->target_offset);
7466 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
7467 source_address, dest_address))
7476 /* Move a literal to another literal location because it is
7477 the same as the other literal value. */
7480 coalesce_shared_literal (asection *sec,
7482 property_table_entry *prop_table,
7486 property_table_entry *entry;
7488 property_table_entry *the_add_entry;
7490 xtensa_relax_info *relax_info;
7492 relax_info = get_xtensa_relax_info (sec);
7496 entry = elf_xtensa_find_property_entry
7497 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
7498 if (entry && (entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM))
7501 /* Mark that the literal will be coalesced. */
7502 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
7504 text_action_add (&relax_info->action_list,
7505 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7507 /* If the section is 4-byte aligned, do not add fill. */
7508 if (sec->alignment_power > 2)
7510 int fill_extra_space;
7511 bfd_vma entry_sec_offset;
7514 entry_sec_offset = entry->address - sec->vma + entry->size;
7516 entry_sec_offset = rel->r_rel.target_offset + 4;
7518 /* If the literal range is at the end of the section,
7520 fill_extra_space = 0;
7521 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7523 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7524 fill_extra_space = the_add_entry->size;
7526 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7527 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7528 -4, fill_extra_space);
7530 adjust_fill_action (fa, removed_diff);
7532 text_action_add (&relax_info->action_list,
7533 ta_fill, sec, entry_sec_offset, removed_diff);
7540 /* Move a literal to another location. This may actually increase the
7541 total amount of space used because of alignments so we need to do
7542 this carefully. Also, it may make a branch go out of range. */
7545 move_shared_literal (asection *sec,
7546 struct bfd_link_info *link_info,
7548 property_table_entry *prop_table,
7550 const r_reloc *target_loc,
7551 const literal_value *lit_value,
7552 section_cache_t *target_sec_cache)
7554 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
7555 text_action *fa, *target_fa;
7557 xtensa_relax_info *relax_info, *target_relax_info;
7558 asection *target_sec;
7560 ebb_constraint ebb_table;
7561 bfd_boolean relocs_fit;
7563 /* If this routine always returns FALSE, the literals that cannot be
7564 coalesced will not be moved. */
7565 if (elf32xtensa_no_literal_movement)
7568 relax_info = get_xtensa_relax_info (sec);
7572 target_sec = r_reloc_get_section (target_loc);
7573 target_relax_info = get_xtensa_relax_info (target_sec);
7575 /* Literals to undefined sections may not be moved because they
7576 must report an error. */
7577 if (bfd_is_und_section (target_sec))
7580 src_entry = elf_xtensa_find_property_entry
7581 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
7583 if (!section_cache_section (target_sec_cache, target_sec, link_info))
7586 target_entry = elf_xtensa_find_property_entry
7587 (target_sec_cache->ptbl, target_sec_cache->pte_count,
7588 target_sec->vma + target_loc->target_offset);
7593 /* Make sure that we have not broken any branches. */
7596 init_ebb_constraint (&ebb_table);
7597 ebb = &ebb_table.ebb;
7598 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
7599 target_sec_cache->content_length,
7600 target_sec_cache->ptbl, target_sec_cache->pte_count,
7601 target_sec_cache->relocs, target_sec_cache->reloc_count);
7603 /* Propose to add 4 bytes + worst-case alignment size increase to
7605 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
7606 ta_fill, target_loc->target_offset,
7607 -4 - (1 << target_sec->alignment_power), TRUE);
7609 /* Check all of the PC-relative relocations to make sure they still fit. */
7610 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
7611 target_sec_cache->contents,
7612 target_sec_cache->relocs,
7618 text_action_add_literal (&target_relax_info->action_list,
7619 ta_add_literal, target_loc, lit_value, -4);
7621 if (target_sec->alignment_power > 2 && target_entry != src_entry)
7623 /* May need to add or remove some fill to maintain alignment. */
7624 int fill_extra_space;
7625 bfd_vma entry_sec_offset;
7628 target_entry->address - target_sec->vma + target_entry->size;
7630 /* If the literal range is at the end of the section,
7632 fill_extra_space = 0;
7634 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
7635 target_sec_cache->pte_count,
7637 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7638 fill_extra_space = the_add_entry->size;
7640 target_fa = find_fill_action (&target_relax_info->action_list,
7641 target_sec, entry_sec_offset);
7642 removed_diff = compute_removed_action_diff (target_fa, target_sec,
7643 entry_sec_offset, 4,
7646 adjust_fill_action (target_fa, removed_diff);
7648 text_action_add (&target_relax_info->action_list,
7649 ta_fill, target_sec, entry_sec_offset, removed_diff);
7652 /* Mark that the literal will be moved to the new location. */
7653 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
7655 /* Remove the literal. */
7656 text_action_add (&relax_info->action_list,
7657 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7659 /* If the section is 4-byte aligned, do not add fill. */
7660 if (sec->alignment_power > 2 && target_entry != src_entry)
7662 int fill_extra_space;
7663 bfd_vma entry_sec_offset;
7666 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
7668 entry_sec_offset = rel->r_rel.target_offset+4;
7670 /* If the literal range is at the end of the section,
7672 fill_extra_space = 0;
7673 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7675 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7676 fill_extra_space = the_add_entry->size;
7678 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7679 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7680 -4, fill_extra_space);
7682 adjust_fill_action (fa, removed_diff);
7684 text_action_add (&relax_info->action_list,
7685 ta_fill, sec, entry_sec_offset, removed_diff);
7692 /* Second relaxation pass. */
7694 /* Modify all of the relocations to point to the right spot, and if this
7695 is a relaxable section, delete the unwanted literals and fix the
7699 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
7701 Elf_Internal_Rela *internal_relocs;
7702 xtensa_relax_info *relax_info;
7704 bfd_boolean ok = TRUE;
7706 bfd_boolean rv = FALSE;
7707 bfd_boolean virtual_action;
7708 bfd_size_type sec_size;
7710 sec_size = bfd_get_section_limit (abfd, sec);
7711 relax_info = get_xtensa_relax_info (sec);
7712 BFD_ASSERT (relax_info);
7714 /* First translate any of the fixes that have been added already. */
7715 translate_section_fixes (sec);
7717 /* Handle property sections (e.g., literal tables) specially. */
7718 if (xtensa_is_property_section (sec))
7720 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
7721 return relax_property_section (abfd, sec, link_info);
7724 internal_relocs = retrieve_internal_relocs (abfd, sec,
7725 link_info->keep_memory);
7726 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7727 if (contents == NULL && sec_size != 0)
7733 if (internal_relocs)
7735 for (i = 0; i < sec->reloc_count; i++)
7737 Elf_Internal_Rela *irel;
7738 xtensa_relax_info *target_relax_info;
7739 bfd_vma source_offset, old_source_offset;
7742 asection *target_sec;
7744 /* Locally change the source address.
7745 Translate the target to the new target address.
7746 If it points to this section and has been removed,
7750 irel = &internal_relocs[i];
7751 source_offset = irel->r_offset;
7752 old_source_offset = source_offset;
7754 r_type = ELF32_R_TYPE (irel->r_info);
7755 r_reloc_init (&r_rel, abfd, irel, contents,
7756 bfd_get_section_limit (abfd, sec));
7758 /* If this section could have changed then we may need to
7759 change the relocation's offset. */
7761 if (relax_info->is_relaxable_literal_section
7762 || relax_info->is_relaxable_asm_section)
7764 if (r_type != R_XTENSA_NONE
7765 && find_removed_literal (&relax_info->removed_list,
7768 /* Remove this relocation. */
7769 if (elf_hash_table (link_info)->dynamic_sections_created)
7770 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
7771 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7772 irel->r_offset = offset_with_removed_text
7773 (&relax_info->action_list, irel->r_offset);
7774 pin_internal_relocs (sec, internal_relocs);
7778 if (r_type == R_XTENSA_ASM_SIMPLIFY)
7780 text_action *action =
7781 find_insn_action (&relax_info->action_list,
7783 if (action && (action->action == ta_convert_longcall
7784 || action->action == ta_remove_longcall))
7786 bfd_reloc_status_type retval;
7787 char *error_message = NULL;
7789 retval = contract_asm_expansion (contents, sec_size,
7790 irel, &error_message);
7791 if (retval != bfd_reloc_ok)
7793 (*link_info->callbacks->reloc_dangerous)
7794 (link_info, error_message, abfd, sec,
7798 /* Update the action so that the code that moves
7799 the contents will do the right thing. */
7800 if (action->action == ta_remove_longcall)
7801 action->action = ta_remove_insn;
7803 action->action = ta_none;
7804 /* Refresh the info in the r_rel. */
7805 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7806 r_type = ELF32_R_TYPE (irel->r_info);
7810 source_offset = offset_with_removed_text
7811 (&relax_info->action_list, irel->r_offset);
7812 irel->r_offset = source_offset;
7815 /* If the target section could have changed then
7816 we may need to change the relocation's target offset. */
7818 target_sec = r_reloc_get_section (&r_rel);
7819 target_relax_info = get_xtensa_relax_info (target_sec);
7821 if (target_relax_info
7822 && (target_relax_info->is_relaxable_literal_section
7823 || target_relax_info->is_relaxable_asm_section))
7827 bfd_vma addend_displacement;
7829 translate_reloc (&r_rel, &new_reloc);
7831 if (r_type == R_XTENSA_DIFF8
7832 || r_type == R_XTENSA_DIFF16
7833 || r_type == R_XTENSA_DIFF32)
7835 bfd_vma diff_value = 0, new_end_offset, diff_mask = 0;
7837 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
7839 (*link_info->callbacks->reloc_dangerous)
7840 (link_info, _("invalid relocation address"),
7841 abfd, sec, old_source_offset);
7847 case R_XTENSA_DIFF8:
7849 bfd_get_8 (abfd, &contents[old_source_offset]);
7851 case R_XTENSA_DIFF16:
7853 bfd_get_16 (abfd, &contents[old_source_offset]);
7855 case R_XTENSA_DIFF32:
7857 bfd_get_32 (abfd, &contents[old_source_offset]);
7861 new_end_offset = offset_with_removed_text
7862 (&target_relax_info->action_list,
7863 r_rel.target_offset + diff_value);
7864 diff_value = new_end_offset - new_reloc.target_offset;
7868 case R_XTENSA_DIFF8:
7870 bfd_put_8 (abfd, diff_value,
7871 &contents[old_source_offset]);
7873 case R_XTENSA_DIFF16:
7875 bfd_put_16 (abfd, diff_value,
7876 &contents[old_source_offset]);
7878 case R_XTENSA_DIFF32:
7879 diff_mask = 0xffffffff;
7880 bfd_put_32 (abfd, diff_value,
7881 &contents[old_source_offset]);
7885 /* Check for overflow. */
7886 if ((diff_value & ~diff_mask) != 0)
7888 (*link_info->callbacks->reloc_dangerous)
7889 (link_info, _("overflow after relaxation"),
7890 abfd, sec, old_source_offset);
7894 pin_contents (sec, contents);
7897 /* FIXME: If the relocation still references a section in
7898 the same input file, the relocation should be modified
7899 directly instead of adding a "fix" record. */
7901 addend_displacement =
7902 new_reloc.target_offset + new_reloc.virtual_offset;
7904 fix = reloc_bfd_fix_init (sec, source_offset, r_type, 0,
7905 r_reloc_get_section (&new_reloc),
7906 addend_displacement, TRUE);
7910 pin_internal_relocs (sec, internal_relocs);
7914 if ((relax_info->is_relaxable_literal_section
7915 || relax_info->is_relaxable_asm_section)
7916 && relax_info->action_list.head)
7918 /* Walk through the planned actions and build up a table
7919 of move, copy and fill records. Use the move, copy and
7920 fill records to perform the actions once. */
7922 bfd_size_type size = sec->size;
7924 bfd_size_type final_size, copy_size, orig_insn_size;
7925 bfd_byte *scratch = NULL;
7926 bfd_byte *dup_contents = NULL;
7927 bfd_size_type orig_size = size;
7928 bfd_vma orig_dot = 0;
7929 bfd_vma orig_dot_copied = 0; /* Byte copied already from
7930 orig dot in physical memory. */
7931 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
7932 bfd_vma dup_dot = 0;
7934 text_action *action = relax_info->action_list.head;
7936 final_size = sec->size;
7937 for (action = relax_info->action_list.head; action;
7938 action = action->next)
7940 final_size -= action->removed_bytes;
7943 scratch = (bfd_byte *) bfd_zmalloc (final_size);
7944 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
7946 /* The dot is the current fill location. */
7948 print_action_list (stderr, &relax_info->action_list);
7951 for (action = relax_info->action_list.head; action;
7952 action = action->next)
7954 virtual_action = FALSE;
7955 if (action->offset > orig_dot)
7957 orig_dot += orig_dot_copied;
7958 orig_dot_copied = 0;
7960 /* Out of the virtual world. */
7963 if (action->offset > orig_dot)
7965 copy_size = action->offset - orig_dot;
7966 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
7967 orig_dot += copy_size;
7968 dup_dot += copy_size;
7969 BFD_ASSERT (action->offset == orig_dot);
7971 else if (action->offset < orig_dot)
7973 if (action->action == ta_fill
7974 && action->offset - action->removed_bytes == orig_dot)
7976 /* This is OK because the fill only effects the dup_dot. */
7978 else if (action->action == ta_add_literal)
7980 /* TBD. Might need to handle this. */
7983 if (action->offset == orig_dot)
7985 if (action->virtual_offset > orig_dot_vo)
7987 if (orig_dot_vo == 0)
7989 /* Need to copy virtual_offset bytes. Probably four. */
7990 copy_size = action->virtual_offset - orig_dot_vo;
7991 memmove (&dup_contents[dup_dot],
7992 &contents[orig_dot], copy_size);
7993 orig_dot_copied = copy_size;
7994 dup_dot += copy_size;
7996 virtual_action = TRUE;
7999 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
8001 switch (action->action)
8003 case ta_remove_literal:
8004 case ta_remove_insn:
8005 BFD_ASSERT (action->removed_bytes >= 0);
8006 orig_dot += action->removed_bytes;
8009 case ta_narrow_insn:
8012 memmove (scratch, &contents[orig_dot], orig_insn_size);
8013 BFD_ASSERT (action->removed_bytes == 1);
8014 rv = narrow_instruction (scratch, final_size, 0, TRUE);
8016 memmove (&dup_contents[dup_dot], scratch, copy_size);
8017 orig_dot += orig_insn_size;
8018 dup_dot += copy_size;
8022 if (action->removed_bytes >= 0)
8023 orig_dot += action->removed_bytes;
8026 /* Already zeroed in dup_contents. Just bump the
8028 dup_dot += (-action->removed_bytes);
8033 BFD_ASSERT (action->removed_bytes == 0);
8036 case ta_convert_longcall:
8037 case ta_remove_longcall:
8038 /* These will be removed or converted before we get here. */
8045 memmove (scratch, &contents[orig_dot], orig_insn_size);
8046 BFD_ASSERT (action->removed_bytes == -1);
8047 rv = widen_instruction (scratch, final_size, 0, TRUE);
8049 memmove (&dup_contents[dup_dot], scratch, copy_size);
8050 orig_dot += orig_insn_size;
8051 dup_dot += copy_size;
8054 case ta_add_literal:
8057 BFD_ASSERT (action->removed_bytes == -4);
8058 /* TBD -- place the literal value here and insert
8060 memset (&dup_contents[dup_dot], 0, 4);
8061 pin_internal_relocs (sec, internal_relocs);
8062 pin_contents (sec, contents);
8064 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
8065 relax_info, &internal_relocs, &action->value))
8069 orig_dot_vo += copy_size;
8071 orig_dot += orig_insn_size;
8072 dup_dot += copy_size;
8076 /* Not implemented yet. */
8081 size -= action->removed_bytes;
8082 removed += action->removed_bytes;
8083 BFD_ASSERT (dup_dot <= final_size);
8084 BFD_ASSERT (orig_dot <= orig_size);
8087 orig_dot += orig_dot_copied;
8088 orig_dot_copied = 0;
8090 if (orig_dot != orig_size)
8092 copy_size = orig_size - orig_dot;
8093 BFD_ASSERT (orig_size > orig_dot);
8094 BFD_ASSERT (dup_dot + copy_size == final_size);
8095 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
8096 orig_dot += copy_size;
8097 dup_dot += copy_size;
8099 BFD_ASSERT (orig_size == orig_dot);
8100 BFD_ASSERT (final_size == dup_dot);
8102 /* Move the dup_contents back. */
8103 if (final_size > orig_size)
8105 /* Contents need to be reallocated. Swap the dup_contents into
8107 sec->contents = dup_contents;
8109 contents = dup_contents;
8110 pin_contents (sec, contents);
8114 BFD_ASSERT (final_size <= orig_size);
8115 memset (contents, 0, orig_size);
8116 memcpy (contents, dup_contents, final_size);
8117 free (dup_contents);
8120 pin_contents (sec, contents);
8122 sec->size = final_size;
8126 release_internal_relocs (sec, internal_relocs);
8127 release_contents (sec, contents);
8133 translate_section_fixes (asection *sec)
8135 xtensa_relax_info *relax_info;
8138 relax_info = get_xtensa_relax_info (sec);
8142 for (r = relax_info->fix_list; r != NULL; r = r->next)
8143 if (!translate_reloc_bfd_fix (r))
8150 /* Translate a fix given the mapping in the relax info for the target
8151 section. If it has already been translated, no work is required. */
8154 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
8156 reloc_bfd_fix new_fix;
8158 xtensa_relax_info *relax_info;
8159 removed_literal *removed;
8160 bfd_vma new_offset, target_offset;
8162 if (fix->translated)
8165 sec = fix->target_sec;
8166 target_offset = fix->target_offset;
8168 relax_info = get_xtensa_relax_info (sec);
8171 fix->translated = TRUE;
8177 /* The fix does not need to be translated if the section cannot change. */
8178 if (!relax_info->is_relaxable_literal_section
8179 && !relax_info->is_relaxable_asm_section)
8181 fix->translated = TRUE;
8185 /* If the literal has been moved and this relocation was on an
8186 opcode, then the relocation should move to the new literal
8187 location. Otherwise, the relocation should move within the
8191 if (is_operand_relocation (fix->src_type))
8193 /* Check if the original relocation is against a literal being
8195 removed = find_removed_literal (&relax_info->removed_list,
8203 /* The fact that there is still a relocation to this literal indicates
8204 that the literal is being coalesced, not simply removed. */
8205 BFD_ASSERT (removed->to.abfd != NULL);
8207 /* This was moved to some other address (possibly another section). */
8208 new_sec = r_reloc_get_section (&removed->to);
8212 relax_info = get_xtensa_relax_info (sec);
8214 (!relax_info->is_relaxable_literal_section
8215 && !relax_info->is_relaxable_asm_section))
8217 target_offset = removed->to.target_offset;
8218 new_fix.target_sec = new_sec;
8219 new_fix.target_offset = target_offset;
8220 new_fix.translated = TRUE;
8225 target_offset = removed->to.target_offset;
8226 new_fix.target_sec = new_sec;
8229 /* The target address may have been moved within its section. */
8230 new_offset = offset_with_removed_text (&relax_info->action_list,
8233 new_fix.target_offset = new_offset;
8234 new_fix.target_offset = new_offset;
8235 new_fix.translated = TRUE;
8241 /* Fix up a relocation to take account of removed literals. */
8244 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel)
8247 xtensa_relax_info *relax_info;
8248 removed_literal *removed;
8249 bfd_vma new_offset, target_offset, removed_bytes;
8251 *new_rel = *orig_rel;
8253 if (!r_reloc_is_defined (orig_rel))
8255 sec = r_reloc_get_section (orig_rel);
8257 relax_info = get_xtensa_relax_info (sec);
8258 BFD_ASSERT (relax_info);
8260 if (!relax_info->is_relaxable_literal_section
8261 && !relax_info->is_relaxable_asm_section)
8264 target_offset = orig_rel->target_offset;
8267 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
8269 /* Check if the original relocation is against a literal being
8271 removed = find_removed_literal (&relax_info->removed_list,
8274 if (removed && removed->to.abfd)
8278 /* The fact that there is still a relocation to this literal indicates
8279 that the literal is being coalesced, not simply removed. */
8280 BFD_ASSERT (removed->to.abfd != NULL);
8282 /* This was moved to some other address
8283 (possibly in another section). */
8284 *new_rel = removed->to;
8285 new_sec = r_reloc_get_section (new_rel);
8289 relax_info = get_xtensa_relax_info (sec);
8291 || (!relax_info->is_relaxable_literal_section
8292 && !relax_info->is_relaxable_asm_section))
8295 target_offset = new_rel->target_offset;
8298 /* ...and the target address may have been moved within its section. */
8299 new_offset = offset_with_removed_text (&relax_info->action_list,
8302 /* Modify the offset and addend. */
8303 removed_bytes = target_offset - new_offset;
8304 new_rel->target_offset = new_offset;
8305 new_rel->rela.r_addend -= removed_bytes;
8309 /* For dynamic links, there may be a dynamic relocation for each
8310 literal. The number of dynamic relocations must be computed in
8311 size_dynamic_sections, which occurs before relaxation. When a
8312 literal is removed, this function checks if there is a corresponding
8313 dynamic relocation and shrinks the size of the appropriate dynamic
8314 relocation section accordingly. At this point, the contents of the
8315 dynamic relocation sections have not yet been filled in, so there's
8316 nothing else that needs to be done. */
8319 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
8321 asection *input_section,
8322 Elf_Internal_Rela *rel)
8324 Elf_Internal_Shdr *symtab_hdr;
8325 struct elf_link_hash_entry **sym_hashes;
8326 unsigned long r_symndx;
8328 struct elf_link_hash_entry *h;
8329 bfd_boolean dynamic_symbol;
8331 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8332 sym_hashes = elf_sym_hashes (abfd);
8334 r_type = ELF32_R_TYPE (rel->r_info);
8335 r_symndx = ELF32_R_SYM (rel->r_info);
8337 if (r_symndx < symtab_hdr->sh_info)
8340 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8342 dynamic_symbol = xtensa_elf_dynamic_symbol_p (h, info);
8344 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
8345 && (input_section->flags & SEC_ALLOC) != 0
8346 && (dynamic_symbol || info->shared))
8349 const char *srel_name;
8351 bfd_boolean is_plt = FALSE;
8353 dynobj = elf_hash_table (info)->dynobj;
8354 BFD_ASSERT (dynobj != NULL);
8356 if (dynamic_symbol && r_type == R_XTENSA_PLT)
8358 srel_name = ".rela.plt";
8362 srel_name = ".rela.got";
8364 /* Reduce size of the .rela.* section by one reloc. */
8365 srel = bfd_get_section_by_name (dynobj, srel_name);
8366 BFD_ASSERT (srel != NULL);
8367 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
8368 srel->size -= sizeof (Elf32_External_Rela);
8372 asection *splt, *sgotplt, *srelgot;
8373 int reloc_index, chunk;
8375 /* Find the PLT reloc index of the entry being removed. This
8376 is computed from the size of ".rela.plt". It is needed to
8377 figure out which PLT chunk to resize. Usually "last index
8378 = size - 1" since the index starts at zero, but in this
8379 context, the size has just been decremented so there's no
8380 need to subtract one. */
8381 reloc_index = srel->size / sizeof (Elf32_External_Rela);
8383 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
8384 splt = elf_xtensa_get_plt_section (dynobj, chunk);
8385 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
8386 BFD_ASSERT (splt != NULL && sgotplt != NULL);
8388 /* Check if an entire PLT chunk has just been eliminated. */
8389 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
8391 /* The two magic GOT entries for that chunk can go away. */
8392 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
8393 BFD_ASSERT (srelgot != NULL);
8394 srelgot->reloc_count -= 2;
8395 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
8398 /* There should be only one entry left (and it will be
8400 BFD_ASSERT (sgotplt->size == 4);
8401 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
8404 BFD_ASSERT (sgotplt->size >= 4);
8405 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
8408 splt->size -= PLT_ENTRY_SIZE;
8414 /* Take an r_rel and move it to another section. This usually
8415 requires extending the interal_relocation array and pinning it. If
8416 the original r_rel is from the same BFD, we can complete this here.
8417 Otherwise, we add a fix record to let the final link fix the
8418 appropriate address. Contents and internal relocations for the
8419 section must be pinned after calling this routine. */
8422 move_literal (bfd *abfd,
8423 struct bfd_link_info *link_info,
8427 xtensa_relax_info *relax_info,
8428 Elf_Internal_Rela **internal_relocs_p,
8429 const literal_value *lit)
8431 Elf_Internal_Rela *new_relocs = NULL;
8432 size_t new_relocs_count = 0;
8433 Elf_Internal_Rela this_rela;
8434 const r_reloc *r_rel;
8436 r_rel = &lit->r_rel;
8437 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
8439 if (r_reloc_is_const (r_rel))
8440 bfd_put_32 (abfd, lit->value, contents + offset);
8445 asection *target_sec;
8449 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
8450 target_sec = r_reloc_get_section (r_rel);
8452 /* This is the difficult case. We have to create a fix up. */
8453 this_rela.r_offset = offset;
8454 this_rela.r_info = ELF32_R_INFO (0, r_type);
8455 this_rela.r_addend =
8456 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
8457 bfd_put_32 (abfd, lit->value, contents + offset);
8459 /* Currently, we cannot move relocations during a relocatable link. */
8460 BFD_ASSERT (!link_info->relocatable);
8461 fix = reloc_bfd_fix_init (sec, offset, r_type, r_rel->abfd,
8462 r_reloc_get_section (r_rel),
8463 r_rel->target_offset + r_rel->virtual_offset,
8465 /* We also need to mark that relocations are needed here. */
8466 sec->flags |= SEC_RELOC;
8468 translate_reloc_bfd_fix (fix);
8469 /* This fix has not yet been translated. */
8472 /* Add the relocation. If we have already allocated our own
8473 space for the relocations and we have room for more, then use
8474 it. Otherwise, allocate new space and move the literals. */
8475 insert_at = sec->reloc_count;
8476 for (i = 0; i < sec->reloc_count; ++i)
8478 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
8485 if (*internal_relocs_p != relax_info->allocated_relocs
8486 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
8488 BFD_ASSERT (relax_info->allocated_relocs == NULL
8489 || sec->reloc_count == relax_info->relocs_count);
8491 if (relax_info->allocated_relocs_count == 0)
8492 new_relocs_count = (sec->reloc_count + 2) * 2;
8494 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
8496 new_relocs = (Elf_Internal_Rela *)
8497 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
8501 /* We could handle this more quickly by finding the split point. */
8503 memcpy (new_relocs, *internal_relocs_p,
8504 insert_at * sizeof (Elf_Internal_Rela));
8506 new_relocs[insert_at] = this_rela;
8508 if (insert_at != sec->reloc_count)
8509 memcpy (new_relocs + insert_at + 1,
8510 (*internal_relocs_p) + insert_at,
8511 (sec->reloc_count - insert_at)
8512 * sizeof (Elf_Internal_Rela));
8514 if (*internal_relocs_p != relax_info->allocated_relocs)
8516 /* The first time we re-allocate, we can only free the
8517 old relocs if they were allocated with bfd_malloc.
8518 This is not true when keep_memory is in effect. */
8519 if (!link_info->keep_memory)
8520 free (*internal_relocs_p);
8523 free (*internal_relocs_p);
8524 relax_info->allocated_relocs = new_relocs;
8525 relax_info->allocated_relocs_count = new_relocs_count;
8526 elf_section_data (sec)->relocs = new_relocs;
8528 relax_info->relocs_count = sec->reloc_count;
8529 *internal_relocs_p = new_relocs;
8533 if (insert_at != sec->reloc_count)
8536 for (idx = sec->reloc_count; idx > insert_at; idx--)
8537 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
8539 (*internal_relocs_p)[insert_at] = this_rela;
8541 if (relax_info->allocated_relocs)
8542 relax_info->relocs_count = sec->reloc_count;
8549 /* This is similar to relax_section except that when a target is moved,
8550 we shift addresses up. We also need to modify the size. This
8551 algorithm does NOT allow for relocations into the middle of the
8552 property sections. */
8555 relax_property_section (bfd *abfd,
8557 struct bfd_link_info *link_info)
8559 Elf_Internal_Rela *internal_relocs;
8562 bfd_boolean ok = TRUE;
8563 bfd_boolean is_full_prop_section;
8564 size_t last_zfill_target_offset = 0;
8565 asection *last_zfill_target_sec = NULL;
8566 bfd_size_type sec_size;
8568 sec_size = bfd_get_section_limit (abfd, sec);
8569 internal_relocs = retrieve_internal_relocs (abfd, sec,
8570 link_info->keep_memory);
8571 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8572 if (contents == NULL && sec_size != 0)
8578 is_full_prop_section =
8579 ((strcmp (sec->name, XTENSA_PROP_SEC_NAME) == 0)
8580 || (strncmp (sec->name, ".gnu.linkonce.prop.",
8581 sizeof ".gnu.linkonce.prop." - 1) == 0));
8583 if (internal_relocs)
8585 for (i = 0; i < sec->reloc_count; i++)
8587 Elf_Internal_Rela *irel;
8588 xtensa_relax_info *target_relax_info;
8590 asection *target_sec;
8592 bfd_byte *size_p, *flags_p;
8594 /* Locally change the source address.
8595 Translate the target to the new target address.
8596 If it points to this section and has been removed, MOVE IT.
8597 Also, don't forget to modify the associated SIZE at
8600 irel = &internal_relocs[i];
8601 r_type = ELF32_R_TYPE (irel->r_info);
8602 if (r_type == R_XTENSA_NONE)
8605 /* Find the literal value. */
8606 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
8607 size_p = &contents[irel->r_offset + 4];
8609 if (is_full_prop_section)
8611 flags_p = &contents[irel->r_offset + 8];
8612 BFD_ASSERT (irel->r_offset + 12 <= sec_size);
8615 BFD_ASSERT (irel->r_offset + 8 <= sec_size);
8617 target_sec = r_reloc_get_section (&val.r_rel);
8618 target_relax_info = get_xtensa_relax_info (target_sec);
8620 if (target_relax_info
8621 && (target_relax_info->is_relaxable_literal_section
8622 || target_relax_info->is_relaxable_asm_section ))
8624 /* Translate the relocation's destination. */
8625 bfd_vma new_offset, new_end_offset;
8626 long old_size, new_size;
8628 new_offset = offset_with_removed_text
8629 (&target_relax_info->action_list, val.r_rel.target_offset);
8631 /* Assert that we are not out of bounds. */
8632 old_size = bfd_get_32 (abfd, size_p);
8636 /* Only the first zero-sized unreachable entry is
8637 allowed to expand. In this case the new offset
8638 should be the offset before the fill and the new
8639 size is the expansion size. For other zero-sized
8640 entries the resulting size should be zero with an
8641 offset before or after the fill address depending
8642 on whether the expanding unreachable entry
8644 if (last_zfill_target_sec
8645 && last_zfill_target_sec == target_sec
8646 && last_zfill_target_offset == val.r_rel.target_offset)
8647 new_end_offset = new_offset;
8650 new_end_offset = new_offset;
8651 new_offset = offset_with_removed_text_before_fill
8652 (&target_relax_info->action_list,
8653 val.r_rel.target_offset);
8655 /* If it is not unreachable and we have not yet
8656 seen an unreachable at this address, place it
8657 before the fill address. */
8659 || (bfd_get_32 (abfd, flags_p)
8660 & XTENSA_PROP_UNREACHABLE) == 0)
8661 new_end_offset = new_offset;
8664 last_zfill_target_sec = target_sec;
8665 last_zfill_target_offset = val.r_rel.target_offset;
8671 new_end_offset = offset_with_removed_text_before_fill
8672 (&target_relax_info->action_list,
8673 val.r_rel.target_offset + old_size);
8676 new_size = new_end_offset - new_offset;
8678 if (new_size != old_size)
8680 bfd_put_32 (abfd, new_size, size_p);
8681 pin_contents (sec, contents);
8684 if (new_offset != val.r_rel.target_offset)
8686 bfd_vma diff = new_offset - val.r_rel.target_offset;
8687 irel->r_addend += diff;
8688 pin_internal_relocs (sec, internal_relocs);
8694 /* Combine adjacent property table entries. This is also done in
8695 finish_dynamic_sections() but at that point it's too late to
8696 reclaim the space in the output section, so we do this twice. */
8698 if (internal_relocs && (!link_info->relocatable
8699 || strcmp (sec->name, XTENSA_LIT_SEC_NAME) == 0))
8701 Elf_Internal_Rela *last_irel = NULL;
8702 int removed_bytes = 0;
8703 bfd_vma offset, last_irel_offset;
8704 bfd_vma section_size;
8705 bfd_size_type entry_size;
8706 flagword predef_flags;
8708 if (is_full_prop_section)
8713 predef_flags = xtensa_get_property_predef_flags (sec);
8715 /* Walk over memory and irels at the same time.
8716 This REQUIRES that the internal_relocs be sorted by offset. */
8717 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
8718 internal_reloc_compare);
8719 nexti = 0; /* Index into internal_relocs. */
8721 pin_internal_relocs (sec, internal_relocs);
8722 pin_contents (sec, contents);
8724 last_irel_offset = (bfd_vma) -1;
8725 section_size = sec->size;
8726 BFD_ASSERT (section_size % entry_size == 0);
8728 for (offset = 0; offset < section_size; offset += entry_size)
8730 Elf_Internal_Rela *irel, *next_irel;
8731 bfd_vma bytes_to_remove, size, actual_offset;
8732 bfd_boolean remove_this_irel;
8738 /* Find the next two relocations (if there are that many left),
8739 skipping over any R_XTENSA_NONE relocs. On entry, "nexti" is
8740 the starting reloc index. After these two loops, "i"
8741 is the index of the first non-NONE reloc past that starting
8742 index, and "nexti" is the index for the next non-NONE reloc
8745 for (i = nexti; i < sec->reloc_count; i++)
8747 if (ELF32_R_TYPE (internal_relocs[i].r_info) != R_XTENSA_NONE)
8749 irel = &internal_relocs[i];
8752 internal_relocs[i].r_offset -= removed_bytes;
8755 for (nexti = i + 1; nexti < sec->reloc_count; nexti++)
8757 if (ELF32_R_TYPE (internal_relocs[nexti].r_info)
8760 next_irel = &internal_relocs[nexti];
8763 internal_relocs[nexti].r_offset -= removed_bytes;
8766 remove_this_irel = FALSE;
8767 bytes_to_remove = 0;
8768 actual_offset = offset - removed_bytes;
8769 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
8771 if (is_full_prop_section)
8772 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
8774 flags = predef_flags;
8776 /* Check that the irels are sorted by offset,
8777 with only one per address. */
8778 BFD_ASSERT (!irel || (int) irel->r_offset > (int) last_irel_offset);
8779 BFD_ASSERT (!next_irel || next_irel->r_offset > irel->r_offset);
8781 /* Make sure there aren't relocs on the size or flag fields. */
8782 if ((irel && irel->r_offset == offset + 4)
8783 || (is_full_prop_section
8784 && irel && irel->r_offset == offset + 8))
8786 irel->r_offset -= removed_bytes;
8787 last_irel_offset = irel->r_offset;
8789 else if (next_irel && (next_irel->r_offset == offset + 4
8790 || (is_full_prop_section
8791 && next_irel->r_offset == offset + 8)))
8794 irel->r_offset -= removed_bytes;
8795 next_irel->r_offset -= removed_bytes;
8796 last_irel_offset = next_irel->r_offset;
8798 else if (size == 0 && (flags & XTENSA_PROP_ALIGN) == 0
8799 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
8801 /* Always remove entries with zero size and no alignment. */
8802 bytes_to_remove = entry_size;
8803 if (irel && irel->r_offset == offset)
8805 remove_this_irel = TRUE;
8807 irel->r_offset -= removed_bytes;
8808 last_irel_offset = irel->r_offset;
8811 else if (irel && irel->r_offset == offset)
8813 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32)
8819 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
8820 bfd_vma old_address =
8821 (last_irel->r_addend
8822 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
8823 bfd_vma new_address =
8825 + bfd_get_32 (abfd, &contents[actual_offset]));
8826 if (is_full_prop_section)
8827 old_flags = bfd_get_32
8828 (abfd, &contents[last_irel->r_offset + 8]);
8830 old_flags = predef_flags;
8832 if ((ELF32_R_SYM (irel->r_info)
8833 == ELF32_R_SYM (last_irel->r_info))
8834 && old_address + old_size == new_address
8835 && old_flags == flags
8836 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
8837 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
8839 /* Fix the old size. */
8840 bfd_put_32 (abfd, old_size + size,
8841 &contents[last_irel->r_offset + 4]);
8842 bytes_to_remove = entry_size;
8843 remove_this_irel = TRUE;
8852 irel->r_offset -= removed_bytes;
8853 last_irel_offset = irel->r_offset;
8856 if (remove_this_irel)
8858 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8859 irel->r_offset -= bytes_to_remove;
8862 if (bytes_to_remove != 0)
8864 removed_bytes += bytes_to_remove;
8865 if (offset + bytes_to_remove < section_size)
8866 memmove (&contents[actual_offset],
8867 &contents[actual_offset + bytes_to_remove],
8868 section_size - offset - bytes_to_remove);
8874 /* Clear the removed bytes. */
8875 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
8877 sec->size = section_size - removed_bytes;
8879 if (xtensa_is_littable_section (sec))
8881 bfd *dynobj = elf_hash_table (link_info)->dynobj;
8885 bfd_get_section_by_name (dynobj, ".got.loc");
8887 sgotloc->size -= removed_bytes;
8894 release_internal_relocs (sec, internal_relocs);
8895 release_contents (sec, contents);
8900 /* Third relaxation pass. */
8902 /* Change symbol values to account for removed literals. */
8905 relax_section_symbols (bfd *abfd, asection *sec)
8907 xtensa_relax_info *relax_info;
8908 unsigned int sec_shndx;
8909 Elf_Internal_Shdr *symtab_hdr;
8910 Elf_Internal_Sym *isymbuf;
8911 unsigned i, num_syms, num_locals;
8913 relax_info = get_xtensa_relax_info (sec);
8914 BFD_ASSERT (relax_info);
8916 if (!relax_info->is_relaxable_literal_section
8917 && !relax_info->is_relaxable_asm_section)
8920 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
8922 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8923 isymbuf = retrieve_local_syms (abfd);
8925 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
8926 num_locals = symtab_hdr->sh_info;
8928 /* Adjust the local symbols defined in this section. */
8929 for (i = 0; i < num_locals; i++)
8931 Elf_Internal_Sym *isym = &isymbuf[i];
8933 if (isym->st_shndx == sec_shndx)
8935 bfd_vma new_address = offset_with_removed_text
8936 (&relax_info->action_list, isym->st_value);
8937 bfd_vma new_size = isym->st_size;
8939 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
8941 bfd_vma new_end = offset_with_removed_text
8942 (&relax_info->action_list, isym->st_value + isym->st_size);
8943 new_size = new_end - new_address;
8946 isym->st_value = new_address;
8947 isym->st_size = new_size;
8951 /* Now adjust the global symbols defined in this section. */
8952 for (i = 0; i < (num_syms - num_locals); i++)
8954 struct elf_link_hash_entry *sym_hash;
8956 sym_hash = elf_sym_hashes (abfd)[i];
8958 if (sym_hash->root.type == bfd_link_hash_warning)
8959 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
8961 if ((sym_hash->root.type == bfd_link_hash_defined
8962 || sym_hash->root.type == bfd_link_hash_defweak)
8963 && sym_hash->root.u.def.section == sec)
8965 bfd_vma new_address = offset_with_removed_text
8966 (&relax_info->action_list, sym_hash->root.u.def.value);
8967 bfd_vma new_size = sym_hash->size;
8969 if (sym_hash->type == STT_FUNC)
8971 bfd_vma new_end = offset_with_removed_text
8972 (&relax_info->action_list,
8973 sym_hash->root.u.def.value + sym_hash->size);
8974 new_size = new_end - new_address;
8977 sym_hash->root.u.def.value = new_address;
8978 sym_hash->size = new_size;
8986 /* "Fix" handling functions, called while performing relocations. */
8989 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
8991 asection *input_section,
8995 asection *sec, *old_sec;
8997 int r_type = ELF32_R_TYPE (rel->r_info);
9000 if (r_type == R_XTENSA_NONE)
9003 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
9007 r_reloc_init (&r_rel, input_bfd, rel, contents,
9008 bfd_get_section_limit (input_bfd, input_section));
9009 old_sec = r_reloc_get_section (&r_rel);
9010 old_offset = r_rel.target_offset;
9012 if (!old_sec || !r_reloc_is_defined (&r_rel))
9014 if (r_type != R_XTENSA_ASM_EXPAND)
9016 (*_bfd_error_handler)
9017 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
9018 input_bfd, input_section, rel->r_offset,
9019 elf_howto_table[r_type].name);
9022 /* Leave it be. Resolution will happen in a later stage. */
9026 sec = fix->target_sec;
9027 rel->r_addend += ((sec->output_offset + fix->target_offset)
9028 - (old_sec->output_offset + old_offset));
9035 do_fix_for_final_link (Elf_Internal_Rela *rel,
9037 asection *input_section,
9039 bfd_vma *relocationp)
9042 int r_type = ELF32_R_TYPE (rel->r_info);
9046 if (r_type == R_XTENSA_NONE)
9049 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
9053 sec = fix->target_sec;
9055 fixup_diff = rel->r_addend;
9056 if (elf_howto_table[fix->src_type].partial_inplace)
9058 bfd_vma inplace_val;
9059 BFD_ASSERT (fix->src_offset
9060 < bfd_get_section_limit (input_bfd, input_section));
9061 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
9062 fixup_diff += inplace_val;
9065 *relocationp = (sec->output_section->vma
9066 + sec->output_offset
9067 + fix->target_offset - fixup_diff);
9071 /* Miscellaneous utility functions.... */
9074 elf_xtensa_get_plt_section (bfd *dynobj, int chunk)
9079 return bfd_get_section_by_name (dynobj, ".plt");
9081 sprintf (plt_name, ".plt.%u", chunk);
9082 return bfd_get_section_by_name (dynobj, plt_name);
9087 elf_xtensa_get_gotplt_section (bfd *dynobj, int chunk)
9092 return bfd_get_section_by_name (dynobj, ".got.plt");
9094 sprintf (got_name, ".got.plt.%u", chunk);
9095 return bfd_get_section_by_name (dynobj, got_name);
9099 /* Get the input section for a given symbol index.
9101 . a section symbol, return the section;
9102 . a common symbol, return the common section;
9103 . an undefined symbol, return the undefined section;
9104 . an indirect symbol, follow the links;
9105 . an absolute value, return the absolute section. */
9108 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
9110 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9111 asection *target_sec = NULL;
9112 if (r_symndx < symtab_hdr->sh_info)
9114 Elf_Internal_Sym *isymbuf;
9115 unsigned int section_index;
9117 isymbuf = retrieve_local_syms (abfd);
9118 section_index = isymbuf[r_symndx].st_shndx;
9120 if (section_index == SHN_UNDEF)
9121 target_sec = bfd_und_section_ptr;
9122 else if (section_index > 0 && section_index < SHN_LORESERVE)
9123 target_sec = bfd_section_from_elf_index (abfd, section_index);
9124 else if (section_index == SHN_ABS)
9125 target_sec = bfd_abs_section_ptr;
9126 else if (section_index == SHN_COMMON)
9127 target_sec = bfd_com_section_ptr;
9134 unsigned long indx = r_symndx - symtab_hdr->sh_info;
9135 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
9137 while (h->root.type == bfd_link_hash_indirect
9138 || h->root.type == bfd_link_hash_warning)
9139 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9141 switch (h->root.type)
9143 case bfd_link_hash_defined:
9144 case bfd_link_hash_defweak:
9145 target_sec = h->root.u.def.section;
9147 case bfd_link_hash_common:
9148 target_sec = bfd_com_section_ptr;
9150 case bfd_link_hash_undefined:
9151 case bfd_link_hash_undefweak:
9152 target_sec = bfd_und_section_ptr;
9154 default: /* New indirect warning. */
9155 target_sec = bfd_und_section_ptr;
9163 static struct elf_link_hash_entry *
9164 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
9167 struct elf_link_hash_entry *h;
9168 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9170 if (r_symndx < symtab_hdr->sh_info)
9173 indx = r_symndx - symtab_hdr->sh_info;
9174 h = elf_sym_hashes (abfd)[indx];
9175 while (h->root.type == bfd_link_hash_indirect
9176 || h->root.type == bfd_link_hash_warning)
9177 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9182 /* Get the section-relative offset for a symbol number. */
9185 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
9187 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9190 if (r_symndx < symtab_hdr->sh_info)
9192 Elf_Internal_Sym *isymbuf;
9193 isymbuf = retrieve_local_syms (abfd);
9194 offset = isymbuf[r_symndx].st_value;
9198 unsigned long indx = r_symndx - symtab_hdr->sh_info;
9199 struct elf_link_hash_entry *h =
9200 elf_sym_hashes (abfd)[indx];
9202 while (h->root.type == bfd_link_hash_indirect
9203 || h->root.type == bfd_link_hash_warning)
9204 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9205 if (h->root.type == bfd_link_hash_defined
9206 || h->root.type == bfd_link_hash_defweak)
9207 offset = h->root.u.def.value;
9214 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
9216 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
9217 struct elf_link_hash_entry *h;
9219 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
9220 if (h && h->root.type == bfd_link_hash_defweak)
9227 pcrel_reloc_fits (xtensa_opcode opc,
9229 bfd_vma self_address,
9230 bfd_vma dest_address)
9232 xtensa_isa isa = xtensa_default_isa;
9233 uint32 valp = dest_address;
9234 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
9235 || xtensa_operand_encode (isa, opc, opnd, &valp))
9241 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
9242 static int insn_sec_len = sizeof (XTENSA_INSN_SEC_NAME) - 1;
9243 static int lit_sec_len = sizeof (XTENSA_LIT_SEC_NAME) - 1;
9244 static int prop_sec_len = sizeof (XTENSA_PROP_SEC_NAME) - 1;
9248 xtensa_is_property_section (asection *sec)
9250 if (strncmp (XTENSA_INSN_SEC_NAME, sec->name, insn_sec_len) == 0
9251 || strncmp (XTENSA_LIT_SEC_NAME, sec->name, lit_sec_len) == 0
9252 || strncmp (XTENSA_PROP_SEC_NAME, sec->name, prop_sec_len) == 0)
9255 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0
9256 && (strncmp (&sec->name[linkonce_len], "x.", 2) == 0
9257 || strncmp (&sec->name[linkonce_len], "p.", 2) == 0
9258 || strncmp (&sec->name[linkonce_len], "prop.", 5) == 0))
9266 xtensa_is_littable_section (asection *sec)
9268 if (strncmp (XTENSA_LIT_SEC_NAME, sec->name, lit_sec_len) == 0)
9271 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0
9272 && sec->name[linkonce_len] == 'p'
9273 && sec->name[linkonce_len + 1] == '.')
9281 internal_reloc_compare (const void *ap, const void *bp)
9283 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
9284 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
9286 if (a->r_offset != b->r_offset)
9287 return (a->r_offset - b->r_offset);
9289 /* We don't need to sort on these criteria for correctness,
9290 but enforcing a more strict ordering prevents unstable qsort
9291 from behaving differently with different implementations.
9292 Without the code below we get correct but different results
9293 on Solaris 2.7 and 2.8. We would like to always produce the
9294 same results no matter the host. */
9296 if (a->r_info != b->r_info)
9297 return (a->r_info - b->r_info);
9299 return (a->r_addend - b->r_addend);
9304 internal_reloc_matches (const void *ap, const void *bp)
9306 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
9307 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
9309 /* Check if one entry overlaps with the other; this shouldn't happen
9310 except when searching for a match. */
9311 return (a->r_offset - b->r_offset);
9316 xtensa_get_property_section_name (asection *sec, const char *base_name)
9318 if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
9320 char *prop_sec_name;
9322 char *linkonce_kind = 0;
9324 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
9325 linkonce_kind = "x";
9326 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
9327 linkonce_kind = "p";
9328 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
9329 linkonce_kind = "prop.";
9333 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
9334 + strlen (linkonce_kind) + 1);
9335 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
9336 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
9338 suffix = sec->name + linkonce_len;
9339 /* For backward compatibility, replace "t." instead of inserting
9340 the new linkonce_kind (but not for "prop" sections). */
9341 if (strncmp (suffix, "t.", 2) == 0 && linkonce_kind[1] == '.')
9343 strcat (prop_sec_name + linkonce_len, suffix);
9345 return prop_sec_name;
9348 return strdup (base_name);
9353 xtensa_get_property_predef_flags (asection *sec)
9355 if (strcmp (sec->name, XTENSA_INSN_SEC_NAME) == 0
9356 || strncmp (sec->name, ".gnu.linkonce.x.",
9357 sizeof ".gnu.linkonce.x." - 1) == 0)
9358 return (XTENSA_PROP_INSN
9359 | XTENSA_PROP_INSN_NO_TRANSFORM
9360 | XTENSA_PROP_INSN_NO_REORDER);
9362 if (xtensa_is_littable_section (sec))
9363 return (XTENSA_PROP_LITERAL
9364 | XTENSA_PROP_INSN_NO_TRANSFORM
9365 | XTENSA_PROP_INSN_NO_REORDER);
9371 /* Other functions called directly by the linker. */
9374 xtensa_callback_required_dependence (bfd *abfd,
9376 struct bfd_link_info *link_info,
9377 deps_callback_t callback,
9380 Elf_Internal_Rela *internal_relocs;
9383 bfd_boolean ok = TRUE;
9384 bfd_size_type sec_size;
9386 sec_size = bfd_get_section_limit (abfd, sec);
9388 /* ".plt*" sections have no explicit relocations but they contain L32R
9389 instructions that reference the corresponding ".got.plt*" sections. */
9390 if ((sec->flags & SEC_LINKER_CREATED) != 0
9391 && strncmp (sec->name, ".plt", 4) == 0)
9395 /* Find the corresponding ".got.plt*" section. */
9396 if (sec->name[4] == '\0')
9397 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
9403 BFD_ASSERT (sec->name[4] == '.');
9404 chunk = strtol (&sec->name[5], NULL, 10);
9406 sprintf (got_name, ".got.plt.%u", chunk);
9407 sgotplt = bfd_get_section_by_name (sec->owner, got_name);
9409 BFD_ASSERT (sgotplt);
9411 /* Assume worst-case offsets: L32R at the very end of the ".plt"
9412 section referencing a literal at the very beginning of
9413 ".got.plt". This is very close to the real dependence, anyway. */
9414 (*callback) (sec, sec_size, sgotplt, 0, closure);
9417 internal_relocs = retrieve_internal_relocs (abfd, sec,
9418 link_info->keep_memory);
9419 if (internal_relocs == NULL
9420 || sec->reloc_count == 0)
9423 /* Cache the contents for the duration of this scan. */
9424 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9425 if (contents == NULL && sec_size != 0)
9431 if (!xtensa_default_isa)
9432 xtensa_default_isa = xtensa_isa_init (0, 0);
9434 for (i = 0; i < sec->reloc_count; i++)
9436 Elf_Internal_Rela *irel = &internal_relocs[i];
9437 if (is_l32r_relocation (abfd, sec, contents, irel))
9440 asection *target_sec;
9441 bfd_vma target_offset;
9443 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
9446 /* L32Rs must be local to the input file. */
9447 if (r_reloc_is_defined (&l32r_rel))
9449 target_sec = r_reloc_get_section (&l32r_rel);
9450 target_offset = l32r_rel.target_offset;
9452 (*callback) (sec, irel->r_offset, target_sec, target_offset,
9458 release_internal_relocs (sec, internal_relocs);
9459 release_contents (sec, contents);
9463 /* The default literal sections should always be marked as "code" (i.e.,
9464 SHF_EXECINSTR). This is particularly important for the Linux kernel
9465 module loader so that the literals are not placed after the text. */
9466 static struct bfd_elf_special_section const elf_xtensa_special_sections[]=
9468 { ".literal", 8, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9469 { ".init.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9470 { ".fini.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9471 { NULL, 0, 0, 0, 0 }
9476 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
9477 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
9478 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
9479 #define TARGET_BIG_NAME "elf32-xtensa-be"
9480 #define ELF_ARCH bfd_arch_xtensa
9482 /* The new EM_XTENSA value will be recognized beginning in the Xtensa T1040
9483 release. However, we still have to generate files with the EM_XTENSA_OLD
9484 value so that pre-T1040 tools can read the files. As soon as we stop
9485 caring about pre-T1040 tools, the following two values should be
9486 swapped. At the same time, any other code that uses EM_XTENSA_OLD
9487 should be changed to use EM_XTENSA. */
9488 #define ELF_MACHINE_CODE EM_XTENSA_OLD
9489 #define ELF_MACHINE_ALT1 EM_XTENSA
9492 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
9493 #else /* !XCHAL_HAVE_MMU */
9494 #define ELF_MAXPAGESIZE 1
9495 #endif /* !XCHAL_HAVE_MMU */
9496 #endif /* ELF_ARCH */
9498 #define elf_backend_can_gc_sections 1
9499 #define elf_backend_can_refcount 1
9500 #define elf_backend_plt_readonly 1
9501 #define elf_backend_got_header_size 4
9502 #define elf_backend_want_dynbss 0
9503 #define elf_backend_want_got_plt 1
9505 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
9507 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
9508 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
9509 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
9510 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
9511 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
9512 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
9514 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
9515 #define elf_backend_check_relocs elf_xtensa_check_relocs
9516 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
9517 #define elf_backend_discard_info elf_xtensa_discard_info
9518 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
9519 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
9520 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
9521 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
9522 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
9523 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
9524 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
9525 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
9526 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
9527 #define elf_backend_modify_segment_map elf_xtensa_modify_segment_map
9528 #define elf_backend_object_p elf_xtensa_object_p
9529 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
9530 #define elf_backend_relocate_section elf_xtensa_relocate_section
9531 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
9532 #define elf_backend_special_sections elf_xtensa_special_sections
9534 #include "elf32-target.h"