1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright 2003, 2004, 2005, 2006 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., 51 Franklin Street - Fifth Floor, Boston, MA
30 #include "elf/xtensa.h"
31 #include "xtensa-isa.h"
32 #include "xtensa-config.h"
34 #define XTENSA_NO_NOP_REMOVAL 0
36 /* Local helper functions. */
38 static bfd_boolean
add_extra_plt_sections (bfd
*, int);
39 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
40 static bfd_reloc_status_type bfd_elf_xtensa_reloc
41 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
42 static bfd_boolean do_fix_for_relocatable_link
43 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*);
44 static void do_fix_for_final_link
45 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*, bfd_vma
*);
47 /* Local functions to handle Xtensa configurability. */
49 static bfd_boolean
is_indirect_call_opcode (xtensa_opcode
);
50 static bfd_boolean
is_direct_call_opcode (xtensa_opcode
);
51 static bfd_boolean
is_windowed_call_opcode (xtensa_opcode
);
52 static xtensa_opcode
get_const16_opcode (void);
53 static xtensa_opcode
get_l32r_opcode (void);
54 static bfd_vma
l32r_offset (bfd_vma
, bfd_vma
);
55 static int get_relocation_opnd (xtensa_opcode
, int);
56 static int get_relocation_slot (int);
57 static xtensa_opcode get_relocation_opcode
58 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
59 static bfd_boolean is_l32r_relocation
60 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
61 static bfd_boolean
is_alt_relocation (int);
62 static bfd_boolean
is_operand_relocation (int);
63 static bfd_size_type insn_decode_len
64 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
65 static xtensa_opcode insn_decode_opcode
66 (bfd_byte
*, bfd_size_type
, bfd_size_type
, int);
67 static bfd_boolean check_branch_target_aligned
68 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
69 static bfd_boolean check_loop_aligned
70 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
71 static bfd_boolean
check_branch_target_aligned_address (bfd_vma
, int);
72 static bfd_size_type get_asm_simplify_size
73 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
75 /* Functions for link-time code simplifications. */
77 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
78 (bfd_byte
*, bfd_vma
, bfd_vma
, char **);
79 static bfd_reloc_status_type contract_asm_expansion
80 (bfd_byte
*, bfd_vma
, Elf_Internal_Rela
*, char **);
81 static xtensa_opcode
swap_callx_for_call_opcode (xtensa_opcode
);
82 static xtensa_opcode
get_expanded_call_opcode (bfd_byte
*, int, bfd_boolean
*);
84 /* Access to internal relocations, section contents and symbols. */
86 static Elf_Internal_Rela
*retrieve_internal_relocs
87 (bfd
*, asection
*, bfd_boolean
);
88 static void pin_internal_relocs (asection
*, Elf_Internal_Rela
*);
89 static void release_internal_relocs (asection
*, Elf_Internal_Rela
*);
90 static bfd_byte
*retrieve_contents (bfd
*, asection
*, bfd_boolean
);
91 static void pin_contents (asection
*, bfd_byte
*);
92 static void release_contents (asection
*, bfd_byte
*);
93 static Elf_Internal_Sym
*retrieve_local_syms (bfd
*);
95 /* Miscellaneous utility functions. */
97 static asection
*elf_xtensa_get_plt_section (bfd
*, int);
98 static asection
*elf_xtensa_get_gotplt_section (bfd
*, int);
99 static asection
*get_elf_r_symndx_section (bfd
*, unsigned long);
100 static struct elf_link_hash_entry
*get_elf_r_symndx_hash_entry
101 (bfd
*, unsigned long);
102 static bfd_vma
get_elf_r_symndx_offset (bfd
*, unsigned long);
103 static bfd_boolean
is_reloc_sym_weak (bfd
*, Elf_Internal_Rela
*);
104 static bfd_boolean
pcrel_reloc_fits (xtensa_opcode
, int, bfd_vma
, bfd_vma
);
105 static bfd_boolean
xtensa_is_property_section (asection
*);
106 static bfd_boolean
xtensa_is_littable_section (asection
*);
107 static int internal_reloc_compare (const void *, const void *);
108 static int internal_reloc_matches (const void *, const void *);
109 extern char *xtensa_get_property_section_name (asection
*, const char *);
110 static flagword
xtensa_get_property_predef_flags (asection
*);
112 /* Other functions called directly by the linker. */
114 typedef void (*deps_callback_t
)
115 (asection
*, bfd_vma
, asection
*, bfd_vma
, void *);
116 extern bfd_boolean xtensa_callback_required_dependence
117 (bfd
*, asection
*, struct bfd_link_info
*, deps_callback_t
, void *);
120 /* Globally visible flag for choosing size optimization of NOP removal
121 instead of branch-target-aware minimization for NOP removal.
122 When nonzero, narrow all instructions and remove all NOPs possible
123 around longcall expansions. */
125 int elf32xtensa_size_opt
;
128 /* The "new_section_hook" is used to set up a per-section
129 "xtensa_relax_info" data structure with additional information used
130 during relaxation. */
132 typedef struct xtensa_relax_info_struct xtensa_relax_info
;
135 /* Total count of PLT relocations seen during check_relocs.
136 The actual PLT code must be split into multiple sections and all
137 the sections have to be created before size_dynamic_sections,
138 where we figure out the exact number of PLT entries that will be
139 needed. It is OK if this count is an overestimate, e.g., some
140 relocations may be removed by GC. */
142 static int plt_reloc_count
= 0;
145 /* The GNU tools do not easily allow extending interfaces to pass around
146 the pointer to the Xtensa ISA information, so instead we add a global
147 variable here (in BFD) that can be used by any of the tools that need
150 xtensa_isa xtensa_default_isa
;
153 /* When this is true, relocations may have been modified to refer to
154 symbols from other input files. The per-section list of "fix"
155 records needs to be checked when resolving relocations. */
157 static bfd_boolean relaxing_section
= FALSE
;
159 /* When this is true, during final links, literals that cannot be
160 coalesced and their relocations may be moved to other sections. */
162 int elf32xtensa_no_literal_movement
= 1;
165 static reloc_howto_type elf_howto_table
[] =
167 HOWTO (R_XTENSA_NONE
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
168 bfd_elf_xtensa_reloc
, "R_XTENSA_NONE",
169 FALSE
, 0x00000000, 0x00000000, FALSE
),
170 HOWTO (R_XTENSA_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
171 bfd_elf_xtensa_reloc
, "R_XTENSA_32",
172 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
173 /* Replace a 32-bit value with a value from the runtime linker (only
174 used by linker-generated stub functions). The r_addend value is
175 special: 1 means to substitute a pointer to the runtime linker's
176 dynamic resolver function; 2 means to substitute the link map for
177 the shared object. */
178 HOWTO (R_XTENSA_RTLD
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
179 NULL
, "R_XTENSA_RTLD",
180 FALSE
, 0x00000000, 0x00000000, FALSE
),
181 HOWTO (R_XTENSA_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
182 bfd_elf_generic_reloc
, "R_XTENSA_GLOB_DAT",
183 FALSE
, 0xffffffff, 0xffffffff, FALSE
),
184 HOWTO (R_XTENSA_JMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
185 bfd_elf_generic_reloc
, "R_XTENSA_JMP_SLOT",
186 FALSE
, 0xffffffff, 0xffffffff, FALSE
),
187 HOWTO (R_XTENSA_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
188 bfd_elf_generic_reloc
, "R_XTENSA_RELATIVE",
189 FALSE
, 0xffffffff, 0xffffffff, FALSE
),
190 HOWTO (R_XTENSA_PLT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
191 bfd_elf_xtensa_reloc
, "R_XTENSA_PLT",
192 FALSE
, 0xffffffff, 0xffffffff, FALSE
),
194 HOWTO (R_XTENSA_OP0
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
195 bfd_elf_xtensa_reloc
, "R_XTENSA_OP0",
196 FALSE
, 0x00000000, 0x00000000, TRUE
),
197 HOWTO (R_XTENSA_OP1
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
198 bfd_elf_xtensa_reloc
, "R_XTENSA_OP1",
199 FALSE
, 0x00000000, 0x00000000, TRUE
),
200 HOWTO (R_XTENSA_OP2
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
201 bfd_elf_xtensa_reloc
, "R_XTENSA_OP2",
202 FALSE
, 0x00000000, 0x00000000, TRUE
),
203 /* Assembly auto-expansion. */
204 HOWTO (R_XTENSA_ASM_EXPAND
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
205 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_EXPAND",
206 FALSE
, 0x00000000, 0x00000000, FALSE
),
207 /* Relax assembly auto-expansion. */
208 HOWTO (R_XTENSA_ASM_SIMPLIFY
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
209 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_SIMPLIFY",
210 FALSE
, 0x00000000, 0x00000000, TRUE
),
213 /* GNU extension to record C++ vtable hierarchy. */
214 HOWTO (R_XTENSA_GNU_VTINHERIT
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
215 NULL
, "R_XTENSA_GNU_VTINHERIT",
216 FALSE
, 0x00000000, 0x00000000, FALSE
),
217 /* GNU extension to record C++ vtable member usage. */
218 HOWTO (R_XTENSA_GNU_VTENTRY
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
219 _bfd_elf_rel_vtable_reloc_fn
, "R_XTENSA_GNU_VTENTRY",
220 FALSE
, 0x00000000, 0x00000000, FALSE
),
222 /* Relocations for supporting difference of symbols. */
223 HOWTO (R_XTENSA_DIFF8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
,
224 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF8",
225 FALSE
, 0xffffffff, 0xffffffff, FALSE
),
226 HOWTO (R_XTENSA_DIFF16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
,
227 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF16",
228 FALSE
, 0xffffffff, 0xffffffff, FALSE
),
229 HOWTO (R_XTENSA_DIFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
230 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF32",
231 FALSE
, 0xffffffff, 0xffffffff, FALSE
),
233 /* General immediate operand relocations. */
234 HOWTO (R_XTENSA_SLOT0_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
235 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_OP",
236 FALSE
, 0x00000000, 0x00000000, TRUE
),
237 HOWTO (R_XTENSA_SLOT1_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
238 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_OP",
239 FALSE
, 0x00000000, 0x00000000, TRUE
),
240 HOWTO (R_XTENSA_SLOT2_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
241 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_OP",
242 FALSE
, 0x00000000, 0x00000000, TRUE
),
243 HOWTO (R_XTENSA_SLOT3_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
244 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_OP",
245 FALSE
, 0x00000000, 0x00000000, TRUE
),
246 HOWTO (R_XTENSA_SLOT4_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
247 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_OP",
248 FALSE
, 0x00000000, 0x00000000, TRUE
),
249 HOWTO (R_XTENSA_SLOT5_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
250 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_OP",
251 FALSE
, 0x00000000, 0x00000000, TRUE
),
252 HOWTO (R_XTENSA_SLOT6_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
253 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_OP",
254 FALSE
, 0x00000000, 0x00000000, TRUE
),
255 HOWTO (R_XTENSA_SLOT7_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
256 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_OP",
257 FALSE
, 0x00000000, 0x00000000, TRUE
),
258 HOWTO (R_XTENSA_SLOT8_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
259 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_OP",
260 FALSE
, 0x00000000, 0x00000000, TRUE
),
261 HOWTO (R_XTENSA_SLOT9_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
262 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_OP",
263 FALSE
, 0x00000000, 0x00000000, TRUE
),
264 HOWTO (R_XTENSA_SLOT10_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
265 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_OP",
266 FALSE
, 0x00000000, 0x00000000, TRUE
),
267 HOWTO (R_XTENSA_SLOT11_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
268 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_OP",
269 FALSE
, 0x00000000, 0x00000000, TRUE
),
270 HOWTO (R_XTENSA_SLOT12_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
271 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_OP",
272 FALSE
, 0x00000000, 0x00000000, TRUE
),
273 HOWTO (R_XTENSA_SLOT13_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
274 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_OP",
275 FALSE
, 0x00000000, 0x00000000, TRUE
),
276 HOWTO (R_XTENSA_SLOT14_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
277 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_OP",
278 FALSE
, 0x00000000, 0x00000000, TRUE
),
280 /* "Alternate" relocations. The meaning of these is opcode-specific. */
281 HOWTO (R_XTENSA_SLOT0_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
282 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_ALT",
283 FALSE
, 0x00000000, 0x00000000, TRUE
),
284 HOWTO (R_XTENSA_SLOT1_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
285 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_ALT",
286 FALSE
, 0x00000000, 0x00000000, TRUE
),
287 HOWTO (R_XTENSA_SLOT2_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
288 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_ALT",
289 FALSE
, 0x00000000, 0x00000000, TRUE
),
290 HOWTO (R_XTENSA_SLOT3_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
291 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_ALT",
292 FALSE
, 0x00000000, 0x00000000, TRUE
),
293 HOWTO (R_XTENSA_SLOT4_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
294 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_ALT",
295 FALSE
, 0x00000000, 0x00000000, TRUE
),
296 HOWTO (R_XTENSA_SLOT5_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
297 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_ALT",
298 FALSE
, 0x00000000, 0x00000000, TRUE
),
299 HOWTO (R_XTENSA_SLOT6_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
300 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_ALT",
301 FALSE
, 0x00000000, 0x00000000, TRUE
),
302 HOWTO (R_XTENSA_SLOT7_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
303 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_ALT",
304 FALSE
, 0x00000000, 0x00000000, TRUE
),
305 HOWTO (R_XTENSA_SLOT8_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
306 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_ALT",
307 FALSE
, 0x00000000, 0x00000000, TRUE
),
308 HOWTO (R_XTENSA_SLOT9_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
309 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_ALT",
310 FALSE
, 0x00000000, 0x00000000, TRUE
),
311 HOWTO (R_XTENSA_SLOT10_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
312 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_ALT",
313 FALSE
, 0x00000000, 0x00000000, TRUE
),
314 HOWTO (R_XTENSA_SLOT11_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
315 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_ALT",
316 FALSE
, 0x00000000, 0x00000000, TRUE
),
317 HOWTO (R_XTENSA_SLOT12_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
318 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_ALT",
319 FALSE
, 0x00000000, 0x00000000, TRUE
),
320 HOWTO (R_XTENSA_SLOT13_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
321 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_ALT",
322 FALSE
, 0x00000000, 0x00000000, TRUE
),
323 HOWTO (R_XTENSA_SLOT14_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
324 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_ALT",
325 FALSE
, 0x00000000, 0x00000000, TRUE
)
330 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
335 static reloc_howto_type
*
336 elf_xtensa_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
337 bfd_reloc_code_real_type code
)
342 TRACE ("BFD_RELOC_NONE");
343 return &elf_howto_table
[(unsigned) R_XTENSA_NONE
];
346 TRACE ("BFD_RELOC_32");
347 return &elf_howto_table
[(unsigned) R_XTENSA_32
];
349 case BFD_RELOC_XTENSA_DIFF8
:
350 TRACE ("BFD_RELOC_XTENSA_DIFF8");
351 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF8
];
353 case BFD_RELOC_XTENSA_DIFF16
:
354 TRACE ("BFD_RELOC_XTENSA_DIFF16");
355 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF16
];
357 case BFD_RELOC_XTENSA_DIFF32
:
358 TRACE ("BFD_RELOC_XTENSA_DIFF32");
359 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF32
];
361 case BFD_RELOC_XTENSA_RTLD
:
362 TRACE ("BFD_RELOC_XTENSA_RTLD");
363 return &elf_howto_table
[(unsigned) R_XTENSA_RTLD
];
365 case BFD_RELOC_XTENSA_GLOB_DAT
:
366 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
367 return &elf_howto_table
[(unsigned) R_XTENSA_GLOB_DAT
];
369 case BFD_RELOC_XTENSA_JMP_SLOT
:
370 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
371 return &elf_howto_table
[(unsigned) R_XTENSA_JMP_SLOT
];
373 case BFD_RELOC_XTENSA_RELATIVE
:
374 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
375 return &elf_howto_table
[(unsigned) R_XTENSA_RELATIVE
];
377 case BFD_RELOC_XTENSA_PLT
:
378 TRACE ("BFD_RELOC_XTENSA_PLT");
379 return &elf_howto_table
[(unsigned) R_XTENSA_PLT
];
381 case BFD_RELOC_XTENSA_OP0
:
382 TRACE ("BFD_RELOC_XTENSA_OP0");
383 return &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
385 case BFD_RELOC_XTENSA_OP1
:
386 TRACE ("BFD_RELOC_XTENSA_OP1");
387 return &elf_howto_table
[(unsigned) R_XTENSA_OP1
];
389 case BFD_RELOC_XTENSA_OP2
:
390 TRACE ("BFD_RELOC_XTENSA_OP2");
391 return &elf_howto_table
[(unsigned) R_XTENSA_OP2
];
393 case BFD_RELOC_XTENSA_ASM_EXPAND
:
394 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
395 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_EXPAND
];
397 case BFD_RELOC_XTENSA_ASM_SIMPLIFY
:
398 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
399 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_SIMPLIFY
];
401 case BFD_RELOC_VTABLE_INHERIT
:
402 TRACE ("BFD_RELOC_VTABLE_INHERIT");
403 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTINHERIT
];
405 case BFD_RELOC_VTABLE_ENTRY
:
406 TRACE ("BFD_RELOC_VTABLE_ENTRY");
407 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTENTRY
];
410 if (code
>= BFD_RELOC_XTENSA_SLOT0_OP
411 && code
<= BFD_RELOC_XTENSA_SLOT14_OP
)
413 unsigned n
= (R_XTENSA_SLOT0_OP
+
414 (code
- BFD_RELOC_XTENSA_SLOT0_OP
));
415 return &elf_howto_table
[n
];
418 if (code
>= BFD_RELOC_XTENSA_SLOT0_ALT
419 && code
<= BFD_RELOC_XTENSA_SLOT14_ALT
)
421 unsigned n
= (R_XTENSA_SLOT0_ALT
+
422 (code
- BFD_RELOC_XTENSA_SLOT0_ALT
));
423 return &elf_howto_table
[n
];
434 /* Given an ELF "rela" relocation, find the corresponding howto and record
435 it in the BFD internal arelent representation of the relocation. */
438 elf_xtensa_info_to_howto_rela (bfd
*abfd ATTRIBUTE_UNUSED
,
440 Elf_Internal_Rela
*dst
)
442 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
444 BFD_ASSERT (r_type
< (unsigned int) R_XTENSA_max
);
445 cache_ptr
->howto
= &elf_howto_table
[r_type
];
449 /* Functions for the Xtensa ELF linker. */
451 /* The name of the dynamic interpreter. This is put in the .interp
454 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
456 /* The size in bytes of an entry in the procedure linkage table.
457 (This does _not_ include the space for the literals associated with
460 #define PLT_ENTRY_SIZE 16
462 /* For _really_ large PLTs, we may need to alternate between literals
463 and code to keep the literals within the 256K range of the L32R
464 instructions in the code. It's unlikely that anyone would ever need
465 such a big PLT, but an arbitrary limit on the PLT size would be bad.
466 Thus, we split the PLT into chunks. Since there's very little
467 overhead (2 extra literals) for each chunk, the chunk size is kept
468 small so that the code for handling multiple chunks get used and
469 tested regularly. With 254 entries, there are 1K of literals for
470 each chunk, and that seems like a nice round number. */
472 #define PLT_ENTRIES_PER_CHUNK 254
474 /* PLT entries are actually used as stub functions for lazy symbol
475 resolution. Once the symbol is resolved, the stub function is never
476 invoked. Note: the 32-byte frame size used here cannot be changed
477 without a corresponding change in the runtime linker. */
479 static const bfd_byte elf_xtensa_be_plt_entry
[PLT_ENTRY_SIZE
] =
481 0x6c, 0x10, 0x04, /* entry sp, 32 */
482 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
483 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
484 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
485 0x0a, 0x80, 0x00, /* jx a8 */
489 static const bfd_byte elf_xtensa_le_plt_entry
[PLT_ENTRY_SIZE
] =
491 0x36, 0x41, 0x00, /* entry sp, 32 */
492 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
493 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
494 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
495 0xa0, 0x08, 0x00, /* jx a8 */
500 static inline bfd_boolean
501 xtensa_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
502 struct bfd_link_info
*info
)
504 /* Check if we should do dynamic things to this symbol. The
505 "ignore_protected" argument need not be set, because Xtensa code
506 does not require special handling of STV_PROTECTED to make function
507 pointer comparisons work properly. The PLT addresses are never
508 used for function pointers. */
510 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
515 property_table_compare (const void *ap
, const void *bp
)
517 const property_table_entry
*a
= (const property_table_entry
*) ap
;
518 const property_table_entry
*b
= (const property_table_entry
*) bp
;
520 if (a
->address
== b
->address
)
522 if (a
->size
!= b
->size
)
523 return (a
->size
- b
->size
);
525 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
526 return ((b
->flags
& XTENSA_PROP_ALIGN
)
527 - (a
->flags
& XTENSA_PROP_ALIGN
));
529 if ((a
->flags
& XTENSA_PROP_ALIGN
)
530 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
531 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
532 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
533 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
535 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
536 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
537 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
538 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
540 return (a
->flags
- b
->flags
);
543 return (a
->address
- b
->address
);
548 property_table_matches (const void *ap
, const void *bp
)
550 const property_table_entry
*a
= (const property_table_entry
*) ap
;
551 const property_table_entry
*b
= (const property_table_entry
*) bp
;
553 /* Check if one entry overlaps with the other. */
554 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
555 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
558 return (a
->address
- b
->address
);
562 /* Get the literal table or property table entries for the given
563 section. Sets TABLE_P and returns the number of entries. On
564 error, returns a negative value. */
567 xtensa_read_table_entries (bfd
*abfd
,
569 property_table_entry
**table_p
,
570 const char *sec_name
,
571 bfd_boolean output_addr
)
573 asection
*table_section
;
574 char *table_section_name
;
575 bfd_size_type table_size
= 0;
576 bfd_byte
*table_data
;
577 property_table_entry
*blocks
;
578 int blk
, block_count
;
579 bfd_size_type num_records
;
580 Elf_Internal_Rela
*internal_relocs
;
581 bfd_vma section_addr
;
582 flagword predef_flags
;
583 bfd_size_type table_entry_size
;
586 || !(section
->flags
& SEC_ALLOC
)
587 || (section
->flags
& SEC_DEBUGGING
))
593 table_section_name
= xtensa_get_property_section_name (section
, sec_name
);
594 table_section
= bfd_get_section_by_name (abfd
, table_section_name
);
595 free (table_section_name
);
597 table_size
= table_section
->size
;
605 predef_flags
= xtensa_get_property_predef_flags (table_section
);
606 table_entry_size
= 12;
608 table_entry_size
-= 4;
610 num_records
= table_size
/ table_entry_size
;
611 table_data
= retrieve_contents (abfd
, table_section
, TRUE
);
612 blocks
= (property_table_entry
*)
613 bfd_malloc (num_records
* sizeof (property_table_entry
));
617 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
619 section_addr
= section
->vma
;
621 /* If the file has not yet been relocated, process the relocations
622 and sort out the table entries that apply to the specified section. */
623 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, TRUE
);
624 if (internal_relocs
&& !table_section
->reloc_done
)
628 for (i
= 0; i
< table_section
->reloc_count
; i
++)
630 Elf_Internal_Rela
*rel
= &internal_relocs
[i
];
631 unsigned long r_symndx
;
633 if (ELF32_R_TYPE (rel
->r_info
) == R_XTENSA_NONE
)
636 BFD_ASSERT (ELF32_R_TYPE (rel
->r_info
) == R_XTENSA_32
);
637 r_symndx
= ELF32_R_SYM (rel
->r_info
);
639 if (get_elf_r_symndx_section (abfd
, r_symndx
) == section
)
641 bfd_vma sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
642 BFD_ASSERT (sym_off
== 0);
643 blocks
[block_count
].address
=
644 (section_addr
+ sym_off
+ rel
->r_addend
645 + bfd_get_32 (abfd
, table_data
+ rel
->r_offset
));
646 blocks
[block_count
].size
=
647 bfd_get_32 (abfd
, table_data
+ rel
->r_offset
+ 4);
649 blocks
[block_count
].flags
= predef_flags
;
651 blocks
[block_count
].flags
=
652 bfd_get_32 (abfd
, table_data
+ rel
->r_offset
+ 8);
659 /* The file has already been relocated and the addresses are
660 already in the table. */
662 bfd_size_type section_limit
= bfd_get_section_limit (abfd
, section
);
664 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
666 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
668 if (address
>= section_addr
669 && address
< section_addr
+ section_limit
)
671 blocks
[block_count
].address
= address
;
672 blocks
[block_count
].size
=
673 bfd_get_32 (abfd
, table_data
+ off
+ 4);
675 blocks
[block_count
].flags
= predef_flags
;
677 blocks
[block_count
].flags
=
678 bfd_get_32 (abfd
, table_data
+ off
+ 8);
684 release_contents (table_section
, table_data
);
685 release_internal_relocs (table_section
, internal_relocs
);
689 /* Now sort them into address order for easy reference. */
690 qsort (blocks
, block_count
, sizeof (property_table_entry
),
691 property_table_compare
);
693 /* Check that the table contents are valid. Problems may occur,
694 for example, if an unrelocated object file is stripped. */
695 for (blk
= 1; blk
< block_count
; blk
++)
697 /* The only circumstance where two entries may legitimately
698 have the same address is when one of them is a zero-size
699 placeholder to mark a place where fill can be inserted.
700 The zero-size entry should come first. */
701 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
702 blocks
[blk
- 1].size
!= 0)
704 (*_bfd_error_handler
) (_("%B(%A): invalid property table"),
706 bfd_set_error (bfd_error_bad_value
);
718 static property_table_entry
*
719 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
720 int property_table_size
,
723 property_table_entry entry
;
724 property_table_entry
*rv
;
726 if (property_table_size
== 0)
729 entry
.address
= addr
;
733 rv
= bsearch (&entry
, property_table
, property_table_size
,
734 sizeof (property_table_entry
), property_table_matches
);
740 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
744 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
751 /* Look through the relocs for a section during the first phase, and
752 calculate needed space in the dynamic reloc sections. */
755 elf_xtensa_check_relocs (bfd
*abfd
,
756 struct bfd_link_info
*info
,
758 const Elf_Internal_Rela
*relocs
)
760 Elf_Internal_Shdr
*symtab_hdr
;
761 struct elf_link_hash_entry
**sym_hashes
;
762 const Elf_Internal_Rela
*rel
;
763 const Elf_Internal_Rela
*rel_end
;
765 if (info
->relocatable
)
768 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
769 sym_hashes
= elf_sym_hashes (abfd
);
771 rel_end
= relocs
+ sec
->reloc_count
;
772 for (rel
= relocs
; rel
< rel_end
; rel
++)
775 unsigned long r_symndx
;
776 struct elf_link_hash_entry
*h
;
778 r_symndx
= ELF32_R_SYM (rel
->r_info
);
779 r_type
= ELF32_R_TYPE (rel
->r_info
);
781 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
783 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
788 if (r_symndx
< symtab_hdr
->sh_info
)
792 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
793 while (h
->root
.type
== bfd_link_hash_indirect
794 || h
->root
.type
== bfd_link_hash_warning
)
795 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
804 if ((sec
->flags
& SEC_ALLOC
) != 0)
806 if (h
->got
.refcount
<= 0)
809 h
->got
.refcount
+= 1;
814 /* If this relocation is against a local symbol, then it's
815 exactly the same as a normal local GOT entry. */
819 if ((sec
->flags
& SEC_ALLOC
) != 0)
821 if (h
->plt
.refcount
<= 0)
827 h
->plt
.refcount
+= 1;
829 /* Keep track of the total PLT relocation count even if we
830 don't yet know whether the dynamic sections will be
832 plt_reloc_count
+= 1;
834 if (elf_hash_table (info
)->dynamic_sections_created
)
836 if (!add_extra_plt_sections (elf_hash_table (info
)->dynobj
,
844 if ((sec
->flags
& SEC_ALLOC
) != 0)
846 bfd_signed_vma
*local_got_refcounts
;
848 /* This is a global offset table entry for a local symbol. */
849 local_got_refcounts
= elf_local_got_refcounts (abfd
);
850 if (local_got_refcounts
== NULL
)
854 size
= symtab_hdr
->sh_info
;
855 size
*= sizeof (bfd_signed_vma
);
856 local_got_refcounts
=
857 (bfd_signed_vma
*) bfd_zalloc (abfd
, size
);
858 if (local_got_refcounts
== NULL
)
860 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
862 local_got_refcounts
[r_symndx
] += 1;
869 case R_XTENSA_SLOT0_OP
:
870 case R_XTENSA_SLOT1_OP
:
871 case R_XTENSA_SLOT2_OP
:
872 case R_XTENSA_SLOT3_OP
:
873 case R_XTENSA_SLOT4_OP
:
874 case R_XTENSA_SLOT5_OP
:
875 case R_XTENSA_SLOT6_OP
:
876 case R_XTENSA_SLOT7_OP
:
877 case R_XTENSA_SLOT8_OP
:
878 case R_XTENSA_SLOT9_OP
:
879 case R_XTENSA_SLOT10_OP
:
880 case R_XTENSA_SLOT11_OP
:
881 case R_XTENSA_SLOT12_OP
:
882 case R_XTENSA_SLOT13_OP
:
883 case R_XTENSA_SLOT14_OP
:
884 case R_XTENSA_SLOT0_ALT
:
885 case R_XTENSA_SLOT1_ALT
:
886 case R_XTENSA_SLOT2_ALT
:
887 case R_XTENSA_SLOT3_ALT
:
888 case R_XTENSA_SLOT4_ALT
:
889 case R_XTENSA_SLOT5_ALT
:
890 case R_XTENSA_SLOT6_ALT
:
891 case R_XTENSA_SLOT7_ALT
:
892 case R_XTENSA_SLOT8_ALT
:
893 case R_XTENSA_SLOT9_ALT
:
894 case R_XTENSA_SLOT10_ALT
:
895 case R_XTENSA_SLOT11_ALT
:
896 case R_XTENSA_SLOT12_ALT
:
897 case R_XTENSA_SLOT13_ALT
:
898 case R_XTENSA_SLOT14_ALT
:
899 case R_XTENSA_ASM_EXPAND
:
900 case R_XTENSA_ASM_SIMPLIFY
:
902 case R_XTENSA_DIFF16
:
903 case R_XTENSA_DIFF32
:
904 /* Nothing to do for these. */
907 case R_XTENSA_GNU_VTINHERIT
:
908 /* This relocation describes the C++ object vtable hierarchy.
909 Reconstruct it for later use during GC. */
910 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
914 case R_XTENSA_GNU_VTENTRY
:
915 /* This relocation describes which C++ vtable entries are actually
916 used. Record for later use during GC. */
917 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
931 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
932 struct elf_link_hash_entry
*h
)
936 if (h
->plt
.refcount
> 0)
938 /* Will use RELATIVE relocs instead of JMP_SLOT relocs. */
939 if (h
->got
.refcount
< 0)
941 h
->got
.refcount
+= h
->plt
.refcount
;
947 /* Don't need any dynamic relocations at all. */
955 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
956 struct elf_link_hash_entry
*h
,
957 bfd_boolean force_local
)
959 /* For a shared link, move the plt refcount to the got refcount to leave
960 space for RELATIVE relocs. */
961 elf_xtensa_make_sym_local (info
, h
);
963 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
967 /* Return the section that should be marked against GC for a given
971 elf_xtensa_gc_mark_hook (asection
*sec
,
972 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
973 Elf_Internal_Rela
*rel
,
974 struct elf_link_hash_entry
*h
,
975 Elf_Internal_Sym
*sym
)
979 switch (ELF32_R_TYPE (rel
->r_info
))
981 case R_XTENSA_GNU_VTINHERIT
:
982 case R_XTENSA_GNU_VTENTRY
:
986 switch (h
->root
.type
)
988 case bfd_link_hash_defined
:
989 case bfd_link_hash_defweak
:
990 return h
->root
.u
.def
.section
;
992 case bfd_link_hash_common
:
993 return h
->root
.u
.c
.p
->section
;
1001 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
1007 /* Update the GOT & PLT entry reference counts
1008 for the section being removed. */
1011 elf_xtensa_gc_sweep_hook (bfd
*abfd
,
1012 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1014 const Elf_Internal_Rela
*relocs
)
1016 Elf_Internal_Shdr
*symtab_hdr
;
1017 struct elf_link_hash_entry
**sym_hashes
;
1018 bfd_signed_vma
*local_got_refcounts
;
1019 const Elf_Internal_Rela
*rel
, *relend
;
1021 if ((sec
->flags
& SEC_ALLOC
) == 0)
1024 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1025 sym_hashes
= elf_sym_hashes (abfd
);
1026 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1028 relend
= relocs
+ sec
->reloc_count
;
1029 for (rel
= relocs
; rel
< relend
; rel
++)
1031 unsigned long r_symndx
;
1032 unsigned int r_type
;
1033 struct elf_link_hash_entry
*h
= NULL
;
1035 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1036 if (r_symndx
>= symtab_hdr
->sh_info
)
1038 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1039 while (h
->root
.type
== bfd_link_hash_indirect
1040 || h
->root
.type
== bfd_link_hash_warning
)
1041 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1044 r_type
= ELF32_R_TYPE (rel
->r_info
);
1050 if (h
->got
.refcount
> 0)
1057 if (h
->plt
.refcount
> 0)
1062 if (local_got_refcounts
[r_symndx
] > 0)
1063 local_got_refcounts
[r_symndx
] -= 1;
1075 /* Create all the dynamic sections. */
1078 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1080 flagword flags
, noalloc_flags
;
1083 /* First do all the standard stuff. */
1084 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1087 /* Create any extra PLT sections in case check_relocs has already
1088 been called on all the non-dynamic input files. */
1089 if (!add_extra_plt_sections (dynobj
, plt_reloc_count
))
1092 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1093 | SEC_LINKER_CREATED
| SEC_READONLY
);
1094 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1096 /* Mark the ".got.plt" section READONLY. */
1097 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
1099 || ! bfd_set_section_flags (dynobj
, s
, flags
))
1102 /* Create ".rela.got". */
1103 s
= bfd_make_section_with_flags (dynobj
, ".rela.got", flags
);
1105 || ! bfd_set_section_alignment (dynobj
, s
, 2))
1108 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1109 s
= bfd_make_section_with_flags (dynobj
, ".got.loc", flags
);
1111 || ! bfd_set_section_alignment (dynobj
, s
, 2))
1114 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1115 s
= bfd_make_section_with_flags (dynobj
, ".xt.lit.plt",
1118 || ! bfd_set_section_alignment (dynobj
, s
, 2))
1126 add_extra_plt_sections (bfd
*dynobj
, int count
)
1130 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1131 ".got.plt" sections. */
1132 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1138 /* Stop when we find a section has already been created. */
1139 if (elf_xtensa_get_plt_section (dynobj
, chunk
))
1142 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1143 | SEC_LINKER_CREATED
| SEC_READONLY
);
1145 sname
= (char *) bfd_malloc (10);
1146 sprintf (sname
, ".plt.%u", chunk
);
1147 s
= bfd_make_section_with_flags (dynobj
, sname
,
1150 || ! bfd_set_section_alignment (dynobj
, s
, 2))
1153 sname
= (char *) bfd_malloc (14);
1154 sprintf (sname
, ".got.plt.%u", chunk
);
1155 s
= bfd_make_section_with_flags (dynobj
, sname
, flags
);
1157 || ! bfd_set_section_alignment (dynobj
, s
, 2))
1165 /* Adjust a symbol defined by a dynamic object and referenced by a
1166 regular object. The current definition is in some section of the
1167 dynamic object, but we're not including those sections. We have to
1168 change the definition to something the rest of the link can
1172 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1173 struct elf_link_hash_entry
*h
)
1175 /* If this is a weak symbol, and there is a real definition, the
1176 processor independent code will have arranged for us to see the
1177 real definition first, and we can just use the same value. */
1180 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1181 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1182 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1183 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1187 /* This is a reference to a symbol defined by a dynamic object. The
1188 reference must go through the GOT, so there's no need for COPY relocs,
1196 elf_xtensa_fix_refcounts (struct elf_link_hash_entry
*h
, void *arg
)
1198 struct bfd_link_info
*info
= (struct bfd_link_info
*) arg
;
1200 if (h
->root
.type
== bfd_link_hash_warning
)
1201 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1203 if (! xtensa_elf_dynamic_symbol_p (h
, info
))
1204 elf_xtensa_make_sym_local (info
, h
);
1211 elf_xtensa_allocate_plt_size (struct elf_link_hash_entry
*h
, void *arg
)
1213 asection
*srelplt
= (asection
*) arg
;
1215 if (h
->root
.type
== bfd_link_hash_warning
)
1216 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1218 if (h
->plt
.refcount
> 0)
1219 srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1226 elf_xtensa_allocate_got_size (struct elf_link_hash_entry
*h
, void *arg
)
1228 asection
*srelgot
= (asection
*) arg
;
1230 if (h
->root
.type
== bfd_link_hash_warning
)
1231 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1233 if (h
->got
.refcount
> 0)
1234 srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1241 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
,
1246 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
1248 bfd_signed_vma
*local_got_refcounts
;
1249 bfd_size_type j
, cnt
;
1250 Elf_Internal_Shdr
*symtab_hdr
;
1252 local_got_refcounts
= elf_local_got_refcounts (i
);
1253 if (!local_got_refcounts
)
1256 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1257 cnt
= symtab_hdr
->sh_info
;
1259 for (j
= 0; j
< cnt
; ++j
)
1261 if (local_got_refcounts
[j
] > 0)
1262 srelgot
->size
+= (local_got_refcounts
[j
]
1263 * sizeof (Elf32_External_Rela
));
1269 /* Set the sizes of the dynamic sections. */
1272 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1273 struct bfd_link_info
*info
)
1276 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1277 bfd_boolean relplt
, relgot
;
1278 int plt_entries
, plt_chunks
, chunk
;
1284 dynobj
= elf_hash_table (info
)->dynobj
;
1288 if (elf_hash_table (info
)->dynamic_sections_created
)
1290 /* Set the contents of the .interp section to the interpreter. */
1291 if (info
->executable
)
1293 s
= bfd_get_section_by_name (dynobj
, ".interp");
1296 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1297 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1300 /* Allocate room for one word in ".got". */
1301 s
= bfd_get_section_by_name (dynobj
, ".got");
1306 /* Adjust refcounts for symbols that we now know are not "dynamic". */
1307 elf_link_hash_traverse (elf_hash_table (info
),
1308 elf_xtensa_fix_refcounts
,
1311 /* Allocate space in ".rela.got" for literals that reference
1313 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
1314 if (srelgot
== NULL
)
1316 elf_link_hash_traverse (elf_hash_table (info
),
1317 elf_xtensa_allocate_got_size
,
1320 /* If we are generating a shared object, we also need space in
1321 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1322 reference local symbols. */
1324 elf_xtensa_allocate_local_got_size (info
, srelgot
);
1326 /* Allocate space in ".rela.plt" for literals that have PLT entries. */
1327 srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1328 if (srelplt
== NULL
)
1330 elf_link_hash_traverse (elf_hash_table (info
),
1331 elf_xtensa_allocate_plt_size
,
1334 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1335 each PLT entry, we need the PLT code plus a 4-byte literal.
1336 For each chunk of ".plt", we also need two more 4-byte
1337 literals, two corresponding entries in ".rela.got", and an
1338 8-byte entry in ".xt.lit.plt". */
1339 spltlittbl
= bfd_get_section_by_name (dynobj
, ".xt.lit.plt");
1340 if (spltlittbl
== NULL
)
1343 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1345 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1347 /* Iterate over all the PLT chunks, including any extra sections
1348 created earlier because the initial count of PLT relocations
1349 was an overestimate. */
1351 (splt
= elf_xtensa_get_plt_section (dynobj
, chunk
)) != NULL
;
1356 sgotplt
= elf_xtensa_get_gotplt_section (dynobj
, chunk
);
1357 if (sgotplt
== NULL
)
1360 if (chunk
< plt_chunks
- 1)
1361 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1362 else if (chunk
== plt_chunks
- 1)
1363 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1367 if (chunk_entries
!= 0)
1369 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1370 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1371 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1372 spltlittbl
->size
+= 8;
1381 /* Allocate space in ".got.loc" to match the total size of all the
1383 sgotloc
= bfd_get_section_by_name (dynobj
, ".got.loc");
1384 if (sgotloc
== NULL
)
1386 sgotloc
->size
= spltlittbl
->size
;
1387 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
1389 if (abfd
->flags
& DYNAMIC
)
1391 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1393 if (! elf_discarded_section (s
)
1394 && xtensa_is_littable_section (s
)
1396 sgotloc
->size
+= s
->size
;
1401 /* Allocate memory for dynamic sections. */
1404 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1408 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1411 /* It's OK to base decisions on the section name, because none
1412 of the dynobj section names depend upon the input files. */
1413 name
= bfd_get_section_name (dynobj
, s
);
1415 if (strncmp (name
, ".rela", 5) == 0)
1419 if (strcmp (name
, ".rela.plt") == 0)
1421 else if (strcmp (name
, ".rela.got") == 0)
1424 /* We use the reloc_count field as a counter if we need
1425 to copy relocs into the output file. */
1429 else if (strncmp (name
, ".plt.", 5) != 0
1430 && strncmp (name
, ".got.plt.", 9) != 0
1431 && strcmp (name
, ".got") != 0
1432 && strcmp (name
, ".plt") != 0
1433 && strcmp (name
, ".got.plt") != 0
1434 && strcmp (name
, ".xt.lit.plt") != 0
1435 && strcmp (name
, ".got.loc") != 0)
1437 /* It's not one of our sections, so don't allocate space. */
1443 /* If we don't need this section, strip it from the output
1444 file. We must create the ".plt*" and ".got.plt*"
1445 sections in create_dynamic_sections and/or check_relocs
1446 based on a conservative estimate of the PLT relocation
1447 count, because the sections must be created before the
1448 linker maps input sections to output sections. The
1449 linker does that before size_dynamic_sections, where we
1450 compute the exact size of the PLT, so there may be more
1451 of these sections than are actually needed. */
1452 s
->flags
|= SEC_EXCLUDE
;
1454 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1456 /* Allocate memory for the section contents. */
1457 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1458 if (s
->contents
== NULL
)
1463 if (elf_hash_table (info
)->dynamic_sections_created
)
1465 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1466 known until finish_dynamic_sections, but we need to get the relocs
1467 in place before they are sorted. */
1468 if (srelgot
== NULL
)
1470 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1472 Elf_Internal_Rela irela
;
1476 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1479 loc
= (srelgot
->contents
1480 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1481 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1482 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1483 loc
+ sizeof (Elf32_External_Rela
));
1484 srelgot
->reloc_count
+= 2;
1487 /* Add some entries to the .dynamic section. We fill in the
1488 values later, in elf_xtensa_finish_dynamic_sections, but we
1489 must add the entries now so that we get the correct size for
1490 the .dynamic section. The DT_DEBUG entry is filled in by the
1491 dynamic linker and used by the debugger. */
1492 #define add_dynamic_entry(TAG, VAL) \
1493 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1497 if (!add_dynamic_entry (DT_DEBUG
, 0))
1503 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1504 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1505 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1506 || !add_dynamic_entry (DT_JMPREL
, 0))
1512 if (!add_dynamic_entry (DT_RELA
, 0)
1513 || !add_dynamic_entry (DT_RELASZ
, 0)
1514 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1518 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1519 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1522 #undef add_dynamic_entry
1528 /* Perform the specified relocation. The instruction at (contents + address)
1529 is modified to set one operand to represent the value in "relocation". The
1530 operand position is determined by the relocation type recorded in the
1533 #define CALL_SEGMENT_BITS (30)
1534 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1536 static bfd_reloc_status_type
1537 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1539 asection
*input_section
,
1543 bfd_boolean is_weak_undef
,
1544 char **error_message
)
1547 xtensa_opcode opcode
;
1548 xtensa_isa isa
= xtensa_default_isa
;
1549 static xtensa_insnbuf ibuff
= NULL
;
1550 static xtensa_insnbuf sbuff
= NULL
;
1551 bfd_vma self_address
= 0;
1552 bfd_size_type input_size
;
1558 ibuff
= xtensa_insnbuf_alloc (isa
);
1559 sbuff
= xtensa_insnbuf_alloc (isa
);
1562 input_size
= bfd_get_section_limit (abfd
, input_section
);
1564 switch (howto
->type
)
1567 case R_XTENSA_DIFF8
:
1568 case R_XTENSA_DIFF16
:
1569 case R_XTENSA_DIFF32
:
1570 return bfd_reloc_ok
;
1572 case R_XTENSA_ASM_EXPAND
:
1575 /* Check for windowed CALL across a 1GB boundary. */
1576 xtensa_opcode opcode
=
1577 get_expanded_call_opcode (contents
+ address
,
1578 input_size
- address
, 0);
1579 if (is_windowed_call_opcode (opcode
))
1581 self_address
= (input_section
->output_section
->vma
1582 + input_section
->output_offset
1584 if ((self_address
>> CALL_SEGMENT_BITS
)
1585 != (relocation
>> CALL_SEGMENT_BITS
))
1587 *error_message
= "windowed longcall crosses 1GB boundary; "
1589 return bfd_reloc_dangerous
;
1593 return bfd_reloc_ok
;
1595 case R_XTENSA_ASM_SIMPLIFY
:
1597 /* Convert the L32R/CALLX to CALL. */
1598 bfd_reloc_status_type retval
=
1599 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1601 if (retval
!= bfd_reloc_ok
)
1602 return bfd_reloc_dangerous
;
1604 /* The CALL needs to be relocated. Continue below for that part. */
1606 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1614 x
= bfd_get_32 (abfd
, contents
+ address
);
1616 bfd_put_32 (abfd
, x
, contents
+ address
);
1618 return bfd_reloc_ok
;
1621 /* Only instruction slot-specific relocations handled below.... */
1622 slot
= get_relocation_slot (howto
->type
);
1623 if (slot
== XTENSA_UNDEFINED
)
1625 *error_message
= "unexpected relocation";
1626 return bfd_reloc_dangerous
;
1629 /* Read the instruction into a buffer and decode the opcode. */
1630 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1631 input_size
- address
);
1632 fmt
= xtensa_format_decode (isa
, ibuff
);
1633 if (fmt
== XTENSA_UNDEFINED
)
1635 *error_message
= "cannot decode instruction format";
1636 return bfd_reloc_dangerous
;
1639 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1641 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1642 if (opcode
== XTENSA_UNDEFINED
)
1644 *error_message
= "cannot decode instruction opcode";
1645 return bfd_reloc_dangerous
;
1648 /* Check for opcode-specific "alternate" relocations. */
1649 if (is_alt_relocation (howto
->type
))
1651 if (opcode
== get_l32r_opcode ())
1653 /* Handle the special-case of non-PC-relative L32R instructions. */
1654 bfd
*output_bfd
= input_section
->output_section
->owner
;
1655 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
1658 *error_message
= "relocation references missing .lit4 section";
1659 return bfd_reloc_dangerous
;
1661 self_address
= ((lit4_sec
->vma
& ~0xfff)
1662 + 0x40000 - 3); /* -3 to compensate for do_reloc */
1663 newval
= relocation
;
1666 else if (opcode
== get_const16_opcode ())
1668 /* ALT used for high 16 bits. */
1669 newval
= relocation
>> 16;
1674 /* No other "alternate" relocations currently defined. */
1675 *error_message
= "unexpected relocation";
1676 return bfd_reloc_dangerous
;
1679 else /* Not an "alternate" relocation.... */
1681 if (opcode
== get_const16_opcode ())
1683 newval
= relocation
& 0xffff;
1688 /* ...normal PC-relative relocation.... */
1690 /* Determine which operand is being relocated. */
1691 opnd
= get_relocation_opnd (opcode
, howto
->type
);
1692 if (opnd
== XTENSA_UNDEFINED
)
1694 *error_message
= "unexpected relocation";
1695 return bfd_reloc_dangerous
;
1698 if (!howto
->pc_relative
)
1700 *error_message
= "expected PC-relative relocation";
1701 return bfd_reloc_dangerous
;
1704 /* Calculate the PC address for this instruction. */
1705 self_address
= (input_section
->output_section
->vma
1706 + input_section
->output_offset
1709 newval
= relocation
;
1713 /* Apply the relocation. */
1714 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
1715 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
1716 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
1719 const char *opname
= xtensa_opcode_name (isa
, opcode
);
1722 msg
= "cannot encode";
1723 if (is_direct_call_opcode (opcode
))
1725 if ((relocation
& 0x3) != 0)
1726 msg
= "misaligned call target";
1728 msg
= "call target out of range";
1730 else if (opcode
== get_l32r_opcode ())
1732 if ((relocation
& 0x3) != 0)
1733 msg
= "misaligned literal target";
1734 else if (is_alt_relocation (howto
->type
))
1735 msg
= "literal target out of range (too many literals)";
1736 else if (self_address
> relocation
)
1737 msg
= "literal target out of range (try using text-section-literals)";
1739 msg
= "literal placed after use";
1742 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
1743 return bfd_reloc_dangerous
;
1746 /* Check for calls across 1GB boundaries. */
1747 if (is_direct_call_opcode (opcode
)
1748 && is_windowed_call_opcode (opcode
))
1750 if ((self_address
>> CALL_SEGMENT_BITS
)
1751 != (relocation
>> CALL_SEGMENT_BITS
))
1754 "windowed call crosses 1GB boundary; return may fail";
1755 return bfd_reloc_dangerous
;
1759 /* Write the modified instruction back out of the buffer. */
1760 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1761 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
1762 input_size
- address
);
1763 return bfd_reloc_ok
;
1768 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
1770 /* To reduce the size of the memory leak,
1771 we only use a single message buffer. */
1772 static bfd_size_type alloc_size
= 0;
1773 static char *message
= NULL
;
1774 bfd_size_type orig_len
, len
= 0;
1775 bfd_boolean is_append
;
1777 VA_OPEN (ap
, arglen
);
1778 VA_FIXEDARG (ap
, const char *, origmsg
);
1780 is_append
= (origmsg
== message
);
1782 orig_len
= strlen (origmsg
);
1783 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
1784 if (len
> alloc_size
)
1786 message
= (char *) bfd_realloc (message
, len
);
1790 memcpy (message
, origmsg
, orig_len
);
1791 vsprintf (message
+ orig_len
, fmt
, ap
);
1797 /* This function is registered as the "special_function" in the
1798 Xtensa howto for handling simplify operations.
1799 bfd_perform_relocation / bfd_install_relocation use it to
1800 perform (install) the specified relocation. Since this replaces the code
1801 in bfd_perform_relocation, it is basically an Xtensa-specific,
1802 stripped-down version of bfd_perform_relocation. */
1804 static bfd_reloc_status_type
1805 bfd_elf_xtensa_reloc (bfd
*abfd
,
1806 arelent
*reloc_entry
,
1809 asection
*input_section
,
1811 char **error_message
)
1814 bfd_reloc_status_type flag
;
1815 bfd_size_type octets
= reloc_entry
->address
* bfd_octets_per_byte (abfd
);
1816 bfd_vma output_base
= 0;
1817 reloc_howto_type
*howto
= reloc_entry
->howto
;
1818 asection
*reloc_target_output_section
;
1819 bfd_boolean is_weak_undef
;
1821 if (!xtensa_default_isa
)
1822 xtensa_default_isa
= xtensa_isa_init (0, 0);
1824 /* ELF relocs are against symbols. If we are producing relocatable
1825 output, and the reloc is against an external symbol, the resulting
1826 reloc will also be against the same symbol. In such a case, we
1827 don't want to change anything about the way the reloc is handled,
1828 since it will all be done at final link time. This test is similar
1829 to what bfd_elf_generic_reloc does except that it lets relocs with
1830 howto->partial_inplace go through even if the addend is non-zero.
1831 (The real problem is that partial_inplace is set for XTENSA_32
1832 relocs to begin with, but that's a long story and there's little we
1833 can do about it now....) */
1835 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
1837 reloc_entry
->address
+= input_section
->output_offset
;
1838 return bfd_reloc_ok
;
1841 /* Is the address of the relocation really within the section? */
1842 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
1843 return bfd_reloc_outofrange
;
1845 /* Work out which section the relocation is targeted at and the
1846 initial relocation command value. */
1848 /* Get symbol value. (Common symbols are special.) */
1849 if (bfd_is_com_section (symbol
->section
))
1852 relocation
= symbol
->value
;
1854 reloc_target_output_section
= symbol
->section
->output_section
;
1856 /* Convert input-section-relative symbol value to absolute. */
1857 if ((output_bfd
&& !howto
->partial_inplace
)
1858 || reloc_target_output_section
== NULL
)
1861 output_base
= reloc_target_output_section
->vma
;
1863 relocation
+= output_base
+ symbol
->section
->output_offset
;
1865 /* Add in supplied addend. */
1866 relocation
+= reloc_entry
->addend
;
1868 /* Here the variable relocation holds the final address of the
1869 symbol we are relocating against, plus any addend. */
1872 if (!howto
->partial_inplace
)
1874 /* This is a partial relocation, and we want to apply the relocation
1875 to the reloc entry rather than the raw data. Everything except
1876 relocations against section symbols has already been handled
1879 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
1880 reloc_entry
->addend
= relocation
;
1881 reloc_entry
->address
+= input_section
->output_offset
;
1882 return bfd_reloc_ok
;
1886 reloc_entry
->address
+= input_section
->output_offset
;
1887 reloc_entry
->addend
= 0;
1891 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
1892 && (symbol
->flags
& BSF_WEAK
) != 0);
1893 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
1894 (bfd_byte
*) data
, (bfd_vma
) octets
,
1895 is_weak_undef
, error_message
);
1897 if (flag
== bfd_reloc_dangerous
)
1899 /* Add the symbol name to the error message. */
1900 if (! *error_message
)
1901 *error_message
= "";
1902 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
1903 strlen (symbol
->name
) + 17,
1905 (unsigned long) reloc_entry
->addend
);
1912 /* Set up an entry in the procedure linkage table. */
1915 elf_xtensa_create_plt_entry (bfd
*dynobj
,
1917 unsigned reloc_index
)
1919 asection
*splt
, *sgotplt
;
1920 bfd_vma plt_base
, got_base
;
1921 bfd_vma code_offset
, lit_offset
;
1924 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
1925 splt
= elf_xtensa_get_plt_section (dynobj
, chunk
);
1926 sgotplt
= elf_xtensa_get_gotplt_section (dynobj
, chunk
);
1927 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
1929 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
1930 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
1932 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
1933 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
1935 /* Fill in the literal entry. This is the offset of the dynamic
1936 relocation entry. */
1937 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
1938 sgotplt
->contents
+ lit_offset
);
1940 /* Fill in the entry in the procedure linkage table. */
1941 memcpy (splt
->contents
+ code_offset
,
1942 (bfd_big_endian (output_bfd
)
1943 ? elf_xtensa_be_plt_entry
1944 : elf_xtensa_le_plt_entry
),
1946 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
1947 plt_base
+ code_offset
+ 3),
1948 splt
->contents
+ code_offset
+ 4);
1949 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
1950 plt_base
+ code_offset
+ 6),
1951 splt
->contents
+ code_offset
+ 7);
1952 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
1953 plt_base
+ code_offset
+ 9),
1954 splt
->contents
+ code_offset
+ 10);
1956 return plt_base
+ code_offset
;
1960 /* Relocate an Xtensa ELF section. This is invoked by the linker for
1961 both relocatable and final links. */
1964 elf_xtensa_relocate_section (bfd
*output_bfd
,
1965 struct bfd_link_info
*info
,
1967 asection
*input_section
,
1969 Elf_Internal_Rela
*relocs
,
1970 Elf_Internal_Sym
*local_syms
,
1971 asection
**local_sections
)
1973 Elf_Internal_Shdr
*symtab_hdr
;
1974 Elf_Internal_Rela
*rel
;
1975 Elf_Internal_Rela
*relend
;
1976 struct elf_link_hash_entry
**sym_hashes
;
1977 asection
*srelgot
, *srelplt
;
1979 property_table_entry
*lit_table
= 0;
1981 char *error_message
= NULL
;
1982 bfd_size_type input_size
;
1984 if (!xtensa_default_isa
)
1985 xtensa_default_isa
= xtensa_isa_init (0, 0);
1987 dynobj
= elf_hash_table (info
)->dynobj
;
1988 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1989 sym_hashes
= elf_sym_hashes (input_bfd
);
1995 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");;
1996 srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1999 if (elf_hash_table (info
)->dynamic_sections_created
)
2001 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2002 &lit_table
, XTENSA_LIT_SEC_NAME
,
2008 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2011 relend
= relocs
+ input_section
->reloc_count
;
2012 for (; rel
< relend
; rel
++)
2015 reloc_howto_type
*howto
;
2016 unsigned long r_symndx
;
2017 struct elf_link_hash_entry
*h
;
2018 Elf_Internal_Sym
*sym
;
2021 bfd_reloc_status_type r
;
2022 bfd_boolean is_weak_undef
;
2023 bfd_boolean unresolved_reloc
;
2026 r_type
= ELF32_R_TYPE (rel
->r_info
);
2027 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2028 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2031 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2033 bfd_set_error (bfd_error_bad_value
);
2036 howto
= &elf_howto_table
[r_type
];
2038 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2040 if (info
->relocatable
)
2042 /* This is a relocatable link.
2043 1) If the reloc is against a section symbol, adjust
2044 according to the output section.
2045 2) If there is a new target for this relocation,
2046 the new target will be in the same output section.
2047 We adjust the relocation by the output section
2050 if (relaxing_section
)
2052 /* Check if this references a section in another input file. */
2053 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2056 r_type
= ELF32_R_TYPE (rel
->r_info
);
2059 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2061 char *error_message
= NULL
;
2062 /* Convert ASM_SIMPLIFY into the simpler relocation
2063 so that they never escape a relaxing link. */
2064 r
= contract_asm_expansion (contents
, input_size
, rel
,
2066 if (r
!= bfd_reloc_ok
)
2068 if (!((*info
->callbacks
->reloc_dangerous
)
2069 (info
, error_message
, input_bfd
, input_section
,
2073 r_type
= ELF32_R_TYPE (rel
->r_info
);
2076 /* This is a relocatable link, so we don't have to change
2077 anything unless the reloc is against a section symbol,
2078 in which case we have to adjust according to where the
2079 section symbol winds up in the output section. */
2080 if (r_symndx
< symtab_hdr
->sh_info
)
2082 sym
= local_syms
+ r_symndx
;
2083 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2085 sec
= local_sections
[r_symndx
];
2086 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2090 /* If there is an addend with a partial_inplace howto,
2091 then move the addend to the contents. This is a hack
2092 to work around problems with DWARF in relocatable links
2093 with some previous version of BFD. Now we can't easily get
2094 rid of the hack without breaking backward compatibility.... */
2097 howto
= &elf_howto_table
[r_type
];
2098 if (howto
->partial_inplace
)
2100 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2101 rel
->r_addend
, contents
,
2102 rel
->r_offset
, FALSE
,
2104 if (r
!= bfd_reloc_ok
)
2106 if (!((*info
->callbacks
->reloc_dangerous
)
2107 (info
, error_message
, input_bfd
, input_section
,
2115 /* Done with work for relocatable link; continue with next reloc. */
2119 /* This is a final link. */
2124 is_weak_undef
= FALSE
;
2125 unresolved_reloc
= FALSE
;
2128 if (howto
->partial_inplace
)
2130 /* Because R_XTENSA_32 was made partial_inplace to fix some
2131 problems with DWARF info in partial links, there may be
2132 an addend stored in the contents. Take it out of there
2133 and move it back into the addend field of the reloc. */
2134 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2135 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2138 if (r_symndx
< symtab_hdr
->sh_info
)
2140 sym
= local_syms
+ r_symndx
;
2141 sec
= local_sections
[r_symndx
];
2142 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2146 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2147 r_symndx
, symtab_hdr
, sym_hashes
,
2149 unresolved_reloc
, warned
);
2152 && !unresolved_reloc
2153 && h
->root
.type
== bfd_link_hash_undefweak
)
2154 is_weak_undef
= TRUE
;
2157 if (relaxing_section
)
2159 /* Check if this references a section in another input file. */
2160 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2163 /* Update some already cached values. */
2164 r_type
= ELF32_R_TYPE (rel
->r_info
);
2165 howto
= &elf_howto_table
[r_type
];
2168 /* Sanity check the address. */
2169 if (rel
->r_offset
>= input_size
2170 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2172 (*_bfd_error_handler
)
2173 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2174 input_bfd
, input_section
, rel
->r_offset
, input_size
);
2175 bfd_set_error (bfd_error_bad_value
);
2179 /* Generate dynamic relocations. */
2180 if (elf_hash_table (info
)->dynamic_sections_created
)
2182 bfd_boolean dynamic_symbol
= xtensa_elf_dynamic_symbol_p (h
, info
);
2184 if (dynamic_symbol
&& is_operand_relocation (r_type
))
2186 /* This is an error. The symbol's real value won't be known
2187 until runtime and it's likely to be out of range anyway. */
2188 const char *name
= h
->root
.root
.string
;
2189 error_message
= vsprint_msg ("invalid relocation for dynamic "
2191 strlen (name
) + 2, name
);
2192 if (!((*info
->callbacks
->reloc_dangerous
)
2193 (info
, error_message
, input_bfd
, input_section
,
2197 else if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
2198 && (input_section
->flags
& SEC_ALLOC
) != 0
2199 && (dynamic_symbol
|| info
->shared
))
2201 Elf_Internal_Rela outrel
;
2205 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2210 BFD_ASSERT (srel
!= NULL
);
2213 _bfd_elf_section_offset (output_bfd
, info
,
2214 input_section
, rel
->r_offset
);
2216 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2217 memset (&outrel
, 0, sizeof outrel
);
2220 outrel
.r_offset
+= (input_section
->output_section
->vma
2221 + input_section
->output_offset
);
2223 /* Complain if the relocation is in a read-only section
2224 and not in a literal pool. */
2225 if ((input_section
->flags
& SEC_READONLY
) != 0
2226 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2230 _("dynamic relocation in read-only section");
2231 if (!((*info
->callbacks
->reloc_dangerous
)
2232 (info
, error_message
, input_bfd
, input_section
,
2239 outrel
.r_addend
= rel
->r_addend
;
2242 if (r_type
== R_XTENSA_32
)
2245 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2248 else /* r_type == R_XTENSA_PLT */
2251 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2253 /* Create the PLT entry and set the initial
2254 contents of the literal entry to the address of
2257 elf_xtensa_create_plt_entry (dynobj
, output_bfd
,
2260 unresolved_reloc
= FALSE
;
2264 /* Generate a RELATIVE relocation. */
2265 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2266 outrel
.r_addend
= 0;
2270 loc
= (srel
->contents
2271 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2272 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2273 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2278 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2279 because such sections are not SEC_ALLOC and thus ld.so will
2280 not process them. */
2281 if (unresolved_reloc
2282 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2284 (*_bfd_error_handler
)
2285 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2288 (long) rel
->r_offset
,
2290 h
->root
.root
.string
);
2292 /* There's no point in calling bfd_perform_relocation here.
2293 Just go directly to our "special function". */
2294 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2295 relocation
+ rel
->r_addend
,
2296 contents
, rel
->r_offset
, is_weak_undef
,
2299 if (r
!= bfd_reloc_ok
&& !warned
)
2303 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
2304 BFD_ASSERT (error_message
!= NULL
);
2307 name
= h
->root
.root
.string
;
2310 name
= bfd_elf_string_from_elf_section
2311 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
2312 if (name
&& *name
== '\0')
2313 name
= bfd_section_name (input_bfd
, sec
);
2317 if (rel
->r_addend
== 0)
2318 error_message
= vsprint_msg (error_message
, ": %s",
2319 strlen (name
) + 2, name
);
2321 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
2323 name
, (int)rel
->r_addend
);
2326 if (!((*info
->callbacks
->reloc_dangerous
)
2327 (info
, error_message
, input_bfd
, input_section
,
2336 input_section
->reloc_done
= TRUE
;
2342 /* Finish up dynamic symbol handling. There's not much to do here since
2343 the PLT and GOT entries are all set up by relocate_section. */
2346 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2347 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2348 struct elf_link_hash_entry
*h
,
2349 Elf_Internal_Sym
*sym
)
2354 /* Mark the symbol as undefined, rather than as defined in
2355 the .plt section. Leave the value alone. */
2356 sym
->st_shndx
= SHN_UNDEF
;
2359 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2360 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2361 || h
== elf_hash_table (info
)->hgot
)
2362 sym
->st_shndx
= SHN_ABS
;
2368 /* Combine adjacent literal table entries in the output. Adjacent
2369 entries within each input section may have been removed during
2370 relaxation, but we repeat the process here, even though it's too late
2371 to shrink the output section, because it's important to minimize the
2372 number of literal table entries to reduce the start-up work for the
2373 runtime linker. Returns the number of remaining table entries or -1
2377 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
2382 property_table_entry
*table
;
2383 bfd_size_type section_size
, sgotloc_size
;
2387 section_size
= sxtlit
->size
;
2388 BFD_ASSERT (section_size
% 8 == 0);
2389 num
= section_size
/ 8;
2391 sgotloc_size
= sgotloc
->size
;
2392 if (sgotloc_size
!= section_size
)
2394 (*_bfd_error_handler
)
2395 (_("internal inconsistency in size of .got.loc section"));
2399 table
= bfd_malloc (num
* sizeof (property_table_entry
));
2403 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
2404 propagates to the output section, where it doesn't really apply and
2405 where it breaks the following call to bfd_malloc_and_get_section. */
2406 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
2408 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
2416 /* There should never be any relocations left at this point, so this
2417 is quite a bit easier than what is done during relaxation. */
2419 /* Copy the raw contents into a property table array and sort it. */
2421 for (n
= 0; n
< num
; n
++)
2423 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
2424 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
2427 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
2429 for (n
= 0; n
< num
; n
++)
2431 bfd_boolean remove
= FALSE
;
2433 if (table
[n
].size
== 0)
2436 (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
2438 table
[n
-1].size
+= table
[n
].size
;
2444 for (m
= n
; m
< num
- 1; m
++)
2446 table
[m
].address
= table
[m
+1].address
;
2447 table
[m
].size
= table
[m
+1].size
;
2455 /* Copy the data back to the raw contents. */
2457 for (n
= 0; n
< num
; n
++)
2459 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
2460 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
2464 /* Clear the removed bytes. */
2465 if ((bfd_size_type
) (num
* 8) < section_size
)
2466 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
2468 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
2472 /* Copy the contents to ".got.loc". */
2473 memcpy (sgotloc
->contents
, contents
, section_size
);
2481 /* Finish up the dynamic sections. */
2484 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
2485 struct bfd_link_info
*info
)
2488 asection
*sdyn
, *srelplt
, *sgot
, *sxtlit
, *sgotloc
;
2489 Elf32_External_Dyn
*dyncon
, *dynconend
;
2490 int num_xtlit_entries
;
2492 if (! elf_hash_table (info
)->dynamic_sections_created
)
2495 dynobj
= elf_hash_table (info
)->dynobj
;
2496 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2497 BFD_ASSERT (sdyn
!= NULL
);
2499 /* Set the first entry in the global offset table to the address of
2500 the dynamic section. */
2501 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2504 BFD_ASSERT (sgot
->size
== 4);
2506 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
2508 bfd_put_32 (output_bfd
,
2509 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2513 srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
2514 if (srelplt
&& srelplt
->size
!= 0)
2516 asection
*sgotplt
, *srelgot
, *spltlittbl
;
2517 int chunk
, plt_chunks
, plt_entries
;
2518 Elf_Internal_Rela irela
;
2520 unsigned rtld_reloc
;
2522 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");;
2523 BFD_ASSERT (srelgot
!= NULL
);
2525 spltlittbl
= bfd_get_section_by_name (dynobj
, ".xt.lit.plt");
2526 BFD_ASSERT (spltlittbl
!= NULL
);
2528 /* Find the first XTENSA_RTLD relocation. Presumably the rest
2529 of them follow immediately after.... */
2530 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
2532 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
2533 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
2534 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
2537 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
2539 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
2541 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
2543 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
2545 int chunk_entries
= 0;
2547 sgotplt
= elf_xtensa_get_gotplt_section (dynobj
, chunk
);
2548 BFD_ASSERT (sgotplt
!= NULL
);
2550 /* Emit special RTLD relocations for the first two entries in
2551 each chunk of the .got.plt section. */
2553 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
2554 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
2555 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
2556 irela
.r_offset
= (sgotplt
->output_section
->vma
2557 + sgotplt
->output_offset
);
2558 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
2559 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
2561 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
2563 /* Next literal immediately follows the first. */
2564 loc
+= sizeof (Elf32_External_Rela
);
2565 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
2566 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
2567 irela
.r_offset
= (sgotplt
->output_section
->vma
2568 + sgotplt
->output_offset
+ 4);
2569 /* Tell rtld to set value to object's link map. */
2571 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
2573 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
2575 /* Fill in the literal table. */
2576 if (chunk
< plt_chunks
- 1)
2577 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
2579 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
2581 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
2582 bfd_put_32 (output_bfd
,
2583 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
2584 spltlittbl
->contents
+ (chunk
* 8) + 0);
2585 bfd_put_32 (output_bfd
,
2586 8 + (chunk_entries
* 4),
2587 spltlittbl
->contents
+ (chunk
* 8) + 4);
2590 /* All the dynamic relocations have been emitted at this point.
2591 Make sure the relocation sections are the correct size. */
2592 if (srelgot
->size
!= (sizeof (Elf32_External_Rela
)
2593 * srelgot
->reloc_count
)
2594 || srelplt
->size
!= (sizeof (Elf32_External_Rela
)
2595 * srelplt
->reloc_count
))
2598 /* The .xt.lit.plt section has just been modified. This must
2599 happen before the code below which combines adjacent literal
2600 table entries, and the .xt.lit.plt contents have to be forced to
2602 if (! bfd_set_section_contents (output_bfd
,
2603 spltlittbl
->output_section
,
2604 spltlittbl
->contents
,
2605 spltlittbl
->output_offset
,
2608 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
2609 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
2612 /* Combine adjacent literal table entries. */
2613 BFD_ASSERT (! info
->relocatable
);
2614 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
2615 sgotloc
= bfd_get_section_by_name (dynobj
, ".got.loc");
2616 BFD_ASSERT (sxtlit
&& sgotloc
);
2618 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
2619 if (num_xtlit_entries
< 0)
2622 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2623 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2624 for (; dyncon
< dynconend
; dyncon
++)
2626 Elf_Internal_Dyn dyn
;
2630 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2637 case DT_XTENSA_GOT_LOC_SZ
:
2638 dyn
.d_un
.d_val
= num_xtlit_entries
;
2641 case DT_XTENSA_GOT_LOC_OFF
:
2650 s
= bfd_get_section_by_name (output_bfd
, name
);
2652 dyn
.d_un
.d_ptr
= s
->vma
;
2656 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2658 dyn
.d_un
.d_val
= s
->size
;
2662 /* Adjust RELASZ to not include JMPREL. This matches what
2663 glibc expects and what is done for several other ELF
2664 targets (e.g., i386, alpha), but the "correct" behavior
2665 seems to be unresolved. Since the linker script arranges
2666 for .rela.plt to follow all other relocation sections, we
2667 don't have to worry about changing the DT_RELA entry. */
2668 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2670 dyn
.d_un
.d_val
-= s
->size
;
2674 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2681 /* Functions for dealing with the e_flags field. */
2683 /* Merge backend specific data from an object file to the output
2684 object file when linking. */
2687 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
2689 unsigned out_mach
, in_mach
;
2690 flagword out_flag
, in_flag
;
2692 /* Check if we have the same endianess. */
2693 if (!_bfd_generic_verify_endian_match (ibfd
, obfd
))
2696 /* Don't even pretend to support mixed-format linking. */
2697 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2698 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2701 out_flag
= elf_elfheader (obfd
)->e_flags
;
2702 in_flag
= elf_elfheader (ibfd
)->e_flags
;
2704 out_mach
= out_flag
& EF_XTENSA_MACH
;
2705 in_mach
= in_flag
& EF_XTENSA_MACH
;
2706 if (out_mach
!= in_mach
)
2708 (*_bfd_error_handler
)
2709 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
2710 ibfd
, out_mach
, in_mach
);
2711 bfd_set_error (bfd_error_wrong_format
);
2715 if (! elf_flags_init (obfd
))
2717 elf_flags_init (obfd
) = TRUE
;
2718 elf_elfheader (obfd
)->e_flags
= in_flag
;
2720 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
2721 && bfd_get_arch_info (obfd
)->the_default
)
2722 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
2723 bfd_get_mach (ibfd
));
2728 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
2729 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
2731 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
2732 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
2739 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
2741 BFD_ASSERT (!elf_flags_init (abfd
)
2742 || elf_elfheader (abfd
)->e_flags
== flags
);
2744 elf_elfheader (abfd
)->e_flags
|= flags
;
2745 elf_flags_init (abfd
) = TRUE
;
2752 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
2754 FILE *f
= (FILE *) farg
;
2755 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
2757 fprintf (f
, "\nXtensa header:\n");
2758 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
2759 fprintf (f
, "\nMachine = Base\n");
2761 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
2763 fprintf (f
, "Insn tables = %s\n",
2764 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
2766 fprintf (f
, "Literal tables = %s\n",
2767 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
2769 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
2773 /* Set the right machine number for an Xtensa ELF file. */
2776 elf_xtensa_object_p (bfd
*abfd
)
2779 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
2784 mach
= bfd_mach_xtensa
;
2790 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
2795 /* The final processing done just before writing out an Xtensa ELF object
2796 file. This gets the Xtensa architecture right based on the machine
2800 elf_xtensa_final_write_processing (bfd
*abfd
,
2801 bfd_boolean linker ATTRIBUTE_UNUSED
)
2806 switch (mach
= bfd_get_mach (abfd
))
2808 case bfd_mach_xtensa
:
2809 val
= E_XTENSA_MACH
;
2815 elf_elfheader (abfd
)->e_flags
&= (~ EF_XTENSA_MACH
);
2816 elf_elfheader (abfd
)->e_flags
|= val
;
2820 static enum elf_reloc_type_class
2821 elf_xtensa_reloc_type_class (const Elf_Internal_Rela
*rela
)
2823 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2825 case R_XTENSA_RELATIVE
:
2826 return reloc_class_relative
;
2827 case R_XTENSA_JMP_SLOT
:
2828 return reloc_class_plt
;
2830 return reloc_class_normal
;
2836 elf_xtensa_discard_info_for_section (bfd
*abfd
,
2837 struct elf_reloc_cookie
*cookie
,
2838 struct bfd_link_info
*info
,
2842 bfd_vma section_size
;
2843 bfd_vma offset
, actual_offset
;
2844 size_t removed_bytes
= 0;
2846 section_size
= sec
->size
;
2847 if (section_size
== 0 || section_size
% 8 != 0)
2850 if (sec
->output_section
2851 && bfd_is_abs_section (sec
->output_section
))
2854 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
2858 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
2861 release_contents (sec
, contents
);
2865 cookie
->rel
= cookie
->rels
;
2866 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
2868 for (offset
= 0; offset
< section_size
; offset
+= 8)
2870 actual_offset
= offset
- removed_bytes
;
2872 /* The ...symbol_deleted_p function will skip over relocs but it
2873 won't adjust their offsets, so do that here. */
2874 while (cookie
->rel
< cookie
->relend
2875 && cookie
->rel
->r_offset
< offset
)
2877 cookie
->rel
->r_offset
-= removed_bytes
;
2881 while (cookie
->rel
< cookie
->relend
2882 && cookie
->rel
->r_offset
== offset
)
2884 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
2886 /* Remove the table entry. (If the reloc type is NONE, then
2887 the entry has already been merged with another and deleted
2888 during relaxation.) */
2889 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
2891 /* Shift the contents up. */
2892 if (offset
+ 8 < section_size
)
2893 memmove (&contents
[actual_offset
],
2894 &contents
[actual_offset
+8],
2895 section_size
- offset
- 8);
2899 /* Remove this relocation. */
2900 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
2903 /* Adjust the relocation offset for previous removals. This
2904 should not be done before calling ...symbol_deleted_p
2905 because it might mess up the offset comparisons there.
2906 Make sure the offset doesn't underflow in the case where
2907 the first entry is removed. */
2908 if (cookie
->rel
->r_offset
>= removed_bytes
)
2909 cookie
->rel
->r_offset
-= removed_bytes
;
2911 cookie
->rel
->r_offset
= 0;
2917 if (removed_bytes
!= 0)
2919 /* Adjust any remaining relocs (shouldn't be any). */
2920 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
2922 if (cookie
->rel
->r_offset
>= removed_bytes
)
2923 cookie
->rel
->r_offset
-= removed_bytes
;
2925 cookie
->rel
->r_offset
= 0;
2928 /* Clear the removed bytes. */
2929 memset (&contents
[section_size
- removed_bytes
], 0, removed_bytes
);
2931 pin_contents (sec
, contents
);
2932 pin_internal_relocs (sec
, cookie
->rels
);
2935 sec
->size
= section_size
- removed_bytes
;
2937 if (xtensa_is_littable_section (sec
))
2939 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
2943 bfd_get_section_by_name (dynobj
, ".got.loc");
2945 sgotloc
->size
-= removed_bytes
;
2951 release_contents (sec
, contents
);
2952 release_internal_relocs (sec
, cookie
->rels
);
2955 return (removed_bytes
!= 0);
2960 elf_xtensa_discard_info (bfd
*abfd
,
2961 struct elf_reloc_cookie
*cookie
,
2962 struct bfd_link_info
*info
)
2965 bfd_boolean changed
= FALSE
;
2967 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2969 if (xtensa_is_property_section (sec
))
2971 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
2981 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
2983 return xtensa_is_property_section (sec
);
2987 /* Support for core dump NOTE sections. */
2990 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2995 /* The size for Xtensa is variable, so don't try to recognize the format
2996 based on the size. Just assume this is GNU/Linux. */
2999 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3002 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3006 size
= note
->descsz
- offset
- 4;
3008 /* Make a ".reg/999" section. */
3009 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3010 size
, note
->descpos
+ offset
);
3015 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3017 switch (note
->descsz
)
3022 case 128: /* GNU/Linux elf_prpsinfo */
3023 elf_tdata (abfd
)->core_program
3024 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3025 elf_tdata (abfd
)->core_command
3026 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3029 /* Note that for some reason, a spurious space is tacked
3030 onto the end of the args in some (at least one anyway)
3031 implementations, so strip it off if it exists. */
3034 char *command
= elf_tdata (abfd
)->core_command
;
3035 int n
= strlen (command
);
3037 if (0 < n
&& command
[n
- 1] == ' ')
3038 command
[n
- 1] = '\0';
3045 /* Generic Xtensa configurability stuff. */
3047 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3048 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3049 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3050 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3051 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3052 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3053 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3054 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3057 init_call_opcodes (void)
3059 if (callx0_op
== XTENSA_UNDEFINED
)
3061 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3062 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3063 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3064 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3065 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3066 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3067 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3068 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3074 is_indirect_call_opcode (xtensa_opcode opcode
)
3076 init_call_opcodes ();
3077 return (opcode
== callx0_op
3078 || opcode
== callx4_op
3079 || opcode
== callx8_op
3080 || opcode
== callx12_op
);
3085 is_direct_call_opcode (xtensa_opcode opcode
)
3087 init_call_opcodes ();
3088 return (opcode
== call0_op
3089 || opcode
== call4_op
3090 || opcode
== call8_op
3091 || opcode
== call12_op
);
3096 is_windowed_call_opcode (xtensa_opcode opcode
)
3098 init_call_opcodes ();
3099 return (opcode
== call4_op
3100 || opcode
== call8_op
3101 || opcode
== call12_op
3102 || opcode
== callx4_op
3103 || opcode
== callx8_op
3104 || opcode
== callx12_op
);
3108 static xtensa_opcode
3109 get_const16_opcode (void)
3111 static bfd_boolean done_lookup
= FALSE
;
3112 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3115 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3118 return const16_opcode
;
3122 static xtensa_opcode
3123 get_l32r_opcode (void)
3125 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3126 static bfd_boolean done_lookup
= FALSE
;
3130 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3138 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3142 offset
= addr
- ((pc
+3) & -4);
3143 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3144 offset
= (signed int) offset
>> 2;
3145 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3151 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3153 xtensa_isa isa
= xtensa_default_isa
;
3154 int last_immed
, last_opnd
, opi
;
3156 if (opcode
== XTENSA_UNDEFINED
)
3157 return XTENSA_UNDEFINED
;
3159 /* Find the last visible PC-relative immediate operand for the opcode.
3160 If there are no PC-relative immediates, then choose the last visible
3161 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3162 last_immed
= XTENSA_UNDEFINED
;
3163 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3164 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3166 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3168 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3173 if (last_immed
== XTENSA_UNDEFINED
3174 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3178 return XTENSA_UNDEFINED
;
3180 /* If the operand number was specified in an old-style relocation,
3181 check for consistency with the operand computed above. */
3182 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3184 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3185 if (reloc_opnd
!= last_immed
)
3186 return XTENSA_UNDEFINED
;
3194 get_relocation_slot (int r_type
)
3204 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
3205 return r_type
- R_XTENSA_SLOT0_OP
;
3206 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
3207 return r_type
- R_XTENSA_SLOT0_ALT
;
3211 return XTENSA_UNDEFINED
;
3215 /* Get the opcode for a relocation. */
3217 static xtensa_opcode
3218 get_relocation_opcode (bfd
*abfd
,
3221 Elf_Internal_Rela
*irel
)
3223 static xtensa_insnbuf ibuff
= NULL
;
3224 static xtensa_insnbuf sbuff
= NULL
;
3225 xtensa_isa isa
= xtensa_default_isa
;
3229 if (contents
== NULL
)
3230 return XTENSA_UNDEFINED
;
3232 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
3233 return XTENSA_UNDEFINED
;
3237 ibuff
= xtensa_insnbuf_alloc (isa
);
3238 sbuff
= xtensa_insnbuf_alloc (isa
);
3241 /* Decode the instruction. */
3242 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
3243 sec
->size
- irel
->r_offset
);
3244 fmt
= xtensa_format_decode (isa
, ibuff
);
3245 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
3246 if (slot
== XTENSA_UNDEFINED
)
3247 return XTENSA_UNDEFINED
;
3248 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
3249 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
3254 is_l32r_relocation (bfd
*abfd
,
3257 Elf_Internal_Rela
*irel
)
3259 xtensa_opcode opcode
;
3260 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
3262 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
3263 return (opcode
== get_l32r_opcode ());
3267 static bfd_size_type
3268 get_asm_simplify_size (bfd_byte
*contents
,
3269 bfd_size_type content_len
,
3270 bfd_size_type offset
)
3272 bfd_size_type insnlen
, size
= 0;
3274 /* Decode the size of the next two instructions. */
3275 insnlen
= insn_decode_len (contents
, content_len
, offset
);
3281 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
3291 is_alt_relocation (int r_type
)
3293 return (r_type
>= R_XTENSA_SLOT0_ALT
3294 && r_type
<= R_XTENSA_SLOT14_ALT
);
3299 is_operand_relocation (int r_type
)
3309 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
3311 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
3320 #define MIN_INSN_LENGTH 2
3322 /* Return 0 if it fails to decode. */
3325 insn_decode_len (bfd_byte
*contents
,
3326 bfd_size_type content_len
,
3327 bfd_size_type offset
)
3330 xtensa_isa isa
= xtensa_default_isa
;
3332 static xtensa_insnbuf ibuff
= NULL
;
3334 if (offset
+ MIN_INSN_LENGTH
> content_len
)
3338 ibuff
= xtensa_insnbuf_alloc (isa
);
3339 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
3340 content_len
- offset
);
3341 fmt
= xtensa_format_decode (isa
, ibuff
);
3342 if (fmt
== XTENSA_UNDEFINED
)
3344 insn_len
= xtensa_format_length (isa
, fmt
);
3345 if (insn_len
== XTENSA_UNDEFINED
)
3351 /* Decode the opcode for a single slot instruction.
3352 Return 0 if it fails to decode or the instruction is multi-slot. */
3355 insn_decode_opcode (bfd_byte
*contents
,
3356 bfd_size_type content_len
,
3357 bfd_size_type offset
,
3360 xtensa_isa isa
= xtensa_default_isa
;
3362 static xtensa_insnbuf insnbuf
= NULL
;
3363 static xtensa_insnbuf slotbuf
= NULL
;
3365 if (offset
+ MIN_INSN_LENGTH
> content_len
)
3366 return XTENSA_UNDEFINED
;
3368 if (insnbuf
== NULL
)
3370 insnbuf
= xtensa_insnbuf_alloc (isa
);
3371 slotbuf
= xtensa_insnbuf_alloc (isa
);
3374 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
3375 content_len
- offset
);
3376 fmt
= xtensa_format_decode (isa
, insnbuf
);
3377 if (fmt
== XTENSA_UNDEFINED
)
3378 return XTENSA_UNDEFINED
;
3380 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
3381 return XTENSA_UNDEFINED
;
3383 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
3384 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
3388 /* The offset is the offset in the contents.
3389 The address is the address of that offset. */
3392 check_branch_target_aligned (bfd_byte
*contents
,
3393 bfd_size_type content_length
,
3397 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
3400 return check_branch_target_aligned_address (address
, insn_len
);
3405 check_loop_aligned (bfd_byte
*contents
,
3406 bfd_size_type content_length
,
3410 bfd_size_type loop_len
, insn_len
;
3411 xtensa_opcode opcode
;
3413 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
3414 if (opcode
== XTENSA_UNDEFINED
3415 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
3421 loop_len
= insn_decode_len (contents
, content_length
, offset
);
3422 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
3423 if (loop_len
== 0 || insn_len
== 0)
3429 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
3434 check_branch_target_aligned_address (bfd_vma addr
, int len
)
3437 return (addr
% 8 == 0);
3438 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
3442 /* Instruction widening and narrowing. */
3444 /* When FLIX is available we need to access certain instructions only
3445 when they are 16-bit or 24-bit instructions. This table caches
3446 information about such instructions by walking through all the
3447 opcodes and finding the smallest single-slot format into which each
3450 static xtensa_format
*op_single_fmt_table
= NULL
;
3454 init_op_single_format_table (void)
3456 xtensa_isa isa
= xtensa_default_isa
;
3457 xtensa_insnbuf ibuf
;
3458 xtensa_opcode opcode
;
3462 if (op_single_fmt_table
)
3465 ibuf
= xtensa_insnbuf_alloc (isa
);
3466 num_opcodes
= xtensa_isa_num_opcodes (isa
);
3468 op_single_fmt_table
= (xtensa_format
*)
3469 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
3470 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
3472 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
3473 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
3475 if (xtensa_format_num_slots (isa
, fmt
) == 1
3476 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
3478 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
3479 int fmt_length
= xtensa_format_length (isa
, fmt
);
3480 if (old_fmt
== XTENSA_UNDEFINED
3481 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
3482 op_single_fmt_table
[opcode
] = fmt
;
3486 xtensa_insnbuf_free (isa
, ibuf
);
3490 static xtensa_format
3491 get_single_format (xtensa_opcode opcode
)
3493 init_op_single_format_table ();
3494 return op_single_fmt_table
[opcode
];
3498 /* For the set of narrowable instructions we do NOT include the
3499 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
3500 involved during linker relaxation that may require these to
3501 re-expand in some conditions. Also, the narrowing "or" -> mov.n
3502 requires special case code to ensure it only works when op1 == op2. */
3510 struct string_pair narrowable
[] =
3513 { "addi", "addi.n" },
3514 { "addmi", "addi.n" },
3515 { "l32i", "l32i.n" },
3516 { "movi", "movi.n" },
3518 { "retw", "retw.n" },
3519 { "s32i", "s32i.n" },
3520 { "or", "mov.n" } /* special case only when op1 == op2 */
3523 struct string_pair widenable
[] =
3526 { "addi", "addi.n" },
3527 { "addmi", "addi.n" },
3528 { "beqz", "beqz.n" },
3529 { "bnez", "bnez.n" },
3530 { "l32i", "l32i.n" },
3531 { "movi", "movi.n" },
3533 { "retw", "retw.n" },
3534 { "s32i", "s32i.n" },
3535 { "or", "mov.n" } /* special case only when op1 == op2 */
3539 /* Check if an instruction can be "narrowed", i.e., changed from a standard
3540 3-byte instruction to a 2-byte "density" instruction. If it is valid,
3541 return the instruction buffer holding the narrow instruction. Otherwise,
3542 return 0. The set of valid narrowing are specified by a string table
3543 but require some special case operand checks in some cases. */
3545 static xtensa_insnbuf
3546 can_narrow_instruction (xtensa_insnbuf slotbuf
,
3548 xtensa_opcode opcode
)
3550 xtensa_isa isa
= xtensa_default_isa
;
3551 xtensa_format o_fmt
;
3554 static xtensa_insnbuf o_insnbuf
= NULL
;
3555 static xtensa_insnbuf o_slotbuf
= NULL
;
3557 if (o_insnbuf
== NULL
)
3559 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
3560 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
3563 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
3565 bfd_boolean is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
3567 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
3569 uint32 value
, newval
;
3570 int i
, operand_count
, o_operand_count
;
3571 xtensa_opcode o_opcode
;
3573 /* Address does not matter in this case. We might need to
3574 fix it to handle branches/jumps. */
3575 bfd_vma self_address
= 0;
3577 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
3578 if (o_opcode
== XTENSA_UNDEFINED
)
3580 o_fmt
= get_single_format (o_opcode
);
3581 if (o_fmt
== XTENSA_UNDEFINED
)
3584 if (xtensa_format_length (isa
, fmt
) != 3
3585 || xtensa_format_length (isa
, o_fmt
) != 2)
3588 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
3589 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
3590 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
3592 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
3597 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
3602 uint32 rawval0
, rawval1
, rawval2
;
3604 if (o_operand_count
+ 1 != operand_count
3605 || xtensa_operand_get_field (isa
, opcode
, 0,
3606 fmt
, 0, slotbuf
, &rawval0
) != 0
3607 || xtensa_operand_get_field (isa
, opcode
, 1,
3608 fmt
, 0, slotbuf
, &rawval1
) != 0
3609 || xtensa_operand_get_field (isa
, opcode
, 2,
3610 fmt
, 0, slotbuf
, &rawval2
) != 0
3611 || rawval1
!= rawval2
3612 || rawval0
== rawval1
/* it is a nop */)
3616 for (i
= 0; i
< o_operand_count
; ++i
)
3618 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
3620 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
3623 /* PC-relative branches need adjustment, but
3624 the PC-rel operand will always have a relocation. */
3626 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
3628 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
3629 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
3634 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
3644 /* Attempt to narrow an instruction. If the narrowing is valid, perform
3645 the action in-place directly into the contents and return TRUE. Otherwise,
3646 the return value is FALSE and the contents are not modified. */
3649 narrow_instruction (bfd_byte
*contents
,
3650 bfd_size_type content_length
,
3651 bfd_size_type offset
)
3653 xtensa_opcode opcode
;
3654 bfd_size_type insn_len
;
3655 xtensa_isa isa
= xtensa_default_isa
;
3657 xtensa_insnbuf o_insnbuf
;
3659 static xtensa_insnbuf insnbuf
= NULL
;
3660 static xtensa_insnbuf slotbuf
= NULL
;
3662 if (insnbuf
== NULL
)
3664 insnbuf
= xtensa_insnbuf_alloc (isa
);
3665 slotbuf
= xtensa_insnbuf_alloc (isa
);
3668 BFD_ASSERT (offset
< content_length
);
3670 if (content_length
< 2)
3673 /* We will hand-code a few of these for a little while.
3674 These have all been specified in the assembler aleady. */
3675 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
3676 content_length
- offset
);
3677 fmt
= xtensa_format_decode (isa
, insnbuf
);
3678 if (xtensa_format_num_slots (isa
, fmt
) != 1)
3681 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
3684 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
3685 if (opcode
== XTENSA_UNDEFINED
)
3687 insn_len
= xtensa_format_length (isa
, fmt
);
3688 if (insn_len
> content_length
)
3691 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
3694 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
3695 content_length
- offset
);
3703 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
3704 "density" instruction to a standard 3-byte instruction. If it is valid,
3705 return the instruction buffer holding the wide instruction. Otherwise,
3706 return 0. The set of valid widenings are specified by a string table
3707 but require some special case operand checks in some cases. */
3709 static xtensa_insnbuf
3710 can_widen_instruction (xtensa_insnbuf slotbuf
,
3712 xtensa_opcode opcode
)
3714 xtensa_isa isa
= xtensa_default_isa
;
3715 xtensa_format o_fmt
;
3718 static xtensa_insnbuf o_insnbuf
= NULL
;
3719 static xtensa_insnbuf o_slotbuf
= NULL
;
3721 if (o_insnbuf
== NULL
)
3723 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
3724 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
3727 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
3729 bfd_boolean is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
3730 bfd_boolean is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
3731 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
3733 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
3735 uint32 value
, newval
;
3736 int i
, operand_count
, o_operand_count
, check_operand_count
;
3737 xtensa_opcode o_opcode
;
3739 /* Address does not matter in this case. We might need to fix it
3740 to handle branches/jumps. */
3741 bfd_vma self_address
= 0;
3743 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
3744 if (o_opcode
== XTENSA_UNDEFINED
)
3746 o_fmt
= get_single_format (o_opcode
);
3747 if (o_fmt
== XTENSA_UNDEFINED
)
3750 if (xtensa_format_length (isa
, fmt
) != 2
3751 || xtensa_format_length (isa
, o_fmt
) != 3)
3754 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
3755 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
3756 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
3757 check_operand_count
= o_operand_count
;
3759 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
3764 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
3769 uint32 rawval0
, rawval1
;
3771 if (o_operand_count
!= operand_count
+ 1
3772 || xtensa_operand_get_field (isa
, opcode
, 0,
3773 fmt
, 0, slotbuf
, &rawval0
) != 0
3774 || xtensa_operand_get_field (isa
, opcode
, 1,
3775 fmt
, 0, slotbuf
, &rawval1
) != 0
3776 || rawval0
== rawval1
/* it is a nop */)
3780 check_operand_count
--;
3782 for (i
= 0; i
< check_operand_count
; i
++)
3785 if (is_or
&& i
== o_operand_count
- 1)
3787 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
3789 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
3792 /* PC-relative branches need adjustment, but
3793 the PC-rel operand will always have a relocation. */
3795 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
3797 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
3798 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
3803 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
3813 /* Attempt to widen an instruction. If the widening is valid, perform
3814 the action in-place directly into the contents and return TRUE. Otherwise,
3815 the return value is FALSE and the contents are not modified. */
3818 widen_instruction (bfd_byte
*contents
,
3819 bfd_size_type content_length
,
3820 bfd_size_type offset
)
3822 xtensa_opcode opcode
;
3823 bfd_size_type insn_len
;
3824 xtensa_isa isa
= xtensa_default_isa
;
3826 xtensa_insnbuf o_insnbuf
;
3828 static xtensa_insnbuf insnbuf
= NULL
;
3829 static xtensa_insnbuf slotbuf
= NULL
;
3831 if (insnbuf
== NULL
)
3833 insnbuf
= xtensa_insnbuf_alloc (isa
);
3834 slotbuf
= xtensa_insnbuf_alloc (isa
);
3837 BFD_ASSERT (offset
< content_length
);
3839 if (content_length
< 2)
3842 /* We will hand-code a few of these for a little while.
3843 These have all been specified in the assembler aleady. */
3844 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
3845 content_length
- offset
);
3846 fmt
= xtensa_format_decode (isa
, insnbuf
);
3847 if (xtensa_format_num_slots (isa
, fmt
) != 1)
3850 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
3853 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
3854 if (opcode
== XTENSA_UNDEFINED
)
3856 insn_len
= xtensa_format_length (isa
, fmt
);
3857 if (insn_len
> content_length
)
3860 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
3863 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
3864 content_length
- offset
);
3871 /* Code for transforming CALLs at link-time. */
3873 static bfd_reloc_status_type
3874 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
3876 bfd_vma content_length
,
3877 char **error_message
)
3879 static xtensa_insnbuf insnbuf
= NULL
;
3880 static xtensa_insnbuf slotbuf
= NULL
;
3881 xtensa_format core_format
= XTENSA_UNDEFINED
;
3882 xtensa_opcode opcode
;
3883 xtensa_opcode direct_call_opcode
;
3884 xtensa_isa isa
= xtensa_default_isa
;
3885 bfd_byte
*chbuf
= contents
+ address
;
3888 if (insnbuf
== NULL
)
3890 insnbuf
= xtensa_insnbuf_alloc (isa
);
3891 slotbuf
= xtensa_insnbuf_alloc (isa
);
3894 if (content_length
< address
)
3896 *error_message
= _("Attempt to convert L32R/CALLX to CALL failed");
3897 return bfd_reloc_other
;
3900 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
3901 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
3902 if (direct_call_opcode
== XTENSA_UNDEFINED
)
3904 *error_message
= _("Attempt to convert L32R/CALLX to CALL failed");
3905 return bfd_reloc_other
;
3908 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
3909 core_format
= xtensa_format_lookup (isa
, "x24");
3910 opcode
= xtensa_opcode_lookup (isa
, "or");
3911 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
3912 for (opn
= 0; opn
< 3; opn
++)
3915 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
3916 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
3919 xtensa_format_encode (isa
, core_format
, insnbuf
);
3920 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
3921 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
3923 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
3924 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
3925 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
3927 xtensa_format_encode (isa
, core_format
, insnbuf
);
3928 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
3929 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
3930 content_length
- address
- 3);
3932 return bfd_reloc_ok
;
3936 static bfd_reloc_status_type
3937 contract_asm_expansion (bfd_byte
*contents
,
3938 bfd_vma content_length
,
3939 Elf_Internal_Rela
*irel
,
3940 char **error_message
)
3942 bfd_reloc_status_type retval
=
3943 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
3946 if (retval
!= bfd_reloc_ok
)
3947 return bfd_reloc_dangerous
;
3949 /* Update the irel->r_offset field so that the right immediate and
3950 the right instruction are modified during the relocation. */
3951 irel
->r_offset
+= 3;
3952 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
3953 return bfd_reloc_ok
;
3957 static xtensa_opcode
3958 swap_callx_for_call_opcode (xtensa_opcode opcode
)
3960 init_call_opcodes ();
3962 if (opcode
== callx0_op
) return call0_op
;
3963 if (opcode
== callx4_op
) return call4_op
;
3964 if (opcode
== callx8_op
) return call8_op
;
3965 if (opcode
== callx12_op
) return call12_op
;
3967 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
3968 return XTENSA_UNDEFINED
;
3972 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
3973 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
3974 If not, return XTENSA_UNDEFINED. */
3976 #define L32R_TARGET_REG_OPERAND 0
3977 #define CONST16_TARGET_REG_OPERAND 0
3978 #define CALLN_SOURCE_OPERAND 0
3980 static xtensa_opcode
3981 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bfd_boolean
*p_uses_l32r
)
3983 static xtensa_insnbuf insnbuf
= NULL
;
3984 static xtensa_insnbuf slotbuf
= NULL
;
3986 xtensa_opcode opcode
;
3987 xtensa_isa isa
= xtensa_default_isa
;
3988 uint32 regno
, const16_regno
, call_regno
;
3991 if (insnbuf
== NULL
)
3993 insnbuf
= xtensa_insnbuf_alloc (isa
);
3994 slotbuf
= xtensa_insnbuf_alloc (isa
);
3997 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
3998 fmt
= xtensa_format_decode (isa
, insnbuf
);
3999 if (fmt
== XTENSA_UNDEFINED
4000 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4001 return XTENSA_UNDEFINED
;
4003 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4004 if (opcode
== XTENSA_UNDEFINED
)
4005 return XTENSA_UNDEFINED
;
4007 if (opcode
== get_l32r_opcode ())
4010 *p_uses_l32r
= TRUE
;
4011 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4012 fmt
, 0, slotbuf
, ®no
)
4013 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4015 return XTENSA_UNDEFINED
;
4017 else if (opcode
== get_const16_opcode ())
4020 *p_uses_l32r
= FALSE
;
4021 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4022 fmt
, 0, slotbuf
, ®no
)
4023 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4025 return XTENSA_UNDEFINED
;
4027 /* Check that the next instruction is also CONST16. */
4028 offset
+= xtensa_format_length (isa
, fmt
);
4029 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4030 fmt
= xtensa_format_decode (isa
, insnbuf
);
4031 if (fmt
== XTENSA_UNDEFINED
4032 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4033 return XTENSA_UNDEFINED
;
4034 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4035 if (opcode
!= get_const16_opcode ())
4036 return XTENSA_UNDEFINED
;
4038 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4039 fmt
, 0, slotbuf
, &const16_regno
)
4040 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4042 || const16_regno
!= regno
)
4043 return XTENSA_UNDEFINED
;
4046 return XTENSA_UNDEFINED
;
4048 /* Next instruction should be an CALLXn with operand 0 == regno. */
4049 offset
+= xtensa_format_length (isa
, fmt
);
4050 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4051 fmt
= xtensa_format_decode (isa
, insnbuf
);
4052 if (fmt
== XTENSA_UNDEFINED
4053 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4054 return XTENSA_UNDEFINED
;
4055 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4056 if (opcode
== XTENSA_UNDEFINED
4057 || !is_indirect_call_opcode (opcode
))
4058 return XTENSA_UNDEFINED
;
4060 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4061 fmt
, 0, slotbuf
, &call_regno
)
4062 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4064 return XTENSA_UNDEFINED
;
4066 if (call_regno
!= regno
)
4067 return XTENSA_UNDEFINED
;
4073 /* Data structures used during relaxation. */
4075 /* r_reloc: relocation values. */
4077 /* Through the relaxation process, we need to keep track of the values
4078 that will result from evaluating relocations. The standard ELF
4079 relocation structure is not sufficient for this purpose because we're
4080 operating on multiple input files at once, so we need to know which
4081 input file a relocation refers to. The r_reloc structure thus
4082 records both the input file (bfd) and ELF relocation.
4084 For efficiency, an r_reloc also contains a "target_offset" field to
4085 cache the target-section-relative offset value that is represented by
4088 The r_reloc also contains a virtual offset that allows multiple
4089 inserted literals to be placed at the same "address" with
4090 different offsets. */
4092 typedef struct r_reloc_struct r_reloc
;
4094 struct r_reloc_struct
4097 Elf_Internal_Rela rela
;
4098 bfd_vma target_offset
;
4099 bfd_vma virtual_offset
;
4103 /* The r_reloc structure is included by value in literal_value, but not
4104 every literal_value has an associated relocation -- some are simple
4105 constants. In such cases, we set all the fields in the r_reloc
4106 struct to zero. The r_reloc_is_const function should be used to
4107 detect this case. */
4110 r_reloc_is_const (const r_reloc
*r_rel
)
4112 return (r_rel
->abfd
== NULL
);
4117 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4119 bfd_vma target_offset
;
4120 unsigned long r_symndx
;
4122 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4123 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4124 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4125 return (target_offset
+ r_rel
->rela
.r_addend
);
4129 static struct elf_link_hash_entry
*
4130 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4132 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4133 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4138 r_reloc_get_section (const r_reloc
*r_rel
)
4140 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4141 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4146 r_reloc_is_defined (const r_reloc
*r_rel
)
4152 sec
= r_reloc_get_section (r_rel
);
4153 if (sec
== bfd_abs_section_ptr
4154 || sec
== bfd_com_section_ptr
4155 || sec
== bfd_und_section_ptr
)
4162 r_reloc_init (r_reloc
*r_rel
,
4164 Elf_Internal_Rela
*irel
,
4166 bfd_size_type content_length
)
4169 reloc_howto_type
*howto
;
4173 r_rel
->rela
= *irel
;
4175 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
4176 r_rel
->virtual_offset
= 0;
4177 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
4178 howto
= &elf_howto_table
[r_type
];
4179 if (howto
->partial_inplace
)
4181 bfd_vma inplace_val
;
4182 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
4184 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
4185 r_rel
->target_offset
+= inplace_val
;
4189 memset (r_rel
, 0, sizeof (r_reloc
));
4196 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
4198 if (r_reloc_is_defined (r_rel
))
4200 asection
*sec
= r_reloc_get_section (r_rel
);
4201 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
4203 else if (r_reloc_get_hash_entry (r_rel
))
4204 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
4206 fprintf (fp
, " ?? + ");
4208 fprintf_vma (fp
, r_rel
->target_offset
);
4209 if (r_rel
->virtual_offset
)
4211 fprintf (fp
, " + ");
4212 fprintf_vma (fp
, r_rel
->virtual_offset
);
4221 /* source_reloc: relocations that reference literals. */
4223 /* To determine whether literals can be coalesced, we need to first
4224 record all the relocations that reference the literals. The
4225 source_reloc structure below is used for this purpose. The
4226 source_reloc entries are kept in a per-literal-section array, sorted
4227 by offset within the literal section (i.e., target offset).
4229 The source_sec and r_rel.rela.r_offset fields identify the source of
4230 the relocation. The r_rel field records the relocation value, i.e.,
4231 the offset of the literal being referenced. The opnd field is needed
4232 to determine the range of the immediate field to which the relocation
4233 applies, so we can determine whether another literal with the same
4234 value is within range. The is_null field is true when the relocation
4235 is being removed (e.g., when an L32R is being removed due to a CALLX
4236 that is converted to a direct CALL). */
4238 typedef struct source_reloc_struct source_reloc
;
4240 struct source_reloc_struct
4242 asection
*source_sec
;
4244 xtensa_opcode opcode
;
4246 bfd_boolean is_null
;
4247 bfd_boolean is_abs_literal
;
4252 init_source_reloc (source_reloc
*reloc
,
4253 asection
*source_sec
,
4254 const r_reloc
*r_rel
,
4255 xtensa_opcode opcode
,
4257 bfd_boolean is_abs_literal
)
4259 reloc
->source_sec
= source_sec
;
4260 reloc
->r_rel
= *r_rel
;
4261 reloc
->opcode
= opcode
;
4263 reloc
->is_null
= FALSE
;
4264 reloc
->is_abs_literal
= is_abs_literal
;
4268 /* Find the source_reloc for a particular source offset and relocation
4269 type. Note that the array is sorted by _target_ offset, so this is
4270 just a linear search. */
4272 static source_reloc
*
4273 find_source_reloc (source_reloc
*src_relocs
,
4276 Elf_Internal_Rela
*irel
)
4280 for (i
= 0; i
< src_count
; i
++)
4282 if (src_relocs
[i
].source_sec
== sec
4283 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
4284 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
4285 == ELF32_R_TYPE (irel
->r_info
)))
4286 return &src_relocs
[i
];
4294 source_reloc_compare (const void *ap
, const void *bp
)
4296 const source_reloc
*a
= (const source_reloc
*) ap
;
4297 const source_reloc
*b
= (const source_reloc
*) bp
;
4299 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
4300 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
4302 /* We don't need to sort on these criteria for correctness,
4303 but enforcing a more strict ordering prevents unstable qsort
4304 from behaving differently with different implementations.
4305 Without the code below we get correct but different results
4306 on Solaris 2.7 and 2.8. We would like to always produce the
4307 same results no matter the host. */
4309 if ((!a
->is_null
) - (!b
->is_null
))
4310 return ((!a
->is_null
) - (!b
->is_null
));
4311 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
4315 /* Literal values and value hash tables. */
4317 /* Literals with the same value can be coalesced. The literal_value
4318 structure records the value of a literal: the "r_rel" field holds the
4319 information from the relocation on the literal (if there is one) and
4320 the "value" field holds the contents of the literal word itself.
4322 The value_map structure records a literal value along with the
4323 location of a literal holding that value. The value_map hash table
4324 is indexed by the literal value, so that we can quickly check if a
4325 particular literal value has been seen before and is thus a candidate
4328 typedef struct literal_value_struct literal_value
;
4329 typedef struct value_map_struct value_map
;
4330 typedef struct value_map_hash_table_struct value_map_hash_table
;
4332 struct literal_value_struct
4335 unsigned long value
;
4336 bfd_boolean is_abs_literal
;
4339 struct value_map_struct
4341 literal_value val
; /* The literal value. */
4342 r_reloc loc
; /* Location of the literal. */
4346 struct value_map_hash_table_struct
4348 unsigned bucket_count
;
4349 value_map
**buckets
;
4351 bfd_boolean has_last_loc
;
4357 init_literal_value (literal_value
*lit
,
4358 const r_reloc
*r_rel
,
4359 unsigned long value
,
4360 bfd_boolean is_abs_literal
)
4362 lit
->r_rel
= *r_rel
;
4364 lit
->is_abs_literal
= is_abs_literal
;
4369 literal_value_equal (const literal_value
*src1
,
4370 const literal_value
*src2
,
4371 bfd_boolean final_static_link
)
4373 struct elf_link_hash_entry
*h1
, *h2
;
4375 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
4378 if (r_reloc_is_const (&src1
->r_rel
))
4379 return (src1
->value
== src2
->value
);
4381 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
4382 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
4385 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
4388 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
4391 if (src1
->value
!= src2
->value
)
4394 /* Now check for the same section (if defined) or the same elf_hash
4395 (if undefined or weak). */
4396 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
4397 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
4398 if (r_reloc_is_defined (&src1
->r_rel
)
4399 && (final_static_link
4400 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
4401 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
4403 if (r_reloc_get_section (&src1
->r_rel
)
4404 != r_reloc_get_section (&src2
->r_rel
))
4409 /* Require that the hash entries (i.e., symbols) be identical. */
4410 if (h1
!= h2
|| h1
== 0)
4414 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
4421 /* Must be power of 2. */
4422 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
4424 static value_map_hash_table
*
4425 value_map_hash_table_init (void)
4427 value_map_hash_table
*values
;
4429 values
= (value_map_hash_table
*)
4430 bfd_zmalloc (sizeof (value_map_hash_table
));
4431 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
4433 values
->buckets
= (value_map
**)
4434 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
4435 if (values
->buckets
== NULL
)
4440 values
->has_last_loc
= FALSE
;
4447 value_map_hash_table_delete (value_map_hash_table
*table
)
4449 free (table
->buckets
);
4455 hash_bfd_vma (bfd_vma val
)
4457 return (val
>> 2) + (val
>> 10);
4462 literal_value_hash (const literal_value
*src
)
4466 hash_val
= hash_bfd_vma (src
->value
);
4467 if (!r_reloc_is_const (&src
->r_rel
))
4471 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
4472 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
4473 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
4475 /* Now check for the same section and the same elf_hash. */
4476 if (r_reloc_is_defined (&src
->r_rel
))
4477 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
4479 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
4480 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
4486 /* Check if the specified literal_value has been seen before. */
4489 value_map_get_cached_value (value_map_hash_table
*map
,
4490 const literal_value
*val
,
4491 bfd_boolean final_static_link
)
4497 idx
= literal_value_hash (val
);
4498 idx
= idx
& (map
->bucket_count
- 1);
4499 bucket
= map
->buckets
[idx
];
4500 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
4502 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
4509 /* Record a new literal value. It is illegal to call this if VALUE
4510 already has an entry here. */
4513 add_value_map (value_map_hash_table
*map
,
4514 const literal_value
*val
,
4516 bfd_boolean final_static_link
)
4518 value_map
**bucket_p
;
4521 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
4524 bfd_set_error (bfd_error_no_memory
);
4528 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
4532 idx
= literal_value_hash (val
);
4533 idx
= idx
& (map
->bucket_count
- 1);
4534 bucket_p
= &map
->buckets
[idx
];
4536 val_e
->next
= *bucket_p
;
4539 /* FIXME: Consider resizing the hash table if we get too many entries. */
4545 /* Lists of text actions (ta_) for narrowing, widening, longcall
4546 conversion, space fill, code & literal removal, etc. */
4548 /* The following text actions are generated:
4550 "ta_remove_insn" remove an instruction or instructions
4551 "ta_remove_longcall" convert longcall to call
4552 "ta_convert_longcall" convert longcall to nop/call
4553 "ta_narrow_insn" narrow a wide instruction
4554 "ta_widen" widen a narrow instruction
4555 "ta_fill" add fill or remove fill
4556 removed < 0 is a fill; branches to the fill address will be
4557 changed to address + fill size (e.g., address - removed)
4558 removed >= 0 branches to the fill address will stay unchanged
4559 "ta_remove_literal" remove a literal; this action is
4560 indicated when a literal is removed
4562 "ta_add_literal" insert a new literal; this action is
4563 indicated when a literal has been moved.
4564 It may use a virtual_offset because
4565 multiple literals can be placed at the
4568 For each of these text actions, we also record the number of bytes
4569 removed by performing the text action. In the case of a "ta_widen"
4570 or a "ta_fill" that adds space, the removed_bytes will be negative. */
4572 typedef struct text_action_struct text_action
;
4573 typedef struct text_action_list_struct text_action_list
;
4574 typedef enum text_action_enum_t text_action_t
;
4576 enum text_action_enum_t
4579 ta_remove_insn
, /* removed = -size */
4580 ta_remove_longcall
, /* removed = -size */
4581 ta_convert_longcall
, /* removed = 0 */
4582 ta_narrow_insn
, /* removed = -1 */
4583 ta_widen_insn
, /* removed = +1 */
4584 ta_fill
, /* removed = +size */
4590 /* Structure for a text action record. */
4591 struct text_action_struct
4593 text_action_t action
;
4594 asection
*sec
; /* Optional */
4596 bfd_vma virtual_offset
; /* Zero except for adding literals. */
4598 literal_value value
; /* Only valid when adding literals. */
4604 /* List of all of the actions taken on a text section. */
4605 struct text_action_list_struct
4611 static text_action
*
4612 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
4616 /* It is not necessary to fill at the end of a section. */
4617 if (sec
->size
== offset
)
4620 for (m_p
= &l
->head
; *m_p
&& (*m_p
)->offset
<= offset
; m_p
= &(*m_p
)->next
)
4622 text_action
*t
= *m_p
;
4623 /* When the action is another fill at the same address,
4624 just increase the size. */
4625 if (t
->offset
== offset
&& t
->action
== ta_fill
)
4633 compute_removed_action_diff (const text_action
*ta
,
4637 int removable_space
)
4640 int current_removed
= 0;
4643 current_removed
= ta
->removed_bytes
;
4645 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
4646 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
4648 /* It is not necessary to fill at the end of a section. Clean this up. */
4649 if (sec
->size
== offset
)
4650 new_removed
= removable_space
- 0;
4654 int added
= -removed
- current_removed
;
4655 /* Ignore multiples of the section alignment. */
4656 added
= ((1 << sec
->alignment_power
) - 1) & added
;
4657 new_removed
= (-added
);
4659 /* Modify for removable. */
4660 space
= removable_space
- new_removed
;
4661 new_removed
= (removable_space
4662 - (((1 << sec
->alignment_power
) - 1) & space
));
4664 return (new_removed
- current_removed
);
4669 adjust_fill_action (text_action
*ta
, int fill_diff
)
4671 ta
->removed_bytes
+= fill_diff
;
4675 /* Add a modification action to the text. For the case of adding or
4676 removing space, modify any current fill and assume that
4677 "unreachable_space" bytes can be freely contracted. Note that a
4678 negative removed value is a fill. */
4681 text_action_add (text_action_list
*l
,
4682 text_action_t action
,
4690 /* It is not necessary to fill at the end of a section. */
4691 if (action
== ta_fill
&& sec
->size
== offset
)
4694 /* It is not necessary to fill 0 bytes. */
4695 if (action
== ta_fill
&& removed
== 0)
4698 for (m_p
= &l
->head
; *m_p
&& (*m_p
)->offset
<= offset
; m_p
= &(*m_p
)->next
)
4700 text_action
*t
= *m_p
;
4701 /* When the action is another fill at the same address,
4702 just increase the size. */
4703 if (t
->offset
== offset
&& t
->action
== ta_fill
&& action
== ta_fill
)
4705 t
->removed_bytes
+= removed
;
4710 /* Create a new record and fill it up. */
4711 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
4712 ta
->action
= action
;
4714 ta
->offset
= offset
;
4715 ta
->removed_bytes
= removed
;
4722 text_action_add_literal (text_action_list
*l
,
4723 text_action_t action
,
4725 const literal_value
*value
,
4730 asection
*sec
= r_reloc_get_section (loc
);
4731 bfd_vma offset
= loc
->target_offset
;
4732 bfd_vma virtual_offset
= loc
->virtual_offset
;
4734 BFD_ASSERT (action
== ta_add_literal
);
4736 for (m_p
= &l
->head
; *m_p
!= NULL
; m_p
= &(*m_p
)->next
)
4738 if ((*m_p
)->offset
> offset
4739 && ((*m_p
)->offset
!= offset
4740 || (*m_p
)->virtual_offset
> virtual_offset
))
4744 /* Create a new record and fill it up. */
4745 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
4746 ta
->action
= action
;
4748 ta
->offset
= offset
;
4749 ta
->virtual_offset
= virtual_offset
;
4751 ta
->removed_bytes
= removed
;
4758 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
4763 for (r
= action_list
->head
; r
&& r
->offset
<= offset
; r
= r
->next
)
4765 if (r
->offset
< offset
4766 || (r
->action
== ta_fill
&& r
->removed_bytes
< 0))
4767 removed
+= r
->removed_bytes
;
4770 return (offset
- removed
);
4775 action_list_count (text_action_list
*action_list
)
4777 text_action
*r
= action_list
->head
;
4779 for (r
= action_list
->head
; r
!= NULL
; r
= r
->next
)
4788 offset_with_removed_text_before_fill (text_action_list
*action_list
,
4794 for (r
= action_list
->head
; r
&& r
->offset
< offset
; r
= r
->next
)
4795 removed
+= r
->removed_bytes
;
4797 return (offset
- removed
);
4801 /* The find_insn_action routine will only find non-fill actions. */
4803 static text_action
*
4804 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
4807 for (t
= action_list
->head
; t
; t
= t
->next
)
4809 if (t
->offset
== offset
)
4816 case ta_remove_insn
:
4817 case ta_remove_longcall
:
4818 case ta_convert_longcall
:
4819 case ta_narrow_insn
:
4822 case ta_remove_literal
:
4823 case ta_add_literal
:
4836 print_action_list (FILE *fp
, text_action_list
*action_list
)
4840 fprintf (fp
, "Text Action\n");
4841 for (r
= action_list
->head
; r
!= NULL
; r
= r
->next
)
4843 const char *t
= "unknown";
4846 case ta_remove_insn
:
4847 t
= "remove_insn"; break;
4848 case ta_remove_longcall
:
4849 t
= "remove_longcall"; break;
4850 case ta_convert_longcall
:
4851 t
= "remove_longcall"; break;
4852 case ta_narrow_insn
:
4853 t
= "narrow_insn"; break;
4855 t
= "widen_insn"; break;
4860 case ta_remove_literal
:
4861 t
= "remove_literal"; break;
4862 case ta_add_literal
:
4863 t
= "add_literal"; break;
4866 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
4867 r
->sec
->owner
->filename
,
4868 r
->sec
->name
, r
->offset
, t
, r
->removed_bytes
);
4875 /* Lists of literals being coalesced or removed. */
4877 /* In the usual case, the literal identified by "from" is being
4878 coalesced with another literal identified by "to". If the literal is
4879 unused and is being removed altogether, "to.abfd" will be NULL.
4880 The removed_literal entries are kept on a per-section list, sorted
4881 by the "from" offset field. */
4883 typedef struct removed_literal_struct removed_literal
;
4884 typedef struct removed_literal_list_struct removed_literal_list
;
4886 struct removed_literal_struct
4890 removed_literal
*next
;
4893 struct removed_literal_list_struct
4895 removed_literal
*head
;
4896 removed_literal
*tail
;
4900 /* Record that the literal at "from" is being removed. If "to" is not
4901 NULL, the "from" literal is being coalesced with the "to" literal. */
4904 add_removed_literal (removed_literal_list
*removed_list
,
4905 const r_reloc
*from
,
4908 removed_literal
*r
, *new_r
, *next_r
;
4910 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
4912 new_r
->from
= *from
;
4916 new_r
->to
.abfd
= NULL
;
4919 r
= removed_list
->head
;
4922 removed_list
->head
= new_r
;
4923 removed_list
->tail
= new_r
;
4925 /* Special check for common case of append. */
4926 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
4928 removed_list
->tail
->next
= new_r
;
4929 removed_list
->tail
= new_r
;
4933 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
4939 new_r
->next
= next_r
;
4941 removed_list
->tail
= new_r
;
4946 /* Check if the list of removed literals contains an entry for the
4947 given address. Return the entry if found. */
4949 static removed_literal
*
4950 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
4952 removed_literal
*r
= removed_list
->head
;
4953 while (r
&& r
->from
.target_offset
< addr
)
4955 if (r
&& r
->from
.target_offset
== addr
)
4964 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
4967 r
= removed_list
->head
;
4969 fprintf (fp
, "Removed Literals\n");
4970 for (; r
!= NULL
; r
= r
->next
)
4972 print_r_reloc (fp
, &r
->from
);
4973 fprintf (fp
, " => ");
4974 if (r
->to
.abfd
== NULL
)
4975 fprintf (fp
, "REMOVED");
4977 print_r_reloc (fp
, &r
->to
);
4985 /* Per-section data for relaxation. */
4987 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
4989 struct xtensa_relax_info_struct
4991 bfd_boolean is_relaxable_literal_section
;
4992 bfd_boolean is_relaxable_asm_section
;
4993 int visited
; /* Number of times visited. */
4995 source_reloc
*src_relocs
; /* Array[src_count]. */
4997 int src_next
; /* Next src_relocs entry to assign. */
4999 removed_literal_list removed_list
;
5000 text_action_list action_list
;
5002 reloc_bfd_fix
*fix_list
;
5003 reloc_bfd_fix
*fix_array
;
5004 unsigned fix_array_count
;
5006 /* Support for expanding the reloc array that is stored
5007 in the section structure. If the relocations have been
5008 reallocated, the newly allocated relocations will be referenced
5009 here along with the actual size allocated. The relocation
5010 count will always be found in the section structure. */
5011 Elf_Internal_Rela
*allocated_relocs
;
5012 unsigned relocs_count
;
5013 unsigned allocated_relocs_count
;
5016 struct elf_xtensa_section_data
5018 struct bfd_elf_section_data elf
;
5019 xtensa_relax_info relax_info
;
5024 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
5026 if (!sec
->used_by_bfd
)
5028 struct elf_xtensa_section_data
*sdata
;
5029 bfd_size_type amt
= sizeof (*sdata
);
5031 sdata
= bfd_zalloc (abfd
, amt
);
5034 sec
->used_by_bfd
= sdata
;
5037 return _bfd_elf_new_section_hook (abfd
, sec
);
5041 static xtensa_relax_info
*
5042 get_xtensa_relax_info (asection
*sec
)
5044 struct elf_xtensa_section_data
*section_data
;
5046 /* No info available if no section or if it is an output section. */
5047 if (!sec
|| sec
== sec
->output_section
)
5050 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
5051 return §ion_data
->relax_info
;
5056 init_xtensa_relax_info (asection
*sec
)
5058 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
5060 relax_info
->is_relaxable_literal_section
= FALSE
;
5061 relax_info
->is_relaxable_asm_section
= FALSE
;
5062 relax_info
->visited
= 0;
5064 relax_info
->src_relocs
= NULL
;
5065 relax_info
->src_count
= 0;
5066 relax_info
->src_next
= 0;
5068 relax_info
->removed_list
.head
= NULL
;
5069 relax_info
->removed_list
.tail
= NULL
;
5071 relax_info
->action_list
.head
= NULL
;
5073 relax_info
->fix_list
= NULL
;
5074 relax_info
->fix_array
= NULL
;
5075 relax_info
->fix_array_count
= 0;
5077 relax_info
->allocated_relocs
= NULL
;
5078 relax_info
->relocs_count
= 0;
5079 relax_info
->allocated_relocs_count
= 0;
5083 /* Coalescing literals may require a relocation to refer to a section in
5084 a different input file, but the standard relocation information
5085 cannot express that. Instead, the reloc_bfd_fix structures are used
5086 to "fix" the relocations that refer to sections in other input files.
5087 These structures are kept on per-section lists. The "src_type" field
5088 records the relocation type in case there are multiple relocations on
5089 the same location. FIXME: This is ugly; an alternative might be to
5090 add new symbols with the "owner" field to some other input file. */
5092 struct reloc_bfd_fix_struct
5096 unsigned src_type
; /* Relocation type. */
5099 asection
*target_sec
;
5100 bfd_vma target_offset
;
5101 bfd_boolean translated
;
5103 reloc_bfd_fix
*next
;
5107 static reloc_bfd_fix
*
5108 reloc_bfd_fix_init (asection
*src_sec
,
5112 asection
*target_sec
,
5113 bfd_vma target_offset
,
5114 bfd_boolean translated
)
5118 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
5119 fix
->src_sec
= src_sec
;
5120 fix
->src_offset
= src_offset
;
5121 fix
->src_type
= src_type
;
5122 fix
->target_abfd
= target_abfd
;
5123 fix
->target_sec
= target_sec
;
5124 fix
->target_offset
= target_offset
;
5125 fix
->translated
= translated
;
5132 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
5134 xtensa_relax_info
*relax_info
;
5136 relax_info
= get_xtensa_relax_info (src_sec
);
5137 fix
->next
= relax_info
->fix_list
;
5138 relax_info
->fix_list
= fix
;
5143 fix_compare (const void *ap
, const void *bp
)
5145 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
5146 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
5148 if (a
->src_offset
!= b
->src_offset
)
5149 return (a
->src_offset
- b
->src_offset
);
5150 return (a
->src_type
- b
->src_type
);
5155 cache_fix_array (asection
*sec
)
5157 unsigned i
, count
= 0;
5159 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
5161 if (relax_info
== NULL
)
5163 if (relax_info
->fix_list
== NULL
)
5166 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
5169 relax_info
->fix_array
=
5170 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
5171 relax_info
->fix_array_count
= count
;
5173 r
= relax_info
->fix_list
;
5174 for (i
= 0; i
< count
; i
++, r
= r
->next
)
5176 relax_info
->fix_array
[count
- 1 - i
] = *r
;
5177 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
5180 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
5181 sizeof (reloc_bfd_fix
), fix_compare
);
5185 static reloc_bfd_fix
*
5186 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
5188 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
5192 if (relax_info
== NULL
)
5194 if (relax_info
->fix_list
== NULL
)
5197 if (relax_info
->fix_array
== NULL
)
5198 cache_fix_array (sec
);
5200 key
.src_offset
= offset
;
5201 key
.src_type
= type
;
5202 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
5203 sizeof (reloc_bfd_fix
), fix_compare
);
5208 /* Section caching. */
5210 typedef struct section_cache_struct section_cache_t
;
5212 struct section_cache_struct
5216 bfd_byte
*contents
; /* Cache of the section contents. */
5217 bfd_size_type content_length
;
5219 property_table_entry
*ptbl
; /* Cache of the section property table. */
5222 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
5223 unsigned reloc_count
;
5228 init_section_cache (section_cache_t
*sec_cache
)
5230 memset (sec_cache
, 0, sizeof (*sec_cache
));
5235 clear_section_cache (section_cache_t
*sec_cache
)
5239 release_contents (sec_cache
->sec
, sec_cache
->contents
);
5240 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
5241 if (sec_cache
->ptbl
)
5242 free (sec_cache
->ptbl
);
5243 memset (sec_cache
, 0, sizeof (sec_cache
));
5249 section_cache_section (section_cache_t
*sec_cache
,
5251 struct bfd_link_info
*link_info
)
5254 property_table_entry
*prop_table
= NULL
;
5256 bfd_byte
*contents
= NULL
;
5257 Elf_Internal_Rela
*internal_relocs
= NULL
;
5258 bfd_size_type sec_size
;
5262 if (sec
== sec_cache
->sec
)
5266 sec_size
= bfd_get_section_limit (abfd
, sec
);
5268 /* Get the contents. */
5269 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
5270 if (contents
== NULL
&& sec_size
!= 0)
5273 /* Get the relocations. */
5274 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
5275 link_info
->keep_memory
);
5277 /* Get the entry table. */
5278 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
5279 XTENSA_PROP_SEC_NAME
, FALSE
);
5283 /* Fill in the new section cache. */
5284 clear_section_cache (sec_cache
);
5285 memset (sec_cache
, 0, sizeof (sec_cache
));
5287 sec_cache
->sec
= sec
;
5288 sec_cache
->contents
= contents
;
5289 sec_cache
->content_length
= sec_size
;
5290 sec_cache
->relocs
= internal_relocs
;
5291 sec_cache
->reloc_count
= sec
->reloc_count
;
5292 sec_cache
->pte_count
= ptblsize
;
5293 sec_cache
->ptbl
= prop_table
;
5298 release_contents (sec
, contents
);
5299 release_internal_relocs (sec
, internal_relocs
);
5306 /* Extended basic blocks. */
5308 /* An ebb_struct represents an Extended Basic Block. Within this
5309 range, we guarantee that all instructions are decodable, the
5310 property table entries are contiguous, and no property table
5311 specifies a segment that cannot have instructions moved. This
5312 structure contains caches of the contents, property table and
5313 relocations for the specified section for easy use. The range is
5314 specified by ranges of indices for the byte offset, property table
5315 offsets and relocation offsets. These must be consistent. */
5317 typedef struct ebb_struct ebb_t
;
5323 bfd_byte
*contents
; /* Cache of the section contents. */
5324 bfd_size_type content_length
;
5326 property_table_entry
*ptbl
; /* Cache of the section property table. */
5329 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
5330 unsigned reloc_count
;
5332 bfd_vma start_offset
; /* Offset in section. */
5333 unsigned start_ptbl_idx
; /* Offset in the property table. */
5334 unsigned start_reloc_idx
; /* Offset in the relocations. */
5337 unsigned end_ptbl_idx
;
5338 unsigned end_reloc_idx
;
5340 bfd_boolean ends_section
; /* Is this the last ebb in a section? */
5342 /* The unreachable property table at the end of this set of blocks;
5343 NULL if the end is not an unreachable block. */
5344 property_table_entry
*ends_unreachable
;
5348 enum ebb_target_enum
5351 EBB_DESIRE_TGT_ALIGN
,
5352 EBB_REQUIRE_TGT_ALIGN
,
5353 EBB_REQUIRE_LOOP_ALIGN
,
5358 /* proposed_action_struct is similar to the text_action_struct except
5359 that is represents a potential transformation, not one that will
5360 occur. We build a list of these for an extended basic block
5361 and use them to compute the actual actions desired. We must be
5362 careful that the entire set of actual actions we perform do not
5363 break any relocations that would fit if the actions were not
5366 typedef struct proposed_action_struct proposed_action
;
5368 struct proposed_action_struct
5370 enum ebb_target_enum align_type
; /* for the target alignment */
5371 bfd_vma alignment_pow
;
5372 text_action_t action
;
5375 bfd_boolean do_action
; /* If false, then we will not perform the action. */
5379 /* The ebb_constraint_struct keeps a set of proposed actions for an
5380 extended basic block. */
5382 typedef struct ebb_constraint_struct ebb_constraint
;
5384 struct ebb_constraint_struct
5387 bfd_boolean start_movable
;
5389 /* Bytes of extra space at the beginning if movable. */
5390 int start_extra_space
;
5392 enum ebb_target_enum start_align
;
5394 bfd_boolean end_movable
;
5396 /* Bytes of extra space at the end if movable. */
5397 int end_extra_space
;
5399 unsigned action_count
;
5400 unsigned action_allocated
;
5402 /* Array of proposed actions. */
5403 proposed_action
*actions
;
5405 /* Action alignments -- one for each proposed action. */
5406 enum ebb_target_enum
*action_aligns
;
5411 init_ebb_constraint (ebb_constraint
*c
)
5413 memset (c
, 0, sizeof (ebb_constraint
));
5418 free_ebb_constraint (ebb_constraint
*c
)
5426 init_ebb (ebb_t
*ebb
,
5429 bfd_size_type content_length
,
5430 property_table_entry
*prop_table
,
5432 Elf_Internal_Rela
*internal_relocs
,
5433 unsigned reloc_count
)
5435 memset (ebb
, 0, sizeof (ebb_t
));
5437 ebb
->contents
= contents
;
5438 ebb
->content_length
= content_length
;
5439 ebb
->ptbl
= prop_table
;
5440 ebb
->pte_count
= ptblsize
;
5441 ebb
->relocs
= internal_relocs
;
5442 ebb
->reloc_count
= reloc_count
;
5443 ebb
->start_offset
= 0;
5444 ebb
->end_offset
= ebb
->content_length
- 1;
5445 ebb
->start_ptbl_idx
= 0;
5446 ebb
->end_ptbl_idx
= ptblsize
;
5447 ebb
->start_reloc_idx
= 0;
5448 ebb
->end_reloc_idx
= reloc_count
;
5452 /* Extend the ebb to all decodable contiguous sections. The algorithm
5453 for building a basic block around an instruction is to push it
5454 forward until we hit the end of a section, an unreachable block or
5455 a block that cannot be transformed. Then we push it backwards
5456 searching for similar conditions. */
5458 static bfd_boolean
extend_ebb_bounds_forward (ebb_t
*);
5459 static bfd_boolean
extend_ebb_bounds_backward (ebb_t
*);
5460 static bfd_size_type insn_block_decodable_len
5461 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
5464 extend_ebb_bounds (ebb_t
*ebb
)
5466 if (!extend_ebb_bounds_forward (ebb
))
5468 if (!extend_ebb_bounds_backward (ebb
))
5475 extend_ebb_bounds_forward (ebb_t
*ebb
)
5477 property_table_entry
*the_entry
, *new_entry
;
5479 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
5481 /* Stop when (1) we cannot decode an instruction, (2) we are at
5482 the end of the property tables, (3) we hit a non-contiguous property
5483 table entry, (4) we hit a NO_TRANSFORM region. */
5488 bfd_size_type insn_block_len
;
5490 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
5492 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
5494 entry_end
- ebb
->end_offset
);
5495 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
5497 (*_bfd_error_handler
)
5498 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
5499 ebb
->sec
->owner
, ebb
->sec
, ebb
->end_offset
+ insn_block_len
);
5502 ebb
->end_offset
+= insn_block_len
;
5504 if (ebb
->end_offset
== ebb
->sec
->size
)
5505 ebb
->ends_section
= TRUE
;
5507 /* Update the reloc counter. */
5508 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
5509 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
5512 ebb
->end_reloc_idx
++;
5515 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
5518 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
5519 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
5520 || ((new_entry
->flags
& XTENSA_PROP_INSN_NO_TRANSFORM
) != 0)
5521 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
5524 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
5527 the_entry
= new_entry
;
5528 ebb
->end_ptbl_idx
++;
5531 /* Quick check for an unreachable or end of file just at the end. */
5532 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
5534 if (ebb
->end_offset
== ebb
->content_length
)
5535 ebb
->ends_section
= TRUE
;
5539 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
5540 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
5541 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
5542 ebb
->ends_unreachable
= new_entry
;
5545 /* Any other ending requires exact alignment. */
5551 extend_ebb_bounds_backward (ebb_t
*ebb
)
5553 property_table_entry
*the_entry
, *new_entry
;
5555 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
5557 /* Stop when (1) we cannot decode the instructions in the current entry.
5558 (2) we are at the beginning of the property tables, (3) we hit a
5559 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
5563 bfd_vma block_begin
;
5564 bfd_size_type insn_block_len
;
5566 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
5568 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
5570 ebb
->start_offset
- block_begin
);
5571 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
5573 (*_bfd_error_handler
)
5574 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
5575 ebb
->sec
->owner
, ebb
->sec
, ebb
->end_offset
+ insn_block_len
);
5578 ebb
->start_offset
-= insn_block_len
;
5580 /* Update the reloc counter. */
5581 while (ebb
->start_reloc_idx
> 0
5582 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
5583 >= ebb
->start_offset
))
5585 ebb
->start_reloc_idx
--;
5588 if (ebb
->start_ptbl_idx
== 0)
5591 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
5592 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
5593 || ((new_entry
->flags
& XTENSA_PROP_INSN_NO_TRANSFORM
) != 0)
5594 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
5596 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
5599 the_entry
= new_entry
;
5600 ebb
->start_ptbl_idx
--;
5606 static bfd_size_type
5607 insn_block_decodable_len (bfd_byte
*contents
,
5608 bfd_size_type content_len
,
5609 bfd_vma block_offset
,
5610 bfd_size_type block_len
)
5612 bfd_vma offset
= block_offset
;
5614 while (offset
< block_offset
+ block_len
)
5616 bfd_size_type insn_len
= 0;
5618 insn_len
= insn_decode_len (contents
, content_len
, offset
);
5620 return (offset
- block_offset
);
5623 return (offset
- block_offset
);
5628 ebb_propose_action (ebb_constraint
*c
,
5629 enum ebb_target_enum align_type
,
5630 bfd_vma alignment_pow
,
5631 text_action_t action
,
5634 bfd_boolean do_action
)
5636 proposed_action
*act
;
5638 if (c
->action_allocated
<= c
->action_count
)
5640 unsigned new_allocated
, i
;
5641 proposed_action
*new_actions
;
5643 new_allocated
= (c
->action_count
+ 2) * 2;
5644 new_actions
= (proposed_action
*)
5645 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
5647 for (i
= 0; i
< c
->action_count
; i
++)
5648 new_actions
[i
] = c
->actions
[i
];
5651 c
->actions
= new_actions
;
5652 c
->action_allocated
= new_allocated
;
5655 act
= &c
->actions
[c
->action_count
];
5656 act
->align_type
= align_type
;
5657 act
->alignment_pow
= alignment_pow
;
5658 act
->action
= action
;
5659 act
->offset
= offset
;
5660 act
->removed_bytes
= removed_bytes
;
5661 act
->do_action
= do_action
;
5667 /* Access to internal relocations, section contents and symbols. */
5669 /* During relaxation, we need to modify relocations, section contents,
5670 and symbol definitions, and we need to keep the original values from
5671 being reloaded from the input files, i.e., we need to "pin" the
5672 modified values in memory. We also want to continue to observe the
5673 setting of the "keep-memory" flag. The following functions wrap the
5674 standard BFD functions to take care of this for us. */
5676 static Elf_Internal_Rela
*
5677 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
5679 Elf_Internal_Rela
*internal_relocs
;
5681 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
5684 internal_relocs
= elf_section_data (sec
)->relocs
;
5685 if (internal_relocs
== NULL
)
5686 internal_relocs
= (_bfd_elf_link_read_relocs
5687 (abfd
, sec
, NULL
, NULL
, keep_memory
));
5688 return internal_relocs
;
5693 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
5695 elf_section_data (sec
)->relocs
= internal_relocs
;
5700 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
5703 && elf_section_data (sec
)->relocs
!= internal_relocs
)
5704 free (internal_relocs
);
5709 retrieve_contents (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
5712 bfd_size_type sec_size
;
5714 sec_size
= bfd_get_section_limit (abfd
, sec
);
5715 contents
= elf_section_data (sec
)->this_hdr
.contents
;
5717 if (contents
== NULL
&& sec_size
!= 0)
5719 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
5726 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5733 pin_contents (asection
*sec
, bfd_byte
*contents
)
5735 elf_section_data (sec
)->this_hdr
.contents
= contents
;
5740 release_contents (asection
*sec
, bfd_byte
*contents
)
5742 if (contents
&& elf_section_data (sec
)->this_hdr
.contents
!= contents
)
5747 static Elf_Internal_Sym
*
5748 retrieve_local_syms (bfd
*input_bfd
)
5750 Elf_Internal_Shdr
*symtab_hdr
;
5751 Elf_Internal_Sym
*isymbuf
;
5754 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
5755 locsymcount
= symtab_hdr
->sh_info
;
5757 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5758 if (isymbuf
== NULL
&& locsymcount
!= 0)
5759 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
5762 /* Save the symbols for this input file so they won't be read again. */
5763 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
5764 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
5770 /* Code for link-time relaxation. */
5772 /* Initialization for relaxation: */
5773 static bfd_boolean
analyze_relocations (struct bfd_link_info
*);
5774 static bfd_boolean find_relaxable_sections
5775 (bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*);
5776 static bfd_boolean collect_source_relocs
5777 (bfd
*, asection
*, struct bfd_link_info
*);
5778 static bfd_boolean is_resolvable_asm_expansion
5779 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
5781 static Elf_Internal_Rela
*find_associated_l32r_irel
5782 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
5783 static bfd_boolean compute_text_actions
5784 (bfd
*, asection
*, struct bfd_link_info
*);
5785 static bfd_boolean
compute_ebb_proposed_actions (ebb_constraint
*);
5786 static bfd_boolean
compute_ebb_actions (ebb_constraint
*);
5787 static bfd_boolean check_section_ebb_pcrels_fit
5788 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, const ebb_constraint
*,
5789 const xtensa_opcode
*);
5790 static bfd_boolean
check_section_ebb_reduces (const ebb_constraint
*);
5791 static void text_action_add_proposed
5792 (text_action_list
*, const ebb_constraint
*, asection
*);
5793 static int compute_fill_extra_space (property_table_entry
*);
5796 static bfd_boolean compute_removed_literals
5797 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
5798 static Elf_Internal_Rela
*get_irel_at_offset
5799 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
5800 static bfd_boolean is_removable_literal
5801 (const source_reloc
*, int, const source_reloc
*, int);
5802 static bfd_boolean remove_dead_literal
5803 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
5804 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
5805 static bfd_boolean identify_literal_placement
5806 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
5807 value_map_hash_table
*, bfd_boolean
*, Elf_Internal_Rela
*, int,
5808 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
5810 static bfd_boolean
relocations_reach (source_reloc
*, int, const r_reloc
*);
5811 static bfd_boolean coalesce_shared_literal
5812 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
5813 static bfd_boolean move_shared_literal
5814 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
5815 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
5818 static bfd_boolean
relax_section (bfd
*, asection
*, struct bfd_link_info
*);
5819 static bfd_boolean
translate_section_fixes (asection
*);
5820 static bfd_boolean
translate_reloc_bfd_fix (reloc_bfd_fix
*);
5821 static void translate_reloc (const r_reloc
*, r_reloc
*);
5822 static void shrink_dynamic_reloc_sections
5823 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
5824 static bfd_boolean move_literal
5825 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
5826 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
5827 static bfd_boolean relax_property_section
5828 (bfd
*, asection
*, struct bfd_link_info
*);
5831 static bfd_boolean
relax_section_symbols (bfd
*, asection
*);
5835 elf_xtensa_relax_section (bfd
*abfd
,
5837 struct bfd_link_info
*link_info
,
5840 static value_map_hash_table
*values
= NULL
;
5841 static bfd_boolean relocations_analyzed
= FALSE
;
5842 xtensa_relax_info
*relax_info
;
5844 if (!relocations_analyzed
)
5846 /* Do some overall initialization for relaxation. */
5847 values
= value_map_hash_table_init ();
5850 relaxing_section
= TRUE
;
5851 if (!analyze_relocations (link_info
))
5853 relocations_analyzed
= TRUE
;
5857 /* Don't mess with linker-created sections. */
5858 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
5861 relax_info
= get_xtensa_relax_info (sec
);
5862 BFD_ASSERT (relax_info
!= NULL
);
5864 switch (relax_info
->visited
)
5867 /* Note: It would be nice to fold this pass into
5868 analyze_relocations, but it is important for this step that the
5869 sections be examined in link order. */
5870 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
5877 value_map_hash_table_delete (values
);
5879 if (!relax_section (abfd
, sec
, link_info
))
5885 if (!relax_section_symbols (abfd
, sec
))
5890 relax_info
->visited
++;
5895 /* Initialization for relaxation. */
5897 /* This function is called once at the start of relaxation. It scans
5898 all the input sections and marks the ones that are relaxable (i.e.,
5899 literal sections with L32R relocations against them), and then
5900 collects source_reloc information for all the relocations against
5901 those relaxable sections. During this process, it also detects
5902 longcalls, i.e., calls relaxed by the assembler into indirect
5903 calls, that can be optimized back into direct calls. Within each
5904 extended basic block (ebb) containing an optimized longcall, it
5905 computes a set of "text actions" that can be performed to remove
5906 the L32R associated with the longcall while optionally preserving
5907 branch target alignments. */
5910 analyze_relocations (struct bfd_link_info
*link_info
)
5914 bfd_boolean is_relaxable
= FALSE
;
5916 /* Initialize the per-section relaxation info. */
5917 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
5918 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5920 init_xtensa_relax_info (sec
);
5923 /* Mark relaxable sections (and count relocations against each one). */
5924 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
5925 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5927 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
5931 /* Bail out if there are no relaxable sections. */
5935 /* Allocate space for source_relocs. */
5936 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
5937 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5939 xtensa_relax_info
*relax_info
;
5941 relax_info
= get_xtensa_relax_info (sec
);
5942 if (relax_info
->is_relaxable_literal_section
5943 || relax_info
->is_relaxable_asm_section
)
5945 relax_info
->src_relocs
= (source_reloc
*)
5946 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
5950 /* Collect info on relocations against each relaxable section. */
5951 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
5952 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5954 if (!collect_source_relocs (abfd
, sec
, link_info
))
5958 /* Compute the text actions. */
5959 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
5960 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5962 if (!compute_text_actions (abfd
, sec
, link_info
))
5970 /* Find all the sections that might be relaxed. The motivation for
5971 this pass is that collect_source_relocs() needs to record _all_ the
5972 relocations that target each relaxable section. That is expensive
5973 and unnecessary unless the target section is actually going to be
5974 relaxed. This pass identifies all such sections by checking if
5975 they have L32Rs pointing to them. In the process, the total number
5976 of relocations targeting each section is also counted so that we
5977 know how much space to allocate for source_relocs against each
5978 relaxable literal section. */
5981 find_relaxable_sections (bfd
*abfd
,
5983 struct bfd_link_info
*link_info
,
5984 bfd_boolean
*is_relaxable_p
)
5986 Elf_Internal_Rela
*internal_relocs
;
5988 bfd_boolean ok
= TRUE
;
5990 xtensa_relax_info
*source_relax_info
;
5992 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
5993 link_info
->keep_memory
);
5994 if (internal_relocs
== NULL
)
5997 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
5998 if (contents
== NULL
&& sec
->size
!= 0)
6004 source_relax_info
= get_xtensa_relax_info (sec
);
6005 for (i
= 0; i
< sec
->reloc_count
; i
++)
6007 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
6009 asection
*target_sec
;
6010 xtensa_relax_info
*target_relax_info
;
6012 /* If this section has not already been marked as "relaxable", and
6013 if it contains any ASM_EXPAND relocations (marking expanded
6014 longcalls) that can be optimized into direct calls, then mark
6015 the section as "relaxable". */
6016 if (source_relax_info
6017 && !source_relax_info
->is_relaxable_asm_section
6018 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
6020 bfd_boolean is_reachable
= FALSE
;
6021 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
6022 link_info
, &is_reachable
)
6025 source_relax_info
->is_relaxable_asm_section
= TRUE
;
6026 *is_relaxable_p
= TRUE
;
6030 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
6031 bfd_get_section_limit (abfd
, sec
));
6033 target_sec
= r_reloc_get_section (&r_rel
);
6034 target_relax_info
= get_xtensa_relax_info (target_sec
);
6035 if (!target_relax_info
)
6038 /* Count PC-relative operand relocations against the target section.
6039 Note: The conditions tested here must match the conditions under
6040 which init_source_reloc is called in collect_source_relocs(). */
6041 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
))
6042 && (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
6043 || is_l32r_relocation (abfd
, sec
, contents
, irel
)))
6044 target_relax_info
->src_count
++;
6046 if (is_l32r_relocation (abfd
, sec
, contents
, irel
)
6047 && r_reloc_is_defined (&r_rel
))
6049 /* Mark the target section as relaxable. */
6050 target_relax_info
->is_relaxable_literal_section
= TRUE
;
6051 *is_relaxable_p
= TRUE
;
6056 release_contents (sec
, contents
);
6057 release_internal_relocs (sec
, internal_relocs
);
6062 /* Record _all_ the relocations that point to relaxable sections, and
6063 get rid of ASM_EXPAND relocs by either converting them to
6064 ASM_SIMPLIFY or by removing them. */
6067 collect_source_relocs (bfd
*abfd
,
6069 struct bfd_link_info
*link_info
)
6071 Elf_Internal_Rela
*internal_relocs
;
6073 bfd_boolean ok
= TRUE
;
6075 bfd_size_type sec_size
;
6077 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6078 link_info
->keep_memory
);
6079 if (internal_relocs
== NULL
)
6082 sec_size
= bfd_get_section_limit (abfd
, sec
);
6083 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6084 if (contents
== NULL
&& sec_size
!= 0)
6090 /* Record relocations against relaxable literal sections. */
6091 for (i
= 0; i
< sec
->reloc_count
; i
++)
6093 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
6095 asection
*target_sec
;
6096 xtensa_relax_info
*target_relax_info
;
6098 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
6100 target_sec
= r_reloc_get_section (&r_rel
);
6101 target_relax_info
= get_xtensa_relax_info (target_sec
);
6103 if (target_relax_info
6104 && (target_relax_info
->is_relaxable_literal_section
6105 || target_relax_info
->is_relaxable_asm_section
))
6107 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
6109 bfd_boolean is_abs_literal
= FALSE
;
6111 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
6113 /* None of the current alternate relocs are PC-relative,
6114 and only PC-relative relocs matter here. However, we
6115 still need to record the opcode for literal
6117 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
6118 if (opcode
== get_l32r_opcode ())
6120 is_abs_literal
= TRUE
;
6124 opcode
= XTENSA_UNDEFINED
;
6126 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
6128 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
6129 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
6132 if (opcode
!= XTENSA_UNDEFINED
)
6134 int src_next
= target_relax_info
->src_next
++;
6135 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
6137 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
6143 /* Now get rid of ASM_EXPAND relocations. At this point, the
6144 src_relocs array for the target literal section may still be
6145 incomplete, but it must at least contain the entries for the L32R
6146 relocations associated with ASM_EXPANDs because they were just
6147 added in the preceding loop over the relocations. */
6149 for (i
= 0; i
< sec
->reloc_count
; i
++)
6151 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
6152 bfd_boolean is_reachable
;
6154 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
6160 Elf_Internal_Rela
*l32r_irel
;
6162 asection
*target_sec
;
6163 xtensa_relax_info
*target_relax_info
;
6165 /* Mark the source_reloc for the L32R so that it will be
6166 removed in compute_removed_literals(), along with the
6167 associated literal. */
6168 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
6169 irel
, internal_relocs
);
6170 if (l32r_irel
== NULL
)
6173 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
6175 target_sec
= r_reloc_get_section (&r_rel
);
6176 target_relax_info
= get_xtensa_relax_info (target_sec
);
6178 if (target_relax_info
6179 && (target_relax_info
->is_relaxable_literal_section
6180 || target_relax_info
->is_relaxable_asm_section
))
6182 source_reloc
*s_reloc
;
6184 /* Search the source_relocs for the entry corresponding to
6185 the l32r_irel. Note: The src_relocs array is not yet
6186 sorted, but it wouldn't matter anyway because we're
6187 searching by source offset instead of target offset. */
6188 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
6189 target_relax_info
->src_next
,
6191 BFD_ASSERT (s_reloc
);
6192 s_reloc
->is_null
= TRUE
;
6195 /* Convert this reloc to ASM_SIMPLIFY. */
6196 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
6197 R_XTENSA_ASM_SIMPLIFY
);
6198 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
6200 pin_internal_relocs (sec
, internal_relocs
);
6204 /* It is resolvable but doesn't reach. We resolve now
6205 by eliminating the relocation -- the call will remain
6206 expanded into L32R/CALLX. */
6207 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
6208 pin_internal_relocs (sec
, internal_relocs
);
6213 release_contents (sec
, contents
);
6214 release_internal_relocs (sec
, internal_relocs
);
6219 /* Return TRUE if the asm expansion can be resolved. Generally it can
6220 be resolved on a final link or when a partial link locates it in the
6221 same section as the target. Set "is_reachable" flag if the target of
6222 the call is within the range of a direct call, given the current VMA
6223 for this section and the target section. */
6226 is_resolvable_asm_expansion (bfd
*abfd
,
6229 Elf_Internal_Rela
*irel
,
6230 struct bfd_link_info
*link_info
,
6231 bfd_boolean
*is_reachable_p
)
6233 asection
*target_sec
;
6234 bfd_vma target_offset
;
6236 xtensa_opcode opcode
, direct_call_opcode
;
6237 bfd_vma self_address
;
6238 bfd_vma dest_address
;
6239 bfd_boolean uses_l32r
;
6240 bfd_size_type sec_size
;
6242 *is_reachable_p
= FALSE
;
6244 if (contents
== NULL
)
6247 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
6250 sec_size
= bfd_get_section_limit (abfd
, sec
);
6251 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
6252 sec_size
- irel
->r_offset
, &uses_l32r
);
6253 /* Optimization of longcalls that use CONST16 is not yet implemented. */
6257 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
6258 if (direct_call_opcode
== XTENSA_UNDEFINED
)
6261 /* Check and see that the target resolves. */
6262 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
6263 if (!r_reloc_is_defined (&r_rel
))
6266 target_sec
= r_reloc_get_section (&r_rel
);
6267 target_offset
= r_rel
.target_offset
;
6269 /* If the target is in a shared library, then it doesn't reach. This
6270 isn't supposed to come up because the compiler should never generate
6271 non-PIC calls on systems that use shared libraries, but the linker
6272 shouldn't crash regardless. */
6273 if (!target_sec
->output_section
)
6276 /* For relocatable sections, we can only simplify when the output
6277 section of the target is the same as the output section of the
6279 if (link_info
->relocatable
6280 && (target_sec
->output_section
!= sec
->output_section
6281 || is_reloc_sym_weak (abfd
, irel
)))
6284 self_address
= (sec
->output_section
->vma
6285 + sec
->output_offset
+ irel
->r_offset
+ 3);
6286 dest_address
= (target_sec
->output_section
->vma
6287 + target_sec
->output_offset
+ target_offset
);
6289 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
6290 self_address
, dest_address
);
6292 if ((self_address
>> CALL_SEGMENT_BITS
) !=
6293 (dest_address
>> CALL_SEGMENT_BITS
))
6300 static Elf_Internal_Rela
*
6301 find_associated_l32r_irel (bfd
*abfd
,
6304 Elf_Internal_Rela
*other_irel
,
6305 Elf_Internal_Rela
*internal_relocs
)
6309 for (i
= 0; i
< sec
->reloc_count
; i
++)
6311 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
6313 if (irel
== other_irel
)
6315 if (irel
->r_offset
!= other_irel
->r_offset
)
6317 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
6325 static xtensa_opcode
*
6326 build_reloc_opcodes (bfd
*abfd
,
6329 Elf_Internal_Rela
*internal_relocs
)
6332 xtensa_opcode
*reloc_opcodes
=
6333 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
6334 for (i
= 0; i
< sec
->reloc_count
; i
++)
6336 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
6337 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
6339 return reloc_opcodes
;
6343 /* The compute_text_actions function will build a list of potential
6344 transformation actions for code in the extended basic block of each
6345 longcall that is optimized to a direct call. From this list we
6346 generate a set of actions to actually perform that optimizes for
6347 space and, if not using size_opt, maintains branch target
6350 These actions to be performed are placed on a per-section list.
6351 The actual changes are performed by relax_section() in the second
6355 compute_text_actions (bfd
*abfd
,
6357 struct bfd_link_info
*link_info
)
6359 xtensa_opcode
*reloc_opcodes
= NULL
;
6360 xtensa_relax_info
*relax_info
;
6362 Elf_Internal_Rela
*internal_relocs
;
6363 bfd_boolean ok
= TRUE
;
6365 property_table_entry
*prop_table
= 0;
6367 bfd_size_type sec_size
;
6368 static bfd_boolean no_insn_move
= FALSE
;
6373 /* Do nothing if the section contains no optimized longcalls. */
6374 relax_info
= get_xtensa_relax_info (sec
);
6375 BFD_ASSERT (relax_info
);
6376 if (!relax_info
->is_relaxable_asm_section
)
6379 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6380 link_info
->keep_memory
);
6382 if (internal_relocs
)
6383 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
6384 internal_reloc_compare
);
6386 sec_size
= bfd_get_section_limit (abfd
, sec
);
6387 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6388 if (contents
== NULL
&& sec_size
!= 0)
6394 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6395 XTENSA_PROP_SEC_NAME
, FALSE
);
6402 for (i
= 0; i
< sec
->reloc_count
; i
++)
6404 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
6406 property_table_entry
*the_entry
;
6409 ebb_constraint ebb_table
;
6410 bfd_size_type simplify_size
;
6412 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
6414 r_offset
= irel
->r_offset
;
6416 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
6417 if (simplify_size
== 0)
6419 (*_bfd_error_handler
)
6420 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
6421 sec
->owner
, sec
, r_offset
);
6425 /* If the instruction table is not around, then don't do this
6427 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
6428 sec
->vma
+ irel
->r_offset
);
6429 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
6431 text_action_add (&relax_info
->action_list
,
6432 ta_convert_longcall
, sec
, r_offset
,
6437 /* If the next longcall happens to be at the same address as an
6438 unreachable section of size 0, then skip forward. */
6439 ptbl_idx
= the_entry
- prop_table
;
6440 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
6441 && the_entry
->size
== 0
6442 && ptbl_idx
+ 1 < ptblsize
6443 && (prop_table
[ptbl_idx
+ 1].address
6444 == prop_table
[ptbl_idx
].address
))
6450 if (the_entry
->flags
& XTENSA_PROP_INSN_NO_TRANSFORM
)
6451 /* NO_REORDER is OK */
6454 init_ebb_constraint (&ebb_table
);
6455 ebb
= &ebb_table
.ebb
;
6456 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
6457 internal_relocs
, sec
->reloc_count
);
6458 ebb
->start_offset
= r_offset
+ simplify_size
;
6459 ebb
->end_offset
= r_offset
+ simplify_size
;
6460 ebb
->start_ptbl_idx
= ptbl_idx
;
6461 ebb
->end_ptbl_idx
= ptbl_idx
;
6462 ebb
->start_reloc_idx
= i
;
6463 ebb
->end_reloc_idx
= i
;
6465 /* Precompute the opcode for each relocation. */
6466 if (reloc_opcodes
== NULL
)
6467 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
,
6470 if (!extend_ebb_bounds (ebb
)
6471 || !compute_ebb_proposed_actions (&ebb_table
)
6472 || !compute_ebb_actions (&ebb_table
)
6473 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
6474 internal_relocs
, &ebb_table
,
6476 || !check_section_ebb_reduces (&ebb_table
))
6478 /* If anything goes wrong or we get unlucky and something does
6479 not fit, with our plan because of expansion between
6480 critical branches, just convert to a NOP. */
6482 text_action_add (&relax_info
->action_list
,
6483 ta_convert_longcall
, sec
, r_offset
, 0);
6484 i
= ebb_table
.ebb
.end_reloc_idx
;
6485 free_ebb_constraint (&ebb_table
);
6489 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
6491 /* Update the index so we do not go looking at the relocations
6492 we have already processed. */
6493 i
= ebb_table
.ebb
.end_reloc_idx
;
6494 free_ebb_constraint (&ebb_table
);
6498 if (relax_info
->action_list
.head
)
6499 print_action_list (stderr
, &relax_info
->action_list
);
6503 release_contents (sec
, contents
);
6504 release_internal_relocs (sec
, internal_relocs
);
6508 free (reloc_opcodes
);
6514 /* Do not widen an instruction if it is preceeded by a
6515 loop opcode. It might cause misalignment. */
6518 prev_instr_is_a_loop (bfd_byte
*contents
,
6519 bfd_size_type content_length
,
6520 bfd_size_type offset
)
6522 xtensa_opcode prev_opcode
;
6526 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
6527 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
6531 /* Find all of the possible actions for an extended basic block. */
6534 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
6536 const ebb_t
*ebb
= &ebb_table
->ebb
;
6537 unsigned rel_idx
= ebb
->start_reloc_idx
;
6538 property_table_entry
*entry
, *start_entry
, *end_entry
;
6540 xtensa_isa isa
= xtensa_default_isa
;
6542 static xtensa_insnbuf insnbuf
= NULL
;
6543 static xtensa_insnbuf slotbuf
= NULL
;
6545 if (insnbuf
== NULL
)
6547 insnbuf
= xtensa_insnbuf_alloc (isa
);
6548 slotbuf
= xtensa_insnbuf_alloc (isa
);
6551 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6552 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6554 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
6556 bfd_vma start_offset
, end_offset
;
6557 bfd_size_type insn_len
;
6559 start_offset
= entry
->address
- ebb
->sec
->vma
;
6560 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
6562 if (entry
== start_entry
)
6563 start_offset
= ebb
->start_offset
;
6564 if (entry
== end_entry
)
6565 end_offset
= ebb
->end_offset
;
6566 offset
= start_offset
;
6568 if (offset
== entry
->address
- ebb
->sec
->vma
6569 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
6571 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
6572 BFD_ASSERT (offset
!= end_offset
);
6573 if (offset
== end_offset
)
6576 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
6581 if (check_branch_target_aligned_address (offset
, insn_len
))
6582 align_type
= EBB_REQUIRE_TGT_ALIGN
;
6584 ebb_propose_action (ebb_table
, align_type
, 0,
6585 ta_none
, offset
, 0, TRUE
);
6588 while (offset
!= end_offset
)
6590 Elf_Internal_Rela
*irel
;
6591 xtensa_opcode opcode
;
6593 while (rel_idx
< ebb
->end_reloc_idx
6594 && (ebb
->relocs
[rel_idx
].r_offset
< offset
6595 || (ebb
->relocs
[rel_idx
].r_offset
== offset
6596 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
6597 != R_XTENSA_ASM_SIMPLIFY
))))
6600 /* Check for longcall. */
6601 irel
= &ebb
->relocs
[rel_idx
];
6602 if (irel
->r_offset
== offset
6603 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
6605 bfd_size_type simplify_size
;
6607 simplify_size
= get_asm_simplify_size (ebb
->contents
,
6608 ebb
->content_length
,
6610 if (simplify_size
== 0)
6613 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
6614 ta_convert_longcall
, offset
, 0, TRUE
);
6616 offset
+= simplify_size
;
6620 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
6622 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
6623 ebb
->content_length
- offset
);
6624 fmt
= xtensa_format_decode (isa
, insnbuf
);
6625 if (fmt
== XTENSA_UNDEFINED
)
6627 insn_len
= xtensa_format_length (isa
, fmt
);
6628 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
6631 if (xtensa_format_num_slots (isa
, fmt
) != 1)
6637 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
6638 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
6639 if (opcode
== XTENSA_UNDEFINED
)
6642 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
6643 && (entry
->flags
& XTENSA_PROP_INSN_NO_TRANSFORM
) == 0
6644 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
6646 /* Add an instruction narrow action. */
6647 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
6648 ta_narrow_insn
, offset
, 0, FALSE
);
6650 else if ((entry
->flags
& XTENSA_PROP_INSN_NO_TRANSFORM
) == 0
6651 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
6652 && ! prev_instr_is_a_loop (ebb
->contents
,
6653 ebb
->content_length
, offset
))
6655 /* Add an instruction widen action. */
6656 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
6657 ta_widen_insn
, offset
, 0, FALSE
);
6659 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
6661 /* Check for branch targets. */
6662 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
6663 ta_none
, offset
, 0, TRUE
);
6670 if (ebb
->ends_unreachable
)
6672 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
6673 ta_fill
, ebb
->end_offset
, 0, TRUE
);
6679 (*_bfd_error_handler
)
6680 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6681 ebb
->sec
->owner
, ebb
->sec
, offset
);
6686 /* After all of the information has collected about the
6687 transformations possible in an EBB, compute the appropriate actions
6688 here in compute_ebb_actions. We still must check later to make
6689 sure that the actions do not break any relocations. The algorithm
6690 used here is pretty greedy. Basically, it removes as many no-ops
6691 as possible so that the end of the EBB has the same alignment
6692 characteristics as the original. First, it uses narrowing, then
6693 fill space at the end of the EBB, and finally widenings. If that
6694 does not work, it tries again with one fewer no-op removed. The
6695 optimization will only be performed if all of the branch targets
6696 that were aligned before transformation are also aligned after the
6699 When the size_opt flag is set, ignore the branch target alignments,
6700 narrow all wide instructions, and remove all no-ops unless the end
6701 of the EBB prevents it. */
6704 compute_ebb_actions (ebb_constraint
*ebb_table
)
6708 int removed_bytes
= 0;
6709 ebb_t
*ebb
= &ebb_table
->ebb
;
6710 unsigned seg_idx_start
= 0;
6711 unsigned seg_idx_end
= 0;
6713 /* We perform this like the assembler relaxation algorithm: Start by
6714 assuming all instructions are narrow and all no-ops removed; then
6717 /* For each segment of this that has a solid constraint, check to
6718 see if there are any combinations that will keep the constraint.
6720 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
6722 bfd_boolean requires_text_end_align
= FALSE
;
6723 unsigned longcall_count
= 0;
6724 unsigned longcall_convert_count
= 0;
6725 unsigned narrowable_count
= 0;
6726 unsigned narrowable_convert_count
= 0;
6727 unsigned widenable_count
= 0;
6728 unsigned widenable_convert_count
= 0;
6730 proposed_action
*action
= NULL
;
6731 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
6733 seg_idx_start
= seg_idx_end
;
6735 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
6737 action
= &ebb_table
->actions
[i
];
6738 if (action
->action
== ta_convert_longcall
)
6740 if (action
->action
== ta_narrow_insn
)
6742 if (action
->action
== ta_widen_insn
)
6744 if (action
->action
== ta_fill
)
6746 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
6748 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
6749 && !elf32xtensa_size_opt
)
6754 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
6755 requires_text_end_align
= TRUE
;
6757 if (elf32xtensa_size_opt
&& !requires_text_end_align
6758 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
6759 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
6761 longcall_convert_count
= longcall_count
;
6762 narrowable_convert_count
= narrowable_count
;
6763 widenable_convert_count
= 0;
6767 /* There is a constraint. Convert the max number of longcalls. */
6768 narrowable_convert_count
= 0;
6769 longcall_convert_count
= 0;
6770 widenable_convert_count
= 0;
6772 for (j
= 0; j
< longcall_count
; j
++)
6774 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
6775 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
6776 unsigned desire_widen
= removed
;
6777 if (desire_narrow
<= narrowable_count
)
6779 narrowable_convert_count
= desire_narrow
;
6780 narrowable_convert_count
+=
6781 (align
* ((narrowable_count
- narrowable_convert_count
)
6783 longcall_convert_count
= (longcall_count
- j
);
6784 widenable_convert_count
= 0;
6787 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
6789 narrowable_convert_count
= 0;
6790 longcall_convert_count
= longcall_count
- j
;
6791 widenable_convert_count
= desire_widen
;
6797 /* Now the number of conversions are saved. Do them. */
6798 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
6800 action
= &ebb_table
->actions
[i
];
6801 switch (action
->action
)
6803 case ta_convert_longcall
:
6804 if (longcall_convert_count
!= 0)
6806 action
->action
= ta_remove_longcall
;
6807 action
->do_action
= TRUE
;
6808 action
->removed_bytes
+= 3;
6809 longcall_convert_count
--;
6812 case ta_narrow_insn
:
6813 if (narrowable_convert_count
!= 0)
6815 action
->do_action
= TRUE
;
6816 action
->removed_bytes
+= 1;
6817 narrowable_convert_count
--;
6821 if (widenable_convert_count
!= 0)
6823 action
->do_action
= TRUE
;
6824 action
->removed_bytes
-= 1;
6825 widenable_convert_count
--;
6834 /* Now we move on to some local opts. Try to remove each of the
6835 remaining longcalls. */
6837 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
6840 for (i
= 0; i
< ebb_table
->action_count
; i
++)
6842 int old_removed_bytes
= removed_bytes
;
6843 proposed_action
*action
= &ebb_table
->actions
[i
];
6845 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
6847 bfd_boolean bad_alignment
= FALSE
;
6849 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
6851 proposed_action
*new_action
= &ebb_table
->actions
[j
];
6852 bfd_vma offset
= new_action
->offset
;
6853 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
6855 if (!check_branch_target_aligned
6856 (ebb_table
->ebb
.contents
,
6857 ebb_table
->ebb
.content_length
,
6858 offset
, offset
- removed_bytes
))
6860 bad_alignment
= TRUE
;
6864 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
6866 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
6867 ebb_table
->ebb
.content_length
,
6869 offset
- removed_bytes
))
6871 bad_alignment
= TRUE
;
6875 if (new_action
->action
== ta_narrow_insn
6876 && !new_action
->do_action
6877 && ebb_table
->ebb
.sec
->alignment_power
== 2)
6879 /* Narrow an instruction and we are done. */
6880 new_action
->do_action
= TRUE
;
6881 new_action
->removed_bytes
+= 1;
6882 bad_alignment
= FALSE
;
6885 if (new_action
->action
== ta_widen_insn
6886 && new_action
->do_action
6887 && ebb_table
->ebb
.sec
->alignment_power
== 2)
6889 /* Narrow an instruction and we are done. */
6890 new_action
->do_action
= FALSE
;
6891 new_action
->removed_bytes
+= 1;
6892 bad_alignment
= FALSE
;
6898 action
->removed_bytes
+= 3;
6899 action
->action
= ta_remove_longcall
;
6900 action
->do_action
= TRUE
;
6903 removed_bytes
= old_removed_bytes
;
6904 if (action
->do_action
)
6905 removed_bytes
+= action
->removed_bytes
;
6910 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
6912 proposed_action
*action
= &ebb_table
->actions
[i
];
6913 if (action
->do_action
)
6914 removed_bytes
+= action
->removed_bytes
;
6917 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
6918 && ebb
->ends_unreachable
)
6920 proposed_action
*action
;
6924 BFD_ASSERT (ebb_table
->action_count
!= 0);
6925 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
6926 BFD_ASSERT (action
->action
== ta_fill
);
6927 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
6929 extra_space
= compute_fill_extra_space (ebb
->ends_unreachable
);
6930 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
6931 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
6933 action
->removed_bytes
= extra_space
- br
;
6939 /* The xlate_map is a sorted array of address mappings designed to
6940 answer the offset_with_removed_text() query with a binary search instead
6941 of a linear search through the section's action_list. */
6943 typedef struct xlate_map_entry xlate_map_entry_t
;
6944 typedef struct xlate_map xlate_map_t
;
6946 struct xlate_map_entry
6948 unsigned orig_address
;
6949 unsigned new_address
;
6955 unsigned entry_count
;
6956 xlate_map_entry_t
*entry
;
6961 xlate_compare (const void *a_v
, const void *b_v
)
6963 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
6964 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
6965 if (a
->orig_address
< b
->orig_address
)
6967 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
6974 xlate_offset_with_removed_text (const xlate_map_t
*map
,
6975 text_action_list
*action_list
,
6978 xlate_map_entry_t tmp
;
6980 xlate_map_entry_t
*e
;
6983 return offset_with_removed_text (action_list
, offset
);
6985 if (map
->entry_count
== 0)
6988 tmp
.orig_address
= offset
;
6989 tmp
.new_address
= offset
;
6992 r
= bsearch (&offset
, map
->entry
, map
->entry_count
,
6993 sizeof (xlate_map_entry_t
), &xlate_compare
);
6994 e
= (xlate_map_entry_t
*) r
;
6996 BFD_ASSERT (e
!= NULL
);
6999 return e
->new_address
- e
->orig_address
+ offset
;
7003 /* Build a binary searchable offset translation map from a section's
7006 static xlate_map_t
*
7007 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
7009 xlate_map_t
*map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
7010 text_action_list
*action_list
= &relax_info
->action_list
;
7011 unsigned num_actions
= 0;
7014 xlate_map_entry_t
*current_entry
;
7019 num_actions
= action_list_count (action_list
);
7020 map
->entry
= (xlate_map_entry_t
*)
7021 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
7022 if (map
->entry
== NULL
)
7027 map
->entry_count
= 0;
7030 current_entry
= &map
->entry
[0];
7032 current_entry
->orig_address
= 0;
7033 current_entry
->new_address
= 0;
7034 current_entry
->size
= 0;
7036 for (r
= action_list
->head
; r
!= NULL
; r
= r
->next
)
7038 unsigned orig_size
= 0;
7042 case ta_remove_insn
:
7043 case ta_convert_longcall
:
7044 case ta_remove_literal
:
7045 case ta_add_literal
:
7047 case ta_remove_longcall
:
7050 case ta_narrow_insn
:
7059 current_entry
->size
=
7060 r
->offset
+ orig_size
- current_entry
->orig_address
;
7061 if (current_entry
->size
!= 0)
7066 current_entry
->orig_address
= r
->offset
+ orig_size
;
7067 removed
+= r
->removed_bytes
;
7068 current_entry
->new_address
= r
->offset
+ orig_size
- removed
;
7069 current_entry
->size
= 0;
7072 current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
7073 - current_entry
->orig_address
);
7074 if (current_entry
->size
!= 0)
7081 /* Free an offset translation map. */
7084 free_xlate_map (xlate_map_t
*map
)
7086 if (map
&& map
->entry
)
7093 /* Use check_section_ebb_pcrels_fit to make sure that all of the
7094 relocations in a section will fit if a proposed set of actions
7098 check_section_ebb_pcrels_fit (bfd
*abfd
,
7101 Elf_Internal_Rela
*internal_relocs
,
7102 const ebb_constraint
*constraint
,
7103 const xtensa_opcode
*reloc_opcodes
)
7106 Elf_Internal_Rela
*irel
;
7107 xlate_map_t
*xmap
= NULL
;
7108 bfd_boolean ok
= TRUE
;
7109 xtensa_relax_info
*relax_info
;
7111 relax_info
= get_xtensa_relax_info (sec
);
7113 if (relax_info
&& sec
->reloc_count
> 100)
7115 xmap
= build_xlate_map (sec
, relax_info
);
7116 /* NULL indicates out of memory, but the slow version
7117 can still be used. */
7120 for (i
= 0; i
< sec
->reloc_count
; i
++)
7123 bfd_vma orig_self_offset
, orig_target_offset
;
7124 bfd_vma self_offset
, target_offset
;
7126 reloc_howto_type
*howto
;
7127 int self_removed_bytes
, target_removed_bytes
;
7129 irel
= &internal_relocs
[i
];
7130 r_type
= ELF32_R_TYPE (irel
->r_info
);
7132 howto
= &elf_howto_table
[r_type
];
7133 /* We maintain the required invariant: PC-relative relocations
7134 that fit before linking must fit after linking. Thus we only
7135 need to deal with relocations to the same section that are
7137 if (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
7138 || !howto
->pc_relative
)
7141 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7142 bfd_get_section_limit (abfd
, sec
));
7144 if (r_reloc_get_section (&r_rel
) != sec
)
7147 orig_self_offset
= irel
->r_offset
;
7148 orig_target_offset
= r_rel
.target_offset
;
7150 self_offset
= orig_self_offset
;
7151 target_offset
= orig_target_offset
;
7156 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
7159 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
7160 orig_target_offset
);
7163 self_removed_bytes
= 0;
7164 target_removed_bytes
= 0;
7166 for (j
= 0; j
< constraint
->action_count
; ++j
)
7168 proposed_action
*action
= &constraint
->actions
[j
];
7169 bfd_vma offset
= action
->offset
;
7170 int removed_bytes
= action
->removed_bytes
;
7171 if (offset
< orig_self_offset
7172 || (offset
== orig_self_offset
&& action
->action
== ta_fill
7173 && action
->removed_bytes
< 0))
7174 self_removed_bytes
+= removed_bytes
;
7175 if (offset
< orig_target_offset
7176 || (offset
== orig_target_offset
&& action
->action
== ta_fill
7177 && action
->removed_bytes
< 0))
7178 target_removed_bytes
+= removed_bytes
;
7180 self_offset
-= self_removed_bytes
;
7181 target_offset
-= target_removed_bytes
;
7183 /* Try to encode it. Get the operand and check. */
7184 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7186 /* None of the current alternate relocs are PC-relative,
7187 and only PC-relative relocs matter here. */
7191 xtensa_opcode opcode
;
7195 opcode
= reloc_opcodes
[i
];
7197 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7198 if (opcode
== XTENSA_UNDEFINED
)
7204 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7205 if (opnum
== XTENSA_UNDEFINED
)
7211 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
7220 free_xlate_map (xmap
);
7227 check_section_ebb_reduces (const ebb_constraint
*constraint
)
7232 for (i
= 0; i
< constraint
->action_count
; i
++)
7234 const proposed_action
*action
= &constraint
->actions
[i
];
7235 if (action
->do_action
)
7236 removed
+= action
->removed_bytes
;
7246 text_action_add_proposed (text_action_list
*l
,
7247 const ebb_constraint
*ebb_table
,
7252 for (i
= 0; i
< ebb_table
->action_count
; i
++)
7254 proposed_action
*action
= &ebb_table
->actions
[i
];
7256 if (!action
->do_action
)
7258 switch (action
->action
)
7260 case ta_remove_insn
:
7261 case ta_remove_longcall
:
7262 case ta_convert_longcall
:
7263 case ta_narrow_insn
:
7266 case ta_remove_literal
:
7267 text_action_add (l
, action
->action
, sec
, action
->offset
,
7268 action
->removed_bytes
);
7281 compute_fill_extra_space (property_table_entry
*entry
)
7283 int fill_extra_space
;
7288 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
7291 fill_extra_space
= entry
->size
;
7292 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
7294 /* Fill bytes for alignment:
7295 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
7296 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
7297 int nsm
= (1 << pow
) - 1;
7298 bfd_vma addr
= entry
->address
+ entry
->size
;
7299 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
7300 fill_extra_space
+= align_fill
;
7302 return fill_extra_space
;
7306 /* First relaxation pass. */
7308 /* If the section contains relaxable literals, check each literal to
7309 see if it has the same value as another literal that has already
7310 been seen, either in the current section or a previous one. If so,
7311 add an entry to the per-section list of removed literals. The
7312 actual changes are deferred until the next pass. */
7315 compute_removed_literals (bfd
*abfd
,
7317 struct bfd_link_info
*link_info
,
7318 value_map_hash_table
*values
)
7320 xtensa_relax_info
*relax_info
;
7322 Elf_Internal_Rela
*internal_relocs
;
7323 source_reloc
*src_relocs
, *rel
;
7324 bfd_boolean ok
= TRUE
;
7325 property_table_entry
*prop_table
= NULL
;
7328 bfd_boolean last_loc_is_prev
= FALSE
;
7329 bfd_vma last_target_offset
= 0;
7330 section_cache_t target_sec_cache
;
7331 bfd_size_type sec_size
;
7333 init_section_cache (&target_sec_cache
);
7335 /* Do nothing if it is not a relaxable literal section. */
7336 relax_info
= get_xtensa_relax_info (sec
);
7337 BFD_ASSERT (relax_info
);
7338 if (!relax_info
->is_relaxable_literal_section
)
7341 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7342 link_info
->keep_memory
);
7344 sec_size
= bfd_get_section_limit (abfd
, sec
);
7345 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7346 if (contents
== NULL
&& sec_size
!= 0)
7352 /* Sort the source_relocs by target offset. */
7353 src_relocs
= relax_info
->src_relocs
;
7354 qsort (src_relocs
, relax_info
->src_count
,
7355 sizeof (source_reloc
), source_reloc_compare
);
7356 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7357 internal_reloc_compare
);
7359 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7360 XTENSA_PROP_SEC_NAME
, FALSE
);
7368 for (i
= 0; i
< relax_info
->src_count
; i
++)
7370 Elf_Internal_Rela
*irel
= NULL
;
7372 rel
= &src_relocs
[i
];
7373 if (get_l32r_opcode () != rel
->opcode
)
7375 irel
= get_irel_at_offset (sec
, internal_relocs
,
7376 rel
->r_rel
.target_offset
);
7378 /* If the relocation on this is not a simple R_XTENSA_32 or
7379 R_XTENSA_PLT then do not consider it. This may happen when
7380 the difference of two symbols is used in a literal. */
7381 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
7382 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
7385 /* If the target_offset for this relocation is the same as the
7386 previous relocation, then we've already considered whether the
7387 literal can be coalesced. Skip to the next one.... */
7388 if (i
!= 0 && prev_i
!= -1
7389 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
7393 if (last_loc_is_prev
&&
7394 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
7395 last_loc_is_prev
= FALSE
;
7397 /* Check if the relocation was from an L32R that is being removed
7398 because a CALLX was converted to a direct CALL, and check if
7399 there are no other relocations to the literal. */
7400 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
))
7402 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
7403 irel
, rel
, prop_table
, ptblsize
))
7408 last_target_offset
= rel
->r_rel
.target_offset
;
7412 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
7414 &last_loc_is_prev
, irel
,
7415 relax_info
->src_count
- i
, rel
,
7416 prop_table
, ptblsize
,
7417 &target_sec_cache
, rel
->is_abs_literal
))
7422 last_target_offset
= rel
->r_rel
.target_offset
;
7426 print_removed_literals (stderr
, &relax_info
->removed_list
);
7427 print_action_list (stderr
, &relax_info
->action_list
);
7431 if (prop_table
) free (prop_table
);
7432 clear_section_cache (&target_sec_cache
);
7434 release_contents (sec
, contents
);
7435 release_internal_relocs (sec
, internal_relocs
);
7440 static Elf_Internal_Rela
*
7441 get_irel_at_offset (asection
*sec
,
7442 Elf_Internal_Rela
*internal_relocs
,
7446 Elf_Internal_Rela
*irel
;
7448 Elf_Internal_Rela key
;
7450 if (!internal_relocs
)
7453 key
.r_offset
= offset
;
7454 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
7455 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
7459 /* bsearch does not guarantee which will be returned if there are
7460 multiple matches. We need the first that is not an alignment. */
7461 i
= irel
- internal_relocs
;
7464 if (internal_relocs
[i
-1].r_offset
!= offset
)
7468 for ( ; i
< sec
->reloc_count
; i
++)
7470 irel
= &internal_relocs
[i
];
7471 r_type
= ELF32_R_TYPE (irel
->r_info
);
7472 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
7481 is_removable_literal (const source_reloc
*rel
,
7483 const source_reloc
*src_relocs
,
7486 const source_reloc
*curr_rel
;
7490 for (++i
; i
< src_count
; ++i
)
7492 curr_rel
= &src_relocs
[i
];
7493 /* If all others have the same target offset.... */
7494 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
7497 if (!curr_rel
->is_null
7498 && !xtensa_is_property_section (curr_rel
->source_sec
)
7499 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
7507 remove_dead_literal (bfd
*abfd
,
7509 struct bfd_link_info
*link_info
,
7510 Elf_Internal_Rela
*internal_relocs
,
7511 Elf_Internal_Rela
*irel
,
7513 property_table_entry
*prop_table
,
7516 property_table_entry
*entry
;
7517 xtensa_relax_info
*relax_info
;
7519 relax_info
= get_xtensa_relax_info (sec
);
7523 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7524 sec
->vma
+ rel
->r_rel
.target_offset
);
7526 /* Mark the unused literal so that it will be removed. */
7527 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
7529 text_action_add (&relax_info
->action_list
,
7530 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
7532 /* If the section is 4-byte aligned, do not add fill. */
7533 if (sec
->alignment_power
> 2)
7535 int fill_extra_space
;
7536 bfd_vma entry_sec_offset
;
7538 property_table_entry
*the_add_entry
;
7542 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
7544 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
7546 /* If the literal range is at the end of the section,
7548 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7550 fill_extra_space
= compute_fill_extra_space (the_add_entry
);
7552 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
7553 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
7554 -4, fill_extra_space
);
7556 adjust_fill_action (fa
, removed_diff
);
7558 text_action_add (&relax_info
->action_list
,
7559 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
7562 /* Zero out the relocation on this literal location. */
7565 if (elf_hash_table (link_info
)->dynamic_sections_created
)
7566 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
7568 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7569 pin_internal_relocs (sec
, internal_relocs
);
7572 /* Do not modify "last_loc_is_prev". */
7578 identify_literal_placement (bfd
*abfd
,
7581 struct bfd_link_info
*link_info
,
7582 value_map_hash_table
*values
,
7583 bfd_boolean
*last_loc_is_prev_p
,
7584 Elf_Internal_Rela
*irel
,
7585 int remaining_src_rels
,
7587 property_table_entry
*prop_table
,
7589 section_cache_t
*target_sec_cache
,
7590 bfd_boolean is_abs_literal
)
7594 xtensa_relax_info
*relax_info
;
7595 bfd_boolean literal_placed
= FALSE
;
7597 unsigned long value
;
7598 bfd_boolean final_static_link
;
7599 bfd_size_type sec_size
;
7601 relax_info
= get_xtensa_relax_info (sec
);
7605 sec_size
= bfd_get_section_limit (abfd
, sec
);
7608 (!link_info
->relocatable
7609 && !elf_hash_table (link_info
)->dynamic_sections_created
);
7611 /* The placement algorithm first checks to see if the literal is
7612 already in the value map. If so and the value map is reachable
7613 from all uses, then the literal is moved to that location. If
7614 not, then we identify the last location where a fresh literal was
7615 placed. If the literal can be safely moved there, then we do so.
7616 If not, then we assume that the literal is not to move and leave
7617 the literal where it is, marking it as the last literal
7620 /* Find the literal value. */
7622 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7625 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
7626 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
7628 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
7630 /* Check if we've seen another literal with the same value that
7631 is in the same output section. */
7632 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
7635 && (r_reloc_get_section (&val_map
->loc
)->output_section
7636 == sec
->output_section
)
7637 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
7638 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
7640 /* No change to last_loc_is_prev. */
7641 literal_placed
= TRUE
;
7644 /* For relocatable links, do not try to move literals. To do it
7645 correctly might increase the number of relocations in an input
7646 section making the default relocatable linking fail. */
7647 if (!link_info
->relocatable
&& !literal_placed
7648 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
7650 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
7651 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
7653 /* Increment the virtual offset. */
7654 r_reloc try_loc
= values
->last_loc
;
7655 try_loc
.virtual_offset
+= 4;
7657 /* There is a last loc that was in the same output section. */
7658 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
7659 && move_shared_literal (sec
, link_info
, rel
,
7660 prop_table
, ptblsize
,
7661 &try_loc
, &val
, target_sec_cache
))
7663 values
->last_loc
.virtual_offset
+= 4;
7664 literal_placed
= TRUE
;
7666 val_map
= add_value_map (values
, &val
, &try_loc
,
7669 val_map
->loc
= try_loc
;
7674 if (!literal_placed
)
7676 /* Nothing worked, leave the literal alone but update the last loc. */
7677 values
->has_last_loc
= TRUE
;
7678 values
->last_loc
= rel
->r_rel
;
7680 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
7682 val_map
->loc
= rel
->r_rel
;
7683 *last_loc_is_prev_p
= TRUE
;
7690 /* Check if the original relocations (presumably on L32R instructions)
7691 identified by reloc[0..N] can be changed to reference the literal
7692 identified by r_rel. If r_rel is out of range for any of the
7693 original relocations, then we don't want to coalesce the original
7694 literal with the one at r_rel. We only check reloc[0..N], where the
7695 offsets are all the same as for reloc[0] (i.e., they're all
7696 referencing the same literal) and where N is also bounded by the
7697 number of remaining entries in the "reloc" array. The "reloc" array
7698 is sorted by target offset so we know all the entries for the same
7699 literal will be contiguous. */
7702 relocations_reach (source_reloc
*reloc
,
7703 int remaining_relocs
,
7704 const r_reloc
*r_rel
)
7706 bfd_vma from_offset
, source_address
, dest_address
;
7710 if (!r_reloc_is_defined (r_rel
))
7713 sec
= r_reloc_get_section (r_rel
);
7714 from_offset
= reloc
[0].r_rel
.target_offset
;
7716 for (i
= 0; i
< remaining_relocs
; i
++)
7718 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
7721 /* Ignore relocations that have been removed. */
7722 if (reloc
[i
].is_null
)
7725 /* The original and new output section for these must be the same
7726 in order to coalesce. */
7727 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
7728 != sec
->output_section
)
7731 /* Absolute literals in the same output section can always be
7733 if (reloc
[i
].is_abs_literal
)
7736 /* A literal with no PC-relative relocations can be moved anywhere. */
7737 if (reloc
[i
].opnd
!= -1)
7739 /* Otherwise, check to see that it fits. */
7740 source_address
= (reloc
[i
].source_sec
->output_section
->vma
7741 + reloc
[i
].source_sec
->output_offset
7742 + reloc
[i
].r_rel
.rela
.r_offset
);
7743 dest_address
= (sec
->output_section
->vma
7744 + sec
->output_offset
7745 + r_rel
->target_offset
);
7747 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
7748 source_address
, dest_address
))
7757 /* Move a literal to another literal location because it is
7758 the same as the other literal value. */
7761 coalesce_shared_literal (asection
*sec
,
7763 property_table_entry
*prop_table
,
7767 property_table_entry
*entry
;
7769 property_table_entry
*the_add_entry
;
7771 xtensa_relax_info
*relax_info
;
7773 relax_info
= get_xtensa_relax_info (sec
);
7777 entry
= elf_xtensa_find_property_entry
7778 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
7779 if (entry
&& (entry
->flags
& XTENSA_PROP_INSN_NO_TRANSFORM
))
7782 /* Mark that the literal will be coalesced. */
7783 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
7785 text_action_add (&relax_info
->action_list
,
7786 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
7788 /* If the section is 4-byte aligned, do not add fill. */
7789 if (sec
->alignment_power
> 2)
7791 int fill_extra_space
;
7792 bfd_vma entry_sec_offset
;
7795 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
7797 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
7799 /* If the literal range is at the end of the section,
7801 fill_extra_space
= 0;
7802 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7804 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
7805 fill_extra_space
= the_add_entry
->size
;
7807 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
7808 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
7809 -4, fill_extra_space
);
7811 adjust_fill_action (fa
, removed_diff
);
7813 text_action_add (&relax_info
->action_list
,
7814 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
7821 /* Move a literal to another location. This may actually increase the
7822 total amount of space used because of alignments so we need to do
7823 this carefully. Also, it may make a branch go out of range. */
7826 move_shared_literal (asection
*sec
,
7827 struct bfd_link_info
*link_info
,
7829 property_table_entry
*prop_table
,
7831 const r_reloc
*target_loc
,
7832 const literal_value
*lit_value
,
7833 section_cache_t
*target_sec_cache
)
7835 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
7836 text_action
*fa
, *target_fa
;
7838 xtensa_relax_info
*relax_info
, *target_relax_info
;
7839 asection
*target_sec
;
7841 ebb_constraint ebb_table
;
7842 bfd_boolean relocs_fit
;
7844 /* If this routine always returns FALSE, the literals that cannot be
7845 coalesced will not be moved. */
7846 if (elf32xtensa_no_literal_movement
)
7849 relax_info
= get_xtensa_relax_info (sec
);
7853 target_sec
= r_reloc_get_section (target_loc
);
7854 target_relax_info
= get_xtensa_relax_info (target_sec
);
7856 /* Literals to undefined sections may not be moved because they
7857 must report an error. */
7858 if (bfd_is_und_section (target_sec
))
7861 src_entry
= elf_xtensa_find_property_entry
7862 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
7864 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
7867 target_entry
= elf_xtensa_find_property_entry
7868 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
7869 target_sec
->vma
+ target_loc
->target_offset
);
7874 /* Make sure that we have not broken any branches. */
7877 init_ebb_constraint (&ebb_table
);
7878 ebb
= &ebb_table
.ebb
;
7879 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
7880 target_sec_cache
->content_length
,
7881 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
7882 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
7884 /* Propose to add 4 bytes + worst-case alignment size increase to
7886 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
7887 ta_fill
, target_loc
->target_offset
,
7888 -4 - (1 << target_sec
->alignment_power
), TRUE
);
7890 /* Check all of the PC-relative relocations to make sure they still fit. */
7891 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
7892 target_sec_cache
->contents
,
7893 target_sec_cache
->relocs
,
7899 text_action_add_literal (&target_relax_info
->action_list
,
7900 ta_add_literal
, target_loc
, lit_value
, -4);
7902 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
7904 /* May need to add or remove some fill to maintain alignment. */
7905 int fill_extra_space
;
7906 bfd_vma entry_sec_offset
;
7909 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
7911 /* If the literal range is at the end of the section,
7913 fill_extra_space
= 0;
7915 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
7916 target_sec_cache
->pte_count
,
7918 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
7919 fill_extra_space
= the_add_entry
->size
;
7921 target_fa
= find_fill_action (&target_relax_info
->action_list
,
7922 target_sec
, entry_sec_offset
);
7923 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
7924 entry_sec_offset
, 4,
7927 adjust_fill_action (target_fa
, removed_diff
);
7929 text_action_add (&target_relax_info
->action_list
,
7930 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
7933 /* Mark that the literal will be moved to the new location. */
7934 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
7936 /* Remove the literal. */
7937 text_action_add (&relax_info
->action_list
,
7938 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
7940 /* If the section is 4-byte aligned, do not add fill. */
7941 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
7943 int fill_extra_space
;
7944 bfd_vma entry_sec_offset
;
7947 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
7949 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
7951 /* If the literal range is at the end of the section,
7953 fill_extra_space
= 0;
7954 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7956 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
7957 fill_extra_space
= the_add_entry
->size
;
7959 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
7960 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
7961 -4, fill_extra_space
);
7963 adjust_fill_action (fa
, removed_diff
);
7965 text_action_add (&relax_info
->action_list
,
7966 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
7973 /* Second relaxation pass. */
7975 /* Modify all of the relocations to point to the right spot, and if this
7976 is a relaxable section, delete the unwanted literals and fix the
7980 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
7982 Elf_Internal_Rela
*internal_relocs
;
7983 xtensa_relax_info
*relax_info
;
7985 bfd_boolean ok
= TRUE
;
7987 bfd_boolean rv
= FALSE
;
7988 bfd_boolean virtual_action
;
7989 bfd_size_type sec_size
;
7991 sec_size
= bfd_get_section_limit (abfd
, sec
);
7992 relax_info
= get_xtensa_relax_info (sec
);
7993 BFD_ASSERT (relax_info
);
7995 /* First translate any of the fixes that have been added already. */
7996 translate_section_fixes (sec
);
7998 /* Handle property sections (e.g., literal tables) specially. */
7999 if (xtensa_is_property_section (sec
))
8001 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
8002 return relax_property_section (abfd
, sec
, link_info
);
8005 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8006 link_info
->keep_memory
);
8007 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8008 if (contents
== NULL
&& sec_size
!= 0)
8014 if (internal_relocs
)
8016 for (i
= 0; i
< sec
->reloc_count
; i
++)
8018 Elf_Internal_Rela
*irel
;
8019 xtensa_relax_info
*target_relax_info
;
8020 bfd_vma source_offset
, old_source_offset
;
8023 asection
*target_sec
;
8025 /* Locally change the source address.
8026 Translate the target to the new target address.
8027 If it points to this section and has been removed,
8031 irel
= &internal_relocs
[i
];
8032 source_offset
= irel
->r_offset
;
8033 old_source_offset
= source_offset
;
8035 r_type
= ELF32_R_TYPE (irel
->r_info
);
8036 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8037 bfd_get_section_limit (abfd
, sec
));
8039 /* If this section could have changed then we may need to
8040 change the relocation's offset. */
8042 if (relax_info
->is_relaxable_literal_section
8043 || relax_info
->is_relaxable_asm_section
)
8045 if (r_type
!= R_XTENSA_NONE
8046 && find_removed_literal (&relax_info
->removed_list
,
8049 /* Remove this relocation. */
8050 if (elf_hash_table (link_info
)->dynamic_sections_created
)
8051 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
8052 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
8053 irel
->r_offset
= offset_with_removed_text
8054 (&relax_info
->action_list
, irel
->r_offset
);
8055 pin_internal_relocs (sec
, internal_relocs
);
8059 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
8061 text_action
*action
=
8062 find_insn_action (&relax_info
->action_list
,
8064 if (action
&& (action
->action
== ta_convert_longcall
8065 || action
->action
== ta_remove_longcall
))
8067 bfd_reloc_status_type retval
;
8068 char *error_message
= NULL
;
8070 retval
= contract_asm_expansion (contents
, sec_size
,
8071 irel
, &error_message
);
8072 if (retval
!= bfd_reloc_ok
)
8074 (*link_info
->callbacks
->reloc_dangerous
)
8075 (link_info
, error_message
, abfd
, sec
,
8079 /* Update the action so that the code that moves
8080 the contents will do the right thing. */
8081 if (action
->action
== ta_remove_longcall
)
8082 action
->action
= ta_remove_insn
;
8084 action
->action
= ta_none
;
8085 /* Refresh the info in the r_rel. */
8086 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
8087 r_type
= ELF32_R_TYPE (irel
->r_info
);
8091 source_offset
= offset_with_removed_text
8092 (&relax_info
->action_list
, irel
->r_offset
);
8093 irel
->r_offset
= source_offset
;
8096 /* If the target section could have changed then
8097 we may need to change the relocation's target offset. */
8099 target_sec
= r_reloc_get_section (&r_rel
);
8100 target_relax_info
= get_xtensa_relax_info (target_sec
);
8102 if (target_relax_info
8103 && (target_relax_info
->is_relaxable_literal_section
8104 || target_relax_info
->is_relaxable_asm_section
))
8108 bfd_vma addend_displacement
;
8110 translate_reloc (&r_rel
, &new_reloc
);
8112 if (r_type
== R_XTENSA_DIFF8
8113 || r_type
== R_XTENSA_DIFF16
8114 || r_type
== R_XTENSA_DIFF32
)
8116 bfd_vma diff_value
= 0, new_end_offset
, diff_mask
= 0;
8118 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
8120 (*link_info
->callbacks
->reloc_dangerous
)
8121 (link_info
, _("invalid relocation address"),
8122 abfd
, sec
, old_source_offset
);
8128 case R_XTENSA_DIFF8
:
8130 bfd_get_8 (abfd
, &contents
[old_source_offset
]);
8132 case R_XTENSA_DIFF16
:
8134 bfd_get_16 (abfd
, &contents
[old_source_offset
]);
8136 case R_XTENSA_DIFF32
:
8138 bfd_get_32 (abfd
, &contents
[old_source_offset
]);
8142 new_end_offset
= offset_with_removed_text
8143 (&target_relax_info
->action_list
,
8144 r_rel
.target_offset
+ diff_value
);
8145 diff_value
= new_end_offset
- new_reloc
.target_offset
;
8149 case R_XTENSA_DIFF8
:
8151 bfd_put_8 (abfd
, diff_value
,
8152 &contents
[old_source_offset
]);
8154 case R_XTENSA_DIFF16
:
8156 bfd_put_16 (abfd
, diff_value
,
8157 &contents
[old_source_offset
]);
8159 case R_XTENSA_DIFF32
:
8160 diff_mask
= 0xffffffff;
8161 bfd_put_32 (abfd
, diff_value
,
8162 &contents
[old_source_offset
]);
8166 /* Check for overflow. */
8167 if ((diff_value
& ~diff_mask
) != 0)
8169 (*link_info
->callbacks
->reloc_dangerous
)
8170 (link_info
, _("overflow after relaxation"),
8171 abfd
, sec
, old_source_offset
);
8175 pin_contents (sec
, contents
);
8178 /* FIXME: If the relocation still references a section in
8179 the same input file, the relocation should be modified
8180 directly instead of adding a "fix" record. */
8182 addend_displacement
=
8183 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
8185 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
, 0,
8186 r_reloc_get_section (&new_reloc
),
8187 addend_displacement
, TRUE
);
8191 pin_internal_relocs (sec
, internal_relocs
);
8195 if ((relax_info
->is_relaxable_literal_section
8196 || relax_info
->is_relaxable_asm_section
)
8197 && relax_info
->action_list
.head
)
8199 /* Walk through the planned actions and build up a table
8200 of move, copy and fill records. Use the move, copy and
8201 fill records to perform the actions once. */
8203 bfd_size_type size
= sec
->size
;
8205 bfd_size_type final_size
, copy_size
, orig_insn_size
;
8206 bfd_byte
*scratch
= NULL
;
8207 bfd_byte
*dup_contents
= NULL
;
8208 bfd_size_type orig_size
= size
;
8209 bfd_vma orig_dot
= 0;
8210 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
8211 orig dot in physical memory. */
8212 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
8213 bfd_vma dup_dot
= 0;
8215 text_action
*action
= relax_info
->action_list
.head
;
8217 final_size
= sec
->size
;
8218 for (action
= relax_info
->action_list
.head
; action
;
8219 action
= action
->next
)
8221 final_size
-= action
->removed_bytes
;
8224 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
8225 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
8227 /* The dot is the current fill location. */
8229 print_action_list (stderr
, &relax_info
->action_list
);
8232 for (action
= relax_info
->action_list
.head
; action
;
8233 action
= action
->next
)
8235 virtual_action
= FALSE
;
8236 if (action
->offset
> orig_dot
)
8238 orig_dot
+= orig_dot_copied
;
8239 orig_dot_copied
= 0;
8241 /* Out of the virtual world. */
8244 if (action
->offset
> orig_dot
)
8246 copy_size
= action
->offset
- orig_dot
;
8247 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
8248 orig_dot
+= copy_size
;
8249 dup_dot
+= copy_size
;
8250 BFD_ASSERT (action
->offset
== orig_dot
);
8252 else if (action
->offset
< orig_dot
)
8254 if (action
->action
== ta_fill
8255 && action
->offset
- action
->removed_bytes
== orig_dot
)
8257 /* This is OK because the fill only effects the dup_dot. */
8259 else if (action
->action
== ta_add_literal
)
8261 /* TBD. Might need to handle this. */
8264 if (action
->offset
== orig_dot
)
8266 if (action
->virtual_offset
> orig_dot_vo
)
8268 if (orig_dot_vo
== 0)
8270 /* Need to copy virtual_offset bytes. Probably four. */
8271 copy_size
= action
->virtual_offset
- orig_dot_vo
;
8272 memmove (&dup_contents
[dup_dot
],
8273 &contents
[orig_dot
], copy_size
);
8274 orig_dot_copied
= copy_size
;
8275 dup_dot
+= copy_size
;
8277 virtual_action
= TRUE
;
8280 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
8282 switch (action
->action
)
8284 case ta_remove_literal
:
8285 case ta_remove_insn
:
8286 BFD_ASSERT (action
->removed_bytes
>= 0);
8287 orig_dot
+= action
->removed_bytes
;
8290 case ta_narrow_insn
:
8293 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
8294 BFD_ASSERT (action
->removed_bytes
== 1);
8295 rv
= narrow_instruction (scratch
, final_size
, 0);
8297 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
8298 orig_dot
+= orig_insn_size
;
8299 dup_dot
+= copy_size
;
8303 if (action
->removed_bytes
>= 0)
8304 orig_dot
+= action
->removed_bytes
;
8307 /* Already zeroed in dup_contents. Just bump the
8309 dup_dot
+= (-action
->removed_bytes
);
8314 BFD_ASSERT (action
->removed_bytes
== 0);
8317 case ta_convert_longcall
:
8318 case ta_remove_longcall
:
8319 /* These will be removed or converted before we get here. */
8326 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
8327 BFD_ASSERT (action
->removed_bytes
== -1);
8328 rv
= widen_instruction (scratch
, final_size
, 0);
8330 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
8331 orig_dot
+= orig_insn_size
;
8332 dup_dot
+= copy_size
;
8335 case ta_add_literal
:
8338 BFD_ASSERT (action
->removed_bytes
== -4);
8339 /* TBD -- place the literal value here and insert
8341 memset (&dup_contents
[dup_dot
], 0, 4);
8342 pin_internal_relocs (sec
, internal_relocs
);
8343 pin_contents (sec
, contents
);
8345 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
8346 relax_info
, &internal_relocs
, &action
->value
))
8350 orig_dot_vo
+= copy_size
;
8352 orig_dot
+= orig_insn_size
;
8353 dup_dot
+= copy_size
;
8357 /* Not implemented yet. */
8362 size
-= action
->removed_bytes
;
8363 removed
+= action
->removed_bytes
;
8364 BFD_ASSERT (dup_dot
<= final_size
);
8365 BFD_ASSERT (orig_dot
<= orig_size
);
8368 orig_dot
+= orig_dot_copied
;
8369 orig_dot_copied
= 0;
8371 if (orig_dot
!= orig_size
)
8373 copy_size
= orig_size
- orig_dot
;
8374 BFD_ASSERT (orig_size
> orig_dot
);
8375 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
8376 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
8377 orig_dot
+= copy_size
;
8378 dup_dot
+= copy_size
;
8380 BFD_ASSERT (orig_size
== orig_dot
);
8381 BFD_ASSERT (final_size
== dup_dot
);
8383 /* Move the dup_contents back. */
8384 if (final_size
> orig_size
)
8386 /* Contents need to be reallocated. Swap the dup_contents into
8388 sec
->contents
= dup_contents
;
8390 contents
= dup_contents
;
8391 pin_contents (sec
, contents
);
8395 BFD_ASSERT (final_size
<= orig_size
);
8396 memset (contents
, 0, orig_size
);
8397 memcpy (contents
, dup_contents
, final_size
);
8398 free (dup_contents
);
8401 pin_contents (sec
, contents
);
8403 sec
->size
= final_size
;
8407 release_internal_relocs (sec
, internal_relocs
);
8408 release_contents (sec
, contents
);
8414 translate_section_fixes (asection
*sec
)
8416 xtensa_relax_info
*relax_info
;
8419 relax_info
= get_xtensa_relax_info (sec
);
8423 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
8424 if (!translate_reloc_bfd_fix (r
))
8431 /* Translate a fix given the mapping in the relax info for the target
8432 section. If it has already been translated, no work is required. */
8435 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
8437 reloc_bfd_fix new_fix
;
8439 xtensa_relax_info
*relax_info
;
8440 removed_literal
*removed
;
8441 bfd_vma new_offset
, target_offset
;
8443 if (fix
->translated
)
8446 sec
= fix
->target_sec
;
8447 target_offset
= fix
->target_offset
;
8449 relax_info
= get_xtensa_relax_info (sec
);
8452 fix
->translated
= TRUE
;
8458 /* The fix does not need to be translated if the section cannot change. */
8459 if (!relax_info
->is_relaxable_literal_section
8460 && !relax_info
->is_relaxable_asm_section
)
8462 fix
->translated
= TRUE
;
8466 /* If the literal has been moved and this relocation was on an
8467 opcode, then the relocation should move to the new literal
8468 location. Otherwise, the relocation should move within the
8472 if (is_operand_relocation (fix
->src_type
))
8474 /* Check if the original relocation is against a literal being
8476 removed
= find_removed_literal (&relax_info
->removed_list
,
8484 /* The fact that there is still a relocation to this literal indicates
8485 that the literal is being coalesced, not simply removed. */
8486 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
8488 /* This was moved to some other address (possibly another section). */
8489 new_sec
= r_reloc_get_section (&removed
->to
);
8493 relax_info
= get_xtensa_relax_info (sec
);
8495 (!relax_info
->is_relaxable_literal_section
8496 && !relax_info
->is_relaxable_asm_section
))
8498 target_offset
= removed
->to
.target_offset
;
8499 new_fix
.target_sec
= new_sec
;
8500 new_fix
.target_offset
= target_offset
;
8501 new_fix
.translated
= TRUE
;
8506 target_offset
= removed
->to
.target_offset
;
8507 new_fix
.target_sec
= new_sec
;
8510 /* The target address may have been moved within its section. */
8511 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
8514 new_fix
.target_offset
= new_offset
;
8515 new_fix
.target_offset
= new_offset
;
8516 new_fix
.translated
= TRUE
;
8522 /* Fix up a relocation to take account of removed literals. */
8525 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
)
8528 xtensa_relax_info
*relax_info
;
8529 removed_literal
*removed
;
8530 bfd_vma new_offset
, target_offset
, removed_bytes
;
8532 *new_rel
= *orig_rel
;
8534 if (!r_reloc_is_defined (orig_rel
))
8536 sec
= r_reloc_get_section (orig_rel
);
8538 relax_info
= get_xtensa_relax_info (sec
);
8539 BFD_ASSERT (relax_info
);
8541 if (!relax_info
->is_relaxable_literal_section
8542 && !relax_info
->is_relaxable_asm_section
)
8545 target_offset
= orig_rel
->target_offset
;
8548 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
8550 /* Check if the original relocation is against a literal being
8552 removed
= find_removed_literal (&relax_info
->removed_list
,
8555 if (removed
&& removed
->to
.abfd
)
8559 /* The fact that there is still a relocation to this literal indicates
8560 that the literal is being coalesced, not simply removed. */
8561 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
8563 /* This was moved to some other address
8564 (possibly in another section). */
8565 *new_rel
= removed
->to
;
8566 new_sec
= r_reloc_get_section (new_rel
);
8570 relax_info
= get_xtensa_relax_info (sec
);
8572 || (!relax_info
->is_relaxable_literal_section
8573 && !relax_info
->is_relaxable_asm_section
))
8576 target_offset
= new_rel
->target_offset
;
8579 /* ...and the target address may have been moved within its section. */
8580 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
8583 /* Modify the offset and addend. */
8584 removed_bytes
= target_offset
- new_offset
;
8585 new_rel
->target_offset
= new_offset
;
8586 new_rel
->rela
.r_addend
-= removed_bytes
;
8590 /* For dynamic links, there may be a dynamic relocation for each
8591 literal. The number of dynamic relocations must be computed in
8592 size_dynamic_sections, which occurs before relaxation. When a
8593 literal is removed, this function checks if there is a corresponding
8594 dynamic relocation and shrinks the size of the appropriate dynamic
8595 relocation section accordingly. At this point, the contents of the
8596 dynamic relocation sections have not yet been filled in, so there's
8597 nothing else that needs to be done. */
8600 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
8602 asection
*input_section
,
8603 Elf_Internal_Rela
*rel
)
8605 Elf_Internal_Shdr
*symtab_hdr
;
8606 struct elf_link_hash_entry
**sym_hashes
;
8607 unsigned long r_symndx
;
8609 struct elf_link_hash_entry
*h
;
8610 bfd_boolean dynamic_symbol
;
8612 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8613 sym_hashes
= elf_sym_hashes (abfd
);
8615 r_type
= ELF32_R_TYPE (rel
->r_info
);
8616 r_symndx
= ELF32_R_SYM (rel
->r_info
);
8618 if (r_symndx
< symtab_hdr
->sh_info
)
8621 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
8623 dynamic_symbol
= xtensa_elf_dynamic_symbol_p (h
, info
);
8625 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
8626 && (input_section
->flags
& SEC_ALLOC
) != 0
8627 && (dynamic_symbol
|| info
->shared
))
8630 const char *srel_name
;
8632 bfd_boolean is_plt
= FALSE
;
8634 dynobj
= elf_hash_table (info
)->dynobj
;
8635 BFD_ASSERT (dynobj
!= NULL
);
8637 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
8639 srel_name
= ".rela.plt";
8643 srel_name
= ".rela.got";
8645 /* Reduce size of the .rela.* section by one reloc. */
8646 srel
= bfd_get_section_by_name (dynobj
, srel_name
);
8647 BFD_ASSERT (srel
!= NULL
);
8648 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
8649 srel
->size
-= sizeof (Elf32_External_Rela
);
8653 asection
*splt
, *sgotplt
, *srelgot
;
8654 int reloc_index
, chunk
;
8656 /* Find the PLT reloc index of the entry being removed. This
8657 is computed from the size of ".rela.plt". It is needed to
8658 figure out which PLT chunk to resize. Usually "last index
8659 = size - 1" since the index starts at zero, but in this
8660 context, the size has just been decremented so there's no
8661 need to subtract one. */
8662 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
8664 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
8665 splt
= elf_xtensa_get_plt_section (dynobj
, chunk
);
8666 sgotplt
= elf_xtensa_get_gotplt_section (dynobj
, chunk
);
8667 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
8669 /* Check if an entire PLT chunk has just been eliminated. */
8670 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
8672 /* The two magic GOT entries for that chunk can go away. */
8673 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
8674 BFD_ASSERT (srelgot
!= NULL
);
8675 srelgot
->reloc_count
-= 2;
8676 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
8679 /* There should be only one entry left (and it will be
8681 BFD_ASSERT (sgotplt
->size
== 4);
8682 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
8685 BFD_ASSERT (sgotplt
->size
>= 4);
8686 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
8689 splt
->size
-= PLT_ENTRY_SIZE
;
8695 /* Take an r_rel and move it to another section. This usually
8696 requires extending the interal_relocation array and pinning it. If
8697 the original r_rel is from the same BFD, we can complete this here.
8698 Otherwise, we add a fix record to let the final link fix the
8699 appropriate address. Contents and internal relocations for the
8700 section must be pinned after calling this routine. */
8703 move_literal (bfd
*abfd
,
8704 struct bfd_link_info
*link_info
,
8708 xtensa_relax_info
*relax_info
,
8709 Elf_Internal_Rela
**internal_relocs_p
,
8710 const literal_value
*lit
)
8712 Elf_Internal_Rela
*new_relocs
= NULL
;
8713 size_t new_relocs_count
= 0;
8714 Elf_Internal_Rela this_rela
;
8715 const r_reloc
*r_rel
;
8717 r_rel
= &lit
->r_rel
;
8718 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
8720 if (r_reloc_is_const (r_rel
))
8721 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
8726 asection
*target_sec
;
8730 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
8731 target_sec
= r_reloc_get_section (r_rel
);
8733 /* This is the difficult case. We have to create a fix up. */
8734 this_rela
.r_offset
= offset
;
8735 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
8736 this_rela
.r_addend
=
8737 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
8738 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
8740 /* Currently, we cannot move relocations during a relocatable link. */
8741 BFD_ASSERT (!link_info
->relocatable
);
8742 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
, r_rel
->abfd
,
8743 r_reloc_get_section (r_rel
),
8744 r_rel
->target_offset
+ r_rel
->virtual_offset
,
8746 /* We also need to mark that relocations are needed here. */
8747 sec
->flags
|= SEC_RELOC
;
8749 translate_reloc_bfd_fix (fix
);
8750 /* This fix has not yet been translated. */
8753 /* Add the relocation. If we have already allocated our own
8754 space for the relocations and we have room for more, then use
8755 it. Otherwise, allocate new space and move the literals. */
8756 insert_at
= sec
->reloc_count
;
8757 for (i
= 0; i
< sec
->reloc_count
; ++i
)
8759 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
8766 if (*internal_relocs_p
!= relax_info
->allocated_relocs
8767 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
8769 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
8770 || sec
->reloc_count
== relax_info
->relocs_count
);
8772 if (relax_info
->allocated_relocs_count
== 0)
8773 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
8775 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
8777 new_relocs
= (Elf_Internal_Rela
*)
8778 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
8782 /* We could handle this more quickly by finding the split point. */
8784 memcpy (new_relocs
, *internal_relocs_p
,
8785 insert_at
* sizeof (Elf_Internal_Rela
));
8787 new_relocs
[insert_at
] = this_rela
;
8789 if (insert_at
!= sec
->reloc_count
)
8790 memcpy (new_relocs
+ insert_at
+ 1,
8791 (*internal_relocs_p
) + insert_at
,
8792 (sec
->reloc_count
- insert_at
)
8793 * sizeof (Elf_Internal_Rela
));
8795 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
8797 /* The first time we re-allocate, we can only free the
8798 old relocs if they were allocated with bfd_malloc.
8799 This is not true when keep_memory is in effect. */
8800 if (!link_info
->keep_memory
)
8801 free (*internal_relocs_p
);
8804 free (*internal_relocs_p
);
8805 relax_info
->allocated_relocs
= new_relocs
;
8806 relax_info
->allocated_relocs_count
= new_relocs_count
;
8807 elf_section_data (sec
)->relocs
= new_relocs
;
8809 relax_info
->relocs_count
= sec
->reloc_count
;
8810 *internal_relocs_p
= new_relocs
;
8814 if (insert_at
!= sec
->reloc_count
)
8817 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
8818 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
8820 (*internal_relocs_p
)[insert_at
] = this_rela
;
8822 if (relax_info
->allocated_relocs
)
8823 relax_info
->relocs_count
= sec
->reloc_count
;
8830 /* This is similar to relax_section except that when a target is moved,
8831 we shift addresses up. We also need to modify the size. This
8832 algorithm does NOT allow for relocations into the middle of the
8833 property sections. */
8836 relax_property_section (bfd
*abfd
,
8838 struct bfd_link_info
*link_info
)
8840 Elf_Internal_Rela
*internal_relocs
;
8843 bfd_boolean ok
= TRUE
;
8844 bfd_boolean is_full_prop_section
;
8845 size_t last_zfill_target_offset
= 0;
8846 asection
*last_zfill_target_sec
= NULL
;
8847 bfd_size_type sec_size
;
8849 sec_size
= bfd_get_section_limit (abfd
, sec
);
8850 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8851 link_info
->keep_memory
);
8852 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8853 if (contents
== NULL
&& sec_size
!= 0)
8859 is_full_prop_section
=
8860 ((strcmp (sec
->name
, XTENSA_PROP_SEC_NAME
) == 0)
8861 || (strncmp (sec
->name
, ".gnu.linkonce.prop.",
8862 sizeof ".gnu.linkonce.prop." - 1) == 0));
8864 if (internal_relocs
)
8866 for (i
= 0; i
< sec
->reloc_count
; i
++)
8868 Elf_Internal_Rela
*irel
;
8869 xtensa_relax_info
*target_relax_info
;
8871 asection
*target_sec
;
8873 bfd_byte
*size_p
, *flags_p
;
8875 /* Locally change the source address.
8876 Translate the target to the new target address.
8877 If it points to this section and has been removed, MOVE IT.
8878 Also, don't forget to modify the associated SIZE at
8881 irel
= &internal_relocs
[i
];
8882 r_type
= ELF32_R_TYPE (irel
->r_info
);
8883 if (r_type
== R_XTENSA_NONE
)
8886 /* Find the literal value. */
8887 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
8888 size_p
= &contents
[irel
->r_offset
+ 4];
8890 if (is_full_prop_section
)
8892 flags_p
= &contents
[irel
->r_offset
+ 8];
8893 BFD_ASSERT (irel
->r_offset
+ 12 <= sec_size
);
8896 BFD_ASSERT (irel
->r_offset
+ 8 <= sec_size
);
8898 target_sec
= r_reloc_get_section (&val
.r_rel
);
8899 target_relax_info
= get_xtensa_relax_info (target_sec
);
8901 if (target_relax_info
8902 && (target_relax_info
->is_relaxable_literal_section
8903 || target_relax_info
->is_relaxable_asm_section
))
8905 /* Translate the relocation's destination. */
8906 bfd_vma new_offset
, new_end_offset
;
8907 long old_size
, new_size
;
8909 new_offset
= offset_with_removed_text
8910 (&target_relax_info
->action_list
, val
.r_rel
.target_offset
);
8912 /* Assert that we are not out of bounds. */
8913 old_size
= bfd_get_32 (abfd
, size_p
);
8917 /* Only the first zero-sized unreachable entry is
8918 allowed to expand. In this case the new offset
8919 should be the offset before the fill and the new
8920 size is the expansion size. For other zero-sized
8921 entries the resulting size should be zero with an
8922 offset before or after the fill address depending
8923 on whether the expanding unreachable entry
8925 if (last_zfill_target_sec
8926 && last_zfill_target_sec
== target_sec
8927 && last_zfill_target_offset
== val
.r_rel
.target_offset
)
8928 new_end_offset
= new_offset
;
8931 new_end_offset
= new_offset
;
8932 new_offset
= offset_with_removed_text_before_fill
8933 (&target_relax_info
->action_list
,
8934 val
.r_rel
.target_offset
);
8936 /* If it is not unreachable and we have not yet
8937 seen an unreachable at this address, place it
8938 before the fill address. */
8940 || (bfd_get_32 (abfd
, flags_p
)
8941 & XTENSA_PROP_UNREACHABLE
) == 0)
8942 new_end_offset
= new_offset
;
8945 last_zfill_target_sec
= target_sec
;
8946 last_zfill_target_offset
= val
.r_rel
.target_offset
;
8952 new_end_offset
= offset_with_removed_text_before_fill
8953 (&target_relax_info
->action_list
,
8954 val
.r_rel
.target_offset
+ old_size
);
8957 new_size
= new_end_offset
- new_offset
;
8959 if (new_size
!= old_size
)
8961 bfd_put_32 (abfd
, new_size
, size_p
);
8962 pin_contents (sec
, contents
);
8965 if (new_offset
!= val
.r_rel
.target_offset
)
8967 bfd_vma diff
= new_offset
- val
.r_rel
.target_offset
;
8968 irel
->r_addend
+= diff
;
8969 pin_internal_relocs (sec
, internal_relocs
);
8975 /* Combine adjacent property table entries. This is also done in
8976 finish_dynamic_sections() but at that point it's too late to
8977 reclaim the space in the output section, so we do this twice. */
8979 if (internal_relocs
&& (!link_info
->relocatable
8980 || strcmp (sec
->name
, XTENSA_LIT_SEC_NAME
) == 0))
8982 Elf_Internal_Rela
*last_irel
= NULL
;
8983 int removed_bytes
= 0;
8984 bfd_vma offset
, last_irel_offset
;
8985 bfd_vma section_size
;
8986 bfd_size_type entry_size
;
8987 flagword predef_flags
;
8989 if (is_full_prop_section
)
8994 predef_flags
= xtensa_get_property_predef_flags (sec
);
8996 /* Walk over memory and irels at the same time.
8997 This REQUIRES that the internal_relocs be sorted by offset. */
8998 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8999 internal_reloc_compare
);
9000 nexti
= 0; /* Index into internal_relocs. */
9002 pin_internal_relocs (sec
, internal_relocs
);
9003 pin_contents (sec
, contents
);
9005 last_irel_offset
= (bfd_vma
) -1;
9006 section_size
= sec
->size
;
9007 BFD_ASSERT (section_size
% entry_size
== 0);
9009 for (offset
= 0; offset
< section_size
; offset
+= entry_size
)
9011 Elf_Internal_Rela
*irel
, *next_irel
;
9012 bfd_vma bytes_to_remove
, size
, actual_offset
;
9013 bfd_boolean remove_this_irel
;
9019 /* Find the next two relocations (if there are that many left),
9020 skipping over any R_XTENSA_NONE relocs. On entry, "nexti" is
9021 the starting reloc index. After these two loops, "i"
9022 is the index of the first non-NONE reloc past that starting
9023 index, and "nexti" is the index for the next non-NONE reloc
9026 for (i
= nexti
; i
< sec
->reloc_count
; i
++)
9028 if (ELF32_R_TYPE (internal_relocs
[i
].r_info
) != R_XTENSA_NONE
)
9030 irel
= &internal_relocs
[i
];
9033 internal_relocs
[i
].r_offset
-= removed_bytes
;
9036 for (nexti
= i
+ 1; nexti
< sec
->reloc_count
; nexti
++)
9038 if (ELF32_R_TYPE (internal_relocs
[nexti
].r_info
)
9041 next_irel
= &internal_relocs
[nexti
];
9044 internal_relocs
[nexti
].r_offset
-= removed_bytes
;
9047 remove_this_irel
= FALSE
;
9048 bytes_to_remove
= 0;
9049 actual_offset
= offset
- removed_bytes
;
9050 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
9052 if (is_full_prop_section
)
9053 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
9055 flags
= predef_flags
;
9057 /* Check that the irels are sorted by offset,
9058 with only one per address. */
9059 BFD_ASSERT (!irel
|| (int) irel
->r_offset
> (int) last_irel_offset
);
9060 BFD_ASSERT (!next_irel
|| next_irel
->r_offset
> irel
->r_offset
);
9062 /* Make sure there aren't relocs on the size or flag fields. */
9063 if ((irel
&& irel
->r_offset
== offset
+ 4)
9064 || (is_full_prop_section
9065 && irel
&& irel
->r_offset
== offset
+ 8))
9067 irel
->r_offset
-= removed_bytes
;
9068 last_irel_offset
= irel
->r_offset
;
9070 else if (next_irel
&& (next_irel
->r_offset
== offset
+ 4
9071 || (is_full_prop_section
9072 && next_irel
->r_offset
== offset
+ 8)))
9075 irel
->r_offset
-= removed_bytes
;
9076 next_irel
->r_offset
-= removed_bytes
;
9077 last_irel_offset
= next_irel
->r_offset
;
9079 else if (size
== 0 && (flags
& XTENSA_PROP_ALIGN
) == 0
9080 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
9082 /* Always remove entries with zero size and no alignment. */
9083 bytes_to_remove
= entry_size
;
9084 if (irel
&& irel
->r_offset
== offset
)
9086 remove_this_irel
= TRUE
;
9088 irel
->r_offset
-= removed_bytes
;
9089 last_irel_offset
= irel
->r_offset
;
9092 else if (irel
&& irel
->r_offset
== offset
)
9094 if (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
)
9100 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
9101 bfd_vma old_address
=
9102 (last_irel
->r_addend
9103 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
9104 bfd_vma new_address
=
9106 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
9107 if (is_full_prop_section
)
9108 old_flags
= bfd_get_32
9109 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
9111 old_flags
= predef_flags
;
9113 if ((ELF32_R_SYM (irel
->r_info
)
9114 == ELF32_R_SYM (last_irel
->r_info
))
9115 && old_address
+ old_size
== new_address
9116 && old_flags
== flags
9117 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
9118 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
9120 /* Fix the old size. */
9121 bfd_put_32 (abfd
, old_size
+ size
,
9122 &contents
[last_irel
->r_offset
+ 4]);
9123 bytes_to_remove
= entry_size
;
9124 remove_this_irel
= TRUE
;
9133 irel
->r_offset
-= removed_bytes
;
9134 last_irel_offset
= irel
->r_offset
;
9137 if (remove_this_irel
)
9139 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9140 irel
->r_offset
-= bytes_to_remove
;
9143 if (bytes_to_remove
!= 0)
9145 removed_bytes
+= bytes_to_remove
;
9146 if (offset
+ bytes_to_remove
< section_size
)
9147 memmove (&contents
[actual_offset
],
9148 &contents
[actual_offset
+ bytes_to_remove
],
9149 section_size
- offset
- bytes_to_remove
);
9155 /* Clear the removed bytes. */
9156 memset (&contents
[section_size
- removed_bytes
], 0, removed_bytes
);
9158 sec
->size
= section_size
- removed_bytes
;
9160 if (xtensa_is_littable_section (sec
))
9162 bfd
*dynobj
= elf_hash_table (link_info
)->dynobj
;
9166 bfd_get_section_by_name (dynobj
, ".got.loc");
9168 sgotloc
->size
-= removed_bytes
;
9175 release_internal_relocs (sec
, internal_relocs
);
9176 release_contents (sec
, contents
);
9181 /* Third relaxation pass. */
9183 /* Change symbol values to account for removed literals. */
9186 relax_section_symbols (bfd
*abfd
, asection
*sec
)
9188 xtensa_relax_info
*relax_info
;
9189 unsigned int sec_shndx
;
9190 Elf_Internal_Shdr
*symtab_hdr
;
9191 Elf_Internal_Sym
*isymbuf
;
9192 unsigned i
, num_syms
, num_locals
;
9194 relax_info
= get_xtensa_relax_info (sec
);
9195 BFD_ASSERT (relax_info
);
9197 if (!relax_info
->is_relaxable_literal_section
9198 && !relax_info
->is_relaxable_asm_section
)
9201 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
9203 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
9204 isymbuf
= retrieve_local_syms (abfd
);
9206 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
9207 num_locals
= symtab_hdr
->sh_info
;
9209 /* Adjust the local symbols defined in this section. */
9210 for (i
= 0; i
< num_locals
; i
++)
9212 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
9214 if (isym
->st_shndx
== sec_shndx
)
9216 bfd_vma new_address
= offset_with_removed_text
9217 (&relax_info
->action_list
, isym
->st_value
);
9218 bfd_vma new_size
= isym
->st_size
;
9220 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
9222 bfd_vma new_end
= offset_with_removed_text
9223 (&relax_info
->action_list
, isym
->st_value
+ isym
->st_size
);
9224 new_size
= new_end
- new_address
;
9227 isym
->st_value
= new_address
;
9228 isym
->st_size
= new_size
;
9232 /* Now adjust the global symbols defined in this section. */
9233 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
9235 struct elf_link_hash_entry
*sym_hash
;
9237 sym_hash
= elf_sym_hashes (abfd
)[i
];
9239 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
9240 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
9242 if ((sym_hash
->root
.type
== bfd_link_hash_defined
9243 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
9244 && sym_hash
->root
.u
.def
.section
== sec
)
9246 bfd_vma new_address
= offset_with_removed_text
9247 (&relax_info
->action_list
, sym_hash
->root
.u
.def
.value
);
9248 bfd_vma new_size
= sym_hash
->size
;
9250 if (sym_hash
->type
== STT_FUNC
)
9252 bfd_vma new_end
= offset_with_removed_text
9253 (&relax_info
->action_list
,
9254 sym_hash
->root
.u
.def
.value
+ sym_hash
->size
);
9255 new_size
= new_end
- new_address
;
9258 sym_hash
->root
.u
.def
.value
= new_address
;
9259 sym_hash
->size
= new_size
;
9267 /* "Fix" handling functions, called while performing relocations. */
9270 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
9272 asection
*input_section
,
9276 asection
*sec
, *old_sec
;
9278 int r_type
= ELF32_R_TYPE (rel
->r_info
);
9281 if (r_type
== R_XTENSA_NONE
)
9284 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
9288 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
9289 bfd_get_section_limit (input_bfd
, input_section
));
9290 old_sec
= r_reloc_get_section (&r_rel
);
9291 old_offset
= r_rel
.target_offset
;
9293 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
9295 if (r_type
!= R_XTENSA_ASM_EXPAND
)
9297 (*_bfd_error_handler
)
9298 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
9299 input_bfd
, input_section
, rel
->r_offset
,
9300 elf_howto_table
[r_type
].name
);
9303 /* Leave it be. Resolution will happen in a later stage. */
9307 sec
= fix
->target_sec
;
9308 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
9309 - (old_sec
->output_offset
+ old_offset
));
9316 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
9318 asection
*input_section
,
9320 bfd_vma
*relocationp
)
9323 int r_type
= ELF32_R_TYPE (rel
->r_info
);
9327 if (r_type
== R_XTENSA_NONE
)
9330 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
9334 sec
= fix
->target_sec
;
9336 fixup_diff
= rel
->r_addend
;
9337 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
9339 bfd_vma inplace_val
;
9340 BFD_ASSERT (fix
->src_offset
9341 < bfd_get_section_limit (input_bfd
, input_section
));
9342 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
9343 fixup_diff
+= inplace_val
;
9346 *relocationp
= (sec
->output_section
->vma
9347 + sec
->output_offset
9348 + fix
->target_offset
- fixup_diff
);
9352 /* Miscellaneous utility functions.... */
9355 elf_xtensa_get_plt_section (bfd
*dynobj
, int chunk
)
9360 return bfd_get_section_by_name (dynobj
, ".plt");
9362 sprintf (plt_name
, ".plt.%u", chunk
);
9363 return bfd_get_section_by_name (dynobj
, plt_name
);
9368 elf_xtensa_get_gotplt_section (bfd
*dynobj
, int chunk
)
9373 return bfd_get_section_by_name (dynobj
, ".got.plt");
9375 sprintf (got_name
, ".got.plt.%u", chunk
);
9376 return bfd_get_section_by_name (dynobj
, got_name
);
9380 /* Get the input section for a given symbol index.
9382 . a section symbol, return the section;
9383 . a common symbol, return the common section;
9384 . an undefined symbol, return the undefined section;
9385 . an indirect symbol, follow the links;
9386 . an absolute value, return the absolute section. */
9389 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
9391 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
9392 asection
*target_sec
= NULL
;
9393 if (r_symndx
< symtab_hdr
->sh_info
)
9395 Elf_Internal_Sym
*isymbuf
;
9396 unsigned int section_index
;
9398 isymbuf
= retrieve_local_syms (abfd
);
9399 section_index
= isymbuf
[r_symndx
].st_shndx
;
9401 if (section_index
== SHN_UNDEF
)
9402 target_sec
= bfd_und_section_ptr
;
9403 else if (section_index
> 0 && section_index
< SHN_LORESERVE
)
9404 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
9405 else if (section_index
== SHN_ABS
)
9406 target_sec
= bfd_abs_section_ptr
;
9407 else if (section_index
== SHN_COMMON
)
9408 target_sec
= bfd_com_section_ptr
;
9415 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
9416 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
9418 while (h
->root
.type
== bfd_link_hash_indirect
9419 || h
->root
.type
== bfd_link_hash_warning
)
9420 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9422 switch (h
->root
.type
)
9424 case bfd_link_hash_defined
:
9425 case bfd_link_hash_defweak
:
9426 target_sec
= h
->root
.u
.def
.section
;
9428 case bfd_link_hash_common
:
9429 target_sec
= bfd_com_section_ptr
;
9431 case bfd_link_hash_undefined
:
9432 case bfd_link_hash_undefweak
:
9433 target_sec
= bfd_und_section_ptr
;
9435 default: /* New indirect warning. */
9436 target_sec
= bfd_und_section_ptr
;
9444 static struct elf_link_hash_entry
*
9445 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
9448 struct elf_link_hash_entry
*h
;
9449 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
9451 if (r_symndx
< symtab_hdr
->sh_info
)
9454 indx
= r_symndx
- symtab_hdr
->sh_info
;
9455 h
= elf_sym_hashes (abfd
)[indx
];
9456 while (h
->root
.type
== bfd_link_hash_indirect
9457 || h
->root
.type
== bfd_link_hash_warning
)
9458 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9463 /* Get the section-relative offset for a symbol number. */
9466 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
9468 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
9471 if (r_symndx
< symtab_hdr
->sh_info
)
9473 Elf_Internal_Sym
*isymbuf
;
9474 isymbuf
= retrieve_local_syms (abfd
);
9475 offset
= isymbuf
[r_symndx
].st_value
;
9479 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
9480 struct elf_link_hash_entry
*h
=
9481 elf_sym_hashes (abfd
)[indx
];
9483 while (h
->root
.type
== bfd_link_hash_indirect
9484 || h
->root
.type
== bfd_link_hash_warning
)
9485 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
9486 if (h
->root
.type
== bfd_link_hash_defined
9487 || h
->root
.type
== bfd_link_hash_defweak
)
9488 offset
= h
->root
.u
.def
.value
;
9495 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
9497 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
9498 struct elf_link_hash_entry
*h
;
9500 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
9501 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
9508 pcrel_reloc_fits (xtensa_opcode opc
,
9510 bfd_vma self_address
,
9511 bfd_vma dest_address
)
9513 xtensa_isa isa
= xtensa_default_isa
;
9514 uint32 valp
= dest_address
;
9515 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
9516 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
9522 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
9523 static int insn_sec_len
= sizeof (XTENSA_INSN_SEC_NAME
) - 1;
9524 static int lit_sec_len
= sizeof (XTENSA_LIT_SEC_NAME
) - 1;
9525 static int prop_sec_len
= sizeof (XTENSA_PROP_SEC_NAME
) - 1;
9529 xtensa_is_property_section (asection
*sec
)
9531 if (strncmp (XTENSA_INSN_SEC_NAME
, sec
->name
, insn_sec_len
) == 0
9532 || strncmp (XTENSA_LIT_SEC_NAME
, sec
->name
, lit_sec_len
) == 0
9533 || strncmp (XTENSA_PROP_SEC_NAME
, sec
->name
, prop_sec_len
) == 0)
9536 if (strncmp (".gnu.linkonce.", sec
->name
, linkonce_len
) == 0
9537 && (strncmp (&sec
->name
[linkonce_len
], "x.", 2) == 0
9538 || strncmp (&sec
->name
[linkonce_len
], "p.", 2) == 0
9539 || strncmp (&sec
->name
[linkonce_len
], "prop.", 5) == 0))
9547 xtensa_is_littable_section (asection
*sec
)
9549 if (strncmp (XTENSA_LIT_SEC_NAME
, sec
->name
, lit_sec_len
) == 0)
9552 if (strncmp (".gnu.linkonce.", sec
->name
, linkonce_len
) == 0
9553 && sec
->name
[linkonce_len
] == 'p'
9554 && sec
->name
[linkonce_len
+ 1] == '.')
9562 internal_reloc_compare (const void *ap
, const void *bp
)
9564 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
9565 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
9567 if (a
->r_offset
!= b
->r_offset
)
9568 return (a
->r_offset
- b
->r_offset
);
9570 /* We don't need to sort on these criteria for correctness,
9571 but enforcing a more strict ordering prevents unstable qsort
9572 from behaving differently with different implementations.
9573 Without the code below we get correct but different results
9574 on Solaris 2.7 and 2.8. We would like to always produce the
9575 same results no matter the host. */
9577 if (a
->r_info
!= b
->r_info
)
9578 return (a
->r_info
- b
->r_info
);
9580 return (a
->r_addend
- b
->r_addend
);
9585 internal_reloc_matches (const void *ap
, const void *bp
)
9587 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
9588 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
9590 /* Check if one entry overlaps with the other; this shouldn't happen
9591 except when searching for a match. */
9592 return (a
->r_offset
- b
->r_offset
);
9597 xtensa_get_property_section_name (asection
*sec
, const char *base_name
)
9599 if (strncmp (sec
->name
, ".gnu.linkonce.", linkonce_len
) == 0)
9601 char *prop_sec_name
;
9603 char *linkonce_kind
= 0;
9605 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
9606 linkonce_kind
= "x.";
9607 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
9608 linkonce_kind
= "p.";
9609 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
9610 linkonce_kind
= "prop.";
9614 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
9615 + strlen (linkonce_kind
) + 1);
9616 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
9617 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
9619 suffix
= sec
->name
+ linkonce_len
;
9620 /* For backward compatibility, replace "t." instead of inserting
9621 the new linkonce_kind (but not for "prop" sections). */
9622 if (strncmp (suffix
, "t.", 2) == 0 && linkonce_kind
[1] == '.')
9624 strcat (prop_sec_name
+ linkonce_len
, suffix
);
9626 return prop_sec_name
;
9629 return strdup (base_name
);
9634 xtensa_get_property_predef_flags (asection
*sec
)
9636 if (strcmp (sec
->name
, XTENSA_INSN_SEC_NAME
) == 0
9637 || strncmp (sec
->name
, ".gnu.linkonce.x.",
9638 sizeof ".gnu.linkonce.x." - 1) == 0)
9639 return (XTENSA_PROP_INSN
9640 | XTENSA_PROP_INSN_NO_TRANSFORM
9641 | XTENSA_PROP_INSN_NO_REORDER
);
9643 if (xtensa_is_littable_section (sec
))
9644 return (XTENSA_PROP_LITERAL
9645 | XTENSA_PROP_INSN_NO_TRANSFORM
9646 | XTENSA_PROP_INSN_NO_REORDER
);
9652 /* Other functions called directly by the linker. */
9655 xtensa_callback_required_dependence (bfd
*abfd
,
9657 struct bfd_link_info
*link_info
,
9658 deps_callback_t callback
,
9661 Elf_Internal_Rela
*internal_relocs
;
9664 bfd_boolean ok
= TRUE
;
9665 bfd_size_type sec_size
;
9667 sec_size
= bfd_get_section_limit (abfd
, sec
);
9669 /* ".plt*" sections have no explicit relocations but they contain L32R
9670 instructions that reference the corresponding ".got.plt*" sections. */
9671 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
9672 && strncmp (sec
->name
, ".plt", 4) == 0)
9676 /* Find the corresponding ".got.plt*" section. */
9677 if (sec
->name
[4] == '\0')
9678 sgotplt
= bfd_get_section_by_name (sec
->owner
, ".got.plt");
9684 BFD_ASSERT (sec
->name
[4] == '.');
9685 chunk
= strtol (&sec
->name
[5], NULL
, 10);
9687 sprintf (got_name
, ".got.plt.%u", chunk
);
9688 sgotplt
= bfd_get_section_by_name (sec
->owner
, got_name
);
9690 BFD_ASSERT (sgotplt
);
9692 /* Assume worst-case offsets: L32R at the very end of the ".plt"
9693 section referencing a literal at the very beginning of
9694 ".got.plt". This is very close to the real dependence, anyway. */
9695 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
9698 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9699 link_info
->keep_memory
);
9700 if (internal_relocs
== NULL
9701 || sec
->reloc_count
== 0)
9704 /* Cache the contents for the duration of this scan. */
9705 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9706 if (contents
== NULL
&& sec_size
!= 0)
9712 if (!xtensa_default_isa
)
9713 xtensa_default_isa
= xtensa_isa_init (0, 0);
9715 for (i
= 0; i
< sec
->reloc_count
; i
++)
9717 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
9718 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
9721 asection
*target_sec
;
9722 bfd_vma target_offset
;
9724 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
9727 /* L32Rs must be local to the input file. */
9728 if (r_reloc_is_defined (&l32r_rel
))
9730 target_sec
= r_reloc_get_section (&l32r_rel
);
9731 target_offset
= l32r_rel
.target_offset
;
9733 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
9739 release_internal_relocs (sec
, internal_relocs
);
9740 release_contents (sec
, contents
);
9744 /* The default literal sections should always be marked as "code" (i.e.,
9745 SHF_EXECINSTR). This is particularly important for the Linux kernel
9746 module loader so that the literals are not placed after the text. */
9747 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
9749 { ".fini.literal", 13, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
9750 { ".init.literal", 13, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
9751 { ".literal", 8, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
9752 { NULL
, 0, 0, 0, 0 }
9756 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
9757 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
9758 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
9759 #define TARGET_BIG_NAME "elf32-xtensa-be"
9760 #define ELF_ARCH bfd_arch_xtensa
9762 #define ELF_MACHINE_CODE EM_XTENSA
9763 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
9766 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
9767 #else /* !XCHAL_HAVE_MMU */
9768 #define ELF_MAXPAGESIZE 1
9769 #endif /* !XCHAL_HAVE_MMU */
9770 #endif /* ELF_ARCH */
9772 #define elf_backend_can_gc_sections 1
9773 #define elf_backend_can_refcount 1
9774 #define elf_backend_plt_readonly 1
9775 #define elf_backend_got_header_size 4
9776 #define elf_backend_want_dynbss 0
9777 #define elf_backend_want_got_plt 1
9779 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
9781 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
9782 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
9783 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
9784 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
9785 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
9786 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
9788 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
9789 #define elf_backend_check_relocs elf_xtensa_check_relocs
9790 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
9791 #define elf_backend_discard_info elf_xtensa_discard_info
9792 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
9793 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
9794 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
9795 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
9796 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
9797 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
9798 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
9799 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
9800 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
9801 #define elf_backend_object_p elf_xtensa_object_p
9802 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
9803 #define elf_backend_relocate_section elf_xtensa_relocate_section
9804 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
9805 #define elf_backend_special_sections elf_xtensa_special_sections
9807 #include "elf32-target.h"