1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright (C) 2003-2019 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 3 of the
9 License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
30 #include "elf/xtensa.h"
31 #include "splay-tree.h"
32 #include "xtensa-isa.h"
33 #include "xtensa-config.h"
35 #define XTENSA_NO_NOP_REMOVAL 0
37 /* Local helper functions. */
39 static bfd_boolean
add_extra_plt_sections (struct bfd_link_info
*, int);
40 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
41 static bfd_reloc_status_type bfd_elf_xtensa_reloc
42 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
43 static bfd_boolean do_fix_for_relocatable_link
44 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*);
45 static void do_fix_for_final_link
46 (Elf_Internal_Rela
*, bfd
*, asection
*, bfd_byte
*, bfd_vma
*);
48 /* Local functions to handle Xtensa configurability. */
50 static bfd_boolean
is_indirect_call_opcode (xtensa_opcode
);
51 static bfd_boolean
is_direct_call_opcode (xtensa_opcode
);
52 static bfd_boolean
is_windowed_call_opcode (xtensa_opcode
);
53 static xtensa_opcode
get_const16_opcode (void);
54 static xtensa_opcode
get_l32r_opcode (void);
55 static bfd_vma
l32r_offset (bfd_vma
, bfd_vma
);
56 static int get_relocation_opnd (xtensa_opcode
, int);
57 static int get_relocation_slot (int);
58 static xtensa_opcode get_relocation_opcode
59 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
60 static bfd_boolean is_l32r_relocation
61 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*);
62 static bfd_boolean
is_alt_relocation (int);
63 static bfd_boolean
is_operand_relocation (int);
64 static bfd_size_type insn_decode_len
65 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
66 static int insn_num_slots
67 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
68 static xtensa_opcode insn_decode_opcode
69 (bfd_byte
*, bfd_size_type
, bfd_size_type
, int);
70 static bfd_boolean check_branch_target_aligned
71 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
72 static bfd_boolean check_loop_aligned
73 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_vma
);
74 static bfd_boolean
check_branch_target_aligned_address (bfd_vma
, int);
75 static bfd_size_type get_asm_simplify_size
76 (bfd_byte
*, bfd_size_type
, bfd_size_type
);
78 /* Functions for link-time code simplifications. */
80 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
81 (bfd_byte
*, bfd_vma
, bfd_vma
, char **);
82 static bfd_reloc_status_type contract_asm_expansion
83 (bfd_byte
*, bfd_vma
, Elf_Internal_Rela
*, char **);
84 static xtensa_opcode
swap_callx_for_call_opcode (xtensa_opcode
);
85 static xtensa_opcode
get_expanded_call_opcode (bfd_byte
*, int, bfd_boolean
*);
87 /* Access to internal relocations, section contents and symbols. */
89 static Elf_Internal_Rela
*retrieve_internal_relocs
90 (bfd
*, asection
*, bfd_boolean
);
91 static void pin_internal_relocs (asection
*, Elf_Internal_Rela
*);
92 static void release_internal_relocs (asection
*, Elf_Internal_Rela
*);
93 static bfd_byte
*retrieve_contents (bfd
*, asection
*, bfd_boolean
);
94 static void pin_contents (asection
*, bfd_byte
*);
95 static void release_contents (asection
*, bfd_byte
*);
96 static Elf_Internal_Sym
*retrieve_local_syms (bfd
*);
98 /* Miscellaneous utility functions. */
100 static asection
*elf_xtensa_get_plt_section (struct bfd_link_info
*, int);
101 static asection
*elf_xtensa_get_gotplt_section (struct bfd_link_info
*, int);
102 static asection
*get_elf_r_symndx_section (bfd
*, unsigned long);
103 static struct elf_link_hash_entry
*get_elf_r_symndx_hash_entry
104 (bfd
*, unsigned long);
105 static bfd_vma
get_elf_r_symndx_offset (bfd
*, unsigned long);
106 static bfd_boolean
is_reloc_sym_weak (bfd
*, Elf_Internal_Rela
*);
107 static bfd_boolean
pcrel_reloc_fits (xtensa_opcode
, int, bfd_vma
, bfd_vma
);
108 static bfd_boolean
xtensa_is_property_section (asection
*);
109 static bfd_boolean
xtensa_is_insntable_section (asection
*);
110 static bfd_boolean
xtensa_is_littable_section (asection
*);
111 static bfd_boolean
xtensa_is_proptable_section (asection
*);
112 static int internal_reloc_compare (const void *, const void *);
113 static int internal_reloc_matches (const void *, const void *);
114 static asection
*xtensa_get_property_section (asection
*, const char *);
115 static flagword
xtensa_get_property_predef_flags (asection
*);
117 /* Other functions called directly by the linker. */
119 typedef void (*deps_callback_t
)
120 (asection
*, bfd_vma
, asection
*, bfd_vma
, void *);
121 extern bfd_boolean xtensa_callback_required_dependence
122 (bfd
*, asection
*, struct bfd_link_info
*, deps_callback_t
, void *);
125 /* Globally visible flag for choosing size optimization of NOP removal
126 instead of branch-target-aware minimization for NOP removal.
127 When nonzero, narrow all instructions and remove all NOPs possible
128 around longcall expansions. */
130 int elf32xtensa_size_opt
;
133 /* The "new_section_hook" is used to set up a per-section
134 "xtensa_relax_info" data structure with additional information used
135 during relaxation. */
137 typedef struct xtensa_relax_info_struct xtensa_relax_info
;
140 /* The GNU tools do not easily allow extending interfaces to pass around
141 the pointer to the Xtensa ISA information, so instead we add a global
142 variable here (in BFD) that can be used by any of the tools that need
145 xtensa_isa xtensa_default_isa
;
148 /* When this is true, relocations may have been modified to refer to
149 symbols from other input files. The per-section list of "fix"
150 records needs to be checked when resolving relocations. */
152 static bfd_boolean relaxing_section
= FALSE
;
154 /* When this is true, during final links, literals that cannot be
155 coalesced and their relocations may be moved to other sections. */
157 int elf32xtensa_no_literal_movement
= 1;
159 /* Place property records for a section into individual property section
160 with xt.prop. prefix. */
162 bfd_boolean elf32xtensa_separate_props
= FALSE
;
164 /* Rename one of the generic section flags to better document how it
166 /* Whether relocations have been processed. */
167 #define reloc_done sec_flg0
169 static reloc_howto_type elf_howto_table
[] =
171 HOWTO (R_XTENSA_NONE
, 0, 3, 0, FALSE
, 0, complain_overflow_dont
,
172 bfd_elf_xtensa_reloc
, "R_XTENSA_NONE",
174 HOWTO (R_XTENSA_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
175 bfd_elf_xtensa_reloc
, "R_XTENSA_32",
176 TRUE
, 0xffffffff, 0xffffffff, FALSE
),
178 /* Replace a 32-bit value with a value from the runtime linker (only
179 used by linker-generated stub functions). The r_addend value is
180 special: 1 means to substitute a pointer to the runtime linker's
181 dynamic resolver function; 2 means to substitute the link map for
182 the shared object. */
183 HOWTO (R_XTENSA_RTLD
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
184 NULL
, "R_XTENSA_RTLD", FALSE
, 0, 0, FALSE
),
186 HOWTO (R_XTENSA_GLOB_DAT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
187 bfd_elf_generic_reloc
, "R_XTENSA_GLOB_DAT",
188 FALSE
, 0, 0xffffffff, FALSE
),
189 HOWTO (R_XTENSA_JMP_SLOT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
190 bfd_elf_generic_reloc
, "R_XTENSA_JMP_SLOT",
191 FALSE
, 0, 0xffffffff, FALSE
),
192 HOWTO (R_XTENSA_RELATIVE
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
193 bfd_elf_generic_reloc
, "R_XTENSA_RELATIVE",
194 FALSE
, 0, 0xffffffff, FALSE
),
195 HOWTO (R_XTENSA_PLT
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
,
196 bfd_elf_xtensa_reloc
, "R_XTENSA_PLT",
197 FALSE
, 0, 0xffffffff, FALSE
),
201 /* Old relocations for backward compatibility. */
202 HOWTO (R_XTENSA_OP0
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
203 bfd_elf_xtensa_reloc
, "R_XTENSA_OP0", FALSE
, 0, 0, TRUE
),
204 HOWTO (R_XTENSA_OP1
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
205 bfd_elf_xtensa_reloc
, "R_XTENSA_OP1", FALSE
, 0, 0, TRUE
),
206 HOWTO (R_XTENSA_OP2
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
207 bfd_elf_xtensa_reloc
, "R_XTENSA_OP2", FALSE
, 0, 0, TRUE
),
209 /* Assembly auto-expansion. */
210 HOWTO (R_XTENSA_ASM_EXPAND
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
211 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_EXPAND", FALSE
, 0, 0, TRUE
),
212 /* Relax assembly auto-expansion. */
213 HOWTO (R_XTENSA_ASM_SIMPLIFY
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
214 bfd_elf_xtensa_reloc
, "R_XTENSA_ASM_SIMPLIFY", FALSE
, 0, 0, TRUE
),
218 HOWTO (R_XTENSA_32_PCREL
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
,
219 bfd_elf_xtensa_reloc
, "R_XTENSA_32_PCREL",
220 FALSE
, 0, 0xffffffff, TRUE
),
222 /* GNU extension to record C++ vtable hierarchy. */
223 HOWTO (R_XTENSA_GNU_VTINHERIT
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
224 NULL
, "R_XTENSA_GNU_VTINHERIT",
226 /* GNU extension to record C++ vtable member usage. */
227 HOWTO (R_XTENSA_GNU_VTENTRY
, 0, 2, 0, FALSE
, 0, complain_overflow_dont
,
228 _bfd_elf_rel_vtable_reloc_fn
, "R_XTENSA_GNU_VTENTRY",
231 /* Relocations for supporting difference of symbols. */
232 HOWTO (R_XTENSA_DIFF8
, 0, 0, 8, FALSE
, 0, complain_overflow_signed
,
233 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF8", FALSE
, 0, 0xff, FALSE
),
234 HOWTO (R_XTENSA_DIFF16
, 0, 1, 16, FALSE
, 0, complain_overflow_signed
,
235 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF16", FALSE
, 0, 0xffff, FALSE
),
236 HOWTO (R_XTENSA_DIFF32
, 0, 2, 32, FALSE
, 0, complain_overflow_signed
,
237 bfd_elf_xtensa_reloc
, "R_XTENSA_DIFF32", FALSE
, 0, 0xffffffff, FALSE
),
239 /* General immediate operand relocations. */
240 HOWTO (R_XTENSA_SLOT0_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
241 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_OP", FALSE
, 0, 0, TRUE
),
242 HOWTO (R_XTENSA_SLOT1_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
243 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_OP", FALSE
, 0, 0, TRUE
),
244 HOWTO (R_XTENSA_SLOT2_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
245 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_OP", FALSE
, 0, 0, TRUE
),
246 HOWTO (R_XTENSA_SLOT3_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
247 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_OP", FALSE
, 0, 0, TRUE
),
248 HOWTO (R_XTENSA_SLOT4_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
249 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_OP", FALSE
, 0, 0, TRUE
),
250 HOWTO (R_XTENSA_SLOT5_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
251 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_OP", FALSE
, 0, 0, TRUE
),
252 HOWTO (R_XTENSA_SLOT6_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
253 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_OP", FALSE
, 0, 0, TRUE
),
254 HOWTO (R_XTENSA_SLOT7_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
255 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_OP", FALSE
, 0, 0, TRUE
),
256 HOWTO (R_XTENSA_SLOT8_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
257 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_OP", FALSE
, 0, 0, TRUE
),
258 HOWTO (R_XTENSA_SLOT9_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
259 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_OP", FALSE
, 0, 0, TRUE
),
260 HOWTO (R_XTENSA_SLOT10_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
261 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_OP", FALSE
, 0, 0, TRUE
),
262 HOWTO (R_XTENSA_SLOT11_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
263 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_OP", FALSE
, 0, 0, TRUE
),
264 HOWTO (R_XTENSA_SLOT12_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
265 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_OP", FALSE
, 0, 0, TRUE
),
266 HOWTO (R_XTENSA_SLOT13_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
267 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_OP", FALSE
, 0, 0, TRUE
),
268 HOWTO (R_XTENSA_SLOT14_OP
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
269 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_OP", FALSE
, 0, 0, TRUE
),
271 /* "Alternate" relocations. The meaning of these is opcode-specific. */
272 HOWTO (R_XTENSA_SLOT0_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
273 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT0_ALT", FALSE
, 0, 0, TRUE
),
274 HOWTO (R_XTENSA_SLOT1_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
275 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT1_ALT", FALSE
, 0, 0, TRUE
),
276 HOWTO (R_XTENSA_SLOT2_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
277 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT2_ALT", FALSE
, 0, 0, TRUE
),
278 HOWTO (R_XTENSA_SLOT3_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
279 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT3_ALT", FALSE
, 0, 0, TRUE
),
280 HOWTO (R_XTENSA_SLOT4_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
281 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT4_ALT", FALSE
, 0, 0, TRUE
),
282 HOWTO (R_XTENSA_SLOT5_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
283 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT5_ALT", FALSE
, 0, 0, TRUE
),
284 HOWTO (R_XTENSA_SLOT6_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
285 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT6_ALT", FALSE
, 0, 0, TRUE
),
286 HOWTO (R_XTENSA_SLOT7_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
287 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT7_ALT", FALSE
, 0, 0, TRUE
),
288 HOWTO (R_XTENSA_SLOT8_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
289 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT8_ALT", FALSE
, 0, 0, TRUE
),
290 HOWTO (R_XTENSA_SLOT9_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
291 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT9_ALT", FALSE
, 0, 0, TRUE
),
292 HOWTO (R_XTENSA_SLOT10_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
293 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT10_ALT", FALSE
, 0, 0, TRUE
),
294 HOWTO (R_XTENSA_SLOT11_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
295 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT11_ALT", FALSE
, 0, 0, TRUE
),
296 HOWTO (R_XTENSA_SLOT12_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
297 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT12_ALT", FALSE
, 0, 0, TRUE
),
298 HOWTO (R_XTENSA_SLOT13_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
299 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT13_ALT", FALSE
, 0, 0, TRUE
),
300 HOWTO (R_XTENSA_SLOT14_ALT
, 0, 0, 0, TRUE
, 0, complain_overflow_dont
,
301 bfd_elf_xtensa_reloc
, "R_XTENSA_SLOT14_ALT", FALSE
, 0, 0, TRUE
),
303 /* TLS relocations. */
304 HOWTO (R_XTENSA_TLSDESC_FN
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
305 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_FN",
306 FALSE
, 0, 0xffffffff, FALSE
),
307 HOWTO (R_XTENSA_TLSDESC_ARG
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
308 bfd_elf_xtensa_reloc
, "R_XTENSA_TLSDESC_ARG",
309 FALSE
, 0, 0xffffffff, FALSE
),
310 HOWTO (R_XTENSA_TLS_DTPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
311 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_DTPOFF",
312 FALSE
, 0, 0xffffffff, FALSE
),
313 HOWTO (R_XTENSA_TLS_TPOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_dont
,
314 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_TPOFF",
315 FALSE
, 0, 0xffffffff, FALSE
),
316 HOWTO (R_XTENSA_TLS_FUNC
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
317 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_FUNC",
319 HOWTO (R_XTENSA_TLS_ARG
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
320 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_ARG",
322 HOWTO (R_XTENSA_TLS_CALL
, 0, 0, 0, FALSE
, 0, complain_overflow_dont
,
323 bfd_elf_xtensa_reloc
, "R_XTENSA_TLS_CALL",
329 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
334 static reloc_howto_type
*
335 elf_xtensa_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
336 bfd_reloc_code_real_type code
)
341 TRACE ("BFD_RELOC_NONE");
342 return &elf_howto_table
[(unsigned) R_XTENSA_NONE
];
345 TRACE ("BFD_RELOC_32");
346 return &elf_howto_table
[(unsigned) R_XTENSA_32
];
348 case BFD_RELOC_32_PCREL
:
349 TRACE ("BFD_RELOC_32_PCREL");
350 return &elf_howto_table
[(unsigned) R_XTENSA_32_PCREL
];
352 case BFD_RELOC_XTENSA_DIFF8
:
353 TRACE ("BFD_RELOC_XTENSA_DIFF8");
354 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF8
];
356 case BFD_RELOC_XTENSA_DIFF16
:
357 TRACE ("BFD_RELOC_XTENSA_DIFF16");
358 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF16
];
360 case BFD_RELOC_XTENSA_DIFF32
:
361 TRACE ("BFD_RELOC_XTENSA_DIFF32");
362 return &elf_howto_table
[(unsigned) R_XTENSA_DIFF32
];
364 case BFD_RELOC_XTENSA_RTLD
:
365 TRACE ("BFD_RELOC_XTENSA_RTLD");
366 return &elf_howto_table
[(unsigned) R_XTENSA_RTLD
];
368 case BFD_RELOC_XTENSA_GLOB_DAT
:
369 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
370 return &elf_howto_table
[(unsigned) R_XTENSA_GLOB_DAT
];
372 case BFD_RELOC_XTENSA_JMP_SLOT
:
373 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
374 return &elf_howto_table
[(unsigned) R_XTENSA_JMP_SLOT
];
376 case BFD_RELOC_XTENSA_RELATIVE
:
377 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
378 return &elf_howto_table
[(unsigned) R_XTENSA_RELATIVE
];
380 case BFD_RELOC_XTENSA_PLT
:
381 TRACE ("BFD_RELOC_XTENSA_PLT");
382 return &elf_howto_table
[(unsigned) R_XTENSA_PLT
];
384 case BFD_RELOC_XTENSA_OP0
:
385 TRACE ("BFD_RELOC_XTENSA_OP0");
386 return &elf_howto_table
[(unsigned) R_XTENSA_OP0
];
388 case BFD_RELOC_XTENSA_OP1
:
389 TRACE ("BFD_RELOC_XTENSA_OP1");
390 return &elf_howto_table
[(unsigned) R_XTENSA_OP1
];
392 case BFD_RELOC_XTENSA_OP2
:
393 TRACE ("BFD_RELOC_XTENSA_OP2");
394 return &elf_howto_table
[(unsigned) R_XTENSA_OP2
];
396 case BFD_RELOC_XTENSA_ASM_EXPAND
:
397 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
398 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_EXPAND
];
400 case BFD_RELOC_XTENSA_ASM_SIMPLIFY
:
401 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
402 return &elf_howto_table
[(unsigned) R_XTENSA_ASM_SIMPLIFY
];
404 case BFD_RELOC_VTABLE_INHERIT
:
405 TRACE ("BFD_RELOC_VTABLE_INHERIT");
406 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTINHERIT
];
408 case BFD_RELOC_VTABLE_ENTRY
:
409 TRACE ("BFD_RELOC_VTABLE_ENTRY");
410 return &elf_howto_table
[(unsigned) R_XTENSA_GNU_VTENTRY
];
412 case BFD_RELOC_XTENSA_TLSDESC_FN
:
413 TRACE ("BFD_RELOC_XTENSA_TLSDESC_FN");
414 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_FN
];
416 case BFD_RELOC_XTENSA_TLSDESC_ARG
:
417 TRACE ("BFD_RELOC_XTENSA_TLSDESC_ARG");
418 return &elf_howto_table
[(unsigned) R_XTENSA_TLSDESC_ARG
];
420 case BFD_RELOC_XTENSA_TLS_DTPOFF
:
421 TRACE ("BFD_RELOC_XTENSA_TLS_DTPOFF");
422 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_DTPOFF
];
424 case BFD_RELOC_XTENSA_TLS_TPOFF
:
425 TRACE ("BFD_RELOC_XTENSA_TLS_TPOFF");
426 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_TPOFF
];
428 case BFD_RELOC_XTENSA_TLS_FUNC
:
429 TRACE ("BFD_RELOC_XTENSA_TLS_FUNC");
430 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_FUNC
];
432 case BFD_RELOC_XTENSA_TLS_ARG
:
433 TRACE ("BFD_RELOC_XTENSA_TLS_ARG");
434 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_ARG
];
436 case BFD_RELOC_XTENSA_TLS_CALL
:
437 TRACE ("BFD_RELOC_XTENSA_TLS_CALL");
438 return &elf_howto_table
[(unsigned) R_XTENSA_TLS_CALL
];
441 if (code
>= BFD_RELOC_XTENSA_SLOT0_OP
442 && code
<= BFD_RELOC_XTENSA_SLOT14_OP
)
444 unsigned n
= (R_XTENSA_SLOT0_OP
+
445 (code
- BFD_RELOC_XTENSA_SLOT0_OP
));
446 return &elf_howto_table
[n
];
449 if (code
>= BFD_RELOC_XTENSA_SLOT0_ALT
450 && code
<= BFD_RELOC_XTENSA_SLOT14_ALT
)
452 unsigned n
= (R_XTENSA_SLOT0_ALT
+
453 (code
- BFD_RELOC_XTENSA_SLOT0_ALT
));
454 return &elf_howto_table
[n
];
460 /* xgettext:c-format */
461 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
, (int) code
);
462 bfd_set_error (bfd_error_bad_value
);
467 static reloc_howto_type
*
468 elf_xtensa_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
473 for (i
= 0; i
< sizeof (elf_howto_table
) / sizeof (elf_howto_table
[0]); i
++)
474 if (elf_howto_table
[i
].name
!= NULL
475 && strcasecmp (elf_howto_table
[i
].name
, r_name
) == 0)
476 return &elf_howto_table
[i
];
482 /* Given an ELF "rela" relocation, find the corresponding howto and record
483 it in the BFD internal arelent representation of the relocation. */
486 elf_xtensa_info_to_howto_rela (bfd
*abfd
,
488 Elf_Internal_Rela
*dst
)
490 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
492 if (r_type
>= (unsigned int) R_XTENSA_max
)
494 /* xgettext:c-format */
495 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
497 bfd_set_error (bfd_error_bad_value
);
500 cache_ptr
->howto
= &elf_howto_table
[r_type
];
505 /* Functions for the Xtensa ELF linker. */
507 /* The name of the dynamic interpreter. This is put in the .interp
510 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
512 /* The size in bytes of an entry in the procedure linkage table.
513 (This does _not_ include the space for the literals associated with
516 #define PLT_ENTRY_SIZE 16
518 /* For _really_ large PLTs, we may need to alternate between literals
519 and code to keep the literals within the 256K range of the L32R
520 instructions in the code. It's unlikely that anyone would ever need
521 such a big PLT, but an arbitrary limit on the PLT size would be bad.
522 Thus, we split the PLT into chunks. Since there's very little
523 overhead (2 extra literals) for each chunk, the chunk size is kept
524 small so that the code for handling multiple chunks get used and
525 tested regularly. With 254 entries, there are 1K of literals for
526 each chunk, and that seems like a nice round number. */
528 #define PLT_ENTRIES_PER_CHUNK 254
530 /* PLT entries are actually used as stub functions for lazy symbol
531 resolution. Once the symbol is resolved, the stub function is never
532 invoked. Note: the 32-byte frame size used here cannot be changed
533 without a corresponding change in the runtime linker. */
535 static const bfd_byte elf_xtensa_be_plt_entry
[][PLT_ENTRY_SIZE
] =
538 0x6c, 0x10, 0x04, /* entry sp, 32 */
539 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
540 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
541 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
542 0x0a, 0x80, 0x00, /* jx a8 */
546 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
547 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
548 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
549 0x0a, 0x80, 0x00, /* jx a8 */
554 static const bfd_byte elf_xtensa_le_plt_entry
[][PLT_ENTRY_SIZE
] =
557 0x36, 0x41, 0x00, /* entry sp, 32 */
558 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
559 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
560 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
561 0xa0, 0x08, 0x00, /* jx a8 */
565 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
566 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
567 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
568 0xa0, 0x08, 0x00, /* jx a8 */
573 /* The size of the thread control block. */
576 struct elf_xtensa_link_hash_entry
578 struct elf_link_hash_entry elf
;
580 bfd_signed_vma tlsfunc_refcount
;
582 #define GOT_UNKNOWN 0
584 #define GOT_TLS_GD 2 /* global or local dynamic */
585 #define GOT_TLS_IE 4 /* initial or local exec */
586 #define GOT_TLS_ANY (GOT_TLS_GD | GOT_TLS_IE)
587 unsigned char tls_type
;
590 #define elf_xtensa_hash_entry(ent) ((struct elf_xtensa_link_hash_entry *)(ent))
592 struct elf_xtensa_obj_tdata
594 struct elf_obj_tdata root
;
596 /* tls_type for each local got entry. */
597 char *local_got_tls_type
;
599 bfd_signed_vma
*local_tlsfunc_refcounts
;
602 #define elf_xtensa_tdata(abfd) \
603 ((struct elf_xtensa_obj_tdata *) (abfd)->tdata.any)
605 #define elf_xtensa_local_got_tls_type(abfd) \
606 (elf_xtensa_tdata (abfd)->local_got_tls_type)
608 #define elf_xtensa_local_tlsfunc_refcounts(abfd) \
609 (elf_xtensa_tdata (abfd)->local_tlsfunc_refcounts)
611 #define is_xtensa_elf(bfd) \
612 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
613 && elf_tdata (bfd) != NULL \
614 && elf_object_id (bfd) == XTENSA_ELF_DATA)
617 elf_xtensa_mkobject (bfd
*abfd
)
619 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_xtensa_obj_tdata
),
623 /* Xtensa ELF linker hash table. */
625 struct elf_xtensa_link_hash_table
627 struct elf_link_hash_table elf
;
629 /* Short-cuts to get to dynamic linker sections. */
631 asection
*spltlittbl
;
633 /* Total count of PLT relocations seen during check_relocs.
634 The actual PLT code must be split into multiple sections and all
635 the sections have to be created before size_dynamic_sections,
636 where we figure out the exact number of PLT entries that will be
637 needed. It is OK if this count is an overestimate, e.g., some
638 relocations may be removed by GC. */
641 struct elf_xtensa_link_hash_entry
*tlsbase
;
644 /* Get the Xtensa ELF linker hash table from a link_info structure. */
646 #define elf_xtensa_hash_table(p) \
647 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
648 == XTENSA_ELF_DATA ? ((struct elf_xtensa_link_hash_table *) ((p)->hash)) : NULL)
650 /* Create an entry in an Xtensa ELF linker hash table. */
652 static struct bfd_hash_entry
*
653 elf_xtensa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
654 struct bfd_hash_table
*table
,
657 /* Allocate the structure if it has not already been allocated by a
661 entry
= bfd_hash_allocate (table
,
662 sizeof (struct elf_xtensa_link_hash_entry
));
667 /* Call the allocation method of the superclass. */
668 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
671 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (entry
);
672 eh
->tlsfunc_refcount
= 0;
673 eh
->tls_type
= GOT_UNKNOWN
;
679 /* Create an Xtensa ELF linker hash table. */
681 static struct bfd_link_hash_table
*
682 elf_xtensa_link_hash_table_create (bfd
*abfd
)
684 struct elf_link_hash_entry
*tlsbase
;
685 struct elf_xtensa_link_hash_table
*ret
;
686 bfd_size_type amt
= sizeof (struct elf_xtensa_link_hash_table
);
688 ret
= bfd_zmalloc (amt
);
692 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
693 elf_xtensa_link_hash_newfunc
,
694 sizeof (struct elf_xtensa_link_hash_entry
),
701 /* Create a hash entry for "_TLS_MODULE_BASE_" to speed up checking
703 tlsbase
= elf_link_hash_lookup (&ret
->elf
, "_TLS_MODULE_BASE_",
705 tlsbase
->root
.type
= bfd_link_hash_new
;
706 tlsbase
->root
.u
.undef
.abfd
= NULL
;
707 tlsbase
->non_elf
= 0;
708 ret
->tlsbase
= elf_xtensa_hash_entry (tlsbase
);
709 ret
->tlsbase
->tls_type
= GOT_UNKNOWN
;
711 return &ret
->elf
.root
;
714 /* Copy the extra info we tack onto an elf_link_hash_entry. */
717 elf_xtensa_copy_indirect_symbol (struct bfd_link_info
*info
,
718 struct elf_link_hash_entry
*dir
,
719 struct elf_link_hash_entry
*ind
)
721 struct elf_xtensa_link_hash_entry
*edir
, *eind
;
723 edir
= elf_xtensa_hash_entry (dir
);
724 eind
= elf_xtensa_hash_entry (ind
);
726 if (ind
->root
.type
== bfd_link_hash_indirect
)
728 edir
->tlsfunc_refcount
+= eind
->tlsfunc_refcount
;
729 eind
->tlsfunc_refcount
= 0;
731 if (dir
->got
.refcount
<= 0)
733 edir
->tls_type
= eind
->tls_type
;
734 eind
->tls_type
= GOT_UNKNOWN
;
738 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
741 static inline bfd_boolean
742 elf_xtensa_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
743 struct bfd_link_info
*info
)
745 /* Check if we should do dynamic things to this symbol. The
746 "ignore_protected" argument need not be set, because Xtensa code
747 does not require special handling of STV_PROTECTED to make function
748 pointer comparisons work properly. The PLT addresses are never
749 used for function pointers. */
751 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
756 property_table_compare (const void *ap
, const void *bp
)
758 const property_table_entry
*a
= (const property_table_entry
*) ap
;
759 const property_table_entry
*b
= (const property_table_entry
*) bp
;
761 if (a
->address
== b
->address
)
763 if (a
->size
!= b
->size
)
764 return (a
->size
- b
->size
);
766 if ((a
->flags
& XTENSA_PROP_ALIGN
) != (b
->flags
& XTENSA_PROP_ALIGN
))
767 return ((b
->flags
& XTENSA_PROP_ALIGN
)
768 - (a
->flags
& XTENSA_PROP_ALIGN
));
770 if ((a
->flags
& XTENSA_PROP_ALIGN
)
771 && (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
772 != GET_XTENSA_PROP_ALIGNMENT (b
->flags
)))
773 return (GET_XTENSA_PROP_ALIGNMENT (a
->flags
)
774 - GET_XTENSA_PROP_ALIGNMENT (b
->flags
));
776 if ((a
->flags
& XTENSA_PROP_UNREACHABLE
)
777 != (b
->flags
& XTENSA_PROP_UNREACHABLE
))
778 return ((b
->flags
& XTENSA_PROP_UNREACHABLE
)
779 - (a
->flags
& XTENSA_PROP_UNREACHABLE
));
781 return (a
->flags
- b
->flags
);
784 return (a
->address
- b
->address
);
789 property_table_matches (const void *ap
, const void *bp
)
791 const property_table_entry
*a
= (const property_table_entry
*) ap
;
792 const property_table_entry
*b
= (const property_table_entry
*) bp
;
794 /* Check if one entry overlaps with the other. */
795 if ((b
->address
>= a
->address
&& b
->address
< (a
->address
+ a
->size
))
796 || (a
->address
>= b
->address
&& a
->address
< (b
->address
+ b
->size
)))
799 return (a
->address
- b
->address
);
803 /* Get the literal table or property table entries for the given
804 section. Sets TABLE_P and returns the number of entries. On
805 error, returns a negative value. */
808 xtensa_read_table_entries (bfd
*abfd
,
810 property_table_entry
**table_p
,
811 const char *sec_name
,
812 bfd_boolean output_addr
)
814 asection
*table_section
;
815 bfd_size_type table_size
= 0;
816 bfd_byte
*table_data
;
817 property_table_entry
*blocks
;
818 int blk
, block_count
;
819 bfd_size_type num_records
;
820 Elf_Internal_Rela
*internal_relocs
, *irel
, *rel_end
;
821 bfd_vma section_addr
, off
;
822 flagword predef_flags
;
823 bfd_size_type table_entry_size
, section_limit
;
826 || !(section
->flags
& SEC_ALLOC
)
827 || (section
->flags
& SEC_DEBUGGING
))
833 table_section
= xtensa_get_property_section (section
, sec_name
);
835 table_size
= table_section
->size
;
843 predef_flags
= xtensa_get_property_predef_flags (table_section
);
844 table_entry_size
= 12;
846 table_entry_size
-= 4;
848 num_records
= table_size
/ table_entry_size
;
849 table_data
= retrieve_contents (abfd
, table_section
, TRUE
);
850 blocks
= (property_table_entry
*)
851 bfd_malloc (num_records
* sizeof (property_table_entry
));
855 section_addr
= section
->output_section
->vma
+ section
->output_offset
;
857 section_addr
= section
->vma
;
859 internal_relocs
= retrieve_internal_relocs (abfd
, table_section
, TRUE
);
860 if (internal_relocs
&& !table_section
->reloc_done
)
862 qsort (internal_relocs
, table_section
->reloc_count
,
863 sizeof (Elf_Internal_Rela
), internal_reloc_compare
);
864 irel
= internal_relocs
;
869 section_limit
= bfd_get_section_limit (abfd
, section
);
870 rel_end
= internal_relocs
+ table_section
->reloc_count
;
872 for (off
= 0; off
< table_size
; off
+= table_entry_size
)
874 bfd_vma address
= bfd_get_32 (abfd
, table_data
+ off
);
876 /* Skip any relocations before the current offset. This should help
877 avoid confusion caused by unexpected relocations for the preceding
880 (irel
->r_offset
< off
881 || (irel
->r_offset
== off
882 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_NONE
)))
889 if (irel
&& irel
->r_offset
== off
)
892 unsigned long r_symndx
= ELF32_R_SYM (irel
->r_info
);
893 BFD_ASSERT (ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_32
);
895 if (get_elf_r_symndx_section (abfd
, r_symndx
) != section
)
898 sym_off
= get_elf_r_symndx_offset (abfd
, r_symndx
);
899 BFD_ASSERT (sym_off
== 0);
900 address
+= (section_addr
+ sym_off
+ irel
->r_addend
);
904 if (address
< section_addr
905 || address
>= section_addr
+ section_limit
)
909 blocks
[block_count
].address
= address
;
910 blocks
[block_count
].size
= bfd_get_32 (abfd
, table_data
+ off
+ 4);
912 blocks
[block_count
].flags
= predef_flags
;
914 blocks
[block_count
].flags
= bfd_get_32 (abfd
, table_data
+ off
+ 8);
918 release_contents (table_section
, table_data
);
919 release_internal_relocs (table_section
, internal_relocs
);
923 /* Now sort them into address order for easy reference. */
924 qsort (blocks
, block_count
, sizeof (property_table_entry
),
925 property_table_compare
);
927 /* Check that the table contents are valid. Problems may occur,
928 for example, if an unrelocated object file is stripped. */
929 for (blk
= 1; blk
< block_count
; blk
++)
931 /* The only circumstance where two entries may legitimately
932 have the same address is when one of them is a zero-size
933 placeholder to mark a place where fill can be inserted.
934 The zero-size entry should come first. */
935 if (blocks
[blk
- 1].address
== blocks
[blk
].address
&&
936 blocks
[blk
- 1].size
!= 0)
938 /* xgettext:c-format */
939 _bfd_error_handler (_("%pB(%pA): invalid property table"),
941 bfd_set_error (bfd_error_bad_value
);
953 static property_table_entry
*
954 elf_xtensa_find_property_entry (property_table_entry
*property_table
,
955 int property_table_size
,
958 property_table_entry entry
;
959 property_table_entry
*rv
;
961 if (property_table_size
== 0)
964 entry
.address
= addr
;
968 rv
= bsearch (&entry
, property_table
, property_table_size
,
969 sizeof (property_table_entry
), property_table_matches
);
975 elf_xtensa_in_literal_pool (property_table_entry
*lit_table
,
979 if (elf_xtensa_find_property_entry (lit_table
, lit_table_size
, addr
))
986 /* Look through the relocs for a section during the first phase, and
987 calculate needed space in the dynamic reloc sections. */
990 elf_xtensa_check_relocs (bfd
*abfd
,
991 struct bfd_link_info
*info
,
993 const Elf_Internal_Rela
*relocs
)
995 struct elf_xtensa_link_hash_table
*htab
;
996 Elf_Internal_Shdr
*symtab_hdr
;
997 struct elf_link_hash_entry
**sym_hashes
;
998 const Elf_Internal_Rela
*rel
;
999 const Elf_Internal_Rela
*rel_end
;
1001 if (bfd_link_relocatable (info
) || (sec
->flags
& SEC_ALLOC
) == 0)
1004 BFD_ASSERT (is_xtensa_elf (abfd
));
1006 htab
= elf_xtensa_hash_table (info
);
1010 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1011 sym_hashes
= elf_sym_hashes (abfd
);
1013 rel_end
= relocs
+ sec
->reloc_count
;
1014 for (rel
= relocs
; rel
< rel_end
; rel
++)
1016 unsigned int r_type
;
1018 struct elf_link_hash_entry
*h
= NULL
;
1019 struct elf_xtensa_link_hash_entry
*eh
;
1020 int tls_type
, old_tls_type
;
1021 bfd_boolean is_got
= FALSE
;
1022 bfd_boolean is_plt
= FALSE
;
1023 bfd_boolean is_tlsfunc
= FALSE
;
1025 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1026 r_type
= ELF32_R_TYPE (rel
->r_info
);
1028 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
1030 /* xgettext:c-format */
1031 _bfd_error_handler (_("%pB: bad symbol index: %d"),
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
;
1043 eh
= elf_xtensa_hash_entry (h
);
1047 case R_XTENSA_TLSDESC_FN
:
1048 if (bfd_link_pic (info
))
1050 tls_type
= GOT_TLS_GD
;
1055 tls_type
= GOT_TLS_IE
;
1058 case R_XTENSA_TLSDESC_ARG
:
1059 if (bfd_link_pic (info
))
1061 tls_type
= GOT_TLS_GD
;
1066 tls_type
= GOT_TLS_IE
;
1067 if (h
&& elf_xtensa_hash_entry (h
) != htab
->tlsbase
)
1072 case R_XTENSA_TLS_DTPOFF
:
1073 if (bfd_link_pic (info
))
1074 tls_type
= GOT_TLS_GD
;
1076 tls_type
= GOT_TLS_IE
;
1079 case R_XTENSA_TLS_TPOFF
:
1080 tls_type
= GOT_TLS_IE
;
1081 if (bfd_link_pic (info
))
1082 info
->flags
|= DF_STATIC_TLS
;
1083 if (bfd_link_pic (info
) || h
)
1088 tls_type
= GOT_NORMAL
;
1093 tls_type
= GOT_NORMAL
;
1097 case R_XTENSA_GNU_VTINHERIT
:
1098 /* This relocation describes the C++ object vtable hierarchy.
1099 Reconstruct it for later use during GC. */
1100 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1104 case R_XTENSA_GNU_VTENTRY
:
1105 /* This relocation describes which C++ vtable entries are actually
1106 used. Record for later use during GC. */
1107 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1112 /* Nothing to do for any other relocations. */
1120 if (h
->plt
.refcount
<= 0)
1123 h
->plt
.refcount
= 1;
1126 h
->plt
.refcount
+= 1;
1128 /* Keep track of the total PLT relocation count even if we
1129 don't yet know whether the dynamic sections will be
1131 htab
->plt_reloc_count
+= 1;
1133 if (elf_hash_table (info
)->dynamic_sections_created
)
1135 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1141 if (h
->got
.refcount
<= 0)
1142 h
->got
.refcount
= 1;
1144 h
->got
.refcount
+= 1;
1148 eh
->tlsfunc_refcount
+= 1;
1150 old_tls_type
= eh
->tls_type
;
1154 /* Allocate storage the first time. */
1155 if (elf_local_got_refcounts (abfd
) == NULL
)
1157 bfd_size_type size
= symtab_hdr
->sh_info
;
1160 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1163 elf_local_got_refcounts (abfd
) = (bfd_signed_vma
*) mem
;
1165 mem
= bfd_zalloc (abfd
, size
);
1168 elf_xtensa_local_got_tls_type (abfd
) = (char *) mem
;
1170 mem
= bfd_zalloc (abfd
, size
* sizeof (bfd_signed_vma
));
1173 elf_xtensa_local_tlsfunc_refcounts (abfd
)
1174 = (bfd_signed_vma
*) mem
;
1177 /* This is a global offset table entry for a local symbol. */
1178 if (is_got
|| is_plt
)
1179 elf_local_got_refcounts (abfd
) [r_symndx
] += 1;
1182 elf_xtensa_local_tlsfunc_refcounts (abfd
) [r_symndx
] += 1;
1184 old_tls_type
= elf_xtensa_local_got_tls_type (abfd
) [r_symndx
];
1187 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_IE
))
1188 tls_type
|= old_tls_type
;
1189 /* If a TLS symbol is accessed using IE at least once,
1190 there is no point to use a dynamic model for it. */
1191 else if (old_tls_type
!= tls_type
&& old_tls_type
!= GOT_UNKNOWN
1192 && ((old_tls_type
& GOT_TLS_GD
) == 0
1193 || (tls_type
& GOT_TLS_IE
) == 0))
1195 if ((old_tls_type
& GOT_TLS_IE
) && (tls_type
& GOT_TLS_GD
))
1196 tls_type
= old_tls_type
;
1197 else if ((old_tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_GD
))
1198 tls_type
|= old_tls_type
;
1202 /* xgettext:c-format */
1203 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1205 h
? h
->root
.root
.string
: "<local>");
1210 if (old_tls_type
!= tls_type
)
1213 eh
->tls_type
= tls_type
;
1215 elf_xtensa_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1224 elf_xtensa_make_sym_local (struct bfd_link_info
*info
,
1225 struct elf_link_hash_entry
*h
)
1227 if (bfd_link_pic (info
))
1229 if (h
->plt
.refcount
> 0)
1231 /* For shared objects, there's no need for PLT entries for local
1232 symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */
1233 if (h
->got
.refcount
< 0)
1234 h
->got
.refcount
= 0;
1235 h
->got
.refcount
+= h
->plt
.refcount
;
1236 h
->plt
.refcount
= 0;
1241 /* Don't need any dynamic relocations at all. */
1242 h
->plt
.refcount
= 0;
1243 h
->got
.refcount
= 0;
1249 elf_xtensa_hide_symbol (struct bfd_link_info
*info
,
1250 struct elf_link_hash_entry
*h
,
1251 bfd_boolean force_local
)
1253 /* For a shared link, move the plt refcount to the got refcount to leave
1254 space for RELATIVE relocs. */
1255 elf_xtensa_make_sym_local (info
, h
);
1257 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
1261 /* Return the section that should be marked against GC for a given
1265 elf_xtensa_gc_mark_hook (asection
*sec
,
1266 struct bfd_link_info
*info
,
1267 Elf_Internal_Rela
*rel
,
1268 struct elf_link_hash_entry
*h
,
1269 Elf_Internal_Sym
*sym
)
1271 /* Property sections are marked "KEEP" in the linker scripts, but they
1272 should not cause other sections to be marked. (This approach relies
1273 on elf_xtensa_discard_info to remove property table entries that
1274 describe discarded sections. Alternatively, it might be more
1275 efficient to avoid using "KEEP" in the linker scripts and instead use
1276 the gc_mark_extra_sections hook to mark only the property sections
1277 that describe marked sections. That alternative does not work well
1278 with the current property table sections, which do not correspond
1279 one-to-one with the sections they describe, but that should be fixed
1281 if (xtensa_is_property_section (sec
))
1285 switch (ELF32_R_TYPE (rel
->r_info
))
1287 case R_XTENSA_GNU_VTINHERIT
:
1288 case R_XTENSA_GNU_VTENTRY
:
1292 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1296 /* Create all the dynamic sections. */
1299 elf_xtensa_create_dynamic_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
1301 struct elf_xtensa_link_hash_table
*htab
;
1302 flagword flags
, noalloc_flags
;
1304 htab
= elf_xtensa_hash_table (info
);
1308 /* First do all the standard stuff. */
1309 if (! _bfd_elf_create_dynamic_sections (dynobj
, info
))
1312 /* Create any extra PLT sections in case check_relocs has already
1313 been called on all the non-dynamic input files. */
1314 if (! add_extra_plt_sections (info
, htab
->plt_reloc_count
))
1317 noalloc_flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1318 | SEC_LINKER_CREATED
| SEC_READONLY
);
1319 flags
= noalloc_flags
| SEC_ALLOC
| SEC_LOAD
;
1321 /* Mark the ".got.plt" section READONLY. */
1322 if (htab
->elf
.sgotplt
== NULL
1323 || !bfd_set_section_flags (htab
->elf
.sgotplt
, flags
))
1326 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1327 htab
->sgotloc
= bfd_make_section_anyway_with_flags (dynobj
, ".got.loc",
1329 if (htab
->sgotloc
== NULL
1330 || !bfd_set_section_alignment (htab
->sgotloc
, 2))
1333 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1334 htab
->spltlittbl
= bfd_make_section_anyway_with_flags (dynobj
, ".xt.lit.plt",
1336 if (htab
->spltlittbl
== NULL
1337 || !bfd_set_section_alignment (htab
->spltlittbl
, 2))
1345 add_extra_plt_sections (struct bfd_link_info
*info
, int count
)
1347 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1350 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1351 ".got.plt" sections. */
1352 for (chunk
= count
/ PLT_ENTRIES_PER_CHUNK
; chunk
> 0; chunk
--)
1358 /* Stop when we find a section has already been created. */
1359 if (elf_xtensa_get_plt_section (info
, chunk
))
1362 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1363 | SEC_LINKER_CREATED
| SEC_READONLY
);
1365 sname
= (char *) bfd_malloc (10);
1366 sprintf (sname
, ".plt.%u", chunk
);
1367 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
| SEC_CODE
);
1369 || !bfd_set_section_alignment (s
, 2))
1372 sname
= (char *) bfd_malloc (14);
1373 sprintf (sname
, ".got.plt.%u", chunk
);
1374 s
= bfd_make_section_anyway_with_flags (dynobj
, sname
, flags
);
1376 || !bfd_set_section_alignment (s
, 2))
1384 /* Adjust a symbol defined by a dynamic object and referenced by a
1385 regular object. The current definition is in some section of the
1386 dynamic object, but we're not including those sections. We have to
1387 change the definition to something the rest of the link can
1391 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1392 struct elf_link_hash_entry
*h
)
1394 /* If this is a weak symbol, and there is a real definition, the
1395 processor independent code will have arranged for us to see the
1396 real definition first, and we can just use the same value. */
1397 if (h
->is_weakalias
)
1399 struct elf_link_hash_entry
*def
= weakdef (h
);
1400 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1401 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1402 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1406 /* This is a reference to a symbol defined by a dynamic object. The
1407 reference must go through the GOT, so there's no need for COPY relocs,
1415 elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *arg
)
1417 struct bfd_link_info
*info
;
1418 struct elf_xtensa_link_hash_table
*htab
;
1419 struct elf_xtensa_link_hash_entry
*eh
= elf_xtensa_hash_entry (h
);
1421 if (h
->root
.type
== bfd_link_hash_indirect
)
1424 info
= (struct bfd_link_info
*) arg
;
1425 htab
= elf_xtensa_hash_table (info
);
1429 /* If we saw any use of an IE model for this symbol, we can then optimize
1430 away GOT entries for any TLSDESC_FN relocs. */
1431 if ((eh
->tls_type
& GOT_TLS_IE
) != 0)
1433 BFD_ASSERT (h
->got
.refcount
>= eh
->tlsfunc_refcount
);
1434 h
->got
.refcount
-= eh
->tlsfunc_refcount
;
1437 if (! elf_xtensa_dynamic_symbol_p (h
, info
))
1438 elf_xtensa_make_sym_local (info
, h
);
1440 if (! elf_xtensa_dynamic_symbol_p (h
, info
)
1441 && h
->root
.type
== bfd_link_hash_undefweak
)
1444 if (h
->plt
.refcount
> 0)
1445 htab
->elf
.srelplt
->size
+= (h
->plt
.refcount
* sizeof (Elf32_External_Rela
));
1447 if (h
->got
.refcount
> 0)
1448 htab
->elf
.srelgot
->size
+= (h
->got
.refcount
* sizeof (Elf32_External_Rela
));
1455 elf_xtensa_allocate_local_got_size (struct bfd_link_info
*info
)
1457 struct elf_xtensa_link_hash_table
*htab
;
1460 htab
= elf_xtensa_hash_table (info
);
1464 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
1466 bfd_signed_vma
*local_got_refcounts
;
1467 bfd_size_type j
, cnt
;
1468 Elf_Internal_Shdr
*symtab_hdr
;
1470 local_got_refcounts
= elf_local_got_refcounts (i
);
1471 if (!local_got_refcounts
)
1474 symtab_hdr
= &elf_tdata (i
)->symtab_hdr
;
1475 cnt
= symtab_hdr
->sh_info
;
1477 for (j
= 0; j
< cnt
; ++j
)
1479 /* If we saw any use of an IE model for this symbol, we can
1480 then optimize away GOT entries for any TLSDESC_FN relocs. */
1481 if ((elf_xtensa_local_got_tls_type (i
) [j
] & GOT_TLS_IE
) != 0)
1483 bfd_signed_vma
*tlsfunc_refcount
1484 = &elf_xtensa_local_tlsfunc_refcounts (i
) [j
];
1485 BFD_ASSERT (local_got_refcounts
[j
] >= *tlsfunc_refcount
);
1486 local_got_refcounts
[j
] -= *tlsfunc_refcount
;
1489 if (local_got_refcounts
[j
] > 0)
1490 htab
->elf
.srelgot
->size
+= (local_got_refcounts
[j
]
1491 * sizeof (Elf32_External_Rela
));
1497 /* Set the sizes of the dynamic sections. */
1500 elf_xtensa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1501 struct bfd_link_info
*info
)
1503 struct elf_xtensa_link_hash_table
*htab
;
1505 asection
*s
, *srelplt
, *splt
, *sgotplt
, *srelgot
, *spltlittbl
, *sgotloc
;
1506 bfd_boolean relplt
, relgot
;
1507 int plt_entries
, plt_chunks
, chunk
;
1512 htab
= elf_xtensa_hash_table (info
);
1516 dynobj
= elf_hash_table (info
)->dynobj
;
1519 srelgot
= htab
->elf
.srelgot
;
1520 srelplt
= htab
->elf
.srelplt
;
1522 if (elf_hash_table (info
)->dynamic_sections_created
)
1524 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
1525 && htab
->elf
.srelplt
!= NULL
1526 && htab
->elf
.sgot
!= NULL
1527 && htab
->spltlittbl
!= NULL
1528 && htab
->sgotloc
!= NULL
);
1530 /* Set the contents of the .interp section to the interpreter. */
1531 if (bfd_link_executable (info
) && !info
->nointerp
)
1533 s
= bfd_get_linker_section (dynobj
, ".interp");
1536 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1537 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1540 /* Allocate room for one word in ".got". */
1541 htab
->elf
.sgot
->size
= 4;
1543 /* Allocate space in ".rela.got" for literals that reference global
1544 symbols and space in ".rela.plt" for literals that have PLT
1546 elf_link_hash_traverse (elf_hash_table (info
),
1547 elf_xtensa_allocate_dynrelocs
,
1550 /* If we are generating a shared object, we also need space in
1551 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1552 reference local symbols. */
1553 if (bfd_link_pic (info
))
1554 elf_xtensa_allocate_local_got_size (info
);
1556 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1557 each PLT entry, we need the PLT code plus a 4-byte literal.
1558 For each chunk of ".plt", we also need two more 4-byte
1559 literals, two corresponding entries in ".rela.got", and an
1560 8-byte entry in ".xt.lit.plt". */
1561 spltlittbl
= htab
->spltlittbl
;
1562 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
1564 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
1566 /* Iterate over all the PLT chunks, including any extra sections
1567 created earlier because the initial count of PLT relocations
1568 was an overestimate. */
1570 (splt
= elf_xtensa_get_plt_section (info
, chunk
)) != NULL
;
1575 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
1576 BFD_ASSERT (sgotplt
!= NULL
);
1578 if (chunk
< plt_chunks
- 1)
1579 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
1580 else if (chunk
== plt_chunks
- 1)
1581 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
1585 if (chunk_entries
!= 0)
1587 sgotplt
->size
= 4 * (chunk_entries
+ 2);
1588 splt
->size
= PLT_ENTRY_SIZE
* chunk_entries
;
1589 srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
1590 spltlittbl
->size
+= 8;
1599 /* Allocate space in ".got.loc" to match the total size of all the
1601 sgotloc
= htab
->sgotloc
;
1602 sgotloc
->size
= spltlittbl
->size
;
1603 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1605 if (abfd
->flags
& DYNAMIC
)
1607 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1609 if (! discarded_section (s
)
1610 && xtensa_is_littable_section (s
)
1612 sgotloc
->size
+= s
->size
;
1617 /* Allocate memory for dynamic sections. */
1620 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1624 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1627 /* It's OK to base decisions on the section name, because none
1628 of the dynobj section names depend upon the input files. */
1629 name
= bfd_section_name (s
);
1631 if (CONST_STRNEQ (name
, ".rela"))
1635 if (strcmp (name
, ".rela.plt") == 0)
1637 else if (strcmp (name
, ".rela.got") == 0)
1640 /* We use the reloc_count field as a counter if we need
1641 to copy relocs into the output file. */
1645 else if (! CONST_STRNEQ (name
, ".plt.")
1646 && ! CONST_STRNEQ (name
, ".got.plt.")
1647 && strcmp (name
, ".got") != 0
1648 && strcmp (name
, ".plt") != 0
1649 && strcmp (name
, ".got.plt") != 0
1650 && strcmp (name
, ".xt.lit.plt") != 0
1651 && strcmp (name
, ".got.loc") != 0)
1653 /* It's not one of our sections, so don't allocate space. */
1659 /* If we don't need this section, strip it from the output
1660 file. We must create the ".plt*" and ".got.plt*"
1661 sections in create_dynamic_sections and/or check_relocs
1662 based on a conservative estimate of the PLT relocation
1663 count, because the sections must be created before the
1664 linker maps input sections to output sections. The
1665 linker does that before size_dynamic_sections, where we
1666 compute the exact size of the PLT, so there may be more
1667 of these sections than are actually needed. */
1668 s
->flags
|= SEC_EXCLUDE
;
1670 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
1672 /* Allocate memory for the section contents. */
1673 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1674 if (s
->contents
== NULL
)
1679 if (elf_hash_table (info
)->dynamic_sections_created
)
1681 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1682 known until finish_dynamic_sections, but we need to get the relocs
1683 in place before they are sorted. */
1684 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
1686 Elf_Internal_Rela irela
;
1690 irela
.r_info
= ELF32_R_INFO (0, R_XTENSA_RTLD
);
1693 loc
= (srelgot
->contents
1694 + srelgot
->reloc_count
* sizeof (Elf32_External_Rela
));
1695 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
1696 bfd_elf32_swap_reloca_out (output_bfd
, &irela
,
1697 loc
+ sizeof (Elf32_External_Rela
));
1698 srelgot
->reloc_count
+= 2;
1701 /* Add some entries to the .dynamic section. We fill in the
1702 values later, in elf_xtensa_finish_dynamic_sections, but we
1703 must add the entries now so that we get the correct size for
1704 the .dynamic section. The DT_DEBUG entry is filled in by the
1705 dynamic linker and used by the debugger. */
1706 #define add_dynamic_entry(TAG, VAL) \
1707 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1709 if (bfd_link_executable (info
))
1711 if (!add_dynamic_entry (DT_DEBUG
, 0))
1717 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1718 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1719 || !add_dynamic_entry (DT_JMPREL
, 0))
1725 if (!add_dynamic_entry (DT_RELA
, 0)
1726 || !add_dynamic_entry (DT_RELASZ
, 0)
1727 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1731 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1732 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF
, 0)
1733 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ
, 0))
1736 #undef add_dynamic_entry
1742 elf_xtensa_always_size_sections (bfd
*output_bfd
,
1743 struct bfd_link_info
*info
)
1745 struct elf_xtensa_link_hash_table
*htab
;
1748 htab
= elf_xtensa_hash_table (info
);
1752 tls_sec
= htab
->elf
.tls_sec
;
1754 if (tls_sec
&& (htab
->tlsbase
->tls_type
& GOT_TLS_ANY
) != 0)
1756 struct elf_link_hash_entry
*tlsbase
= &htab
->tlsbase
->elf
;
1757 struct bfd_link_hash_entry
*bh
= &tlsbase
->root
;
1758 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
1760 tlsbase
->type
= STT_TLS
;
1761 if (!(_bfd_generic_link_add_one_symbol
1762 (info
, output_bfd
, "_TLS_MODULE_BASE_", BSF_LOCAL
,
1763 tls_sec
, 0, NULL
, FALSE
,
1764 bed
->collect
, &bh
)))
1766 tlsbase
->def_regular
= 1;
1767 tlsbase
->other
= STV_HIDDEN
;
1768 (*bed
->elf_backend_hide_symbol
) (info
, tlsbase
, TRUE
);
1775 /* Return the base VMA address which should be subtracted from real addresses
1776 when resolving @dtpoff relocation.
1777 This is PT_TLS segment p_vaddr. */
1780 dtpoff_base (struct bfd_link_info
*info
)
1782 /* If tls_sec is NULL, we should have signalled an error already. */
1783 if (elf_hash_table (info
)->tls_sec
== NULL
)
1785 return elf_hash_table (info
)->tls_sec
->vma
;
1788 /* Return the relocation value for @tpoff relocation
1789 if STT_TLS virtual address is ADDRESS. */
1792 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1794 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1797 /* If tls_sec is NULL, we should have signalled an error already. */
1798 if (htab
->tls_sec
== NULL
)
1800 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
1801 return address
- htab
->tls_sec
->vma
+ base
;
1804 /* Perform the specified relocation. The instruction at (contents + address)
1805 is modified to set one operand to represent the value in "relocation". The
1806 operand position is determined by the relocation type recorded in the
1809 #define CALL_SEGMENT_BITS (30)
1810 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1812 static bfd_reloc_status_type
1813 elf_xtensa_do_reloc (reloc_howto_type
*howto
,
1815 asection
*input_section
,
1819 bfd_boolean is_weak_undef
,
1820 char **error_message
)
1823 xtensa_opcode opcode
;
1824 xtensa_isa isa
= xtensa_default_isa
;
1825 static xtensa_insnbuf ibuff
= NULL
;
1826 static xtensa_insnbuf sbuff
= NULL
;
1827 bfd_vma self_address
;
1828 bfd_size_type input_size
;
1834 ibuff
= xtensa_insnbuf_alloc (isa
);
1835 sbuff
= xtensa_insnbuf_alloc (isa
);
1838 input_size
= bfd_get_section_limit (abfd
, input_section
);
1840 /* Calculate the PC address for this instruction. */
1841 self_address
= (input_section
->output_section
->vma
1842 + input_section
->output_offset
1845 switch (howto
->type
)
1848 case R_XTENSA_DIFF8
:
1849 case R_XTENSA_DIFF16
:
1850 case R_XTENSA_DIFF32
:
1851 case R_XTENSA_TLS_FUNC
:
1852 case R_XTENSA_TLS_ARG
:
1853 case R_XTENSA_TLS_CALL
:
1854 return bfd_reloc_ok
;
1856 case R_XTENSA_ASM_EXPAND
:
1859 /* Check for windowed CALL across a 1GB boundary. */
1860 opcode
= get_expanded_call_opcode (contents
+ address
,
1861 input_size
- address
, 0);
1862 if (is_windowed_call_opcode (opcode
))
1864 if ((self_address
>> CALL_SEGMENT_BITS
)
1865 != (relocation
>> CALL_SEGMENT_BITS
))
1867 *error_message
= "windowed longcall crosses 1GB boundary; "
1869 return bfd_reloc_dangerous
;
1873 return bfd_reloc_ok
;
1875 case R_XTENSA_ASM_SIMPLIFY
:
1877 /* Convert the L32R/CALLX to CALL. */
1878 bfd_reloc_status_type retval
=
1879 elf_xtensa_do_asm_simplify (contents
, address
, input_size
,
1881 if (retval
!= bfd_reloc_ok
)
1882 return bfd_reloc_dangerous
;
1884 /* The CALL needs to be relocated. Continue below for that part. */
1887 howto
= &elf_howto_table
[(unsigned) R_XTENSA_SLOT0_OP
];
1894 x
= bfd_get_32 (abfd
, contents
+ address
);
1896 bfd_put_32 (abfd
, x
, contents
+ address
);
1898 return bfd_reloc_ok
;
1900 case R_XTENSA_32_PCREL
:
1901 bfd_put_32 (abfd
, relocation
- self_address
, contents
+ address
);
1902 return bfd_reloc_ok
;
1905 case R_XTENSA_TLSDESC_FN
:
1906 case R_XTENSA_TLSDESC_ARG
:
1907 case R_XTENSA_TLS_DTPOFF
:
1908 case R_XTENSA_TLS_TPOFF
:
1909 bfd_put_32 (abfd
, relocation
, contents
+ address
);
1910 return bfd_reloc_ok
;
1913 /* Only instruction slot-specific relocations handled below.... */
1914 slot
= get_relocation_slot (howto
->type
);
1915 if (slot
== XTENSA_UNDEFINED
)
1917 *error_message
= "unexpected relocation";
1918 return bfd_reloc_dangerous
;
1921 /* Read the instruction into a buffer and decode the opcode. */
1922 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ address
,
1923 input_size
- address
);
1924 fmt
= xtensa_format_decode (isa
, ibuff
);
1925 if (fmt
== XTENSA_UNDEFINED
)
1927 *error_message
= "cannot decode instruction format";
1928 return bfd_reloc_dangerous
;
1931 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
1933 opcode
= xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
1934 if (opcode
== XTENSA_UNDEFINED
)
1936 *error_message
= "cannot decode instruction opcode";
1937 return bfd_reloc_dangerous
;
1940 /* Check for opcode-specific "alternate" relocations. */
1941 if (is_alt_relocation (howto
->type
))
1943 if (opcode
== get_l32r_opcode ())
1945 /* Handle the special-case of non-PC-relative L32R instructions. */
1946 bfd
*output_bfd
= input_section
->output_section
->owner
;
1947 asection
*lit4_sec
= bfd_get_section_by_name (output_bfd
, ".lit4");
1950 *error_message
= "relocation references missing .lit4 section";
1951 return bfd_reloc_dangerous
;
1953 self_address
= ((lit4_sec
->vma
& ~0xfff)
1954 + 0x40000 - 3); /* -3 to compensate for do_reloc */
1955 newval
= relocation
;
1958 else if (opcode
== get_const16_opcode ())
1960 /* ALT used for high 16 bits.
1961 Ignore 32-bit overflow. */
1962 newval
= (relocation
>> 16) & 0xffff;
1967 /* No other "alternate" relocations currently defined. */
1968 *error_message
= "unexpected relocation";
1969 return bfd_reloc_dangerous
;
1972 else /* Not an "alternate" relocation.... */
1974 if (opcode
== get_const16_opcode ())
1976 newval
= relocation
& 0xffff;
1981 /* ...normal PC-relative relocation.... */
1983 /* Determine which operand is being relocated. */
1984 opnd
= get_relocation_opnd (opcode
, howto
->type
);
1985 if (opnd
== XTENSA_UNDEFINED
)
1987 *error_message
= "unexpected relocation";
1988 return bfd_reloc_dangerous
;
1991 if (!howto
->pc_relative
)
1993 *error_message
= "expected PC-relative relocation";
1994 return bfd_reloc_dangerous
;
1997 newval
= relocation
;
2001 /* Apply the relocation. */
2002 if (xtensa_operand_do_reloc (isa
, opcode
, opnd
, &newval
, self_address
)
2003 || xtensa_operand_encode (isa
, opcode
, opnd
, &newval
)
2004 || xtensa_operand_set_field (isa
, opcode
, opnd
, fmt
, slot
,
2007 const char *opname
= xtensa_opcode_name (isa
, opcode
);
2010 msg
= "cannot encode";
2011 if (is_direct_call_opcode (opcode
))
2013 if ((relocation
& 0x3) != 0)
2014 msg
= "misaligned call target";
2016 msg
= "call target out of range";
2018 else if (opcode
== get_l32r_opcode ())
2020 if ((relocation
& 0x3) != 0)
2021 msg
= "misaligned literal target";
2022 else if (is_alt_relocation (howto
->type
))
2023 msg
= "literal target out of range (too many literals)";
2024 else if (self_address
> relocation
)
2025 msg
= "literal target out of range (try using text-section-literals)";
2027 msg
= "literal placed after use";
2030 *error_message
= vsprint_msg (opname
, ": %s", strlen (msg
) + 2, msg
);
2031 return bfd_reloc_dangerous
;
2034 /* Check for calls across 1GB boundaries. */
2035 if (is_direct_call_opcode (opcode
)
2036 && is_windowed_call_opcode (opcode
))
2038 if ((self_address
>> CALL_SEGMENT_BITS
)
2039 != (relocation
>> CALL_SEGMENT_BITS
))
2042 "windowed call crosses 1GB boundary; return may fail";
2043 return bfd_reloc_dangerous
;
2047 /* Write the modified instruction back out of the buffer. */
2048 xtensa_format_set_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
2049 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ address
,
2050 input_size
- address
);
2051 return bfd_reloc_ok
;
2056 vsprint_msg (const char *origmsg
, const char *fmt
, int arglen
, ...)
2058 /* To reduce the size of the memory leak,
2059 we only use a single message buffer. */
2060 static bfd_size_type alloc_size
= 0;
2061 static char *message
= NULL
;
2062 bfd_size_type orig_len
, len
= 0;
2063 bfd_boolean is_append
;
2066 va_start (ap
, arglen
);
2068 is_append
= (origmsg
== message
);
2070 orig_len
= strlen (origmsg
);
2071 len
= orig_len
+ strlen (fmt
) + arglen
+ 20;
2072 if (len
> alloc_size
)
2074 message
= (char *) bfd_realloc_or_free (message
, len
);
2077 if (message
!= NULL
)
2080 memcpy (message
, origmsg
, orig_len
);
2081 vsprintf (message
+ orig_len
, fmt
, ap
);
2088 /* This function is registered as the "special_function" in the
2089 Xtensa howto for handling simplify operations.
2090 bfd_perform_relocation / bfd_install_relocation use it to
2091 perform (install) the specified relocation. Since this replaces the code
2092 in bfd_perform_relocation, it is basically an Xtensa-specific,
2093 stripped-down version of bfd_perform_relocation. */
2095 static bfd_reloc_status_type
2096 bfd_elf_xtensa_reloc (bfd
*abfd
,
2097 arelent
*reloc_entry
,
2100 asection
*input_section
,
2102 char **error_message
)
2105 bfd_reloc_status_type flag
;
2106 bfd_size_type octets
= (reloc_entry
->address
2107 * bfd_octets_per_byte (abfd
, NULL
));
2108 bfd_vma output_base
= 0;
2109 reloc_howto_type
*howto
= reloc_entry
->howto
;
2110 asection
*reloc_target_output_section
;
2111 bfd_boolean is_weak_undef
;
2113 if (!xtensa_default_isa
)
2114 xtensa_default_isa
= xtensa_isa_init (0, 0);
2116 /* ELF relocs are against symbols. If we are producing relocatable
2117 output, and the reloc is against an external symbol, the resulting
2118 reloc will also be against the same symbol. In such a case, we
2119 don't want to change anything about the way the reloc is handled,
2120 since it will all be done at final link time. This test is similar
2121 to what bfd_elf_generic_reloc does except that it lets relocs with
2122 howto->partial_inplace go through even if the addend is non-zero.
2123 (The real problem is that partial_inplace is set for XTENSA_32
2124 relocs to begin with, but that's a long story and there's little we
2125 can do about it now....) */
2127 if (output_bfd
&& (symbol
->flags
& BSF_SECTION_SYM
) == 0)
2129 reloc_entry
->address
+= input_section
->output_offset
;
2130 return bfd_reloc_ok
;
2133 /* Is the address of the relocation really within the section? */
2134 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
2135 return bfd_reloc_outofrange
;
2137 /* Work out which section the relocation is targeted at and the
2138 initial relocation command value. */
2140 /* Get symbol value. (Common symbols are special.) */
2141 if (bfd_is_com_section (symbol
->section
))
2144 relocation
= symbol
->value
;
2146 reloc_target_output_section
= symbol
->section
->output_section
;
2148 /* Convert input-section-relative symbol value to absolute. */
2149 if ((output_bfd
&& !howto
->partial_inplace
)
2150 || reloc_target_output_section
== NULL
)
2153 output_base
= reloc_target_output_section
->vma
;
2155 relocation
+= output_base
+ symbol
->section
->output_offset
;
2157 /* Add in supplied addend. */
2158 relocation
+= reloc_entry
->addend
;
2160 /* Here the variable relocation holds the final address of the
2161 symbol we are relocating against, plus any addend. */
2164 if (!howto
->partial_inplace
)
2166 /* This is a partial relocation, and we want to apply the relocation
2167 to the reloc entry rather than the raw data. Everything except
2168 relocations against section symbols has already been handled
2171 BFD_ASSERT (symbol
->flags
& BSF_SECTION_SYM
);
2172 reloc_entry
->addend
= relocation
;
2173 reloc_entry
->address
+= input_section
->output_offset
;
2174 return bfd_reloc_ok
;
2178 reloc_entry
->address
+= input_section
->output_offset
;
2179 reloc_entry
->addend
= 0;
2183 is_weak_undef
= (bfd_is_und_section (symbol
->section
)
2184 && (symbol
->flags
& BSF_WEAK
) != 0);
2185 flag
= elf_xtensa_do_reloc (howto
, abfd
, input_section
, relocation
,
2186 (bfd_byte
*) data
, (bfd_vma
) octets
,
2187 is_weak_undef
, error_message
);
2189 if (flag
== bfd_reloc_dangerous
)
2191 /* Add the symbol name to the error message. */
2192 if (! *error_message
)
2193 *error_message
= "";
2194 *error_message
= vsprint_msg (*error_message
, ": (%s + 0x%lx)",
2195 strlen (symbol
->name
) + 17,
2197 (unsigned long) reloc_entry
->addend
);
2204 /* Set up an entry in the procedure linkage table. */
2207 elf_xtensa_create_plt_entry (struct bfd_link_info
*info
,
2209 unsigned reloc_index
)
2211 asection
*splt
, *sgotplt
;
2212 bfd_vma plt_base
, got_base
;
2213 bfd_vma code_offset
, lit_offset
, abi_offset
;
2216 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
2217 splt
= elf_xtensa_get_plt_section (info
, chunk
);
2218 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
2219 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
2221 plt_base
= splt
->output_section
->vma
+ splt
->output_offset
;
2222 got_base
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
2224 lit_offset
= 8 + (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * 4;
2225 code_offset
= (reloc_index
% PLT_ENTRIES_PER_CHUNK
) * PLT_ENTRY_SIZE
;
2227 /* Fill in the literal entry. This is the offset of the dynamic
2228 relocation entry. */
2229 bfd_put_32 (output_bfd
, reloc_index
* sizeof (Elf32_External_Rela
),
2230 sgotplt
->contents
+ lit_offset
);
2232 /* Fill in the entry in the procedure linkage table. */
2233 memcpy (splt
->contents
+ code_offset
,
2234 (bfd_big_endian (output_bfd
)
2235 ? elf_xtensa_be_plt_entry
[XSHAL_ABI
!= XTHAL_ABI_WINDOWED
]
2236 : elf_xtensa_le_plt_entry
[XSHAL_ABI
!= XTHAL_ABI_WINDOWED
]),
2238 abi_offset
= XSHAL_ABI
== XTHAL_ABI_WINDOWED
? 3 : 0;
2239 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 0,
2240 plt_base
+ code_offset
+ abi_offset
),
2241 splt
->contents
+ code_offset
+ abi_offset
+ 1);
2242 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ 4,
2243 plt_base
+ code_offset
+ abi_offset
+ 3),
2244 splt
->contents
+ code_offset
+ abi_offset
+ 4);
2245 bfd_put_16 (output_bfd
, l32r_offset (got_base
+ lit_offset
,
2246 plt_base
+ code_offset
+ abi_offset
+ 6),
2247 splt
->contents
+ code_offset
+ abi_offset
+ 7);
2249 return plt_base
+ code_offset
;
2253 static bfd_boolean
get_indirect_call_dest_reg (xtensa_opcode
, unsigned *);
2256 replace_tls_insn (Elf_Internal_Rela
*rel
,
2258 asection
*input_section
,
2260 bfd_boolean is_ld_model
,
2261 char **error_message
)
2263 static xtensa_insnbuf ibuff
= NULL
;
2264 static xtensa_insnbuf sbuff
= NULL
;
2265 xtensa_isa isa
= xtensa_default_isa
;
2267 xtensa_opcode old_op
, new_op
;
2268 bfd_size_type input_size
;
2270 unsigned dest_reg
, src_reg
;
2274 ibuff
= xtensa_insnbuf_alloc (isa
);
2275 sbuff
= xtensa_insnbuf_alloc (isa
);
2278 input_size
= bfd_get_section_limit (abfd
, input_section
);
2280 /* Read the instruction into a buffer and decode the opcode. */
2281 xtensa_insnbuf_from_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2282 input_size
- rel
->r_offset
);
2283 fmt
= xtensa_format_decode (isa
, ibuff
);
2284 if (fmt
== XTENSA_UNDEFINED
)
2286 *error_message
= "cannot decode instruction format";
2290 BFD_ASSERT (xtensa_format_num_slots (isa
, fmt
) == 1);
2291 xtensa_format_get_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2293 old_op
= xtensa_opcode_decode (isa
, fmt
, 0, sbuff
);
2294 if (old_op
== XTENSA_UNDEFINED
)
2296 *error_message
= "cannot decode instruction opcode";
2300 r_type
= ELF32_R_TYPE (rel
->r_info
);
2303 case R_XTENSA_TLS_FUNC
:
2304 case R_XTENSA_TLS_ARG
:
2305 if (old_op
!= get_l32r_opcode ()
2306 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2307 sbuff
, &dest_reg
) != 0)
2309 *error_message
= "cannot extract L32R destination for TLS access";
2314 case R_XTENSA_TLS_CALL
:
2315 if (! get_indirect_call_dest_reg (old_op
, &dest_reg
)
2316 || xtensa_operand_get_field (isa
, old_op
, 0, fmt
, 0,
2317 sbuff
, &src_reg
) != 0)
2319 *error_message
= "cannot extract CALLXn operands for TLS access";
2332 case R_XTENSA_TLS_FUNC
:
2333 case R_XTENSA_TLS_ARG
:
2334 /* Change the instruction to a NOP (or "OR a1, a1, a1" for older
2335 versions of Xtensa). */
2336 new_op
= xtensa_opcode_lookup (isa
, "nop");
2337 if (new_op
== XTENSA_UNDEFINED
)
2339 new_op
= xtensa_opcode_lookup (isa
, "or");
2340 if (new_op
== XTENSA_UNDEFINED
2341 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2342 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2344 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2346 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2349 *error_message
= "cannot encode OR for TLS access";
2355 if (xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0)
2357 *error_message
= "cannot encode NOP for TLS access";
2363 case R_XTENSA_TLS_CALL
:
2364 /* Read THREADPTR into the CALLX's return value register. */
2365 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2366 if (new_op
== XTENSA_UNDEFINED
2367 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2368 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2369 sbuff
, dest_reg
+ 2) != 0)
2371 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2381 case R_XTENSA_TLS_FUNC
:
2382 new_op
= xtensa_opcode_lookup (isa
, "rur.threadptr");
2383 if (new_op
== XTENSA_UNDEFINED
2384 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2385 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2386 sbuff
, dest_reg
) != 0)
2388 *error_message
= "cannot encode RUR.THREADPTR for TLS access";
2393 case R_XTENSA_TLS_ARG
:
2394 /* Nothing to do. Keep the original L32R instruction. */
2397 case R_XTENSA_TLS_CALL
:
2398 /* Add the CALLX's src register (holding the THREADPTR value)
2399 to the first argument register (holding the offset) and put
2400 the result in the CALLX's return value register. */
2401 new_op
= xtensa_opcode_lookup (isa
, "add");
2402 if (new_op
== XTENSA_UNDEFINED
2403 || xtensa_opcode_encode (isa
, fmt
, 0, sbuff
, new_op
) != 0
2404 || xtensa_operand_set_field (isa
, new_op
, 0, fmt
, 0,
2405 sbuff
, dest_reg
+ 2) != 0
2406 || xtensa_operand_set_field (isa
, new_op
, 1, fmt
, 0,
2407 sbuff
, dest_reg
+ 2) != 0
2408 || xtensa_operand_set_field (isa
, new_op
, 2, fmt
, 0,
2409 sbuff
, src_reg
) != 0)
2411 *error_message
= "cannot encode ADD for TLS access";
2418 xtensa_format_set_slot (isa
, fmt
, 0, ibuff
, sbuff
);
2419 xtensa_insnbuf_to_chars (isa
, ibuff
, contents
+ rel
->r_offset
,
2420 input_size
- rel
->r_offset
);
2426 #define IS_XTENSA_TLS_RELOC(R_TYPE) \
2427 ((R_TYPE) == R_XTENSA_TLSDESC_FN \
2428 || (R_TYPE) == R_XTENSA_TLSDESC_ARG \
2429 || (R_TYPE) == R_XTENSA_TLS_DTPOFF \
2430 || (R_TYPE) == R_XTENSA_TLS_TPOFF \
2431 || (R_TYPE) == R_XTENSA_TLS_FUNC \
2432 || (R_TYPE) == R_XTENSA_TLS_ARG \
2433 || (R_TYPE) == R_XTENSA_TLS_CALL)
2435 /* Relocate an Xtensa ELF section. This is invoked by the linker for
2436 both relocatable and final links. */
2439 elf_xtensa_relocate_section (bfd
*output_bfd
,
2440 struct bfd_link_info
*info
,
2442 asection
*input_section
,
2444 Elf_Internal_Rela
*relocs
,
2445 Elf_Internal_Sym
*local_syms
,
2446 asection
**local_sections
)
2448 struct elf_xtensa_link_hash_table
*htab
;
2449 Elf_Internal_Shdr
*symtab_hdr
;
2450 Elf_Internal_Rela
*rel
;
2451 Elf_Internal_Rela
*relend
;
2452 struct elf_link_hash_entry
**sym_hashes
;
2453 property_table_entry
*lit_table
= 0;
2455 char *local_got_tls_types
;
2456 char *error_message
= NULL
;
2457 bfd_size_type input_size
;
2460 if (!xtensa_default_isa
)
2461 xtensa_default_isa
= xtensa_isa_init (0, 0);
2463 if (!is_xtensa_elf (input_bfd
))
2465 bfd_set_error (bfd_error_wrong_format
);
2469 htab
= elf_xtensa_hash_table (info
);
2473 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2474 sym_hashes
= elf_sym_hashes (input_bfd
);
2475 local_got_tls_types
= elf_xtensa_local_got_tls_type (input_bfd
);
2477 if (elf_hash_table (info
)->dynamic_sections_created
)
2479 ltblsize
= xtensa_read_table_entries (input_bfd
, input_section
,
2480 &lit_table
, XTENSA_LIT_SEC_NAME
,
2486 input_size
= bfd_get_section_limit (input_bfd
, input_section
);
2489 relend
= relocs
+ input_section
->reloc_count
;
2490 for (; rel
< relend
; rel
++)
2493 reloc_howto_type
*howto
;
2494 unsigned long r_symndx
;
2495 struct elf_link_hash_entry
*h
;
2496 Elf_Internal_Sym
*sym
;
2501 bfd_reloc_status_type r
;
2502 bfd_boolean is_weak_undef
;
2503 bfd_boolean unresolved_reloc
;
2505 bfd_boolean dynamic_symbol
;
2507 r_type
= ELF32_R_TYPE (rel
->r_info
);
2508 if (r_type
== (int) R_XTENSA_GNU_VTINHERIT
2509 || r_type
== (int) R_XTENSA_GNU_VTENTRY
)
2512 if (r_type
< 0 || r_type
>= (int) R_XTENSA_max
)
2514 bfd_set_error (bfd_error_bad_value
);
2517 howto
= &elf_howto_table
[r_type
];
2519 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2524 is_weak_undef
= FALSE
;
2525 unresolved_reloc
= FALSE
;
2528 if (howto
->partial_inplace
&& !bfd_link_relocatable (info
))
2530 /* Because R_XTENSA_32 was made partial_inplace to fix some
2531 problems with DWARF info in partial links, there may be
2532 an addend stored in the contents. Take it out of there
2533 and move it back into the addend field of the reloc. */
2534 rel
->r_addend
+= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2535 bfd_put_32 (input_bfd
, 0, contents
+ rel
->r_offset
);
2538 if (r_symndx
< symtab_hdr
->sh_info
)
2540 sym
= local_syms
+ r_symndx
;
2541 sym_type
= ELF32_ST_TYPE (sym
->st_info
);
2542 sec
= local_sections
[r_symndx
];
2543 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2547 bfd_boolean ignored
;
2549 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2550 r_symndx
, symtab_hdr
, sym_hashes
,
2552 unresolved_reloc
, warned
, ignored
);
2555 && !unresolved_reloc
2556 && h
->root
.type
== bfd_link_hash_undefweak
)
2557 is_weak_undef
= TRUE
;
2562 if (sec
!= NULL
&& discarded_section (sec
))
2563 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2564 rel
, 1, relend
, howto
, 0, contents
);
2566 if (bfd_link_relocatable (info
))
2569 asection
* sym_sec
= get_elf_r_symndx_section (input_bfd
, r_symndx
);
2571 /* This is a relocatable link.
2572 1) If the reloc is against a section symbol, adjust
2573 according to the output section.
2574 2) If there is a new target for this relocation,
2575 the new target will be in the same output section.
2576 We adjust the relocation by the output section
2579 if (relaxing_section
)
2581 /* Check if this references a section in another input file. */
2582 if (!do_fix_for_relocatable_link (rel
, input_bfd
, input_section
,
2587 dest_addr
= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
2588 + get_elf_r_symndx_offset (input_bfd
, r_symndx
) + rel
->r_addend
;
2590 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
2592 error_message
= NULL
;
2593 /* Convert ASM_SIMPLIFY into the simpler relocation
2594 so that they never escape a relaxing link. */
2595 r
= contract_asm_expansion (contents
, input_size
, rel
,
2597 if (r
!= bfd_reloc_ok
)
2598 (*info
->callbacks
->reloc_dangerous
)
2599 (info
, error_message
,
2600 input_bfd
, input_section
, rel
->r_offset
);
2602 r_type
= ELF32_R_TYPE (rel
->r_info
);
2605 /* This is a relocatable link, so we don't have to change
2606 anything unless the reloc is against a section symbol,
2607 in which case we have to adjust according to where the
2608 section symbol winds up in the output section. */
2609 if (r_symndx
< symtab_hdr
->sh_info
)
2611 sym
= local_syms
+ r_symndx
;
2612 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2614 sec
= local_sections
[r_symndx
];
2615 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
2619 /* If there is an addend with a partial_inplace howto,
2620 then move the addend to the contents. This is a hack
2621 to work around problems with DWARF in relocatable links
2622 with some previous version of BFD. Now we can't easily get
2623 rid of the hack without breaking backward compatibility.... */
2625 howto
= &elf_howto_table
[r_type
];
2626 if (howto
->partial_inplace
&& rel
->r_addend
)
2628 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2629 rel
->r_addend
, contents
,
2630 rel
->r_offset
, FALSE
,
2636 /* Put the correct bits in the target instruction, even
2637 though the relocation will still be present in the output
2638 file. This makes disassembly clearer, as well as
2639 allowing loadable kernel modules to work without needing
2640 relocations on anything other than calls and l32r's. */
2642 /* If it is not in the same section, there is nothing we can do. */
2643 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
&&
2644 sym_sec
->output_section
== input_section
->output_section
)
2646 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2647 dest_addr
, contents
,
2648 rel
->r_offset
, FALSE
,
2652 if (r
!= bfd_reloc_ok
)
2653 (*info
->callbacks
->reloc_dangerous
)
2654 (info
, error_message
,
2655 input_bfd
, input_section
, rel
->r_offset
);
2657 /* Done with work for relocatable link; continue with next reloc. */
2661 /* This is a final link. */
2663 if (relaxing_section
)
2665 /* Check if this references a section in another input file. */
2666 do_fix_for_final_link (rel
, input_bfd
, input_section
, contents
,
2670 /* Sanity check the address. */
2671 if (rel
->r_offset
>= input_size
2672 && ELF32_R_TYPE (rel
->r_info
) != R_XTENSA_NONE
)
2675 /* xgettext:c-format */
2676 (_("%pB(%pA+%#" PRIx64
"): "
2677 "relocation offset out of range (size=%#" PRIx64
")"),
2678 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
2679 (uint64_t) input_size
);
2680 bfd_set_error (bfd_error_bad_value
);
2685 name
= h
->root
.root
.string
;
2688 name
= (bfd_elf_string_from_elf_section
2689 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2690 if (name
== NULL
|| *name
== '\0')
2691 name
= bfd_section_name (sec
);
2694 if (r_symndx
!= STN_UNDEF
2695 && r_type
!= R_XTENSA_NONE
2697 || h
->root
.type
== bfd_link_hash_defined
2698 || h
->root
.type
== bfd_link_hash_defweak
)
2699 && IS_XTENSA_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
2702 ((sym_type
== STT_TLS
2703 /* xgettext:c-format */
2704 ? _("%pB(%pA+%#" PRIx64
"): %s used with TLS symbol %s")
2705 /* xgettext:c-format */
2706 : _("%pB(%pA+%#" PRIx64
"): %s used with non-TLS symbol %s")),
2709 (uint64_t) rel
->r_offset
,
2714 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
2716 tls_type
= GOT_UNKNOWN
;
2718 tls_type
= elf_xtensa_hash_entry (h
)->tls_type
;
2719 else if (local_got_tls_types
)
2720 tls_type
= local_got_tls_types
[r_symndx
];
2726 if (elf_hash_table (info
)->dynamic_sections_created
2727 && (input_section
->flags
& SEC_ALLOC
) != 0
2728 && (dynamic_symbol
|| bfd_link_pic (info
)))
2730 Elf_Internal_Rela outrel
;
2734 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
2735 srel
= htab
->elf
.srelplt
;
2737 srel
= htab
->elf
.srelgot
;
2739 BFD_ASSERT (srel
!= NULL
);
2742 _bfd_elf_section_offset (output_bfd
, info
,
2743 input_section
, rel
->r_offset
);
2745 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
2746 memset (&outrel
, 0, sizeof outrel
);
2749 outrel
.r_offset
+= (input_section
->output_section
->vma
2750 + input_section
->output_offset
);
2752 /* Complain if the relocation is in a read-only section
2753 and not in a literal pool. */
2754 if ((input_section
->flags
& SEC_READONLY
) != 0
2755 && !elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2759 _("dynamic relocation in read-only section");
2760 (*info
->callbacks
->reloc_dangerous
)
2761 (info
, error_message
,
2762 input_bfd
, input_section
, rel
->r_offset
);
2767 outrel
.r_addend
= rel
->r_addend
;
2770 if (r_type
== R_XTENSA_32
)
2773 ELF32_R_INFO (h
->dynindx
, R_XTENSA_GLOB_DAT
);
2776 else /* r_type == R_XTENSA_PLT */
2779 ELF32_R_INFO (h
->dynindx
, R_XTENSA_JMP_SLOT
);
2781 /* Create the PLT entry and set the initial
2782 contents of the literal entry to the address of
2785 elf_xtensa_create_plt_entry (info
, output_bfd
,
2788 unresolved_reloc
= FALSE
;
2790 else if (!is_weak_undef
)
2792 /* Generate a RELATIVE relocation. */
2793 outrel
.r_info
= ELF32_R_INFO (0, R_XTENSA_RELATIVE
);
2794 outrel
.r_addend
= 0;
2802 loc
= (srel
->contents
2803 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2804 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2805 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2808 else if (r_type
== R_XTENSA_ASM_EXPAND
&& dynamic_symbol
)
2810 /* This should only happen for non-PIC code, which is not
2811 supposed to be used on systems with dynamic linking.
2812 Just ignore these relocations. */
2817 case R_XTENSA_TLS_TPOFF
:
2818 /* Switch to LE model for local symbols in an executable. */
2819 if (! bfd_link_pic (info
) && ! dynamic_symbol
)
2821 relocation
= tpoff (info
, relocation
);
2826 case R_XTENSA_TLSDESC_FN
:
2827 case R_XTENSA_TLSDESC_ARG
:
2829 if (r_type
== R_XTENSA_TLSDESC_FN
)
2831 if (! bfd_link_pic (info
) || (tls_type
& GOT_TLS_IE
) != 0)
2832 r_type
= R_XTENSA_NONE
;
2834 else if (r_type
== R_XTENSA_TLSDESC_ARG
)
2836 if (bfd_link_pic (info
))
2838 if ((tls_type
& GOT_TLS_IE
) != 0)
2839 r_type
= R_XTENSA_TLS_TPOFF
;
2843 r_type
= R_XTENSA_TLS_TPOFF
;
2844 if (! dynamic_symbol
)
2846 relocation
= tpoff (info
, relocation
);
2852 if (r_type
== R_XTENSA_NONE
)
2853 /* Nothing to do here; skip to the next reloc. */
2856 if (! elf_hash_table (info
)->dynamic_sections_created
)
2859 _("TLS relocation invalid without dynamic sections");
2860 (*info
->callbacks
->reloc_dangerous
)
2861 (info
, error_message
,
2862 input_bfd
, input_section
, rel
->r_offset
);
2866 Elf_Internal_Rela outrel
;
2868 asection
*srel
= htab
->elf
.srelgot
;
2871 outrel
.r_offset
= (input_section
->output_section
->vma
2872 + input_section
->output_offset
2875 /* Complain if the relocation is in a read-only section
2876 and not in a literal pool. */
2877 if ((input_section
->flags
& SEC_READONLY
) != 0
2878 && ! elf_xtensa_in_literal_pool (lit_table
, ltblsize
,
2882 _("dynamic relocation in read-only section");
2883 (*info
->callbacks
->reloc_dangerous
)
2884 (info
, error_message
,
2885 input_bfd
, input_section
, rel
->r_offset
);
2888 indx
= h
&& h
->dynindx
!= -1 ? h
->dynindx
: 0;
2890 outrel
.r_addend
= relocation
- dtpoff_base (info
);
2892 outrel
.r_addend
= 0;
2895 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
2897 unresolved_reloc
= FALSE
;
2900 loc
= (srel
->contents
2901 + srel
->reloc_count
++ * sizeof (Elf32_External_Rela
));
2902 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
2903 BFD_ASSERT (sizeof (Elf32_External_Rela
) * srel
->reloc_count
2909 case R_XTENSA_TLS_DTPOFF
:
2910 if (! bfd_link_pic (info
))
2911 /* Switch from LD model to LE model. */
2912 relocation
= tpoff (info
, relocation
);
2914 relocation
-= dtpoff_base (info
);
2917 case R_XTENSA_TLS_FUNC
:
2918 case R_XTENSA_TLS_ARG
:
2919 case R_XTENSA_TLS_CALL
:
2920 /* Check if optimizing to IE or LE model. */
2921 if ((tls_type
& GOT_TLS_IE
) != 0)
2923 bfd_boolean is_ld_model
=
2924 (h
&& elf_xtensa_hash_entry (h
) == htab
->tlsbase
);
2925 if (! replace_tls_insn (rel
, input_bfd
, input_section
, contents
,
2926 is_ld_model
, &error_message
))
2927 (*info
->callbacks
->reloc_dangerous
)
2928 (info
, error_message
,
2929 input_bfd
, input_section
, rel
->r_offset
);
2931 if (r_type
!= R_XTENSA_TLS_ARG
|| is_ld_model
)
2933 /* Skip subsequent relocations on the same instruction. */
2934 while (rel
+ 1 < relend
&& rel
[1].r_offset
== rel
->r_offset
)
2941 if (elf_hash_table (info
)->dynamic_sections_created
2942 && dynamic_symbol
&& (is_operand_relocation (r_type
)
2943 || r_type
== R_XTENSA_32_PCREL
))
2946 vsprint_msg ("invalid relocation for dynamic symbol", ": %s",
2947 strlen (name
) + 2, name
);
2948 (*info
->callbacks
->reloc_dangerous
)
2949 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
2955 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2956 because such sections are not SEC_ALLOC and thus ld.so will
2957 not process them. */
2958 if (unresolved_reloc
2959 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2961 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2962 rel
->r_offset
) != (bfd_vma
) -1)
2965 /* xgettext:c-format */
2966 (_("%pB(%pA+%#" PRIx64
"): "
2967 "unresolvable %s relocation against symbol `%s'"),
2970 (uint64_t) rel
->r_offset
,
2976 /* TLS optimizations may have changed r_type; update "howto". */
2977 howto
= &elf_howto_table
[r_type
];
2979 /* There's no point in calling bfd_perform_relocation here.
2980 Just go directly to our "special function". */
2981 r
= elf_xtensa_do_reloc (howto
, input_bfd
, input_section
,
2982 relocation
+ rel
->r_addend
,
2983 contents
, rel
->r_offset
, is_weak_undef
,
2986 if (r
!= bfd_reloc_ok
&& !warned
)
2988 BFD_ASSERT (r
== bfd_reloc_dangerous
|| r
== bfd_reloc_other
);
2989 BFD_ASSERT (error_message
!= NULL
);
2991 if (rel
->r_addend
== 0)
2992 error_message
= vsprint_msg (error_message
, ": %s",
2993 strlen (name
) + 2, name
);
2995 error_message
= vsprint_msg (error_message
, ": (%s+0x%x)",
2997 name
, (int) rel
->r_addend
);
2999 (*info
->callbacks
->reloc_dangerous
)
3000 (info
, error_message
, input_bfd
, input_section
, rel
->r_offset
);
3007 input_section
->reloc_done
= TRUE
;
3013 /* Finish up dynamic symbol handling. There's not much to do here since
3014 the PLT and GOT entries are all set up by relocate_section. */
3017 elf_xtensa_finish_dynamic_symbol (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3018 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3019 struct elf_link_hash_entry
*h
,
3020 Elf_Internal_Sym
*sym
)
3022 if (h
->needs_plt
&& !h
->def_regular
)
3024 /* Mark the symbol as undefined, rather than as defined in
3025 the .plt section. Leave the value alone. */
3026 sym
->st_shndx
= SHN_UNDEF
;
3027 /* If the symbol is weak, we do need to clear the value.
3028 Otherwise, the PLT entry would provide a definition for
3029 the symbol even if the symbol wasn't defined anywhere,
3030 and so the symbol would never be NULL. */
3031 if (!h
->ref_regular_nonweak
)
3035 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3036 if (h
== elf_hash_table (info
)->hdynamic
3037 || h
== elf_hash_table (info
)->hgot
)
3038 sym
->st_shndx
= SHN_ABS
;
3044 /* Combine adjacent literal table entries in the output. Adjacent
3045 entries within each input section may have been removed during
3046 relaxation, but we repeat the process here, even though it's too late
3047 to shrink the output section, because it's important to minimize the
3048 number of literal table entries to reduce the start-up work for the
3049 runtime linker. Returns the number of remaining table entries or -1
3053 elf_xtensa_combine_prop_entries (bfd
*output_bfd
,
3058 property_table_entry
*table
;
3059 bfd_size_type section_size
, sgotloc_size
;
3063 section_size
= sxtlit
->size
;
3064 BFD_ASSERT (section_size
% 8 == 0);
3065 num
= section_size
/ 8;
3067 sgotloc_size
= sgotloc
->size
;
3068 if (sgotloc_size
!= section_size
)
3071 (_("internal inconsistency in size of .got.loc section"));
3075 table
= bfd_malloc (num
* sizeof (property_table_entry
));
3079 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
3080 propagates to the output section, where it doesn't really apply and
3081 where it breaks the following call to bfd_malloc_and_get_section. */
3082 sxtlit
->flags
&= ~SEC_IN_MEMORY
;
3084 if (!bfd_malloc_and_get_section (output_bfd
, sxtlit
, &contents
))
3092 /* There should never be any relocations left at this point, so this
3093 is quite a bit easier than what is done during relaxation. */
3095 /* Copy the raw contents into a property table array and sort it. */
3097 for (n
= 0; n
< num
; n
++)
3099 table
[n
].address
= bfd_get_32 (output_bfd
, &contents
[offset
]);
3100 table
[n
].size
= bfd_get_32 (output_bfd
, &contents
[offset
+ 4]);
3103 qsort (table
, num
, sizeof (property_table_entry
), property_table_compare
);
3105 for (n
= 0; n
< num
; n
++)
3107 bfd_boolean remove_entry
= FALSE
;
3109 if (table
[n
].size
== 0)
3110 remove_entry
= TRUE
;
3112 && (table
[n
-1].address
+ table
[n
-1].size
== table
[n
].address
))
3114 table
[n
-1].size
+= table
[n
].size
;
3115 remove_entry
= TRUE
;
3120 for (m
= n
; m
< num
- 1; m
++)
3122 table
[m
].address
= table
[m
+1].address
;
3123 table
[m
].size
= table
[m
+1].size
;
3131 /* Copy the data back to the raw contents. */
3133 for (n
= 0; n
< num
; n
++)
3135 bfd_put_32 (output_bfd
, table
[n
].address
, &contents
[offset
]);
3136 bfd_put_32 (output_bfd
, table
[n
].size
, &contents
[offset
+ 4]);
3140 /* Clear the removed bytes. */
3141 if ((bfd_size_type
) (num
* 8) < section_size
)
3142 memset (&contents
[num
* 8], 0, section_size
- num
* 8);
3144 if (! bfd_set_section_contents (output_bfd
, sxtlit
, contents
, 0,
3148 /* Copy the contents to ".got.loc". */
3149 memcpy (sgotloc
->contents
, contents
, section_size
);
3157 /* Finish up the dynamic sections. */
3160 elf_xtensa_finish_dynamic_sections (bfd
*output_bfd
,
3161 struct bfd_link_info
*info
)
3163 struct elf_xtensa_link_hash_table
*htab
;
3165 asection
*sdyn
, *srelplt
, *srelgot
, *sgot
, *sxtlit
, *sgotloc
;
3166 Elf32_External_Dyn
*dyncon
, *dynconend
;
3167 int num_xtlit_entries
= 0;
3169 if (! elf_hash_table (info
)->dynamic_sections_created
)
3172 htab
= elf_xtensa_hash_table (info
);
3176 dynobj
= elf_hash_table (info
)->dynobj
;
3177 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3178 BFD_ASSERT (sdyn
!= NULL
);
3180 /* Set the first entry in the global offset table to the address of
3181 the dynamic section. */
3182 sgot
= htab
->elf
.sgot
;
3185 BFD_ASSERT (sgot
->size
== 4);
3187 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3189 bfd_put_32 (output_bfd
,
3190 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
3194 srelplt
= htab
->elf
.srelplt
;
3195 srelgot
= htab
->elf
.srelgot
;
3196 if (srelplt
&& srelplt
->size
!= 0)
3198 asection
*sgotplt
, *spltlittbl
;
3199 int chunk
, plt_chunks
, plt_entries
;
3200 Elf_Internal_Rela irela
;
3202 unsigned rtld_reloc
;
3204 spltlittbl
= htab
->spltlittbl
;
3205 BFD_ASSERT (srelgot
!= NULL
&& spltlittbl
!= NULL
);
3207 /* Find the first XTENSA_RTLD relocation. Presumably the rest
3208 of them follow immediately after.... */
3209 for (rtld_reloc
= 0; rtld_reloc
< srelgot
->reloc_count
; rtld_reloc
++)
3211 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3212 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3213 if (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
)
3216 BFD_ASSERT (rtld_reloc
< srelgot
->reloc_count
);
3218 plt_entries
= srelplt
->size
/ sizeof (Elf32_External_Rela
);
3220 (plt_entries
+ PLT_ENTRIES_PER_CHUNK
- 1) / PLT_ENTRIES_PER_CHUNK
;
3222 for (chunk
= 0; chunk
< plt_chunks
; chunk
++)
3224 int chunk_entries
= 0;
3226 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
3227 BFD_ASSERT (sgotplt
!= NULL
);
3229 /* Emit special RTLD relocations for the first two entries in
3230 each chunk of the .got.plt section. */
3232 loc
= srelgot
->contents
+ rtld_reloc
* sizeof (Elf32_External_Rela
);
3233 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3234 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3235 irela
.r_offset
= (sgotplt
->output_section
->vma
3236 + sgotplt
->output_offset
);
3237 irela
.r_addend
= 1; /* tell rtld to set value to resolver function */
3238 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3240 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3242 /* Next literal immediately follows the first. */
3243 loc
+= sizeof (Elf32_External_Rela
);
3244 bfd_elf32_swap_reloca_in (output_bfd
, loc
, &irela
);
3245 BFD_ASSERT (ELF32_R_TYPE (irela
.r_info
) == R_XTENSA_RTLD
);
3246 irela
.r_offset
= (sgotplt
->output_section
->vma
3247 + sgotplt
->output_offset
+ 4);
3248 /* Tell rtld to set value to object's link map. */
3250 bfd_elf32_swap_reloca_out (output_bfd
, &irela
, loc
);
3252 BFD_ASSERT (rtld_reloc
<= srelgot
->reloc_count
);
3254 /* Fill in the literal table. */
3255 if (chunk
< plt_chunks
- 1)
3256 chunk_entries
= PLT_ENTRIES_PER_CHUNK
;
3258 chunk_entries
= plt_entries
- (chunk
* PLT_ENTRIES_PER_CHUNK
);
3260 BFD_ASSERT ((unsigned) (chunk
+ 1) * 8 <= spltlittbl
->size
);
3261 bfd_put_32 (output_bfd
,
3262 sgotplt
->output_section
->vma
+ sgotplt
->output_offset
,
3263 spltlittbl
->contents
+ (chunk
* 8) + 0);
3264 bfd_put_32 (output_bfd
,
3265 8 + (chunk_entries
* 4),
3266 spltlittbl
->contents
+ (chunk
* 8) + 4);
3269 /* The .xt.lit.plt section has just been modified. This must
3270 happen before the code below which combines adjacent literal
3271 table entries, and the .xt.lit.plt contents have to be forced to
3273 if (! bfd_set_section_contents (output_bfd
,
3274 spltlittbl
->output_section
,
3275 spltlittbl
->contents
,
3276 spltlittbl
->output_offset
,
3279 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
3280 spltlittbl
->flags
&= ~SEC_HAS_CONTENTS
;
3283 /* All the dynamic relocations have been emitted at this point.
3284 Make sure the relocation sections are the correct size. */
3285 if ((srelgot
&& srelgot
->size
!= (sizeof (Elf32_External_Rela
)
3286 * srelgot
->reloc_count
))
3287 || (srelplt
&& srelplt
->size
!= (sizeof (Elf32_External_Rela
)
3288 * srelplt
->reloc_count
)))
3291 /* Combine adjacent literal table entries. */
3292 BFD_ASSERT (! bfd_link_relocatable (info
));
3293 sxtlit
= bfd_get_section_by_name (output_bfd
, ".xt.lit");
3294 sgotloc
= htab
->sgotloc
;
3295 BFD_ASSERT (sgotloc
);
3299 elf_xtensa_combine_prop_entries (output_bfd
, sxtlit
, sgotloc
);
3300 if (num_xtlit_entries
< 0)
3304 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
3305 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
3306 for (; dyncon
< dynconend
; dyncon
++)
3308 Elf_Internal_Dyn dyn
;
3310 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3317 case DT_XTENSA_GOT_LOC_SZ
:
3318 dyn
.d_un
.d_val
= num_xtlit_entries
;
3321 case DT_XTENSA_GOT_LOC_OFF
:
3322 dyn
.d_un
.d_ptr
= (htab
->sgotloc
->output_section
->vma
3323 + htab
->sgotloc
->output_offset
);
3327 dyn
.d_un
.d_ptr
= (htab
->elf
.sgot
->output_section
->vma
3328 + htab
->elf
.sgot
->output_offset
);
3332 dyn
.d_un
.d_ptr
= (htab
->elf
.srelplt
->output_section
->vma
3333 + htab
->elf
.srelplt
->output_offset
);
3337 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
3341 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3348 /* Functions for dealing with the e_flags field. */
3350 /* Merge backend specific data from an object file to the output
3351 object file when linking. */
3354 elf_xtensa_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3356 bfd
*obfd
= info
->output_bfd
;
3357 unsigned out_mach
, in_mach
;
3358 flagword out_flag
, in_flag
;
3360 /* Check if we have the same endianness. */
3361 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
3364 /* Don't even pretend to support mixed-format linking. */
3365 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3366 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3369 out_flag
= elf_elfheader (obfd
)->e_flags
;
3370 in_flag
= elf_elfheader (ibfd
)->e_flags
;
3372 out_mach
= out_flag
& EF_XTENSA_MACH
;
3373 in_mach
= in_flag
& EF_XTENSA_MACH
;
3374 if (out_mach
!= in_mach
)
3377 /* xgettext:c-format */
3378 (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"),
3379 ibfd
, out_mach
, in_mach
);
3380 bfd_set_error (bfd_error_wrong_format
);
3384 if (! elf_flags_init (obfd
))
3386 elf_flags_init (obfd
) = TRUE
;
3387 elf_elfheader (obfd
)->e_flags
= in_flag
;
3389 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3390 && bfd_get_arch_info (obfd
)->the_default
)
3391 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3392 bfd_get_mach (ibfd
));
3397 if ((out_flag
& EF_XTENSA_XT_INSN
) != (in_flag
& EF_XTENSA_XT_INSN
))
3398 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_INSN
);
3400 if ((out_flag
& EF_XTENSA_XT_LIT
) != (in_flag
& EF_XTENSA_XT_LIT
))
3401 elf_elfheader (obfd
)->e_flags
&= (~ EF_XTENSA_XT_LIT
);
3408 elf_xtensa_set_private_flags (bfd
*abfd
, flagword flags
)
3410 BFD_ASSERT (!elf_flags_init (abfd
)
3411 || elf_elfheader (abfd
)->e_flags
== flags
);
3413 elf_elfheader (abfd
)->e_flags
|= flags
;
3414 elf_flags_init (abfd
) = TRUE
;
3421 elf_xtensa_print_private_bfd_data (bfd
*abfd
, void *farg
)
3423 FILE *f
= (FILE *) farg
;
3424 flagword e_flags
= elf_elfheader (abfd
)->e_flags
;
3426 fprintf (f
, "\nXtensa header:\n");
3427 if ((e_flags
& EF_XTENSA_MACH
) == E_XTENSA_MACH
)
3428 fprintf (f
, "\nMachine = Base\n");
3430 fprintf (f
, "\nMachine Id = 0x%x\n", e_flags
& EF_XTENSA_MACH
);
3432 fprintf (f
, "Insn tables = %s\n",
3433 (e_flags
& EF_XTENSA_XT_INSN
) ? "true" : "false");
3435 fprintf (f
, "Literal tables = %s\n",
3436 (e_flags
& EF_XTENSA_XT_LIT
) ? "true" : "false");
3438 return _bfd_elf_print_private_bfd_data (abfd
, farg
);
3442 /* Set the right machine number for an Xtensa ELF file. */
3445 elf_xtensa_object_p (bfd
*abfd
)
3448 unsigned long arch
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3453 mach
= bfd_mach_xtensa
;
3459 (void) bfd_default_set_arch_mach (abfd
, bfd_arch_xtensa
, mach
);
3464 /* The final processing done just before writing out an Xtensa ELF object
3465 file. This gets the Xtensa architecture right based on the machine
3469 elf_xtensa_final_write_processing (bfd
*abfd
)
3472 unsigned long val
= elf_elfheader (abfd
)->e_flags
& EF_XTENSA_MACH
;
3474 switch (mach
= bfd_get_mach (abfd
))
3476 case bfd_mach_xtensa
:
3477 val
= E_XTENSA_MACH
;
3483 elf_elfheader (abfd
)->e_flags
&= ~EF_XTENSA_MACH
;
3484 elf_elfheader (abfd
)->e_flags
|= val
;
3485 return _bfd_elf_final_write_processing (abfd
);
3489 static enum elf_reloc_type_class
3490 elf_xtensa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3491 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3492 const Elf_Internal_Rela
*rela
)
3494 switch ((int) ELF32_R_TYPE (rela
->r_info
))
3496 case R_XTENSA_RELATIVE
:
3497 return reloc_class_relative
;
3498 case R_XTENSA_JMP_SLOT
:
3499 return reloc_class_plt
;
3501 return reloc_class_normal
;
3507 elf_xtensa_discard_info_for_section (bfd
*abfd
,
3508 struct elf_reloc_cookie
*cookie
,
3509 struct bfd_link_info
*info
,
3513 bfd_vma offset
, actual_offset
;
3514 bfd_size_type removed_bytes
= 0;
3515 bfd_size_type entry_size
;
3517 if (sec
->output_section
3518 && bfd_is_abs_section (sec
->output_section
))
3521 if (xtensa_is_proptable_section (sec
))
3526 if (sec
->size
== 0 || sec
->size
% entry_size
!= 0)
3529 contents
= retrieve_contents (abfd
, sec
, info
->keep_memory
);
3533 cookie
->rels
= retrieve_internal_relocs (abfd
, sec
, info
->keep_memory
);
3536 release_contents (sec
, contents
);
3540 /* Sort the relocations. They should already be in order when
3541 relaxation is enabled, but it might not be. */
3542 qsort (cookie
->rels
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
3543 internal_reloc_compare
);
3545 cookie
->rel
= cookie
->rels
;
3546 cookie
->relend
= cookie
->rels
+ sec
->reloc_count
;
3548 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
3550 actual_offset
= offset
- removed_bytes
;
3552 /* The ...symbol_deleted_p function will skip over relocs but it
3553 won't adjust their offsets, so do that here. */
3554 while (cookie
->rel
< cookie
->relend
3555 && cookie
->rel
->r_offset
< offset
)
3557 cookie
->rel
->r_offset
-= removed_bytes
;
3561 while (cookie
->rel
< cookie
->relend
3562 && cookie
->rel
->r_offset
== offset
)
3564 if (bfd_elf_reloc_symbol_deleted_p (offset
, cookie
))
3566 /* Remove the table entry. (If the reloc type is NONE, then
3567 the entry has already been merged with another and deleted
3568 during relaxation.) */
3569 if (ELF32_R_TYPE (cookie
->rel
->r_info
) != R_XTENSA_NONE
)
3571 /* Shift the contents up. */
3572 if (offset
+ entry_size
< sec
->size
)
3573 memmove (&contents
[actual_offset
],
3574 &contents
[actual_offset
+ entry_size
],
3575 sec
->size
- offset
- entry_size
);
3576 removed_bytes
+= entry_size
;
3579 /* Remove this relocation. */
3580 cookie
->rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
3583 /* Adjust the relocation offset for previous removals. This
3584 should not be done before calling ...symbol_deleted_p
3585 because it might mess up the offset comparisons there.
3586 Make sure the offset doesn't underflow in the case where
3587 the first entry is removed. */
3588 if (cookie
->rel
->r_offset
>= removed_bytes
)
3589 cookie
->rel
->r_offset
-= removed_bytes
;
3591 cookie
->rel
->r_offset
= 0;
3597 if (removed_bytes
!= 0)
3599 /* Adjust any remaining relocs (shouldn't be any). */
3600 for (; cookie
->rel
< cookie
->relend
; cookie
->rel
++)
3602 if (cookie
->rel
->r_offset
>= removed_bytes
)
3603 cookie
->rel
->r_offset
-= removed_bytes
;
3605 cookie
->rel
->r_offset
= 0;
3608 /* Clear the removed bytes. */
3609 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
3611 pin_contents (sec
, contents
);
3612 pin_internal_relocs (sec
, cookie
->rels
);
3615 if (sec
->rawsize
== 0)
3616 sec
->rawsize
= sec
->size
;
3617 sec
->size
-= removed_bytes
;
3619 if (xtensa_is_littable_section (sec
))
3621 asection
*sgotloc
= elf_xtensa_hash_table (info
)->sgotloc
;
3623 sgotloc
->size
-= removed_bytes
;
3628 release_contents (sec
, contents
);
3629 release_internal_relocs (sec
, cookie
->rels
);
3632 return (removed_bytes
!= 0);
3637 elf_xtensa_discard_info (bfd
*abfd
,
3638 struct elf_reloc_cookie
*cookie
,
3639 struct bfd_link_info
*info
)
3642 bfd_boolean changed
= FALSE
;
3644 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3646 if (xtensa_is_property_section (sec
))
3648 if (elf_xtensa_discard_info_for_section (abfd
, cookie
, info
, sec
))
3658 elf_xtensa_ignore_discarded_relocs (asection
*sec
)
3660 return xtensa_is_property_section (sec
);
3665 elf_xtensa_action_discarded (asection
*sec
)
3667 if (strcmp (".xt_except_table", sec
->name
) == 0)
3670 if (strcmp (".xt_except_desc", sec
->name
) == 0)
3673 return _bfd_elf_default_action_discarded (sec
);
3677 /* Support for core dump NOTE sections. */
3680 elf_xtensa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3685 /* The size for Xtensa is variable, so don't try to recognize the format
3686 based on the size. Just assume this is GNU/Linux. */
3689 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3692 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3696 size
= note
->descsz
- offset
- 4;
3698 /* Make a ".reg/999" section. */
3699 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
3700 size
, note
->descpos
+ offset
);
3705 elf_xtensa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3707 switch (note
->descsz
)
3712 case 128: /* GNU/Linux elf_prpsinfo */
3713 elf_tdata (abfd
)->core
->program
3714 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3715 elf_tdata (abfd
)->core
->command
3716 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3719 /* Note that for some reason, a spurious space is tacked
3720 onto the end of the args in some (at least one anyway)
3721 implementations, so strip it off if it exists. */
3724 char *command
= elf_tdata (abfd
)->core
->command
;
3725 int n
= strlen (command
);
3727 if (0 < n
&& command
[n
- 1] == ' ')
3728 command
[n
- 1] = '\0';
3735 /* Generic Xtensa configurability stuff. */
3737 static xtensa_opcode callx0_op
= XTENSA_UNDEFINED
;
3738 static xtensa_opcode callx4_op
= XTENSA_UNDEFINED
;
3739 static xtensa_opcode callx8_op
= XTENSA_UNDEFINED
;
3740 static xtensa_opcode callx12_op
= XTENSA_UNDEFINED
;
3741 static xtensa_opcode call0_op
= XTENSA_UNDEFINED
;
3742 static xtensa_opcode call4_op
= XTENSA_UNDEFINED
;
3743 static xtensa_opcode call8_op
= XTENSA_UNDEFINED
;
3744 static xtensa_opcode call12_op
= XTENSA_UNDEFINED
;
3747 init_call_opcodes (void)
3749 if (callx0_op
== XTENSA_UNDEFINED
)
3751 callx0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx0");
3752 callx4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx4");
3753 callx8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx8");
3754 callx12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "callx12");
3755 call0_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call0");
3756 call4_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call4");
3757 call8_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call8");
3758 call12_op
= xtensa_opcode_lookup (xtensa_default_isa
, "call12");
3764 is_indirect_call_opcode (xtensa_opcode opcode
)
3766 init_call_opcodes ();
3767 return (opcode
== callx0_op
3768 || opcode
== callx4_op
3769 || opcode
== callx8_op
3770 || opcode
== callx12_op
);
3775 is_direct_call_opcode (xtensa_opcode opcode
)
3777 init_call_opcodes ();
3778 return (opcode
== call0_op
3779 || opcode
== call4_op
3780 || opcode
== call8_op
3781 || opcode
== call12_op
);
3786 is_windowed_call_opcode (xtensa_opcode opcode
)
3788 init_call_opcodes ();
3789 return (opcode
== call4_op
3790 || opcode
== call8_op
3791 || opcode
== call12_op
3792 || opcode
== callx4_op
3793 || opcode
== callx8_op
3794 || opcode
== callx12_op
);
3799 get_indirect_call_dest_reg (xtensa_opcode opcode
, unsigned *pdst
)
3801 unsigned dst
= (unsigned) -1;
3803 init_call_opcodes ();
3804 if (opcode
== callx0_op
)
3806 else if (opcode
== callx4_op
)
3808 else if (opcode
== callx8_op
)
3810 else if (opcode
== callx12_op
)
3813 if (dst
== (unsigned) -1)
3821 static xtensa_opcode
3822 get_const16_opcode (void)
3824 static bfd_boolean done_lookup
= FALSE
;
3825 static xtensa_opcode const16_opcode
= XTENSA_UNDEFINED
;
3828 const16_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "const16");
3831 return const16_opcode
;
3835 static xtensa_opcode
3836 get_l32r_opcode (void)
3838 static xtensa_opcode l32r_opcode
= XTENSA_UNDEFINED
;
3839 static bfd_boolean done_lookup
= FALSE
;
3843 l32r_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "l32r");
3851 l32r_offset (bfd_vma addr
, bfd_vma pc
)
3855 offset
= addr
- ((pc
+3) & -4);
3856 BFD_ASSERT ((offset
& ((1 << 2) - 1)) == 0);
3857 offset
= (signed int) offset
>> 2;
3858 BFD_ASSERT ((signed int) offset
>> 16 == -1);
3863 static xtensa_opcode
3864 get_rsr_lend_opcode (void)
3866 static xtensa_opcode rsr_lend_opcode
= XTENSA_UNDEFINED
;
3867 static bfd_boolean done_lookup
= FALSE
;
3870 rsr_lend_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "rsr.lend");
3873 return rsr_lend_opcode
;
3876 static xtensa_opcode
3877 get_wsr_lbeg_opcode (void)
3879 static xtensa_opcode wsr_lbeg_opcode
= XTENSA_UNDEFINED
;
3880 static bfd_boolean done_lookup
= FALSE
;
3883 wsr_lbeg_opcode
= xtensa_opcode_lookup (xtensa_default_isa
, "wsr.lbeg");
3886 return wsr_lbeg_opcode
;
3891 get_relocation_opnd (xtensa_opcode opcode
, int r_type
)
3893 xtensa_isa isa
= xtensa_default_isa
;
3894 int last_immed
, last_opnd
, opi
;
3896 if (opcode
== XTENSA_UNDEFINED
)
3897 return XTENSA_UNDEFINED
;
3899 /* Find the last visible PC-relative immediate operand for the opcode.
3900 If there are no PC-relative immediates, then choose the last visible
3901 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3902 last_immed
= XTENSA_UNDEFINED
;
3903 last_opnd
= xtensa_opcode_num_operands (isa
, opcode
);
3904 for (opi
= last_opnd
- 1; opi
>= 0; opi
--)
3906 if (xtensa_operand_is_visible (isa
, opcode
, opi
) == 0)
3908 if (xtensa_operand_is_PCrelative (isa
, opcode
, opi
) == 1)
3913 if (last_immed
== XTENSA_UNDEFINED
3914 && xtensa_operand_is_register (isa
, opcode
, opi
) == 0)
3918 return XTENSA_UNDEFINED
;
3920 /* If the operand number was specified in an old-style relocation,
3921 check for consistency with the operand computed above. */
3922 if (r_type
>= R_XTENSA_OP0
&& r_type
<= R_XTENSA_OP2
)
3924 int reloc_opnd
= r_type
- R_XTENSA_OP0
;
3925 if (reloc_opnd
!= last_immed
)
3926 return XTENSA_UNDEFINED
;
3934 get_relocation_slot (int r_type
)
3944 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
3945 return r_type
- R_XTENSA_SLOT0_OP
;
3946 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
3947 return r_type
- R_XTENSA_SLOT0_ALT
;
3951 return XTENSA_UNDEFINED
;
3955 /* Get the opcode for a relocation. */
3957 static xtensa_opcode
3958 get_relocation_opcode (bfd
*abfd
,
3961 Elf_Internal_Rela
*irel
)
3963 static xtensa_insnbuf ibuff
= NULL
;
3964 static xtensa_insnbuf sbuff
= NULL
;
3965 xtensa_isa isa
= xtensa_default_isa
;
3969 if (contents
== NULL
)
3970 return XTENSA_UNDEFINED
;
3972 if (bfd_get_section_limit (abfd
, sec
) <= irel
->r_offset
)
3973 return XTENSA_UNDEFINED
;
3977 ibuff
= xtensa_insnbuf_alloc (isa
);
3978 sbuff
= xtensa_insnbuf_alloc (isa
);
3981 /* Decode the instruction. */
3982 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[irel
->r_offset
],
3983 sec
->size
- irel
->r_offset
);
3984 fmt
= xtensa_format_decode (isa
, ibuff
);
3985 slot
= get_relocation_slot (ELF32_R_TYPE (irel
->r_info
));
3986 if (slot
== XTENSA_UNDEFINED
)
3987 return XTENSA_UNDEFINED
;
3988 xtensa_format_get_slot (isa
, fmt
, slot
, ibuff
, sbuff
);
3989 return xtensa_opcode_decode (isa
, fmt
, slot
, sbuff
);
3994 is_l32r_relocation (bfd
*abfd
,
3997 Elf_Internal_Rela
*irel
)
3999 xtensa_opcode opcode
;
4000 if (!is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
4002 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
4003 return (opcode
== get_l32r_opcode ());
4007 static bfd_size_type
4008 get_asm_simplify_size (bfd_byte
*contents
,
4009 bfd_size_type content_len
,
4010 bfd_size_type offset
)
4012 bfd_size_type insnlen
, size
= 0;
4014 /* Decode the size of the next two instructions. */
4015 insnlen
= insn_decode_len (contents
, content_len
, offset
);
4021 insnlen
= insn_decode_len (contents
, content_len
, offset
+ size
);
4031 is_alt_relocation (int r_type
)
4033 return (r_type
>= R_XTENSA_SLOT0_ALT
4034 && r_type
<= R_XTENSA_SLOT14_ALT
);
4039 is_operand_relocation (int r_type
)
4049 if (r_type
>= R_XTENSA_SLOT0_OP
&& r_type
<= R_XTENSA_SLOT14_OP
)
4051 if (r_type
>= R_XTENSA_SLOT0_ALT
&& r_type
<= R_XTENSA_SLOT14_ALT
)
4060 #define MIN_INSN_LENGTH 2
4062 /* Return 0 if it fails to decode. */
4065 insn_decode_len (bfd_byte
*contents
,
4066 bfd_size_type content_len
,
4067 bfd_size_type offset
)
4070 xtensa_isa isa
= xtensa_default_isa
;
4072 static xtensa_insnbuf ibuff
= NULL
;
4074 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4078 ibuff
= xtensa_insnbuf_alloc (isa
);
4079 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4080 content_len
- offset
);
4081 fmt
= xtensa_format_decode (isa
, ibuff
);
4082 if (fmt
== XTENSA_UNDEFINED
)
4084 insn_len
= xtensa_format_length (isa
, fmt
);
4085 if (insn_len
== XTENSA_UNDEFINED
)
4091 insn_num_slots (bfd_byte
*contents
,
4092 bfd_size_type content_len
,
4093 bfd_size_type offset
)
4095 xtensa_isa isa
= xtensa_default_isa
;
4097 static xtensa_insnbuf ibuff
= NULL
;
4099 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4100 return XTENSA_UNDEFINED
;
4103 ibuff
= xtensa_insnbuf_alloc (isa
);
4104 xtensa_insnbuf_from_chars (isa
, ibuff
, &contents
[offset
],
4105 content_len
- offset
);
4106 fmt
= xtensa_format_decode (isa
, ibuff
);
4107 if (fmt
== XTENSA_UNDEFINED
)
4108 return XTENSA_UNDEFINED
;
4109 return xtensa_format_num_slots (isa
, fmt
);
4113 /* Decode the opcode for a single slot instruction.
4114 Return 0 if it fails to decode or the instruction is multi-slot. */
4117 insn_decode_opcode (bfd_byte
*contents
,
4118 bfd_size_type content_len
,
4119 bfd_size_type offset
,
4122 xtensa_isa isa
= xtensa_default_isa
;
4124 static xtensa_insnbuf insnbuf
= NULL
;
4125 static xtensa_insnbuf slotbuf
= NULL
;
4127 if (offset
+ MIN_INSN_LENGTH
> content_len
)
4128 return XTENSA_UNDEFINED
;
4130 if (insnbuf
== NULL
)
4132 insnbuf
= xtensa_insnbuf_alloc (isa
);
4133 slotbuf
= xtensa_insnbuf_alloc (isa
);
4136 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4137 content_len
- offset
);
4138 fmt
= xtensa_format_decode (isa
, insnbuf
);
4139 if (fmt
== XTENSA_UNDEFINED
)
4140 return XTENSA_UNDEFINED
;
4142 if (slot
>= xtensa_format_num_slots (isa
, fmt
))
4143 return XTENSA_UNDEFINED
;
4145 xtensa_format_get_slot (isa
, fmt
, slot
, insnbuf
, slotbuf
);
4146 return xtensa_opcode_decode (isa
, fmt
, slot
, slotbuf
);
4150 /* The offset is the offset in the contents.
4151 The address is the address of that offset. */
4154 check_branch_target_aligned (bfd_byte
*contents
,
4155 bfd_size_type content_length
,
4159 bfd_size_type insn_len
= insn_decode_len (contents
, content_length
, offset
);
4162 return check_branch_target_aligned_address (address
, insn_len
);
4167 check_loop_aligned (bfd_byte
*contents
,
4168 bfd_size_type content_length
,
4172 bfd_size_type loop_len
, insn_len
;
4173 xtensa_opcode opcode
;
4175 opcode
= insn_decode_opcode (contents
, content_length
, offset
, 0);
4176 if (opcode
== XTENSA_UNDEFINED
4177 || xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) != 1)
4183 loop_len
= insn_decode_len (contents
, content_length
, offset
);
4184 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4185 if (loop_len
== 0 || insn_len
== 0)
4191 /* If this is relaxed loop, analyze first instruction of the actual loop
4192 body. It must be at offset 27 from the loop instruction address. */
4194 && insn_num_slots (contents
, content_length
, offset
+ loop_len
) == 1
4195 && insn_decode_opcode (contents
, content_length
,
4196 offset
+ loop_len
, 0) == get_rsr_lend_opcode()
4197 && insn_decode_len (contents
, content_length
, offset
+ loop_len
+ 3) == 3
4198 && insn_num_slots (contents
, content_length
, offset
+ loop_len
+ 3) == 1
4199 && insn_decode_opcode (contents
, content_length
,
4200 offset
+ loop_len
+ 3, 0) == get_wsr_lbeg_opcode())
4203 insn_len
= insn_decode_len (contents
, content_length
, offset
+ loop_len
);
4205 return check_branch_target_aligned_address (address
+ loop_len
, insn_len
);
4210 check_branch_target_aligned_address (bfd_vma addr
, int len
)
4213 return (addr
% 8 == 0);
4214 return ((addr
>> 2) == ((addr
+ len
- 1) >> 2));
4218 /* Instruction widening and narrowing. */
4220 /* When FLIX is available we need to access certain instructions only
4221 when they are 16-bit or 24-bit instructions. This table caches
4222 information about such instructions by walking through all the
4223 opcodes and finding the smallest single-slot format into which each
4226 static xtensa_format
*op_single_fmt_table
= NULL
;
4230 init_op_single_format_table (void)
4232 xtensa_isa isa
= xtensa_default_isa
;
4233 xtensa_insnbuf ibuf
;
4234 xtensa_opcode opcode
;
4238 if (op_single_fmt_table
)
4241 ibuf
= xtensa_insnbuf_alloc (isa
);
4242 num_opcodes
= xtensa_isa_num_opcodes (isa
);
4244 op_single_fmt_table
= (xtensa_format
*)
4245 bfd_malloc (sizeof (xtensa_format
) * num_opcodes
);
4246 for (opcode
= 0; opcode
< num_opcodes
; opcode
++)
4248 op_single_fmt_table
[opcode
] = XTENSA_UNDEFINED
;
4249 for (fmt
= 0; fmt
< xtensa_isa_num_formats (isa
); fmt
++)
4251 if (xtensa_format_num_slots (isa
, fmt
) == 1
4252 && xtensa_opcode_encode (isa
, fmt
, 0, ibuf
, opcode
) == 0)
4254 xtensa_opcode old_fmt
= op_single_fmt_table
[opcode
];
4255 int fmt_length
= xtensa_format_length (isa
, fmt
);
4256 if (old_fmt
== XTENSA_UNDEFINED
4257 || fmt_length
< xtensa_format_length (isa
, old_fmt
))
4258 op_single_fmt_table
[opcode
] = fmt
;
4262 xtensa_insnbuf_free (isa
, ibuf
);
4266 static xtensa_format
4267 get_single_format (xtensa_opcode opcode
)
4269 init_op_single_format_table ();
4270 return op_single_fmt_table
[opcode
];
4274 /* For the set of narrowable instructions we do NOT include the
4275 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
4276 involved during linker relaxation that may require these to
4277 re-expand in some conditions. Also, the narrowing "or" -> mov.n
4278 requires special case code to ensure it only works when op1 == op2. */
4286 struct string_pair narrowable
[] =
4289 { "addi", "addi.n" },
4290 { "addmi", "addi.n" },
4291 { "l32i", "l32i.n" },
4292 { "movi", "movi.n" },
4294 { "retw", "retw.n" },
4295 { "s32i", "s32i.n" },
4296 { "or", "mov.n" } /* special case only when op1 == op2 */
4299 struct string_pair widenable
[] =
4302 { "addi", "addi.n" },
4303 { "addmi", "addi.n" },
4304 { "beqz", "beqz.n" },
4305 { "bnez", "bnez.n" },
4306 { "l32i", "l32i.n" },
4307 { "movi", "movi.n" },
4309 { "retw", "retw.n" },
4310 { "s32i", "s32i.n" },
4311 { "or", "mov.n" } /* special case only when op1 == op2 */
4315 /* Check if an instruction can be "narrowed", i.e., changed from a standard
4316 3-byte instruction to a 2-byte "density" instruction. If it is valid,
4317 return the instruction buffer holding the narrow instruction. Otherwise,
4318 return 0. The set of valid narrowing are specified by a string table
4319 but require some special case operand checks in some cases. */
4321 static xtensa_insnbuf
4322 can_narrow_instruction (xtensa_insnbuf slotbuf
,
4324 xtensa_opcode opcode
)
4326 xtensa_isa isa
= xtensa_default_isa
;
4327 xtensa_format o_fmt
;
4330 static xtensa_insnbuf o_insnbuf
= NULL
;
4331 static xtensa_insnbuf o_slotbuf
= NULL
;
4333 if (o_insnbuf
== NULL
)
4335 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4336 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4339 for (opi
= 0; opi
< (sizeof (narrowable
)/sizeof (struct string_pair
)); opi
++)
4341 bfd_boolean is_or
= (strcmp ("or", narrowable
[opi
].wide
) == 0);
4343 if (opcode
== xtensa_opcode_lookup (isa
, narrowable
[opi
].wide
))
4345 uint32 value
, newval
;
4346 int i
, operand_count
, o_operand_count
;
4347 xtensa_opcode o_opcode
;
4349 /* Address does not matter in this case. We might need to
4350 fix it to handle branches/jumps. */
4351 bfd_vma self_address
= 0;
4353 o_opcode
= xtensa_opcode_lookup (isa
, narrowable
[opi
].narrow
);
4354 if (o_opcode
== XTENSA_UNDEFINED
)
4356 o_fmt
= get_single_format (o_opcode
);
4357 if (o_fmt
== XTENSA_UNDEFINED
)
4360 if (xtensa_format_length (isa
, fmt
) != 3
4361 || xtensa_format_length (isa
, o_fmt
) != 2)
4364 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4365 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4366 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4368 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4373 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4378 uint32 rawval0
, rawval1
, rawval2
;
4380 if (o_operand_count
+ 1 != operand_count
4381 || xtensa_operand_get_field (isa
, opcode
, 0,
4382 fmt
, 0, slotbuf
, &rawval0
) != 0
4383 || xtensa_operand_get_field (isa
, opcode
, 1,
4384 fmt
, 0, slotbuf
, &rawval1
) != 0
4385 || xtensa_operand_get_field (isa
, opcode
, 2,
4386 fmt
, 0, slotbuf
, &rawval2
) != 0
4387 || rawval1
!= rawval2
4388 || rawval0
== rawval1
/* it is a nop */)
4392 for (i
= 0; i
< o_operand_count
; ++i
)
4394 if (xtensa_operand_get_field (isa
, opcode
, i
, fmt
, 0,
4396 || xtensa_operand_decode (isa
, opcode
, i
, &value
))
4399 /* PC-relative branches need adjustment, but
4400 the PC-rel operand will always have a relocation. */
4402 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4404 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4405 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4410 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4420 /* Attempt to narrow an instruction. If the narrowing is valid, perform
4421 the action in-place directly into the contents and return TRUE. Otherwise,
4422 the return value is FALSE and the contents are not modified. */
4425 narrow_instruction (bfd_byte
*contents
,
4426 bfd_size_type content_length
,
4427 bfd_size_type offset
)
4429 xtensa_opcode opcode
;
4430 bfd_size_type insn_len
;
4431 xtensa_isa isa
= xtensa_default_isa
;
4433 xtensa_insnbuf o_insnbuf
;
4435 static xtensa_insnbuf insnbuf
= NULL
;
4436 static xtensa_insnbuf slotbuf
= NULL
;
4438 if (insnbuf
== NULL
)
4440 insnbuf
= xtensa_insnbuf_alloc (isa
);
4441 slotbuf
= xtensa_insnbuf_alloc (isa
);
4444 BFD_ASSERT (offset
< content_length
);
4446 if (content_length
< 2)
4449 /* We will hand-code a few of these for a little while.
4450 These have all been specified in the assembler aleady. */
4451 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4452 content_length
- offset
);
4453 fmt
= xtensa_format_decode (isa
, insnbuf
);
4454 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4457 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4460 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4461 if (opcode
== XTENSA_UNDEFINED
)
4463 insn_len
= xtensa_format_length (isa
, fmt
);
4464 if (insn_len
> content_length
)
4467 o_insnbuf
= can_narrow_instruction (slotbuf
, fmt
, opcode
);
4470 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4471 content_length
- offset
);
4479 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
4480 "density" instruction to a standard 3-byte instruction. If it is valid,
4481 return the instruction buffer holding the wide instruction. Otherwise,
4482 return 0. The set of valid widenings are specified by a string table
4483 but require some special case operand checks in some cases. */
4485 static xtensa_insnbuf
4486 can_widen_instruction (xtensa_insnbuf slotbuf
,
4488 xtensa_opcode opcode
)
4490 xtensa_isa isa
= xtensa_default_isa
;
4491 xtensa_format o_fmt
;
4494 static xtensa_insnbuf o_insnbuf
= NULL
;
4495 static xtensa_insnbuf o_slotbuf
= NULL
;
4497 if (o_insnbuf
== NULL
)
4499 o_insnbuf
= xtensa_insnbuf_alloc (isa
);
4500 o_slotbuf
= xtensa_insnbuf_alloc (isa
);
4503 for (opi
= 0; opi
< (sizeof (widenable
)/sizeof (struct string_pair
)); opi
++)
4505 bfd_boolean is_or
= (strcmp ("or", widenable
[opi
].wide
) == 0);
4506 bfd_boolean is_branch
= (strcmp ("beqz", widenable
[opi
].wide
) == 0
4507 || strcmp ("bnez", widenable
[opi
].wide
) == 0);
4509 if (opcode
== xtensa_opcode_lookup (isa
, widenable
[opi
].narrow
))
4511 uint32 value
, newval
;
4512 int i
, operand_count
, o_operand_count
, check_operand_count
;
4513 xtensa_opcode o_opcode
;
4515 /* Address does not matter in this case. We might need to fix it
4516 to handle branches/jumps. */
4517 bfd_vma self_address
= 0;
4519 o_opcode
= xtensa_opcode_lookup (isa
, widenable
[opi
].wide
);
4520 if (o_opcode
== XTENSA_UNDEFINED
)
4522 o_fmt
= get_single_format (o_opcode
);
4523 if (o_fmt
== XTENSA_UNDEFINED
)
4526 if (xtensa_format_length (isa
, fmt
) != 2
4527 || xtensa_format_length (isa
, o_fmt
) != 3)
4530 xtensa_format_encode (isa
, o_fmt
, o_insnbuf
);
4531 operand_count
= xtensa_opcode_num_operands (isa
, opcode
);
4532 o_operand_count
= xtensa_opcode_num_operands (isa
, o_opcode
);
4533 check_operand_count
= o_operand_count
;
4535 if (xtensa_opcode_encode (isa
, o_fmt
, 0, o_slotbuf
, o_opcode
) != 0)
4540 if (xtensa_opcode_num_operands (isa
, o_opcode
) != operand_count
)
4545 uint32 rawval0
, rawval1
;
4547 if (o_operand_count
!= operand_count
+ 1
4548 || xtensa_operand_get_field (isa
, opcode
, 0,
4549 fmt
, 0, slotbuf
, &rawval0
) != 0
4550 || xtensa_operand_get_field (isa
, opcode
, 1,
4551 fmt
, 0, slotbuf
, &rawval1
) != 0
4552 || rawval0
== rawval1
/* it is a nop */)
4556 check_operand_count
--;
4558 for (i
= 0; i
< check_operand_count
; i
++)
4561 if (is_or
&& i
== o_operand_count
- 1)
4563 if (xtensa_operand_get_field (isa
, opcode
, new_i
, fmt
, 0,
4565 || xtensa_operand_decode (isa
, opcode
, new_i
, &value
))
4568 /* PC-relative branches need adjustment, but
4569 the PC-rel operand will always have a relocation. */
4571 if (xtensa_operand_do_reloc (isa
, o_opcode
, i
, &newval
,
4573 || xtensa_operand_encode (isa
, o_opcode
, i
, &newval
)
4574 || xtensa_operand_set_field (isa
, o_opcode
, i
, o_fmt
, 0,
4579 if (xtensa_format_set_slot (isa
, o_fmt
, 0, o_insnbuf
, o_slotbuf
))
4589 /* Attempt to widen an instruction. If the widening is valid, perform
4590 the action in-place directly into the contents and return TRUE. Otherwise,
4591 the return value is FALSE and the contents are not modified. */
4594 widen_instruction (bfd_byte
*contents
,
4595 bfd_size_type content_length
,
4596 bfd_size_type offset
)
4598 xtensa_opcode opcode
;
4599 bfd_size_type insn_len
;
4600 xtensa_isa isa
= xtensa_default_isa
;
4602 xtensa_insnbuf o_insnbuf
;
4604 static xtensa_insnbuf insnbuf
= NULL
;
4605 static xtensa_insnbuf slotbuf
= NULL
;
4607 if (insnbuf
== NULL
)
4609 insnbuf
= xtensa_insnbuf_alloc (isa
);
4610 slotbuf
= xtensa_insnbuf_alloc (isa
);
4613 BFD_ASSERT (offset
< content_length
);
4615 if (content_length
< 2)
4618 /* We will hand-code a few of these for a little while.
4619 These have all been specified in the assembler aleady. */
4620 xtensa_insnbuf_from_chars (isa
, insnbuf
, &contents
[offset
],
4621 content_length
- offset
);
4622 fmt
= xtensa_format_decode (isa
, insnbuf
);
4623 if (xtensa_format_num_slots (isa
, fmt
) != 1)
4626 if (xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
) != 0)
4629 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4630 if (opcode
== XTENSA_UNDEFINED
)
4632 insn_len
= xtensa_format_length (isa
, fmt
);
4633 if (insn_len
> content_length
)
4636 o_insnbuf
= can_widen_instruction (slotbuf
, fmt
, opcode
);
4639 xtensa_insnbuf_to_chars (isa
, o_insnbuf
, contents
+ offset
,
4640 content_length
- offset
);
4647 /* Code for transforming CALLs at link-time. */
4649 static bfd_reloc_status_type
4650 elf_xtensa_do_asm_simplify (bfd_byte
*contents
,
4652 bfd_vma content_length
,
4653 char **error_message
)
4655 static xtensa_insnbuf insnbuf
= NULL
;
4656 static xtensa_insnbuf slotbuf
= NULL
;
4657 xtensa_format core_format
= XTENSA_UNDEFINED
;
4658 xtensa_opcode opcode
;
4659 xtensa_opcode direct_call_opcode
;
4660 xtensa_isa isa
= xtensa_default_isa
;
4661 bfd_byte
*chbuf
= contents
+ address
;
4664 if (insnbuf
== NULL
)
4666 insnbuf
= xtensa_insnbuf_alloc (isa
);
4667 slotbuf
= xtensa_insnbuf_alloc (isa
);
4670 if (content_length
< address
)
4672 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4673 return bfd_reloc_other
;
4676 opcode
= get_expanded_call_opcode (chbuf
, content_length
- address
, 0);
4677 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
4678 if (direct_call_opcode
== XTENSA_UNDEFINED
)
4680 *error_message
= _("attempt to convert L32R/CALLX to CALL failed");
4681 return bfd_reloc_other
;
4684 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
4685 core_format
= xtensa_format_lookup (isa
, "x24");
4686 opcode
= xtensa_opcode_lookup (isa
, "or");
4687 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, opcode
);
4688 for (opn
= 0; opn
< 3; opn
++)
4691 xtensa_operand_encode (isa
, opcode
, opn
, ®no
);
4692 xtensa_operand_set_field (isa
, opcode
, opn
, core_format
, 0,
4695 xtensa_format_encode (isa
, core_format
, insnbuf
);
4696 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4697 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
, content_length
- address
);
4699 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
4700 xtensa_opcode_encode (isa
, core_format
, 0, slotbuf
, direct_call_opcode
);
4701 xtensa_operand_set_field (isa
, opcode
, 0, core_format
, 0, slotbuf
, 0);
4703 xtensa_format_encode (isa
, core_format
, insnbuf
);
4704 xtensa_format_set_slot (isa
, core_format
, 0, insnbuf
, slotbuf
);
4705 xtensa_insnbuf_to_chars (isa
, insnbuf
, chbuf
+ 3,
4706 content_length
- address
- 3);
4708 return bfd_reloc_ok
;
4712 static bfd_reloc_status_type
4713 contract_asm_expansion (bfd_byte
*contents
,
4714 bfd_vma content_length
,
4715 Elf_Internal_Rela
*irel
,
4716 char **error_message
)
4718 bfd_reloc_status_type retval
=
4719 elf_xtensa_do_asm_simplify (contents
, irel
->r_offset
, content_length
,
4722 if (retval
!= bfd_reloc_ok
)
4723 return bfd_reloc_dangerous
;
4725 /* Update the irel->r_offset field so that the right immediate and
4726 the right instruction are modified during the relocation. */
4727 irel
->r_offset
+= 3;
4728 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
), R_XTENSA_SLOT0_OP
);
4729 return bfd_reloc_ok
;
4733 static xtensa_opcode
4734 swap_callx_for_call_opcode (xtensa_opcode opcode
)
4736 init_call_opcodes ();
4738 if (opcode
== callx0_op
) return call0_op
;
4739 if (opcode
== callx4_op
) return call4_op
;
4740 if (opcode
== callx8_op
) return call8_op
;
4741 if (opcode
== callx12_op
) return call12_op
;
4743 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
4744 return XTENSA_UNDEFINED
;
4748 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
4749 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
4750 If not, return XTENSA_UNDEFINED. */
4752 #define L32R_TARGET_REG_OPERAND 0
4753 #define CONST16_TARGET_REG_OPERAND 0
4754 #define CALLN_SOURCE_OPERAND 0
4756 static xtensa_opcode
4757 get_expanded_call_opcode (bfd_byte
*buf
, int bufsize
, bfd_boolean
*p_uses_l32r
)
4759 static xtensa_insnbuf insnbuf
= NULL
;
4760 static xtensa_insnbuf slotbuf
= NULL
;
4762 xtensa_opcode opcode
;
4763 xtensa_isa isa
= xtensa_default_isa
;
4764 uint32 regno
, const16_regno
, call_regno
;
4767 if (insnbuf
== NULL
)
4769 insnbuf
= xtensa_insnbuf_alloc (isa
);
4770 slotbuf
= xtensa_insnbuf_alloc (isa
);
4773 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
, bufsize
);
4774 fmt
= xtensa_format_decode (isa
, insnbuf
);
4775 if (fmt
== XTENSA_UNDEFINED
4776 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4777 return XTENSA_UNDEFINED
;
4779 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4780 if (opcode
== XTENSA_UNDEFINED
)
4781 return XTENSA_UNDEFINED
;
4783 if (opcode
== get_l32r_opcode ())
4786 *p_uses_l32r
= TRUE
;
4787 if (xtensa_operand_get_field (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4788 fmt
, 0, slotbuf
, ®no
)
4789 || xtensa_operand_decode (isa
, opcode
, L32R_TARGET_REG_OPERAND
,
4791 return XTENSA_UNDEFINED
;
4793 else if (opcode
== get_const16_opcode ())
4796 *p_uses_l32r
= FALSE
;
4797 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4798 fmt
, 0, slotbuf
, ®no
)
4799 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4801 return XTENSA_UNDEFINED
;
4803 /* Check that the next instruction is also CONST16. */
4804 offset
+= xtensa_format_length (isa
, fmt
);
4805 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4806 fmt
= xtensa_format_decode (isa
, insnbuf
);
4807 if (fmt
== XTENSA_UNDEFINED
4808 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4809 return XTENSA_UNDEFINED
;
4810 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4811 if (opcode
!= get_const16_opcode ())
4812 return XTENSA_UNDEFINED
;
4814 if (xtensa_operand_get_field (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4815 fmt
, 0, slotbuf
, &const16_regno
)
4816 || xtensa_operand_decode (isa
, opcode
, CONST16_TARGET_REG_OPERAND
,
4818 || const16_regno
!= regno
)
4819 return XTENSA_UNDEFINED
;
4822 return XTENSA_UNDEFINED
;
4824 /* Next instruction should be an CALLXn with operand 0 == regno. */
4825 offset
+= xtensa_format_length (isa
, fmt
);
4826 xtensa_insnbuf_from_chars (isa
, insnbuf
, buf
+ offset
, bufsize
- offset
);
4827 fmt
= xtensa_format_decode (isa
, insnbuf
);
4828 if (fmt
== XTENSA_UNDEFINED
4829 || xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
))
4830 return XTENSA_UNDEFINED
;
4831 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
4832 if (opcode
== XTENSA_UNDEFINED
4833 || !is_indirect_call_opcode (opcode
))
4834 return XTENSA_UNDEFINED
;
4836 if (xtensa_operand_get_field (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4837 fmt
, 0, slotbuf
, &call_regno
)
4838 || xtensa_operand_decode (isa
, opcode
, CALLN_SOURCE_OPERAND
,
4840 return XTENSA_UNDEFINED
;
4842 if (call_regno
!= regno
)
4843 return XTENSA_UNDEFINED
;
4849 /* Data structures used during relaxation. */
4851 /* r_reloc: relocation values. */
4853 /* Through the relaxation process, we need to keep track of the values
4854 that will result from evaluating relocations. The standard ELF
4855 relocation structure is not sufficient for this purpose because we're
4856 operating on multiple input files at once, so we need to know which
4857 input file a relocation refers to. The r_reloc structure thus
4858 records both the input file (bfd) and ELF relocation.
4860 For efficiency, an r_reloc also contains a "target_offset" field to
4861 cache the target-section-relative offset value that is represented by
4864 The r_reloc also contains a virtual offset that allows multiple
4865 inserted literals to be placed at the same "address" with
4866 different offsets. */
4868 typedef struct r_reloc_struct r_reloc
;
4870 struct r_reloc_struct
4873 Elf_Internal_Rela rela
;
4874 bfd_vma target_offset
;
4875 bfd_vma virtual_offset
;
4879 /* The r_reloc structure is included by value in literal_value, but not
4880 every literal_value has an associated relocation -- some are simple
4881 constants. In such cases, we set all the fields in the r_reloc
4882 struct to zero. The r_reloc_is_const function should be used to
4883 detect this case. */
4886 r_reloc_is_const (const r_reloc
*r_rel
)
4888 return (r_rel
->abfd
== NULL
);
4893 r_reloc_get_target_offset (const r_reloc
*r_rel
)
4895 bfd_vma target_offset
;
4896 unsigned long r_symndx
;
4898 BFD_ASSERT (!r_reloc_is_const (r_rel
));
4899 r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4900 target_offset
= get_elf_r_symndx_offset (r_rel
->abfd
, r_symndx
);
4901 return (target_offset
+ r_rel
->rela
.r_addend
);
4905 static struct elf_link_hash_entry
*
4906 r_reloc_get_hash_entry (const r_reloc
*r_rel
)
4908 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4909 return get_elf_r_symndx_hash_entry (r_rel
->abfd
, r_symndx
);
4914 r_reloc_get_section (const r_reloc
*r_rel
)
4916 unsigned long r_symndx
= ELF32_R_SYM (r_rel
->rela
.r_info
);
4917 return get_elf_r_symndx_section (r_rel
->abfd
, r_symndx
);
4922 r_reloc_is_defined (const r_reloc
*r_rel
)
4928 sec
= r_reloc_get_section (r_rel
);
4929 if (sec
== bfd_abs_section_ptr
4930 || sec
== bfd_com_section_ptr
4931 || sec
== bfd_und_section_ptr
)
4938 r_reloc_init (r_reloc
*r_rel
,
4940 Elf_Internal_Rela
*irel
,
4942 bfd_size_type content_length
)
4945 reloc_howto_type
*howto
;
4949 r_rel
->rela
= *irel
;
4951 r_rel
->target_offset
= r_reloc_get_target_offset (r_rel
);
4952 r_rel
->virtual_offset
= 0;
4953 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
4954 howto
= &elf_howto_table
[r_type
];
4955 if (howto
->partial_inplace
)
4957 bfd_vma inplace_val
;
4958 BFD_ASSERT (r_rel
->rela
.r_offset
< content_length
);
4960 inplace_val
= bfd_get_32 (abfd
, &contents
[r_rel
->rela
.r_offset
]);
4961 r_rel
->target_offset
+= inplace_val
;
4965 memset (r_rel
, 0, sizeof (r_reloc
));
4972 print_r_reloc (FILE *fp
, const r_reloc
*r_rel
)
4974 if (r_reloc_is_defined (r_rel
))
4976 asection
*sec
= r_reloc_get_section (r_rel
);
4977 fprintf (fp
, " %s(%s + ", sec
->owner
->filename
, sec
->name
);
4979 else if (r_reloc_get_hash_entry (r_rel
))
4980 fprintf (fp
, " %s + ", r_reloc_get_hash_entry (r_rel
)->root
.root
.string
);
4982 fprintf (fp
, " ?? + ");
4984 fprintf_vma (fp
, r_rel
->target_offset
);
4985 if (r_rel
->virtual_offset
)
4987 fprintf (fp
, " + ");
4988 fprintf_vma (fp
, r_rel
->virtual_offset
);
4997 /* source_reloc: relocations that reference literals. */
4999 /* To determine whether literals can be coalesced, we need to first
5000 record all the relocations that reference the literals. The
5001 source_reloc structure below is used for this purpose. The
5002 source_reloc entries are kept in a per-literal-section array, sorted
5003 by offset within the literal section (i.e., target offset).
5005 The source_sec and r_rel.rela.r_offset fields identify the source of
5006 the relocation. The r_rel field records the relocation value, i.e.,
5007 the offset of the literal being referenced. The opnd field is needed
5008 to determine the range of the immediate field to which the relocation
5009 applies, so we can determine whether another literal with the same
5010 value is within range. The is_null field is true when the relocation
5011 is being removed (e.g., when an L32R is being removed due to a CALLX
5012 that is converted to a direct CALL). */
5014 typedef struct source_reloc_struct source_reloc
;
5016 struct source_reloc_struct
5018 asection
*source_sec
;
5020 xtensa_opcode opcode
;
5022 bfd_boolean is_null
;
5023 bfd_boolean is_abs_literal
;
5028 init_source_reloc (source_reloc
*reloc
,
5029 asection
*source_sec
,
5030 const r_reloc
*r_rel
,
5031 xtensa_opcode opcode
,
5033 bfd_boolean is_abs_literal
)
5035 reloc
->source_sec
= source_sec
;
5036 reloc
->r_rel
= *r_rel
;
5037 reloc
->opcode
= opcode
;
5039 reloc
->is_null
= FALSE
;
5040 reloc
->is_abs_literal
= is_abs_literal
;
5044 /* Find the source_reloc for a particular source offset and relocation
5045 type. Note that the array is sorted by _target_ offset, so this is
5046 just a linear search. */
5048 static source_reloc
*
5049 find_source_reloc (source_reloc
*src_relocs
,
5052 Elf_Internal_Rela
*irel
)
5056 for (i
= 0; i
< src_count
; i
++)
5058 if (src_relocs
[i
].source_sec
== sec
5059 && src_relocs
[i
].r_rel
.rela
.r_offset
== irel
->r_offset
5060 && (ELF32_R_TYPE (src_relocs
[i
].r_rel
.rela
.r_info
)
5061 == ELF32_R_TYPE (irel
->r_info
)))
5062 return &src_relocs
[i
];
5070 source_reloc_compare (const void *ap
, const void *bp
)
5072 const source_reloc
*a
= (const source_reloc
*) ap
;
5073 const source_reloc
*b
= (const source_reloc
*) bp
;
5075 if (a
->r_rel
.target_offset
!= b
->r_rel
.target_offset
)
5076 return (a
->r_rel
.target_offset
- b
->r_rel
.target_offset
);
5078 /* We don't need to sort on these criteria for correctness,
5079 but enforcing a more strict ordering prevents unstable qsort
5080 from behaving differently with different implementations.
5081 Without the code below we get correct but different results
5082 on Solaris 2.7 and 2.8. We would like to always produce the
5083 same results no matter the host. */
5085 if ((!a
->is_null
) - (!b
->is_null
))
5086 return ((!a
->is_null
) - (!b
->is_null
));
5087 return internal_reloc_compare (&a
->r_rel
.rela
, &b
->r_rel
.rela
);
5091 /* Literal values and value hash tables. */
5093 /* Literals with the same value can be coalesced. The literal_value
5094 structure records the value of a literal: the "r_rel" field holds the
5095 information from the relocation on the literal (if there is one) and
5096 the "value" field holds the contents of the literal word itself.
5098 The value_map structure records a literal value along with the
5099 location of a literal holding that value. The value_map hash table
5100 is indexed by the literal value, so that we can quickly check if a
5101 particular literal value has been seen before and is thus a candidate
5104 typedef struct literal_value_struct literal_value
;
5105 typedef struct value_map_struct value_map
;
5106 typedef struct value_map_hash_table_struct value_map_hash_table
;
5108 struct literal_value_struct
5111 unsigned long value
;
5112 bfd_boolean is_abs_literal
;
5115 struct value_map_struct
5117 literal_value val
; /* The literal value. */
5118 r_reloc loc
; /* Location of the literal. */
5122 struct value_map_hash_table_struct
5124 unsigned bucket_count
;
5125 value_map
**buckets
;
5127 bfd_boolean has_last_loc
;
5133 init_literal_value (literal_value
*lit
,
5134 const r_reloc
*r_rel
,
5135 unsigned long value
,
5136 bfd_boolean is_abs_literal
)
5138 lit
->r_rel
= *r_rel
;
5140 lit
->is_abs_literal
= is_abs_literal
;
5145 literal_value_equal (const literal_value
*src1
,
5146 const literal_value
*src2
,
5147 bfd_boolean final_static_link
)
5149 struct elf_link_hash_entry
*h1
, *h2
;
5151 if (r_reloc_is_const (&src1
->r_rel
) != r_reloc_is_const (&src2
->r_rel
))
5154 if (r_reloc_is_const (&src1
->r_rel
))
5155 return (src1
->value
== src2
->value
);
5157 if (ELF32_R_TYPE (src1
->r_rel
.rela
.r_info
)
5158 != ELF32_R_TYPE (src2
->r_rel
.rela
.r_info
))
5161 if (src1
->r_rel
.target_offset
!= src2
->r_rel
.target_offset
)
5164 if (src1
->r_rel
.virtual_offset
!= src2
->r_rel
.virtual_offset
)
5167 if (src1
->value
!= src2
->value
)
5170 /* Now check for the same section (if defined) or the same elf_hash
5171 (if undefined or weak). */
5172 h1
= r_reloc_get_hash_entry (&src1
->r_rel
);
5173 h2
= r_reloc_get_hash_entry (&src2
->r_rel
);
5174 if (r_reloc_is_defined (&src1
->r_rel
)
5175 && (final_static_link
5176 || ((!h1
|| h1
->root
.type
!= bfd_link_hash_defweak
)
5177 && (!h2
|| h2
->root
.type
!= bfd_link_hash_defweak
))))
5179 if (r_reloc_get_section (&src1
->r_rel
)
5180 != r_reloc_get_section (&src2
->r_rel
))
5185 /* Require that the hash entries (i.e., symbols) be identical. */
5186 if (h1
!= h2
|| h1
== 0)
5190 if (src1
->is_abs_literal
!= src2
->is_abs_literal
)
5197 /* Must be power of 2. */
5198 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
5200 static value_map_hash_table
*
5201 value_map_hash_table_init (void)
5203 value_map_hash_table
*values
;
5205 values
= (value_map_hash_table
*)
5206 bfd_zmalloc (sizeof (value_map_hash_table
));
5207 values
->bucket_count
= INITIAL_HASH_RELOC_BUCKET_COUNT
;
5209 values
->buckets
= (value_map
**)
5210 bfd_zmalloc (sizeof (value_map
*) * values
->bucket_count
);
5211 if (values
->buckets
== NULL
)
5216 values
->has_last_loc
= FALSE
;
5223 value_map_hash_table_delete (value_map_hash_table
*table
)
5225 free (table
->buckets
);
5231 hash_bfd_vma (bfd_vma val
)
5233 return (val
>> 2) + (val
>> 10);
5238 literal_value_hash (const literal_value
*src
)
5242 hash_val
= hash_bfd_vma (src
->value
);
5243 if (!r_reloc_is_const (&src
->r_rel
))
5247 hash_val
+= hash_bfd_vma (src
->is_abs_literal
* 1000);
5248 hash_val
+= hash_bfd_vma (src
->r_rel
.target_offset
);
5249 hash_val
+= hash_bfd_vma (src
->r_rel
.virtual_offset
);
5251 /* Now check for the same section and the same elf_hash. */
5252 if (r_reloc_is_defined (&src
->r_rel
))
5253 sec_or_hash
= r_reloc_get_section (&src
->r_rel
);
5255 sec_or_hash
= r_reloc_get_hash_entry (&src
->r_rel
);
5256 hash_val
+= hash_bfd_vma ((bfd_vma
) (size_t) sec_or_hash
);
5262 /* Check if the specified literal_value has been seen before. */
5265 value_map_get_cached_value (value_map_hash_table
*map
,
5266 const literal_value
*val
,
5267 bfd_boolean final_static_link
)
5273 idx
= literal_value_hash (val
);
5274 idx
= idx
& (map
->bucket_count
- 1);
5275 bucket
= map
->buckets
[idx
];
5276 for (map_e
= bucket
; map_e
; map_e
= map_e
->next
)
5278 if (literal_value_equal (&map_e
->val
, val
, final_static_link
))
5285 /* Record a new literal value. It is illegal to call this if VALUE
5286 already has an entry here. */
5289 add_value_map (value_map_hash_table
*map
,
5290 const literal_value
*val
,
5292 bfd_boolean final_static_link
)
5294 value_map
**bucket_p
;
5297 value_map
*val_e
= (value_map
*) bfd_zmalloc (sizeof (value_map
));
5300 bfd_set_error (bfd_error_no_memory
);
5304 BFD_ASSERT (!value_map_get_cached_value (map
, val
, final_static_link
));
5308 idx
= literal_value_hash (val
);
5309 idx
= idx
& (map
->bucket_count
- 1);
5310 bucket_p
= &map
->buckets
[idx
];
5312 val_e
->next
= *bucket_p
;
5315 /* FIXME: Consider resizing the hash table if we get too many entries. */
5321 /* Lists of text actions (ta_) for narrowing, widening, longcall
5322 conversion, space fill, code & literal removal, etc. */
5324 /* The following text actions are generated:
5326 "ta_remove_insn" remove an instruction or instructions
5327 "ta_remove_longcall" convert longcall to call
5328 "ta_convert_longcall" convert longcall to nop/call
5329 "ta_narrow_insn" narrow a wide instruction
5330 "ta_widen" widen a narrow instruction
5331 "ta_fill" add fill or remove fill
5332 removed < 0 is a fill; branches to the fill address will be
5333 changed to address + fill size (e.g., address - removed)
5334 removed >= 0 branches to the fill address will stay unchanged
5335 "ta_remove_literal" remove a literal; this action is
5336 indicated when a literal is removed
5338 "ta_add_literal" insert a new literal; this action is
5339 indicated when a literal has been moved.
5340 It may use a virtual_offset because
5341 multiple literals can be placed at the
5344 For each of these text actions, we also record the number of bytes
5345 removed by performing the text action. In the case of a "ta_widen"
5346 or a "ta_fill" that adds space, the removed_bytes will be negative. */
5348 typedef struct text_action_struct text_action
;
5349 typedef struct text_action_list_struct text_action_list
;
5350 typedef enum text_action_enum_t text_action_t
;
5352 enum text_action_enum_t
5355 ta_remove_insn
, /* removed = -size */
5356 ta_remove_longcall
, /* removed = -size */
5357 ta_convert_longcall
, /* removed = 0 */
5358 ta_narrow_insn
, /* removed = -1 */
5359 ta_widen_insn
, /* removed = +1 */
5360 ta_fill
, /* removed = +size */
5366 /* Structure for a text action record. */
5367 struct text_action_struct
5369 text_action_t action
;
5370 asection
*sec
; /* Optional */
5372 bfd_vma virtual_offset
; /* Zero except for adding literals. */
5374 literal_value value
; /* Only valid when adding literals. */
5377 struct removal_by_action_entry_struct
5382 int eq_removed_before_fill
;
5384 typedef struct removal_by_action_entry_struct removal_by_action_entry
;
5386 struct removal_by_action_map_struct
5389 removal_by_action_entry
*entry
;
5391 typedef struct removal_by_action_map_struct removal_by_action_map
;
5394 /* List of all of the actions taken on a text section. */
5395 struct text_action_list_struct
5399 removal_by_action_map map
;
5403 static text_action
*
5404 find_fill_action (text_action_list
*l
, asection
*sec
, bfd_vma offset
)
5408 /* It is not necessary to fill at the end of a section. */
5409 if (sec
->size
== offset
)
5415 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5417 return (text_action
*)node
->value
;
5423 compute_removed_action_diff (const text_action
*ta
,
5427 int removable_space
)
5430 int current_removed
= 0;
5433 current_removed
= ta
->removed_bytes
;
5435 BFD_ASSERT (ta
== NULL
|| ta
->offset
== offset
);
5436 BFD_ASSERT (ta
== NULL
|| ta
->action
== ta_fill
);
5438 /* It is not necessary to fill at the end of a section. Clean this up. */
5439 if (sec
->size
== offset
)
5440 new_removed
= removable_space
- 0;
5444 int added
= -removed
- current_removed
;
5445 /* Ignore multiples of the section alignment. */
5446 added
= ((1 << sec
->alignment_power
) - 1) & added
;
5447 new_removed
= (-added
);
5449 /* Modify for removable. */
5450 space
= removable_space
- new_removed
;
5451 new_removed
= (removable_space
5452 - (((1 << sec
->alignment_power
) - 1) & space
));
5454 return (new_removed
- current_removed
);
5459 adjust_fill_action (text_action
*ta
, int fill_diff
)
5461 ta
->removed_bytes
+= fill_diff
;
5466 text_action_compare (splay_tree_key a
, splay_tree_key b
)
5468 text_action
*pa
= (text_action
*)a
;
5469 text_action
*pb
= (text_action
*)b
;
5470 static const int action_priority
[] =
5474 [ta_convert_longcall
] = 2,
5475 [ta_narrow_insn
] = 3,
5476 [ta_remove_insn
] = 4,
5477 [ta_remove_longcall
] = 5,
5478 [ta_remove_literal
] = 6,
5479 [ta_widen_insn
] = 7,
5480 [ta_add_literal
] = 8,
5483 if (pa
->offset
== pb
->offset
)
5485 if (pa
->action
== pb
->action
)
5487 return action_priority
[pa
->action
] - action_priority
[pb
->action
];
5490 return pa
->offset
< pb
->offset
? -1 : 1;
5493 static text_action
*
5494 action_first (text_action_list
*action_list
)
5496 splay_tree_node node
= splay_tree_min (action_list
->tree
);
5497 return node
? (text_action
*)node
->value
: NULL
;
5500 static text_action
*
5501 action_next (text_action_list
*action_list
, text_action
*action
)
5503 splay_tree_node node
= splay_tree_successor (action_list
->tree
,
5504 (splay_tree_key
)action
);
5505 return node
? (text_action
*)node
->value
: NULL
;
5508 /* Add a modification action to the text. For the case of adding or
5509 removing space, modify any current fill and assume that
5510 "unreachable_space" bytes can be freely contracted. Note that a
5511 negative removed value is a fill. */
5514 text_action_add (text_action_list
*l
,
5515 text_action_t action
,
5523 /* It is not necessary to fill at the end of a section. */
5524 if (action
== ta_fill
&& sec
->size
== offset
)
5527 /* It is not necessary to fill 0 bytes. */
5528 if (action
== ta_fill
&& removed
== 0)
5534 if (action
== ta_fill
)
5536 splay_tree_node node
= splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
);
5540 ta
= (text_action
*)node
->value
;
5541 ta
->removed_bytes
+= removed
;
5546 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)&a
) == NULL
);
5548 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5549 ta
->action
= action
;
5551 ta
->offset
= offset
;
5552 ta
->removed_bytes
= removed
;
5553 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5559 text_action_add_literal (text_action_list
*l
,
5560 text_action_t action
,
5562 const literal_value
*value
,
5566 asection
*sec
= r_reloc_get_section (loc
);
5567 bfd_vma offset
= loc
->target_offset
;
5568 bfd_vma virtual_offset
= loc
->virtual_offset
;
5570 BFD_ASSERT (action
== ta_add_literal
);
5572 /* Create a new record and fill it up. */
5573 ta
= (text_action
*) bfd_zmalloc (sizeof (text_action
));
5574 ta
->action
= action
;
5576 ta
->offset
= offset
;
5577 ta
->virtual_offset
= virtual_offset
;
5579 ta
->removed_bytes
= removed
;
5581 BFD_ASSERT (splay_tree_lookup (l
->tree
, (splay_tree_key
)ta
) == NULL
);
5582 splay_tree_insert (l
->tree
, (splay_tree_key
)ta
, (splay_tree_value
)ta
);
5587 /* Find the total offset adjustment for the relaxations specified by
5588 text_actions, beginning from a particular starting action. This is
5589 typically used from offset_with_removed_text to search an entire list of
5590 actions, but it may also be called directly when adjusting adjacent offsets
5591 so that each search may begin where the previous one left off. */
5594 removed_by_actions (text_action_list
*action_list
,
5595 text_action
**p_start_action
,
5597 bfd_boolean before_fill
)
5602 r
= *p_start_action
;
5605 splay_tree_node node
= splay_tree_lookup (action_list
->tree
,
5607 BFD_ASSERT (node
!= NULL
&& r
== (text_action
*)node
->value
);
5612 if (r
->offset
> offset
)
5615 if (r
->offset
== offset
5616 && (before_fill
|| r
->action
!= ta_fill
|| r
->removed_bytes
>= 0))
5619 removed
+= r
->removed_bytes
;
5621 r
= action_next (action_list
, r
);
5624 *p_start_action
= r
;
5630 offset_with_removed_text (text_action_list
*action_list
, bfd_vma offset
)
5632 text_action
*r
= action_first (action_list
);
5634 return offset
- removed_by_actions (action_list
, &r
, offset
, FALSE
);
5639 action_list_count (text_action_list
*action_list
)
5641 return action_list
->count
;
5644 typedef struct map_action_fn_context_struct map_action_fn_context
;
5645 struct map_action_fn_context_struct
5648 removal_by_action_map map
;
5649 bfd_boolean eq_complete
;
5653 map_action_fn (splay_tree_node node
, void *p
)
5655 map_action_fn_context
*ctx
= p
;
5656 text_action
*r
= (text_action
*)node
->value
;
5657 removal_by_action_entry
*ientry
= ctx
->map
.entry
+ ctx
->map
.n_entries
;
5659 if (ctx
->map
.n_entries
&& (ientry
- 1)->offset
== r
->offset
)
5665 ++ctx
->map
.n_entries
;
5666 ctx
->eq_complete
= FALSE
;
5667 ientry
->offset
= r
->offset
;
5668 ientry
->eq_removed_before_fill
= ctx
->removed
;
5671 if (!ctx
->eq_complete
)
5673 if (r
->action
!= ta_fill
|| r
->removed_bytes
>= 0)
5675 ientry
->eq_removed
= ctx
->removed
;
5676 ctx
->eq_complete
= TRUE
;
5679 ientry
->eq_removed
= ctx
->removed
+ r
->removed_bytes
;
5682 ctx
->removed
+= r
->removed_bytes
;
5683 ientry
->removed
= ctx
->removed
;
5688 map_removal_by_action (text_action_list
*action_list
)
5690 map_action_fn_context ctx
;
5693 ctx
.map
.n_entries
= 0;
5694 ctx
.map
.entry
= bfd_malloc (action_list_count (action_list
) *
5695 sizeof (removal_by_action_entry
));
5696 ctx
.eq_complete
= FALSE
;
5698 splay_tree_foreach (action_list
->tree
, map_action_fn
, &ctx
);
5699 action_list
->map
= ctx
.map
;
5703 removed_by_actions_map (text_action_list
*action_list
, bfd_vma offset
,
5704 bfd_boolean before_fill
)
5708 if (!action_list
->map
.entry
)
5709 map_removal_by_action (action_list
);
5711 if (!action_list
->map
.n_entries
)
5715 b
= action_list
->map
.n_entries
;
5719 unsigned c
= (a
+ b
) / 2;
5721 if (action_list
->map
.entry
[c
].offset
<= offset
)
5727 if (action_list
->map
.entry
[a
].offset
< offset
)
5729 return action_list
->map
.entry
[a
].removed
;
5731 else if (action_list
->map
.entry
[a
].offset
== offset
)
5733 return before_fill
?
5734 action_list
->map
.entry
[a
].eq_removed_before_fill
:
5735 action_list
->map
.entry
[a
].eq_removed
;
5744 offset_with_removed_text_map (text_action_list
*action_list
, bfd_vma offset
)
5746 int removed
= removed_by_actions_map (action_list
, offset
, FALSE
);
5747 return offset
- removed
;
5751 /* The find_insn_action routine will only find non-fill actions. */
5753 static text_action
*
5754 find_insn_action (text_action_list
*action_list
, bfd_vma offset
)
5756 static const text_action_t action
[] =
5758 ta_convert_longcall
,
5768 for (i
= 0; i
< sizeof (action
) / sizeof (*action
); ++i
)
5770 splay_tree_node node
;
5772 a
.action
= action
[i
];
5773 node
= splay_tree_lookup (action_list
->tree
, (splay_tree_key
)&a
);
5775 return (text_action
*)node
->value
;
5784 print_action (FILE *fp
, text_action
*r
)
5786 const char *t
= "unknown";
5789 case ta_remove_insn
:
5790 t
= "remove_insn"; break;
5791 case ta_remove_longcall
:
5792 t
= "remove_longcall"; break;
5793 case ta_convert_longcall
:
5794 t
= "convert_longcall"; break;
5795 case ta_narrow_insn
:
5796 t
= "narrow_insn"; break;
5798 t
= "widen_insn"; break;
5803 case ta_remove_literal
:
5804 t
= "remove_literal"; break;
5805 case ta_add_literal
:
5806 t
= "add_literal"; break;
5809 fprintf (fp
, "%s: %s[0x%lx] \"%s\" %d\n",
5810 r
->sec
->owner
->filename
,
5811 r
->sec
->name
, (unsigned long) r
->offset
, t
, r
->removed_bytes
);
5815 print_action_list_fn (splay_tree_node node
, void *p
)
5817 text_action
*r
= (text_action
*)node
->value
;
5819 print_action (p
, r
);
5824 print_action_list (FILE *fp
, text_action_list
*action_list
)
5826 fprintf (fp
, "Text Action\n");
5827 splay_tree_foreach (action_list
->tree
, print_action_list_fn
, fp
);
5833 /* Lists of literals being coalesced or removed. */
5835 /* In the usual case, the literal identified by "from" is being
5836 coalesced with another literal identified by "to". If the literal is
5837 unused and is being removed altogether, "to.abfd" will be NULL.
5838 The removed_literal entries are kept on a per-section list, sorted
5839 by the "from" offset field. */
5841 typedef struct removed_literal_struct removed_literal
;
5842 typedef struct removed_literal_map_entry_struct removed_literal_map_entry
;
5843 typedef struct removed_literal_list_struct removed_literal_list
;
5845 struct removed_literal_struct
5849 removed_literal
*next
;
5852 struct removed_literal_map_entry_struct
5855 removed_literal
*literal
;
5858 struct removed_literal_list_struct
5860 removed_literal
*head
;
5861 removed_literal
*tail
;
5864 removed_literal_map_entry
*map
;
5868 /* Record that the literal at "from" is being removed. If "to" is not
5869 NULL, the "from" literal is being coalesced with the "to" literal. */
5872 add_removed_literal (removed_literal_list
*removed_list
,
5873 const r_reloc
*from
,
5876 removed_literal
*r
, *new_r
, *next_r
;
5878 new_r
= (removed_literal
*) bfd_zmalloc (sizeof (removed_literal
));
5880 new_r
->from
= *from
;
5884 new_r
->to
.abfd
= NULL
;
5887 r
= removed_list
->head
;
5890 removed_list
->head
= new_r
;
5891 removed_list
->tail
= new_r
;
5893 /* Special check for common case of append. */
5894 else if (removed_list
->tail
->from
.target_offset
< from
->target_offset
)
5896 removed_list
->tail
->next
= new_r
;
5897 removed_list
->tail
= new_r
;
5901 while (r
->from
.target_offset
< from
->target_offset
&& r
->next
)
5907 new_r
->next
= next_r
;
5909 removed_list
->tail
= new_r
;
5914 map_removed_literal (removed_literal_list
*removed_list
)
5918 removed_literal_map_entry
*map
= NULL
;
5919 removed_literal
*r
= removed_list
->head
;
5921 for (i
= 0; r
; ++i
, r
= r
->next
)
5925 n_map
= (n_map
* 2) + 2;
5926 map
= bfd_realloc (map
, n_map
* sizeof (*map
));
5928 map
[i
].addr
= r
->from
.target_offset
;
5931 removed_list
->map
= map
;
5932 removed_list
->n_map
= i
;
5936 removed_literal_compare (const void *a
, const void *b
)
5938 const removed_literal_map_entry
*pa
= a
;
5939 const removed_literal_map_entry
*pb
= b
;
5941 if (pa
->addr
== pb
->addr
)
5944 return pa
->addr
< pb
->addr
? -1 : 1;
5947 /* Check if the list of removed literals contains an entry for the
5948 given address. Return the entry if found. */
5950 static removed_literal
*
5951 find_removed_literal (removed_literal_list
*removed_list
, bfd_vma addr
)
5953 removed_literal_map_entry
*p
;
5954 removed_literal
*r
= NULL
;
5956 if (removed_list
->map
== NULL
)
5957 map_removed_literal (removed_list
);
5959 p
= bsearch (&addr
, removed_list
->map
, removed_list
->n_map
,
5960 sizeof (*removed_list
->map
), removed_literal_compare
);
5963 while (p
!= removed_list
->map
&& (p
- 1)->addr
== addr
)
5974 print_removed_literals (FILE *fp
, removed_literal_list
*removed_list
)
5977 r
= removed_list
->head
;
5979 fprintf (fp
, "Removed Literals\n");
5980 for (; r
!= NULL
; r
= r
->next
)
5982 print_r_reloc (fp
, &r
->from
);
5983 fprintf (fp
, " => ");
5984 if (r
->to
.abfd
== NULL
)
5985 fprintf (fp
, "REMOVED");
5987 print_r_reloc (fp
, &r
->to
);
5995 /* Per-section data for relaxation. */
5997 typedef struct reloc_bfd_fix_struct reloc_bfd_fix
;
5999 struct xtensa_relax_info_struct
6001 bfd_boolean is_relaxable_literal_section
;
6002 bfd_boolean is_relaxable_asm_section
;
6003 int visited
; /* Number of times visited. */
6005 source_reloc
*src_relocs
; /* Array[src_count]. */
6007 int src_next
; /* Next src_relocs entry to assign. */
6009 removed_literal_list removed_list
;
6010 text_action_list action_list
;
6012 reloc_bfd_fix
*fix_list
;
6013 reloc_bfd_fix
*fix_array
;
6014 unsigned fix_array_count
;
6016 /* Support for expanding the reloc array that is stored
6017 in the section structure. If the relocations have been
6018 reallocated, the newly allocated relocations will be referenced
6019 here along with the actual size allocated. The relocation
6020 count will always be found in the section structure. */
6021 Elf_Internal_Rela
*allocated_relocs
;
6022 unsigned relocs_count
;
6023 unsigned allocated_relocs_count
;
6026 struct elf_xtensa_section_data
6028 struct bfd_elf_section_data elf
;
6029 xtensa_relax_info relax_info
;
6034 elf_xtensa_new_section_hook (bfd
*abfd
, asection
*sec
)
6036 if (!sec
->used_by_bfd
)
6038 struct elf_xtensa_section_data
*sdata
;
6039 bfd_size_type amt
= sizeof (*sdata
);
6041 sdata
= bfd_zalloc (abfd
, amt
);
6044 sec
->used_by_bfd
= sdata
;
6047 return _bfd_elf_new_section_hook (abfd
, sec
);
6051 static xtensa_relax_info
*
6052 get_xtensa_relax_info (asection
*sec
)
6054 struct elf_xtensa_section_data
*section_data
;
6056 /* No info available if no section or if it is an output section. */
6057 if (!sec
|| sec
== sec
->output_section
)
6060 section_data
= (struct elf_xtensa_section_data
*) elf_section_data (sec
);
6061 return §ion_data
->relax_info
;
6066 init_xtensa_relax_info (asection
*sec
)
6068 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6070 relax_info
->is_relaxable_literal_section
= FALSE
;
6071 relax_info
->is_relaxable_asm_section
= FALSE
;
6072 relax_info
->visited
= 0;
6074 relax_info
->src_relocs
= NULL
;
6075 relax_info
->src_count
= 0;
6076 relax_info
->src_next
= 0;
6078 relax_info
->removed_list
.head
= NULL
;
6079 relax_info
->removed_list
.tail
= NULL
;
6081 relax_info
->action_list
.tree
= splay_tree_new (text_action_compare
,
6083 relax_info
->action_list
.map
.n_entries
= 0;
6084 relax_info
->action_list
.map
.entry
= NULL
;
6086 relax_info
->fix_list
= NULL
;
6087 relax_info
->fix_array
= NULL
;
6088 relax_info
->fix_array_count
= 0;
6090 relax_info
->allocated_relocs
= NULL
;
6091 relax_info
->relocs_count
= 0;
6092 relax_info
->allocated_relocs_count
= 0;
6096 /* Coalescing literals may require a relocation to refer to a section in
6097 a different input file, but the standard relocation information
6098 cannot express that. Instead, the reloc_bfd_fix structures are used
6099 to "fix" the relocations that refer to sections in other input files.
6100 These structures are kept on per-section lists. The "src_type" field
6101 records the relocation type in case there are multiple relocations on
6102 the same location. FIXME: This is ugly; an alternative might be to
6103 add new symbols with the "owner" field to some other input file. */
6105 struct reloc_bfd_fix_struct
6109 unsigned src_type
; /* Relocation type. */
6111 asection
*target_sec
;
6112 bfd_vma target_offset
;
6113 bfd_boolean translated
;
6115 reloc_bfd_fix
*next
;
6119 static reloc_bfd_fix
*
6120 reloc_bfd_fix_init (asection
*src_sec
,
6123 asection
*target_sec
,
6124 bfd_vma target_offset
,
6125 bfd_boolean translated
)
6129 fix
= (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
));
6130 fix
->src_sec
= src_sec
;
6131 fix
->src_offset
= src_offset
;
6132 fix
->src_type
= src_type
;
6133 fix
->target_sec
= target_sec
;
6134 fix
->target_offset
= target_offset
;
6135 fix
->translated
= translated
;
6142 add_fix (asection
*src_sec
, reloc_bfd_fix
*fix
)
6144 xtensa_relax_info
*relax_info
;
6146 relax_info
= get_xtensa_relax_info (src_sec
);
6147 fix
->next
= relax_info
->fix_list
;
6148 relax_info
->fix_list
= fix
;
6153 fix_compare (const void *ap
, const void *bp
)
6155 const reloc_bfd_fix
*a
= (const reloc_bfd_fix
*) ap
;
6156 const reloc_bfd_fix
*b
= (const reloc_bfd_fix
*) bp
;
6158 if (a
->src_offset
!= b
->src_offset
)
6159 return (a
->src_offset
- b
->src_offset
);
6160 return (a
->src_type
- b
->src_type
);
6165 cache_fix_array (asection
*sec
)
6167 unsigned i
, count
= 0;
6169 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6171 if (relax_info
== NULL
)
6173 if (relax_info
->fix_list
== NULL
)
6176 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
6179 relax_info
->fix_array
=
6180 (reloc_bfd_fix
*) bfd_malloc (sizeof (reloc_bfd_fix
) * count
);
6181 relax_info
->fix_array_count
= count
;
6183 r
= relax_info
->fix_list
;
6184 for (i
= 0; i
< count
; i
++, r
= r
->next
)
6186 relax_info
->fix_array
[count
- 1 - i
] = *r
;
6187 relax_info
->fix_array
[count
- 1 - i
].next
= NULL
;
6190 qsort (relax_info
->fix_array
, relax_info
->fix_array_count
,
6191 sizeof (reloc_bfd_fix
), fix_compare
);
6195 static reloc_bfd_fix
*
6196 get_bfd_fix (asection
*sec
, bfd_vma offset
, unsigned type
)
6198 xtensa_relax_info
*relax_info
= get_xtensa_relax_info (sec
);
6202 if (relax_info
== NULL
)
6204 if (relax_info
->fix_list
== NULL
)
6207 if (relax_info
->fix_array
== NULL
)
6208 cache_fix_array (sec
);
6210 key
.src_offset
= offset
;
6211 key
.src_type
= type
;
6212 rv
= bsearch (&key
, relax_info
->fix_array
, relax_info
->fix_array_count
,
6213 sizeof (reloc_bfd_fix
), fix_compare
);
6218 /* Section caching. */
6220 typedef struct section_cache_struct section_cache_t
;
6222 struct section_cache_struct
6226 bfd_byte
*contents
; /* Cache of the section contents. */
6227 bfd_size_type content_length
;
6229 property_table_entry
*ptbl
; /* Cache of the section property table. */
6232 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6233 unsigned reloc_count
;
6238 init_section_cache (section_cache_t
*sec_cache
)
6240 memset (sec_cache
, 0, sizeof (*sec_cache
));
6245 free_section_cache (section_cache_t
*sec_cache
)
6249 release_contents (sec_cache
->sec
, sec_cache
->contents
);
6250 release_internal_relocs (sec_cache
->sec
, sec_cache
->relocs
);
6251 if (sec_cache
->ptbl
)
6252 free (sec_cache
->ptbl
);
6258 section_cache_section (section_cache_t
*sec_cache
,
6260 struct bfd_link_info
*link_info
)
6263 property_table_entry
*prop_table
= NULL
;
6265 bfd_byte
*contents
= NULL
;
6266 Elf_Internal_Rela
*internal_relocs
= NULL
;
6267 bfd_size_type sec_size
;
6271 if (sec
== sec_cache
->sec
)
6275 sec_size
= bfd_get_section_limit (abfd
, sec
);
6277 /* Get the contents. */
6278 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
6279 if (contents
== NULL
&& sec_size
!= 0)
6282 /* Get the relocations. */
6283 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
6284 link_info
->keep_memory
);
6286 /* Get the entry table. */
6287 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
6288 XTENSA_PROP_SEC_NAME
, FALSE
);
6292 /* Fill in the new section cache. */
6293 free_section_cache (sec_cache
);
6294 init_section_cache (sec_cache
);
6296 sec_cache
->sec
= sec
;
6297 sec_cache
->contents
= contents
;
6298 sec_cache
->content_length
= sec_size
;
6299 sec_cache
->relocs
= internal_relocs
;
6300 sec_cache
->reloc_count
= sec
->reloc_count
;
6301 sec_cache
->pte_count
= ptblsize
;
6302 sec_cache
->ptbl
= prop_table
;
6307 release_contents (sec
, contents
);
6308 release_internal_relocs (sec
, internal_relocs
);
6315 /* Extended basic blocks. */
6317 /* An ebb_struct represents an Extended Basic Block. Within this
6318 range, we guarantee that all instructions are decodable, the
6319 property table entries are contiguous, and no property table
6320 specifies a segment that cannot have instructions moved. This
6321 structure contains caches of the contents, property table and
6322 relocations for the specified section for easy use. The range is
6323 specified by ranges of indices for the byte offset, property table
6324 offsets and relocation offsets. These must be consistent. */
6326 typedef struct ebb_struct ebb_t
;
6332 bfd_byte
*contents
; /* Cache of the section contents. */
6333 bfd_size_type content_length
;
6335 property_table_entry
*ptbl
; /* Cache of the section property table. */
6338 Elf_Internal_Rela
*relocs
; /* Cache of the section relocations. */
6339 unsigned reloc_count
;
6341 bfd_vma start_offset
; /* Offset in section. */
6342 unsigned start_ptbl_idx
; /* Offset in the property table. */
6343 unsigned start_reloc_idx
; /* Offset in the relocations. */
6346 unsigned end_ptbl_idx
;
6347 unsigned end_reloc_idx
;
6349 bfd_boolean ends_section
; /* Is this the last ebb in a section? */
6351 /* The unreachable property table at the end of this set of blocks;
6352 NULL if the end is not an unreachable block. */
6353 property_table_entry
*ends_unreachable
;
6357 enum ebb_target_enum
6360 EBB_DESIRE_TGT_ALIGN
,
6361 EBB_REQUIRE_TGT_ALIGN
,
6362 EBB_REQUIRE_LOOP_ALIGN
,
6367 /* proposed_action_struct is similar to the text_action_struct except
6368 that is represents a potential transformation, not one that will
6369 occur. We build a list of these for an extended basic block
6370 and use them to compute the actual actions desired. We must be
6371 careful that the entire set of actual actions we perform do not
6372 break any relocations that would fit if the actions were not
6375 typedef struct proposed_action_struct proposed_action
;
6377 struct proposed_action_struct
6379 enum ebb_target_enum align_type
; /* for the target alignment */
6380 bfd_vma alignment_pow
;
6381 text_action_t action
;
6384 bfd_boolean do_action
; /* If false, then we will not perform the action. */
6388 /* The ebb_constraint_struct keeps a set of proposed actions for an
6389 extended basic block. */
6391 typedef struct ebb_constraint_struct ebb_constraint
;
6393 struct ebb_constraint_struct
6396 bfd_boolean start_movable
;
6398 /* Bytes of extra space at the beginning if movable. */
6399 int start_extra_space
;
6401 enum ebb_target_enum start_align
;
6403 bfd_boolean end_movable
;
6405 /* Bytes of extra space at the end if movable. */
6406 int end_extra_space
;
6408 unsigned action_count
;
6409 unsigned action_allocated
;
6411 /* Array of proposed actions. */
6412 proposed_action
*actions
;
6414 /* Action alignments -- one for each proposed action. */
6415 enum ebb_target_enum
*action_aligns
;
6420 init_ebb_constraint (ebb_constraint
*c
)
6422 memset (c
, 0, sizeof (ebb_constraint
));
6427 free_ebb_constraint (ebb_constraint
*c
)
6435 init_ebb (ebb_t
*ebb
,
6438 bfd_size_type content_length
,
6439 property_table_entry
*prop_table
,
6441 Elf_Internal_Rela
*internal_relocs
,
6442 unsigned reloc_count
)
6444 memset (ebb
, 0, sizeof (ebb_t
));
6446 ebb
->contents
= contents
;
6447 ebb
->content_length
= content_length
;
6448 ebb
->ptbl
= prop_table
;
6449 ebb
->pte_count
= ptblsize
;
6450 ebb
->relocs
= internal_relocs
;
6451 ebb
->reloc_count
= reloc_count
;
6452 ebb
->start_offset
= 0;
6453 ebb
->end_offset
= ebb
->content_length
- 1;
6454 ebb
->start_ptbl_idx
= 0;
6455 ebb
->end_ptbl_idx
= ptblsize
;
6456 ebb
->start_reloc_idx
= 0;
6457 ebb
->end_reloc_idx
= reloc_count
;
6461 /* Extend the ebb to all decodable contiguous sections. The algorithm
6462 for building a basic block around an instruction is to push it
6463 forward until we hit the end of a section, an unreachable block or
6464 a block that cannot be transformed. Then we push it backwards
6465 searching for similar conditions. */
6467 static bfd_boolean
extend_ebb_bounds_forward (ebb_t
*);
6468 static bfd_boolean
extend_ebb_bounds_backward (ebb_t
*);
6469 static bfd_size_type insn_block_decodable_len
6470 (bfd_byte
*, bfd_size_type
, bfd_vma
, bfd_size_type
);
6473 extend_ebb_bounds (ebb_t
*ebb
)
6475 if (!extend_ebb_bounds_forward (ebb
))
6477 if (!extend_ebb_bounds_backward (ebb
))
6484 extend_ebb_bounds_forward (ebb_t
*ebb
)
6486 property_table_entry
*the_entry
, *new_entry
;
6488 the_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
6490 /* Stop when (1) we cannot decode an instruction, (2) we are at
6491 the end of the property tables, (3) we hit a non-contiguous property
6492 table entry, (4) we hit a NO_TRANSFORM region. */
6497 bfd_size_type insn_block_len
;
6499 entry_end
= the_entry
->address
- ebb
->sec
->vma
+ the_entry
->size
;
6501 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6503 entry_end
- ebb
->end_offset
);
6504 if (insn_block_len
!= (entry_end
- ebb
->end_offset
))
6507 /* xgettext:c-format */
6508 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6509 "possible configuration mismatch"),
6510 ebb
->sec
->owner
, ebb
->sec
,
6511 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6514 ebb
->end_offset
+= insn_block_len
;
6516 if (ebb
->end_offset
== ebb
->sec
->size
)
6517 ebb
->ends_section
= TRUE
;
6519 /* Update the reloc counter. */
6520 while (ebb
->end_reloc_idx
+ 1 < ebb
->reloc_count
6521 && (ebb
->relocs
[ebb
->end_reloc_idx
+ 1].r_offset
6524 ebb
->end_reloc_idx
++;
6527 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6530 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6531 if (((new_entry
->flags
& XTENSA_PROP_INSN
) == 0)
6532 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6533 || ((the_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6536 if (the_entry
->address
+ the_entry
->size
!= new_entry
->address
)
6539 the_entry
= new_entry
;
6540 ebb
->end_ptbl_idx
++;
6543 /* Quick check for an unreachable or end of file just at the end. */
6544 if (ebb
->end_ptbl_idx
+ 1 == ebb
->pte_count
)
6546 if (ebb
->end_offset
== ebb
->content_length
)
6547 ebb
->ends_section
= TRUE
;
6551 new_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
+ 1];
6552 if ((new_entry
->flags
& XTENSA_PROP_UNREACHABLE
) != 0
6553 && the_entry
->address
+ the_entry
->size
== new_entry
->address
)
6554 ebb
->ends_unreachable
= new_entry
;
6557 /* Any other ending requires exact alignment. */
6563 extend_ebb_bounds_backward (ebb_t
*ebb
)
6565 property_table_entry
*the_entry
, *new_entry
;
6567 the_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
6569 /* Stop when (1) we cannot decode the instructions in the current entry.
6570 (2) we are at the beginning of the property tables, (3) we hit a
6571 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
6575 bfd_vma block_begin
;
6576 bfd_size_type insn_block_len
;
6578 block_begin
= the_entry
->address
- ebb
->sec
->vma
;
6580 insn_block_decodable_len (ebb
->contents
, ebb
->content_length
,
6582 ebb
->start_offset
- block_begin
);
6583 if (insn_block_len
!= ebb
->start_offset
- block_begin
)
6586 /* xgettext:c-format */
6587 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
6588 "possible configuration mismatch"),
6589 ebb
->sec
->owner
, ebb
->sec
,
6590 (uint64_t) (ebb
->end_offset
+ insn_block_len
));
6593 ebb
->start_offset
-= insn_block_len
;
6595 /* Update the reloc counter. */
6596 while (ebb
->start_reloc_idx
> 0
6597 && (ebb
->relocs
[ebb
->start_reloc_idx
- 1].r_offset
6598 >= ebb
->start_offset
))
6600 ebb
->start_reloc_idx
--;
6603 if (ebb
->start_ptbl_idx
== 0)
6606 new_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
- 1];
6607 if ((new_entry
->flags
& XTENSA_PROP_INSN
) == 0
6608 || ((new_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) != 0)
6609 || ((new_entry
->flags
& XTENSA_PROP_ALIGN
) != 0))
6611 if (new_entry
->address
+ new_entry
->size
!= the_entry
->address
)
6614 the_entry
= new_entry
;
6615 ebb
->start_ptbl_idx
--;
6621 static bfd_size_type
6622 insn_block_decodable_len (bfd_byte
*contents
,
6623 bfd_size_type content_len
,
6624 bfd_vma block_offset
,
6625 bfd_size_type block_len
)
6627 bfd_vma offset
= block_offset
;
6629 while (offset
< block_offset
+ block_len
)
6631 bfd_size_type insn_len
= 0;
6633 insn_len
= insn_decode_len (contents
, content_len
, offset
);
6635 return (offset
- block_offset
);
6638 return (offset
- block_offset
);
6643 ebb_propose_action (ebb_constraint
*c
,
6644 enum ebb_target_enum align_type
,
6645 bfd_vma alignment_pow
,
6646 text_action_t action
,
6649 bfd_boolean do_action
)
6651 proposed_action
*act
;
6653 if (c
->action_allocated
<= c
->action_count
)
6655 unsigned new_allocated
, i
;
6656 proposed_action
*new_actions
;
6658 new_allocated
= (c
->action_count
+ 2) * 2;
6659 new_actions
= (proposed_action
*)
6660 bfd_zmalloc (sizeof (proposed_action
) * new_allocated
);
6662 for (i
= 0; i
< c
->action_count
; i
++)
6663 new_actions
[i
] = c
->actions
[i
];
6666 c
->actions
= new_actions
;
6667 c
->action_allocated
= new_allocated
;
6670 act
= &c
->actions
[c
->action_count
];
6671 act
->align_type
= align_type
;
6672 act
->alignment_pow
= alignment_pow
;
6673 act
->action
= action
;
6674 act
->offset
= offset
;
6675 act
->removed_bytes
= removed_bytes
;
6676 act
->do_action
= do_action
;
6682 /* Access to internal relocations, section contents and symbols. */
6684 /* During relaxation, we need to modify relocations, section contents,
6685 and symbol definitions, and we need to keep the original values from
6686 being reloaded from the input files, i.e., we need to "pin" the
6687 modified values in memory. We also want to continue to observe the
6688 setting of the "keep-memory" flag. The following functions wrap the
6689 standard BFD functions to take care of this for us. */
6691 static Elf_Internal_Rela
*
6692 retrieve_internal_relocs (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6694 Elf_Internal_Rela
*internal_relocs
;
6696 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6699 internal_relocs
= elf_section_data (sec
)->relocs
;
6700 if (internal_relocs
== NULL
)
6701 internal_relocs
= (_bfd_elf_link_read_relocs
6702 (abfd
, sec
, NULL
, NULL
, keep_memory
));
6703 return internal_relocs
;
6708 pin_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6710 elf_section_data (sec
)->relocs
= internal_relocs
;
6715 release_internal_relocs (asection
*sec
, Elf_Internal_Rela
*internal_relocs
)
6718 && elf_section_data (sec
)->relocs
!= internal_relocs
)
6719 free (internal_relocs
);
6724 retrieve_contents (bfd
*abfd
, asection
*sec
, bfd_boolean keep_memory
)
6727 bfd_size_type sec_size
;
6729 sec_size
= bfd_get_section_limit (abfd
, sec
);
6730 contents
= elf_section_data (sec
)->this_hdr
.contents
;
6732 if (contents
== NULL
&& sec_size
!= 0)
6734 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
6741 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6748 pin_contents (asection
*sec
, bfd_byte
*contents
)
6750 elf_section_data (sec
)->this_hdr
.contents
= contents
;
6755 release_contents (asection
*sec
, bfd_byte
*contents
)
6757 if (contents
&& elf_section_data (sec
)->this_hdr
.contents
!= contents
)
6762 static Elf_Internal_Sym
*
6763 retrieve_local_syms (bfd
*input_bfd
)
6765 Elf_Internal_Shdr
*symtab_hdr
;
6766 Elf_Internal_Sym
*isymbuf
;
6769 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
6770 locsymcount
= symtab_hdr
->sh_info
;
6772 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6773 if (isymbuf
== NULL
&& locsymcount
!= 0)
6774 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
, locsymcount
, 0,
6777 /* Save the symbols for this input file so they won't be read again. */
6778 if (isymbuf
&& isymbuf
!= (Elf_Internal_Sym
*) symtab_hdr
->contents
)
6779 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
6785 /* Code for link-time relaxation. */
6787 /* Initialization for relaxation: */
6788 static bfd_boolean
analyze_relocations (struct bfd_link_info
*);
6789 static bfd_boolean find_relaxable_sections
6790 (bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*);
6791 static bfd_boolean collect_source_relocs
6792 (bfd
*, asection
*, struct bfd_link_info
*);
6793 static bfd_boolean is_resolvable_asm_expansion
6794 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, struct bfd_link_info
*,
6796 static Elf_Internal_Rela
*find_associated_l32r_irel
6797 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Rela
*);
6798 static bfd_boolean compute_text_actions
6799 (bfd
*, asection
*, struct bfd_link_info
*);
6800 static bfd_boolean
compute_ebb_proposed_actions (ebb_constraint
*);
6801 static bfd_boolean
compute_ebb_actions (ebb_constraint
*);
6802 typedef struct reloc_range_list_struct reloc_range_list
;
6803 static bfd_boolean check_section_ebb_pcrels_fit
6804 (bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*,
6805 reloc_range_list
*, const ebb_constraint
*,
6806 const xtensa_opcode
*);
6807 static bfd_boolean
check_section_ebb_reduces (const ebb_constraint
*);
6808 static void text_action_add_proposed
6809 (text_action_list
*, const ebb_constraint
*, asection
*);
6812 static bfd_boolean compute_removed_literals
6813 (bfd
*, asection
*, struct bfd_link_info
*, value_map_hash_table
*);
6814 static Elf_Internal_Rela
*get_irel_at_offset
6815 (asection
*, Elf_Internal_Rela
*, bfd_vma
);
6816 static bfd_boolean is_removable_literal
6817 (const source_reloc
*, int, const source_reloc
*, int, asection
*,
6818 property_table_entry
*, int);
6819 static bfd_boolean remove_dead_literal
6820 (bfd
*, asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
6821 Elf_Internal_Rela
*, source_reloc
*, property_table_entry
*, int);
6822 static bfd_boolean identify_literal_placement
6823 (bfd
*, asection
*, bfd_byte
*, struct bfd_link_info
*,
6824 value_map_hash_table
*, bfd_boolean
*, Elf_Internal_Rela
*, int,
6825 source_reloc
*, property_table_entry
*, int, section_cache_t
*,
6827 static bfd_boolean
relocations_reach (source_reloc
*, int, const r_reloc
*);
6828 static bfd_boolean coalesce_shared_literal
6829 (asection
*, source_reloc
*, property_table_entry
*, int, value_map
*);
6830 static bfd_boolean move_shared_literal
6831 (asection
*, struct bfd_link_info
*, source_reloc
*, property_table_entry
*,
6832 int, const r_reloc
*, const literal_value
*, section_cache_t
*);
6835 static bfd_boolean
relax_section (bfd
*, asection
*, struct bfd_link_info
*);
6836 static bfd_boolean
translate_section_fixes (asection
*);
6837 static bfd_boolean
translate_reloc_bfd_fix (reloc_bfd_fix
*);
6838 static asection
*translate_reloc (const r_reloc
*, r_reloc
*, asection
*);
6839 static void shrink_dynamic_reloc_sections
6840 (struct bfd_link_info
*, bfd
*, asection
*, Elf_Internal_Rela
*);
6841 static bfd_boolean move_literal
6842 (bfd
*, struct bfd_link_info
*, asection
*, bfd_vma
, bfd_byte
*,
6843 xtensa_relax_info
*, Elf_Internal_Rela
**, const literal_value
*);
6844 static bfd_boolean relax_property_section
6845 (bfd
*, asection
*, struct bfd_link_info
*);
6848 static bfd_boolean
relax_section_symbols (bfd
*, asection
*);
6852 elf_xtensa_relax_section (bfd
*abfd
,
6854 struct bfd_link_info
*link_info
,
6857 static value_map_hash_table
*values
= NULL
;
6858 static bfd_boolean relocations_analyzed
= FALSE
;
6859 xtensa_relax_info
*relax_info
;
6861 if (!relocations_analyzed
)
6863 /* Do some overall initialization for relaxation. */
6864 values
= value_map_hash_table_init ();
6867 relaxing_section
= TRUE
;
6868 if (!analyze_relocations (link_info
))
6870 relocations_analyzed
= TRUE
;
6874 /* Don't mess with linker-created sections. */
6875 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0)
6878 relax_info
= get_xtensa_relax_info (sec
);
6879 BFD_ASSERT (relax_info
!= NULL
);
6881 switch (relax_info
->visited
)
6884 /* Note: It would be nice to fold this pass into
6885 analyze_relocations, but it is important for this step that the
6886 sections be examined in link order. */
6887 if (!compute_removed_literals (abfd
, sec
, link_info
, values
))
6894 value_map_hash_table_delete (values
);
6896 if (!relax_section (abfd
, sec
, link_info
))
6902 if (!relax_section_symbols (abfd
, sec
))
6907 relax_info
->visited
++;
6912 /* Initialization for relaxation. */
6914 /* This function is called once at the start of relaxation. It scans
6915 all the input sections and marks the ones that are relaxable (i.e.,
6916 literal sections with L32R relocations against them), and then
6917 collects source_reloc information for all the relocations against
6918 those relaxable sections. During this process, it also detects
6919 longcalls, i.e., calls relaxed by the assembler into indirect
6920 calls, that can be optimized back into direct calls. Within each
6921 extended basic block (ebb) containing an optimized longcall, it
6922 computes a set of "text actions" that can be performed to remove
6923 the L32R associated with the longcall while optionally preserving
6924 branch target alignments. */
6927 analyze_relocations (struct bfd_link_info
*link_info
)
6931 bfd_boolean is_relaxable
= FALSE
;
6933 /* Initialize the per-section relaxation info. */
6934 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6935 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6937 init_xtensa_relax_info (sec
);
6940 /* Mark relaxable sections (and count relocations against each one). */
6941 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6942 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6944 if (!find_relaxable_sections (abfd
, sec
, link_info
, &is_relaxable
))
6948 /* Bail out if there are no relaxable sections. */
6952 /* Allocate space for source_relocs. */
6953 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6954 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6956 xtensa_relax_info
*relax_info
;
6958 relax_info
= get_xtensa_relax_info (sec
);
6959 if (relax_info
->is_relaxable_literal_section
6960 || relax_info
->is_relaxable_asm_section
)
6962 relax_info
->src_relocs
= (source_reloc
*)
6963 bfd_malloc (relax_info
->src_count
* sizeof (source_reloc
));
6966 relax_info
->src_count
= 0;
6969 /* Collect info on relocations against each relaxable section. */
6970 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6971 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6973 if (!collect_source_relocs (abfd
, sec
, link_info
))
6977 /* Compute the text actions. */
6978 for (abfd
= link_info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6979 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6981 if (!compute_text_actions (abfd
, sec
, link_info
))
6989 /* Find all the sections that might be relaxed. The motivation for
6990 this pass is that collect_source_relocs() needs to record _all_ the
6991 relocations that target each relaxable section. That is expensive
6992 and unnecessary unless the target section is actually going to be
6993 relaxed. This pass identifies all such sections by checking if
6994 they have L32Rs pointing to them. In the process, the total number
6995 of relocations targeting each section is also counted so that we
6996 know how much space to allocate for source_relocs against each
6997 relaxable literal section. */
7000 find_relaxable_sections (bfd
*abfd
,
7002 struct bfd_link_info
*link_info
,
7003 bfd_boolean
*is_relaxable_p
)
7005 Elf_Internal_Rela
*internal_relocs
;
7007 bfd_boolean ok
= TRUE
;
7009 xtensa_relax_info
*source_relax_info
;
7010 bfd_boolean is_l32r_reloc
;
7012 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7013 link_info
->keep_memory
);
7014 if (internal_relocs
== NULL
)
7017 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7018 if (contents
== NULL
&& sec
->size
!= 0)
7024 source_relax_info
= get_xtensa_relax_info (sec
);
7025 for (i
= 0; i
< sec
->reloc_count
; i
++)
7027 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7029 asection
*target_sec
;
7030 xtensa_relax_info
*target_relax_info
;
7032 /* If this section has not already been marked as "relaxable", and
7033 if it contains any ASM_EXPAND relocations (marking expanded
7034 longcalls) that can be optimized into direct calls, then mark
7035 the section as "relaxable". */
7036 if (source_relax_info
7037 && !source_relax_info
->is_relaxable_asm_section
7038 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_EXPAND
)
7040 bfd_boolean is_reachable
= FALSE
;
7041 if (is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
,
7042 link_info
, &is_reachable
)
7045 source_relax_info
->is_relaxable_asm_section
= TRUE
;
7046 *is_relaxable_p
= TRUE
;
7050 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7051 bfd_get_section_limit (abfd
, sec
));
7053 target_sec
= r_reloc_get_section (&r_rel
);
7054 target_relax_info
= get_xtensa_relax_info (target_sec
);
7055 if (!target_relax_info
)
7058 /* Count PC-relative operand relocations against the target section.
7059 Note: The conditions tested here must match the conditions under
7060 which init_source_reloc is called in collect_source_relocs(). */
7061 is_l32r_reloc
= FALSE
;
7062 if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7064 xtensa_opcode opcode
=
7065 get_relocation_opcode (abfd
, sec
, contents
, irel
);
7066 if (opcode
!= XTENSA_UNDEFINED
)
7068 is_l32r_reloc
= (opcode
== get_l32r_opcode ());
7069 if (!is_alt_relocation (ELF32_R_TYPE (irel
->r_info
))
7071 target_relax_info
->src_count
++;
7075 if (is_l32r_reloc
&& r_reloc_is_defined (&r_rel
))
7077 /* Mark the target section as relaxable. */
7078 target_relax_info
->is_relaxable_literal_section
= TRUE
;
7079 *is_relaxable_p
= TRUE
;
7084 release_contents (sec
, contents
);
7085 release_internal_relocs (sec
, internal_relocs
);
7090 /* Record _all_ the relocations that point to relaxable sections, and
7091 get rid of ASM_EXPAND relocs by either converting them to
7092 ASM_SIMPLIFY or by removing them. */
7095 collect_source_relocs (bfd
*abfd
,
7097 struct bfd_link_info
*link_info
)
7099 Elf_Internal_Rela
*internal_relocs
;
7101 bfd_boolean ok
= TRUE
;
7103 bfd_size_type sec_size
;
7105 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7106 link_info
->keep_memory
);
7107 if (internal_relocs
== NULL
)
7110 sec_size
= bfd_get_section_limit (abfd
, sec
);
7111 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7112 if (contents
== NULL
&& sec_size
!= 0)
7118 /* Record relocations against relaxable literal sections. */
7119 for (i
= 0; i
< sec
->reloc_count
; i
++)
7121 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7123 asection
*target_sec
;
7124 xtensa_relax_info
*target_relax_info
;
7126 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7128 target_sec
= r_reloc_get_section (&r_rel
);
7129 target_relax_info
= get_xtensa_relax_info (target_sec
);
7131 if (target_relax_info
7132 && (target_relax_info
->is_relaxable_literal_section
7133 || target_relax_info
->is_relaxable_asm_section
))
7135 xtensa_opcode opcode
= XTENSA_UNDEFINED
;
7137 bfd_boolean is_abs_literal
= FALSE
;
7139 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7141 /* None of the current alternate relocs are PC-relative,
7142 and only PC-relative relocs matter here. However, we
7143 still need to record the opcode for literal
7145 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7146 if (opcode
== get_l32r_opcode ())
7148 is_abs_literal
= TRUE
;
7152 opcode
= XTENSA_UNDEFINED
;
7154 else if (is_operand_relocation (ELF32_R_TYPE (irel
->r_info
)))
7156 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7157 opnd
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7160 if (opcode
!= XTENSA_UNDEFINED
)
7162 int src_next
= target_relax_info
->src_next
++;
7163 source_reloc
*s_reloc
= &target_relax_info
->src_relocs
[src_next
];
7165 init_source_reloc (s_reloc
, sec
, &r_rel
, opcode
, opnd
,
7171 /* Now get rid of ASM_EXPAND relocations. At this point, the
7172 src_relocs array for the target literal section may still be
7173 incomplete, but it must at least contain the entries for the L32R
7174 relocations associated with ASM_EXPANDs because they were just
7175 added in the preceding loop over the relocations. */
7177 for (i
= 0; i
< sec
->reloc_count
; i
++)
7179 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7180 bfd_boolean is_reachable
;
7182 if (!is_resolvable_asm_expansion (abfd
, sec
, contents
, irel
, link_info
,
7188 Elf_Internal_Rela
*l32r_irel
;
7190 asection
*target_sec
;
7191 xtensa_relax_info
*target_relax_info
;
7193 /* Mark the source_reloc for the L32R so that it will be
7194 removed in compute_removed_literals(), along with the
7195 associated literal. */
7196 l32r_irel
= find_associated_l32r_irel (abfd
, sec
, contents
,
7197 irel
, internal_relocs
);
7198 if (l32r_irel
== NULL
)
7201 r_reloc_init (&r_rel
, abfd
, l32r_irel
, contents
, sec_size
);
7203 target_sec
= r_reloc_get_section (&r_rel
);
7204 target_relax_info
= get_xtensa_relax_info (target_sec
);
7206 if (target_relax_info
7207 && (target_relax_info
->is_relaxable_literal_section
7208 || target_relax_info
->is_relaxable_asm_section
))
7210 source_reloc
*s_reloc
;
7212 /* Search the source_relocs for the entry corresponding to
7213 the l32r_irel. Note: The src_relocs array is not yet
7214 sorted, but it wouldn't matter anyway because we're
7215 searching by source offset instead of target offset. */
7216 s_reloc
= find_source_reloc (target_relax_info
->src_relocs
,
7217 target_relax_info
->src_next
,
7219 BFD_ASSERT (s_reloc
);
7220 s_reloc
->is_null
= TRUE
;
7223 /* Convert this reloc to ASM_SIMPLIFY. */
7224 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
7225 R_XTENSA_ASM_SIMPLIFY
);
7226 l32r_irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7228 pin_internal_relocs (sec
, internal_relocs
);
7232 /* It is resolvable but doesn't reach. We resolve now
7233 by eliminating the relocation -- the call will remain
7234 expanded into L32R/CALLX. */
7235 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
7236 pin_internal_relocs (sec
, internal_relocs
);
7241 release_contents (sec
, contents
);
7242 release_internal_relocs (sec
, internal_relocs
);
7247 /* Return TRUE if the asm expansion can be resolved. Generally it can
7248 be resolved on a final link or when a partial link locates it in the
7249 same section as the target. Set "is_reachable" flag if the target of
7250 the call is within the range of a direct call, given the current VMA
7251 for this section and the target section. */
7254 is_resolvable_asm_expansion (bfd
*abfd
,
7257 Elf_Internal_Rela
*irel
,
7258 struct bfd_link_info
*link_info
,
7259 bfd_boolean
*is_reachable_p
)
7261 asection
*target_sec
;
7265 unsigned int first_align
;
7266 unsigned int adjust
;
7267 bfd_vma target_offset
;
7269 xtensa_opcode opcode
, direct_call_opcode
;
7270 bfd_vma self_address
;
7271 bfd_vma dest_address
;
7272 bfd_boolean uses_l32r
;
7273 bfd_size_type sec_size
;
7275 *is_reachable_p
= FALSE
;
7277 if (contents
== NULL
)
7280 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_EXPAND
)
7283 sec_size
= bfd_get_section_limit (abfd
, sec
);
7284 opcode
= get_expanded_call_opcode (contents
+ irel
->r_offset
,
7285 sec_size
- irel
->r_offset
, &uses_l32r
);
7286 /* Optimization of longcalls that use CONST16 is not yet implemented. */
7290 direct_call_opcode
= swap_callx_for_call_opcode (opcode
);
7291 if (direct_call_opcode
== XTENSA_UNDEFINED
)
7294 /* Check and see that the target resolves. */
7295 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
7296 if (!r_reloc_is_defined (&r_rel
))
7299 target_sec
= r_reloc_get_section (&r_rel
);
7300 target_offset
= r_rel
.target_offset
;
7302 /* If the target is in a shared library, then it doesn't reach. This
7303 isn't supposed to come up because the compiler should never generate
7304 non-PIC calls on systems that use shared libraries, but the linker
7305 shouldn't crash regardless. */
7306 if (!target_sec
->output_section
)
7309 /* For relocatable sections, we can only simplify when the output
7310 section of the target is the same as the output section of the
7312 if (bfd_link_relocatable (link_info
)
7313 && (target_sec
->output_section
!= sec
->output_section
7314 || is_reloc_sym_weak (abfd
, irel
)))
7317 if (target_sec
->output_section
!= sec
->output_section
)
7319 /* If the two sections are sufficiently far away that relaxation
7320 might take the call out of range, we can't simplify. For
7321 example, a positive displacement call into another memory
7322 could get moved to a lower address due to literal removal,
7323 but the destination won't move, and so the displacment might
7326 If the displacement is negative, assume the destination could
7327 move as far back as the start of the output section. The
7328 self_address will be at least as far into the output section
7329 as it is prior to relaxation.
7331 If the displacement is postive, assume the destination will be in
7332 it's pre-relaxed location (because relaxation only makes sections
7333 smaller). The self_address could go all the way to the beginning
7334 of the output section. */
7336 dest_address
= target_sec
->output_section
->vma
;
7337 self_address
= sec
->output_section
->vma
;
7339 if (sec
->output_section
->vma
> target_sec
->output_section
->vma
)
7340 self_address
+= sec
->output_offset
+ irel
->r_offset
+ 3;
7342 dest_address
+= bfd_get_section_limit (abfd
, target_sec
->output_section
);
7343 /* Call targets should be four-byte aligned. */
7344 dest_address
= (dest_address
+ 3) & ~3;
7349 self_address
= (sec
->output_section
->vma
7350 + sec
->output_offset
+ irel
->r_offset
+ 3);
7351 dest_address
= (target_sec
->output_section
->vma
7352 + target_sec
->output_offset
+ target_offset
);
7355 /* Adjust addresses with alignments for the worst case to see if call insn
7356 can fit. Don't relax l32r + callx to call if the target can be out of
7357 range due to alignment.
7358 Caller and target addresses are highest and lowest address.
7359 Search all sections between caller and target, looking for max alignment.
7360 The adjustment is max alignment bytes. If the alignment at the lowest
7361 address is less than the adjustment, apply the adjustment to highest
7364 /* Start from lowest address.
7365 Lowest address aligmnet is from input section.
7366 Initial alignment (adjust) is from input section. */
7367 if (dest_address
> self_address
)
7369 s
= sec
->output_section
;
7370 last_vma
= dest_address
;
7371 first_align
= sec
->alignment_power
;
7372 adjust
= target_sec
->alignment_power
;
7376 s
= target_sec
->output_section
;
7377 last_vma
= self_address
;
7378 first_align
= target_sec
->alignment_power
;
7379 adjust
= sec
->alignment_power
;
7384 /* Find the largest alignment in output section list. */
7385 for (; s
&& s
->vma
>= first_vma
&& s
->vma
<= last_vma
; s
= s
->next
)
7387 if (s
->alignment_power
> adjust
)
7388 adjust
= s
->alignment_power
;
7391 if (adjust
> first_align
)
7393 /* Alignment may enlarge the range, adjust highest address. */
7394 adjust
= 1 << adjust
;
7395 if (dest_address
> self_address
)
7397 dest_address
+= adjust
;
7401 self_address
+= adjust
;
7405 *is_reachable_p
= pcrel_reloc_fits (direct_call_opcode
, 0,
7406 self_address
, dest_address
);
7408 if ((self_address
>> CALL_SEGMENT_BITS
) !=
7409 (dest_address
>> CALL_SEGMENT_BITS
))
7416 static Elf_Internal_Rela
*
7417 find_associated_l32r_irel (bfd
*abfd
,
7420 Elf_Internal_Rela
*other_irel
,
7421 Elf_Internal_Rela
*internal_relocs
)
7425 for (i
= 0; i
< sec
->reloc_count
; i
++)
7427 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7429 if (irel
== other_irel
)
7431 if (irel
->r_offset
!= other_irel
->r_offset
)
7433 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
7441 static xtensa_opcode
*
7442 build_reloc_opcodes (bfd
*abfd
,
7445 Elf_Internal_Rela
*internal_relocs
)
7448 xtensa_opcode
*reloc_opcodes
=
7449 (xtensa_opcode
*) bfd_malloc (sizeof (xtensa_opcode
) * sec
->reloc_count
);
7450 for (i
= 0; i
< sec
->reloc_count
; i
++)
7452 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7453 reloc_opcodes
[i
] = get_relocation_opcode (abfd
, sec
, contents
, irel
);
7455 return reloc_opcodes
;
7458 struct reloc_range_struct
7461 bfd_boolean add
; /* TRUE if start of a range, FALSE otherwise. */
7462 /* Original irel index in the array of relocations for a section. */
7463 unsigned irel_index
;
7465 typedef struct reloc_range_struct reloc_range
;
7467 typedef struct reloc_range_list_entry_struct reloc_range_list_entry
;
7468 struct reloc_range_list_entry_struct
7470 reloc_range_list_entry
*next
;
7471 reloc_range_list_entry
*prev
;
7472 Elf_Internal_Rela
*irel
;
7473 xtensa_opcode opcode
;
7477 struct reloc_range_list_struct
7479 /* The rest of the structure is only meaningful when ok is TRUE. */
7482 unsigned n_range
; /* Number of range markers. */
7483 reloc_range
*range
; /* Sorted range markers. */
7485 unsigned first
; /* Index of a first range element in the list. */
7486 unsigned last
; /* One past index of a last range element in the list. */
7488 unsigned n_list
; /* Number of list elements. */
7489 reloc_range_list_entry
*reloc
; /* */
7490 reloc_range_list_entry list_root
;
7494 reloc_range_compare (const void *a
, const void *b
)
7496 const reloc_range
*ra
= a
;
7497 const reloc_range
*rb
= b
;
7499 if (ra
->addr
!= rb
->addr
)
7500 return ra
->addr
< rb
->addr
? -1 : 1;
7501 if (ra
->add
!= rb
->add
)
7502 return ra
->add
? -1 : 1;
7507 build_reloc_ranges (bfd
*abfd
, asection
*sec
,
7509 Elf_Internal_Rela
*internal_relocs
,
7510 xtensa_opcode
*reloc_opcodes
,
7511 reloc_range_list
*list
)
7516 reloc_range
*ranges
= NULL
;
7517 reloc_range_list_entry
*reloc
=
7518 bfd_malloc (sec
->reloc_count
* sizeof (*reloc
));
7520 memset (list
, 0, sizeof (*list
));
7523 for (i
= 0; i
< sec
->reloc_count
; i
++)
7525 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7526 int r_type
= ELF32_R_TYPE (irel
->r_info
);
7527 reloc_howto_type
*howto
= &elf_howto_table
[r_type
];
7530 if (r_type
== R_XTENSA_ASM_SIMPLIFY
7531 || r_type
== R_XTENSA_32_PCREL
7532 || !howto
->pc_relative
)
7535 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
7536 bfd_get_section_limit (abfd
, sec
));
7538 if (r_reloc_get_section (&r_rel
) != sec
)
7543 max_n
= (max_n
+ 2) * 2;
7544 ranges
= bfd_realloc (ranges
, max_n
* sizeof (*ranges
));
7547 ranges
[n
].addr
= irel
->r_offset
;
7548 ranges
[n
+ 1].addr
= r_rel
.target_offset
;
7550 ranges
[n
].add
= ranges
[n
].addr
< ranges
[n
+ 1].addr
;
7551 ranges
[n
+ 1].add
= !ranges
[n
].add
;
7553 ranges
[n
].irel_index
= i
;
7554 ranges
[n
+ 1].irel_index
= i
;
7558 reloc
[i
].irel
= irel
;
7560 /* Every relocation won't possibly be checked in the optimized version of
7561 check_section_ebb_pcrels_fit, so this needs to be done here. */
7562 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
7564 /* None of the current alternate relocs are PC-relative,
7565 and only PC-relative relocs matter here. */
7569 xtensa_opcode opcode
;
7573 opcode
= reloc_opcodes
[i
];
7575 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
7577 if (opcode
== XTENSA_UNDEFINED
)
7583 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
7584 if (opnum
== XTENSA_UNDEFINED
)
7590 /* Record relocation opcode and opnum as we've calculated them
7591 anyway and they won't change. */
7592 reloc
[i
].opcode
= opcode
;
7593 reloc
[i
].opnum
= opnum
;
7599 ranges
= bfd_realloc (ranges
, n
* sizeof (*ranges
));
7600 qsort (ranges
, n
, sizeof (*ranges
), reloc_range_compare
);
7603 list
->range
= ranges
;
7604 list
->reloc
= reloc
;
7605 list
->list_root
.prev
= &list
->list_root
;
7606 list
->list_root
.next
= &list
->list_root
;
7615 static void reloc_range_list_append (reloc_range_list
*list
,
7616 unsigned irel_index
)
7618 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7620 entry
->prev
= list
->list_root
.prev
;
7621 entry
->next
= &list
->list_root
;
7622 entry
->prev
->next
= entry
;
7623 entry
->next
->prev
= entry
;
7627 static void reloc_range_list_remove (reloc_range_list
*list
,
7628 unsigned irel_index
)
7630 reloc_range_list_entry
*entry
= list
->reloc
+ irel_index
;
7632 entry
->next
->prev
= entry
->prev
;
7633 entry
->prev
->next
= entry
->next
;
7637 /* Update relocation list object so that it lists all relocations that cross
7638 [first; last] range. Range bounds should not decrease with successive
7640 static void reloc_range_list_update_range (reloc_range_list
*list
,
7641 bfd_vma first
, bfd_vma last
)
7643 /* This should not happen: EBBs are iterated from lower addresses to higher.
7644 But even if that happens there's no need to break: just flush current list
7645 and start from scratch. */
7646 if ((list
->last
> 0 && list
->range
[list
->last
- 1].addr
> last
) ||
7647 (list
->first
> 0 && list
->range
[list
->first
- 1].addr
>= first
))
7652 list
->list_root
.next
= &list
->list_root
;
7653 list
->list_root
.prev
= &list
->list_root
;
7654 fprintf (stderr
, "%s: move backwards requested\n", __func__
);
7657 for (; list
->last
< list
->n_range
&&
7658 list
->range
[list
->last
].addr
<= last
; ++list
->last
)
7659 if (list
->range
[list
->last
].add
)
7660 reloc_range_list_append (list
, list
->range
[list
->last
].irel_index
);
7662 for (; list
->first
< list
->n_range
&&
7663 list
->range
[list
->first
].addr
< first
; ++list
->first
)
7664 if (!list
->range
[list
->first
].add
)
7665 reloc_range_list_remove (list
, list
->range
[list
->first
].irel_index
);
7668 static void free_reloc_range_list (reloc_range_list
*list
)
7674 /* The compute_text_actions function will build a list of potential
7675 transformation actions for code in the extended basic block of each
7676 longcall that is optimized to a direct call. From this list we
7677 generate a set of actions to actually perform that optimizes for
7678 space and, if not using size_opt, maintains branch target
7681 These actions to be performed are placed on a per-section list.
7682 The actual changes are performed by relax_section() in the second
7686 compute_text_actions (bfd
*abfd
,
7688 struct bfd_link_info
*link_info
)
7690 xtensa_opcode
*reloc_opcodes
= NULL
;
7691 xtensa_relax_info
*relax_info
;
7693 Elf_Internal_Rela
*internal_relocs
;
7694 bfd_boolean ok
= TRUE
;
7696 property_table_entry
*prop_table
= 0;
7698 bfd_size_type sec_size
;
7699 reloc_range_list relevant_relocs
;
7701 relax_info
= get_xtensa_relax_info (sec
);
7702 BFD_ASSERT (relax_info
);
7703 BFD_ASSERT (relax_info
->src_next
== relax_info
->src_count
);
7705 /* Do nothing if the section contains no optimized longcalls. */
7706 if (!relax_info
->is_relaxable_asm_section
)
7709 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
7710 link_info
->keep_memory
);
7712 if (internal_relocs
)
7713 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
7714 internal_reloc_compare
);
7716 sec_size
= bfd_get_section_limit (abfd
, sec
);
7717 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
7718 if (contents
== NULL
&& sec_size
!= 0)
7724 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
7725 XTENSA_PROP_SEC_NAME
, FALSE
);
7732 /* Precompute the opcode for each relocation. */
7733 reloc_opcodes
= build_reloc_opcodes (abfd
, sec
, contents
, internal_relocs
);
7735 build_reloc_ranges (abfd
, sec
, contents
, internal_relocs
, reloc_opcodes
,
7738 for (i
= 0; i
< sec
->reloc_count
; i
++)
7740 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
7742 property_table_entry
*the_entry
;
7745 ebb_constraint ebb_table
;
7746 bfd_size_type simplify_size
;
7748 if (irel
&& ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_ASM_SIMPLIFY
)
7750 r_offset
= irel
->r_offset
;
7752 simplify_size
= get_asm_simplify_size (contents
, sec_size
, r_offset
);
7753 if (simplify_size
== 0)
7756 /* xgettext:c-format */
7757 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction for "
7758 "XTENSA_ASM_SIMPLIFY relocation; "
7759 "possible configuration mismatch"),
7760 sec
->owner
, sec
, (uint64_t) r_offset
);
7764 /* If the instruction table is not around, then don't do this
7766 the_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
7767 sec
->vma
+ irel
->r_offset
);
7768 if (the_entry
== NULL
|| XTENSA_NO_NOP_REMOVAL
)
7770 text_action_add (&relax_info
->action_list
,
7771 ta_convert_longcall
, sec
, r_offset
,
7776 /* If the next longcall happens to be at the same address as an
7777 unreachable section of size 0, then skip forward. */
7778 ptbl_idx
= the_entry
- prop_table
;
7779 while ((the_entry
->flags
& XTENSA_PROP_UNREACHABLE
)
7780 && the_entry
->size
== 0
7781 && ptbl_idx
+ 1 < ptblsize
7782 && (prop_table
[ptbl_idx
+ 1].address
7783 == prop_table
[ptbl_idx
].address
))
7789 if (the_entry
->flags
& XTENSA_PROP_NO_TRANSFORM
)
7790 /* NO_REORDER is OK */
7793 init_ebb_constraint (&ebb_table
);
7794 ebb
= &ebb_table
.ebb
;
7795 init_ebb (ebb
, sec
, contents
, sec_size
, prop_table
, ptblsize
,
7796 internal_relocs
, sec
->reloc_count
);
7797 ebb
->start_offset
= r_offset
+ simplify_size
;
7798 ebb
->end_offset
= r_offset
+ simplify_size
;
7799 ebb
->start_ptbl_idx
= ptbl_idx
;
7800 ebb
->end_ptbl_idx
= ptbl_idx
;
7801 ebb
->start_reloc_idx
= i
;
7802 ebb
->end_reloc_idx
= i
;
7804 if (!extend_ebb_bounds (ebb
)
7805 || !compute_ebb_proposed_actions (&ebb_table
)
7806 || !compute_ebb_actions (&ebb_table
)
7807 || !check_section_ebb_pcrels_fit (abfd
, sec
, contents
,
7810 &ebb_table
, reloc_opcodes
)
7811 || !check_section_ebb_reduces (&ebb_table
))
7813 /* If anything goes wrong or we get unlucky and something does
7814 not fit, with our plan because of expansion between
7815 critical branches, just convert to a NOP. */
7817 text_action_add (&relax_info
->action_list
,
7818 ta_convert_longcall
, sec
, r_offset
, 0);
7819 i
= ebb_table
.ebb
.end_reloc_idx
;
7820 free_ebb_constraint (&ebb_table
);
7824 text_action_add_proposed (&relax_info
->action_list
, &ebb_table
, sec
);
7826 /* Update the index so we do not go looking at the relocations
7827 we have already processed. */
7828 i
= ebb_table
.ebb
.end_reloc_idx
;
7829 free_ebb_constraint (&ebb_table
);
7832 free_reloc_range_list (&relevant_relocs
);
7835 if (action_list_count (&relax_info
->action_list
))
7836 print_action_list (stderr
, &relax_info
->action_list
);
7840 release_contents (sec
, contents
);
7841 release_internal_relocs (sec
, internal_relocs
);
7845 free (reloc_opcodes
);
7851 /* Do not widen an instruction if it is preceeded by a
7852 loop opcode. It might cause misalignment. */
7855 prev_instr_is_a_loop (bfd_byte
*contents
,
7856 bfd_size_type content_length
,
7857 bfd_size_type offset
)
7859 xtensa_opcode prev_opcode
;
7863 prev_opcode
= insn_decode_opcode (contents
, content_length
, offset
-3, 0);
7864 return (xtensa_opcode_is_loop (xtensa_default_isa
, prev_opcode
) == 1);
7868 /* Find all of the possible actions for an extended basic block. */
7871 compute_ebb_proposed_actions (ebb_constraint
*ebb_table
)
7873 const ebb_t
*ebb
= &ebb_table
->ebb
;
7874 unsigned rel_idx
= ebb
->start_reloc_idx
;
7875 property_table_entry
*entry
, *start_entry
, *end_entry
;
7877 xtensa_isa isa
= xtensa_default_isa
;
7879 static xtensa_insnbuf insnbuf
= NULL
;
7880 static xtensa_insnbuf slotbuf
= NULL
;
7882 if (insnbuf
== NULL
)
7884 insnbuf
= xtensa_insnbuf_alloc (isa
);
7885 slotbuf
= xtensa_insnbuf_alloc (isa
);
7888 start_entry
= &ebb
->ptbl
[ebb
->start_ptbl_idx
];
7889 end_entry
= &ebb
->ptbl
[ebb
->end_ptbl_idx
];
7891 for (entry
= start_entry
; entry
<= end_entry
; entry
++)
7893 bfd_vma start_offset
, end_offset
;
7894 bfd_size_type insn_len
;
7896 start_offset
= entry
->address
- ebb
->sec
->vma
;
7897 end_offset
= entry
->address
+ entry
->size
- ebb
->sec
->vma
;
7899 if (entry
== start_entry
)
7900 start_offset
= ebb
->start_offset
;
7901 if (entry
== end_entry
)
7902 end_offset
= ebb
->end_offset
;
7903 offset
= start_offset
;
7905 if (offset
== entry
->address
- ebb
->sec
->vma
7906 && (entry
->flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) != 0)
7908 enum ebb_target_enum align_type
= EBB_DESIRE_TGT_ALIGN
;
7909 BFD_ASSERT (offset
!= end_offset
);
7910 if (offset
== end_offset
)
7913 insn_len
= insn_decode_len (ebb
->contents
, ebb
->content_length
,
7918 if (check_branch_target_aligned_address (offset
, insn_len
))
7919 align_type
= EBB_REQUIRE_TGT_ALIGN
;
7921 ebb_propose_action (ebb_table
, align_type
, 0,
7922 ta_none
, offset
, 0, TRUE
);
7925 while (offset
!= end_offset
)
7927 Elf_Internal_Rela
*irel
;
7928 xtensa_opcode opcode
;
7930 while (rel_idx
< ebb
->end_reloc_idx
7931 && (ebb
->relocs
[rel_idx
].r_offset
< offset
7932 || (ebb
->relocs
[rel_idx
].r_offset
== offset
7933 && (ELF32_R_TYPE (ebb
->relocs
[rel_idx
].r_info
)
7934 != R_XTENSA_ASM_SIMPLIFY
))))
7937 /* Check for longcall. */
7938 irel
= &ebb
->relocs
[rel_idx
];
7939 if (irel
->r_offset
== offset
7940 && ELF32_R_TYPE (irel
->r_info
) == R_XTENSA_ASM_SIMPLIFY
)
7942 bfd_size_type simplify_size
;
7944 simplify_size
= get_asm_simplify_size (ebb
->contents
,
7945 ebb
->content_length
,
7947 if (simplify_size
== 0)
7950 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7951 ta_convert_longcall
, offset
, 0, TRUE
);
7953 offset
+= simplify_size
;
7957 if (offset
+ MIN_INSN_LENGTH
> ebb
->content_length
)
7959 xtensa_insnbuf_from_chars (isa
, insnbuf
, &ebb
->contents
[offset
],
7960 ebb
->content_length
- offset
);
7961 fmt
= xtensa_format_decode (isa
, insnbuf
);
7962 if (fmt
== XTENSA_UNDEFINED
)
7964 insn_len
= xtensa_format_length (isa
, fmt
);
7965 if (insn_len
== (bfd_size_type
) XTENSA_UNDEFINED
)
7968 if (xtensa_format_num_slots (isa
, fmt
) != 1)
7974 xtensa_format_get_slot (isa
, fmt
, 0, insnbuf
, slotbuf
);
7975 opcode
= xtensa_opcode_decode (isa
, fmt
, 0, slotbuf
);
7976 if (opcode
== XTENSA_UNDEFINED
)
7979 if ((entry
->flags
& XTENSA_PROP_INSN_NO_DENSITY
) == 0
7980 && (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
7981 && can_narrow_instruction (slotbuf
, fmt
, opcode
) != 0)
7983 /* Add an instruction narrow action. */
7984 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7985 ta_narrow_insn
, offset
, 0, FALSE
);
7987 else if ((entry
->flags
& XTENSA_PROP_NO_TRANSFORM
) == 0
7988 && can_widen_instruction (slotbuf
, fmt
, opcode
) != 0
7989 && ! prev_instr_is_a_loop (ebb
->contents
,
7990 ebb
->content_length
, offset
))
7992 /* Add an instruction widen action. */
7993 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
7994 ta_widen_insn
, offset
, 0, FALSE
);
7996 else if (xtensa_opcode_is_loop (xtensa_default_isa
, opcode
) == 1)
7998 /* Check for branch targets. */
7999 ebb_propose_action (ebb_table
, EBB_REQUIRE_LOOP_ALIGN
, 0,
8000 ta_none
, offset
, 0, TRUE
);
8007 if (ebb
->ends_unreachable
)
8009 ebb_propose_action (ebb_table
, EBB_NO_ALIGN
, 0,
8010 ta_fill
, ebb
->end_offset
, 0, TRUE
);
8017 /* xgettext:c-format */
8018 (_("%pB(%pA+%#" PRIx64
"): could not decode instruction; "
8019 "possible configuration mismatch"),
8020 ebb
->sec
->owner
, ebb
->sec
, (uint64_t) offset
);
8025 /* After all of the information has collected about the
8026 transformations possible in an EBB, compute the appropriate actions
8027 here in compute_ebb_actions. We still must check later to make
8028 sure that the actions do not break any relocations. The algorithm
8029 used here is pretty greedy. Basically, it removes as many no-ops
8030 as possible so that the end of the EBB has the same alignment
8031 characteristics as the original. First, it uses narrowing, then
8032 fill space at the end of the EBB, and finally widenings. If that
8033 does not work, it tries again with one fewer no-op removed. The
8034 optimization will only be performed if all of the branch targets
8035 that were aligned before transformation are also aligned after the
8038 When the size_opt flag is set, ignore the branch target alignments,
8039 narrow all wide instructions, and remove all no-ops unless the end
8040 of the EBB prevents it. */
8043 compute_ebb_actions (ebb_constraint
*ebb_table
)
8047 int removed_bytes
= 0;
8048 ebb_t
*ebb
= &ebb_table
->ebb
;
8049 unsigned seg_idx_start
= 0;
8050 unsigned seg_idx_end
= 0;
8052 /* We perform this like the assembler relaxation algorithm: Start by
8053 assuming all instructions are narrow and all no-ops removed; then
8056 /* For each segment of this that has a solid constraint, check to
8057 see if there are any combinations that will keep the constraint.
8059 for (seg_idx_end
= 0; seg_idx_end
< ebb_table
->action_count
; seg_idx_end
++)
8061 bfd_boolean requires_text_end_align
= FALSE
;
8062 unsigned longcall_count
= 0;
8063 unsigned longcall_convert_count
= 0;
8064 unsigned narrowable_count
= 0;
8065 unsigned narrowable_convert_count
= 0;
8066 unsigned widenable_count
= 0;
8067 unsigned widenable_convert_count
= 0;
8069 proposed_action
*action
= NULL
;
8070 int align
= (1 << ebb_table
->ebb
.sec
->alignment_power
);
8072 seg_idx_start
= seg_idx_end
;
8074 for (i
= seg_idx_start
; i
< ebb_table
->action_count
; i
++)
8076 action
= &ebb_table
->actions
[i
];
8077 if (action
->action
== ta_convert_longcall
)
8079 if (action
->action
== ta_narrow_insn
)
8081 if (action
->action
== ta_widen_insn
)
8083 if (action
->action
== ta_fill
)
8085 if (action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8087 if (action
->align_type
== EBB_REQUIRE_TGT_ALIGN
8088 && !elf32xtensa_size_opt
)
8093 if (seg_idx_end
== ebb_table
->action_count
&& !ebb
->ends_unreachable
)
8094 requires_text_end_align
= TRUE
;
8096 if (elf32xtensa_size_opt
&& !requires_text_end_align
8097 && action
->align_type
!= EBB_REQUIRE_LOOP_ALIGN
8098 && action
->align_type
!= EBB_REQUIRE_TGT_ALIGN
)
8100 longcall_convert_count
= longcall_count
;
8101 narrowable_convert_count
= narrowable_count
;
8102 widenable_convert_count
= 0;
8106 /* There is a constraint. Convert the max number of longcalls. */
8107 narrowable_convert_count
= 0;
8108 longcall_convert_count
= 0;
8109 widenable_convert_count
= 0;
8111 for (j
= 0; j
< longcall_count
; j
++)
8113 int removed
= (longcall_count
- j
) * 3 & (align
- 1);
8114 unsigned desire_narrow
= (align
- removed
) & (align
- 1);
8115 unsigned desire_widen
= removed
;
8116 if (desire_narrow
<= narrowable_count
)
8118 narrowable_convert_count
= desire_narrow
;
8119 narrowable_convert_count
+=
8120 (align
* ((narrowable_count
- narrowable_convert_count
)
8122 longcall_convert_count
= (longcall_count
- j
);
8123 widenable_convert_count
= 0;
8126 if (desire_widen
<= widenable_count
&& !elf32xtensa_size_opt
)
8128 narrowable_convert_count
= 0;
8129 longcall_convert_count
= longcall_count
- j
;
8130 widenable_convert_count
= desire_widen
;
8136 /* Now the number of conversions are saved. Do them. */
8137 for (i
= seg_idx_start
; i
< seg_idx_end
; i
++)
8139 action
= &ebb_table
->actions
[i
];
8140 switch (action
->action
)
8142 case ta_convert_longcall
:
8143 if (longcall_convert_count
!= 0)
8145 action
->action
= ta_remove_longcall
;
8146 action
->do_action
= TRUE
;
8147 action
->removed_bytes
+= 3;
8148 longcall_convert_count
--;
8151 case ta_narrow_insn
:
8152 if (narrowable_convert_count
!= 0)
8154 action
->do_action
= TRUE
;
8155 action
->removed_bytes
+= 1;
8156 narrowable_convert_count
--;
8160 if (widenable_convert_count
!= 0)
8162 action
->do_action
= TRUE
;
8163 action
->removed_bytes
-= 1;
8164 widenable_convert_count
--;
8173 /* Now we move on to some local opts. Try to remove each of the
8174 remaining longcalls. */
8176 if (ebb_table
->ebb
.ends_section
|| ebb_table
->ebb
.ends_unreachable
)
8179 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8181 int old_removed_bytes
= removed_bytes
;
8182 proposed_action
*action
= &ebb_table
->actions
[i
];
8184 if (action
->do_action
&& action
->action
== ta_convert_longcall
)
8186 bfd_boolean bad_alignment
= FALSE
;
8188 for (j
= i
+ 1; j
< ebb_table
->action_count
; j
++)
8190 proposed_action
*new_action
= &ebb_table
->actions
[j
];
8191 bfd_vma offset
= new_action
->offset
;
8192 if (new_action
->align_type
== EBB_REQUIRE_TGT_ALIGN
)
8194 if (!check_branch_target_aligned
8195 (ebb_table
->ebb
.contents
,
8196 ebb_table
->ebb
.content_length
,
8197 offset
, offset
- removed_bytes
))
8199 bad_alignment
= TRUE
;
8203 if (new_action
->align_type
== EBB_REQUIRE_LOOP_ALIGN
)
8205 if (!check_loop_aligned (ebb_table
->ebb
.contents
,
8206 ebb_table
->ebb
.content_length
,
8208 offset
- removed_bytes
))
8210 bad_alignment
= TRUE
;
8214 if (new_action
->action
== ta_narrow_insn
8215 && !new_action
->do_action
8216 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8218 /* Narrow an instruction and we are done. */
8219 new_action
->do_action
= TRUE
;
8220 new_action
->removed_bytes
+= 1;
8221 bad_alignment
= FALSE
;
8224 if (new_action
->action
== ta_widen_insn
8225 && new_action
->do_action
8226 && ebb_table
->ebb
.sec
->alignment_power
== 2)
8228 /* Narrow an instruction and we are done. */
8229 new_action
->do_action
= FALSE
;
8230 new_action
->removed_bytes
+= 1;
8231 bad_alignment
= FALSE
;
8234 if (new_action
->do_action
)
8235 removed_bytes
+= new_action
->removed_bytes
;
8239 action
->removed_bytes
+= 3;
8240 action
->action
= ta_remove_longcall
;
8241 action
->do_action
= TRUE
;
8244 removed_bytes
= old_removed_bytes
;
8245 if (action
->do_action
)
8246 removed_bytes
+= action
->removed_bytes
;
8251 for (i
= 0; i
< ebb_table
->action_count
; ++i
)
8253 proposed_action
*action
= &ebb_table
->actions
[i
];
8254 if (action
->do_action
)
8255 removed_bytes
+= action
->removed_bytes
;
8258 if ((removed_bytes
% (1 << ebb_table
->ebb
.sec
->alignment_power
)) != 0
8259 && ebb
->ends_unreachable
)
8261 proposed_action
*action
;
8265 BFD_ASSERT (ebb_table
->action_count
!= 0);
8266 action
= &ebb_table
->actions
[ebb_table
->action_count
- 1];
8267 BFD_ASSERT (action
->action
== ta_fill
);
8268 BFD_ASSERT (ebb
->ends_unreachable
->flags
& XTENSA_PROP_UNREACHABLE
);
8270 extra_space
= xtensa_compute_fill_extra_space (ebb
->ends_unreachable
);
8271 br
= action
->removed_bytes
+ removed_bytes
+ extra_space
;
8272 br
= br
& ((1 << ebb
->sec
->alignment_power
) - 1);
8274 action
->removed_bytes
= extra_space
- br
;
8280 /* The xlate_map is a sorted array of address mappings designed to
8281 answer the offset_with_removed_text() query with a binary search instead
8282 of a linear search through the section's action_list. */
8284 typedef struct xlate_map_entry xlate_map_entry_t
;
8285 typedef struct xlate_map xlate_map_t
;
8287 struct xlate_map_entry
8289 bfd_vma orig_address
;
8290 bfd_vma new_address
;
8296 unsigned entry_count
;
8297 xlate_map_entry_t
*entry
;
8302 xlate_compare (const void *a_v
, const void *b_v
)
8304 const xlate_map_entry_t
*a
= (const xlate_map_entry_t
*) a_v
;
8305 const xlate_map_entry_t
*b
= (const xlate_map_entry_t
*) b_v
;
8306 if (a
->orig_address
< b
->orig_address
)
8308 if (a
->orig_address
> (b
->orig_address
+ b
->size
- 1))
8315 xlate_offset_with_removed_text (const xlate_map_t
*map
,
8316 text_action_list
*action_list
,
8320 xlate_map_entry_t
*e
;
8321 struct xlate_map_entry se
;
8324 return offset_with_removed_text (action_list
, offset
);
8326 if (map
->entry_count
== 0)
8329 se
.orig_address
= offset
;
8330 r
= bsearch (&se
, map
->entry
, map
->entry_count
,
8331 sizeof (xlate_map_entry_t
), &xlate_compare
);
8332 e
= (xlate_map_entry_t
*) r
;
8334 /* There could be a jump past the end of the section,
8335 allow it using the last xlate map entry to translate its address. */
8338 e
= map
->entry
+ map
->entry_count
- 1;
8339 if (xlate_compare (&se
, e
) <= 0)
8342 BFD_ASSERT (e
!= NULL
);
8345 return e
->new_address
- e
->orig_address
+ offset
;
8348 typedef struct xlate_map_context_struct xlate_map_context
;
8349 struct xlate_map_context_struct
8352 xlate_map_entry_t
*current_entry
;
8357 xlate_map_fn (splay_tree_node node
, void *p
)
8359 text_action
*r
= (text_action
*)node
->value
;
8360 xlate_map_context
*ctx
= p
;
8361 unsigned orig_size
= 0;
8366 case ta_remove_insn
:
8367 case ta_convert_longcall
:
8368 case ta_remove_literal
:
8369 case ta_add_literal
:
8371 case ta_remove_longcall
:
8374 case ta_narrow_insn
:
8383 ctx
->current_entry
->size
=
8384 r
->offset
+ orig_size
- ctx
->current_entry
->orig_address
;
8385 if (ctx
->current_entry
->size
!= 0)
8387 ctx
->current_entry
++;
8388 ctx
->map
->entry_count
++;
8390 ctx
->current_entry
->orig_address
= r
->offset
+ orig_size
;
8391 ctx
->removed
+= r
->removed_bytes
;
8392 ctx
->current_entry
->new_address
= r
->offset
+ orig_size
- ctx
->removed
;
8393 ctx
->current_entry
->size
= 0;
8397 /* Build a binary searchable offset translation map from a section's
8400 static xlate_map_t
*
8401 build_xlate_map (asection
*sec
, xtensa_relax_info
*relax_info
)
8403 text_action_list
*action_list
= &relax_info
->action_list
;
8404 unsigned num_actions
= 0;
8405 xlate_map_context ctx
;
8407 ctx
.map
= (xlate_map_t
*) bfd_malloc (sizeof (xlate_map_t
));
8409 if (ctx
.map
== NULL
)
8412 num_actions
= action_list_count (action_list
);
8413 ctx
.map
->entry
= (xlate_map_entry_t
*)
8414 bfd_malloc (sizeof (xlate_map_entry_t
) * (num_actions
+ 1));
8415 if (ctx
.map
->entry
== NULL
)
8420 ctx
.map
->entry_count
= 0;
8423 ctx
.current_entry
= &ctx
.map
->entry
[0];
8425 ctx
.current_entry
->orig_address
= 0;
8426 ctx
.current_entry
->new_address
= 0;
8427 ctx
.current_entry
->size
= 0;
8429 splay_tree_foreach (action_list
->tree
, xlate_map_fn
, &ctx
);
8431 ctx
.current_entry
->size
= (bfd_get_section_limit (sec
->owner
, sec
)
8432 - ctx
.current_entry
->orig_address
);
8433 if (ctx
.current_entry
->size
!= 0)
8434 ctx
.map
->entry_count
++;
8440 /* Free an offset translation map. */
8443 free_xlate_map (xlate_map_t
*map
)
8445 if (map
&& map
->entry
)
8452 /* Use check_section_ebb_pcrels_fit to make sure that all of the
8453 relocations in a section will fit if a proposed set of actions
8457 check_section_ebb_pcrels_fit (bfd
*abfd
,
8460 Elf_Internal_Rela
*internal_relocs
,
8461 reloc_range_list
*relevant_relocs
,
8462 const ebb_constraint
*constraint
,
8463 const xtensa_opcode
*reloc_opcodes
)
8466 unsigned n
= sec
->reloc_count
;
8467 Elf_Internal_Rela
*irel
;
8468 xlate_map_t
*xmap
= NULL
;
8469 bfd_boolean ok
= TRUE
;
8470 xtensa_relax_info
*relax_info
;
8471 reloc_range_list_entry
*entry
= NULL
;
8473 relax_info
= get_xtensa_relax_info (sec
);
8475 if (relax_info
&& sec
->reloc_count
> 100)
8477 xmap
= build_xlate_map (sec
, relax_info
);
8478 /* NULL indicates out of memory, but the slow version
8479 can still be used. */
8482 if (relevant_relocs
&& constraint
->action_count
)
8484 if (!relevant_relocs
->ok
)
8491 bfd_vma min_offset
, max_offset
;
8492 min_offset
= max_offset
= constraint
->actions
[0].offset
;
8494 for (i
= 1; i
< constraint
->action_count
; ++i
)
8496 proposed_action
*action
= &constraint
->actions
[i
];
8497 bfd_vma offset
= action
->offset
;
8499 if (offset
< min_offset
)
8500 min_offset
= offset
;
8501 if (offset
> max_offset
)
8502 max_offset
= offset
;
8504 reloc_range_list_update_range (relevant_relocs
, min_offset
,
8506 n
= relevant_relocs
->n_list
;
8507 entry
= &relevant_relocs
->list_root
;
8512 relevant_relocs
= NULL
;
8515 for (i
= 0; i
< n
; i
++)
8518 bfd_vma orig_self_offset
, orig_target_offset
;
8519 bfd_vma self_offset
, target_offset
;
8521 reloc_howto_type
*howto
;
8522 int self_removed_bytes
, target_removed_bytes
;
8524 if (relevant_relocs
)
8526 entry
= entry
->next
;
8531 irel
= internal_relocs
+ i
;
8533 r_type
= ELF32_R_TYPE (irel
->r_info
);
8535 howto
= &elf_howto_table
[r_type
];
8536 /* We maintain the required invariant: PC-relative relocations
8537 that fit before linking must fit after linking. Thus we only
8538 need to deal with relocations to the same section that are
8540 if (r_type
== R_XTENSA_ASM_SIMPLIFY
8541 || r_type
== R_XTENSA_32_PCREL
8542 || !howto
->pc_relative
)
8545 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
8546 bfd_get_section_limit (abfd
, sec
));
8548 if (r_reloc_get_section (&r_rel
) != sec
)
8551 orig_self_offset
= irel
->r_offset
;
8552 orig_target_offset
= r_rel
.target_offset
;
8554 self_offset
= orig_self_offset
;
8555 target_offset
= orig_target_offset
;
8560 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8563 xlate_offset_with_removed_text (xmap
, &relax_info
->action_list
,
8564 orig_target_offset
);
8567 self_removed_bytes
= 0;
8568 target_removed_bytes
= 0;
8570 for (j
= 0; j
< constraint
->action_count
; ++j
)
8572 proposed_action
*action
= &constraint
->actions
[j
];
8573 bfd_vma offset
= action
->offset
;
8574 int removed_bytes
= action
->removed_bytes
;
8575 if (offset
< orig_self_offset
8576 || (offset
== orig_self_offset
&& action
->action
== ta_fill
8577 && action
->removed_bytes
< 0))
8578 self_removed_bytes
+= removed_bytes
;
8579 if (offset
< orig_target_offset
8580 || (offset
== orig_target_offset
&& action
->action
== ta_fill
8581 && action
->removed_bytes
< 0))
8582 target_removed_bytes
+= removed_bytes
;
8584 self_offset
-= self_removed_bytes
;
8585 target_offset
-= target_removed_bytes
;
8587 /* Try to encode it. Get the operand and check. */
8588 if (is_alt_relocation (ELF32_R_TYPE (irel
->r_info
)))
8590 /* None of the current alternate relocs are PC-relative,
8591 and only PC-relative relocs matter here. */
8595 xtensa_opcode opcode
;
8598 if (relevant_relocs
)
8600 opcode
= entry
->opcode
;
8601 opnum
= entry
->opnum
;
8606 opcode
= reloc_opcodes
[relevant_relocs
?
8607 (unsigned)(entry
- relevant_relocs
->reloc
) : i
];
8609 opcode
= get_relocation_opcode (abfd
, sec
, contents
, irel
);
8610 if (opcode
== XTENSA_UNDEFINED
)
8616 opnum
= get_relocation_opnd (opcode
, ELF32_R_TYPE (irel
->r_info
));
8617 if (opnum
== XTENSA_UNDEFINED
)
8624 if (!pcrel_reloc_fits (opcode
, opnum
, self_offset
, target_offset
))
8633 free_xlate_map (xmap
);
8640 check_section_ebb_reduces (const ebb_constraint
*constraint
)
8645 for (i
= 0; i
< constraint
->action_count
; i
++)
8647 const proposed_action
*action
= &constraint
->actions
[i
];
8648 if (action
->do_action
)
8649 removed
+= action
->removed_bytes
;
8659 text_action_add_proposed (text_action_list
*l
,
8660 const ebb_constraint
*ebb_table
,
8665 for (i
= 0; i
< ebb_table
->action_count
; i
++)
8667 proposed_action
*action
= &ebb_table
->actions
[i
];
8669 if (!action
->do_action
)
8671 switch (action
->action
)
8673 case ta_remove_insn
:
8674 case ta_remove_longcall
:
8675 case ta_convert_longcall
:
8676 case ta_narrow_insn
:
8679 case ta_remove_literal
:
8680 text_action_add (l
, action
->action
, sec
, action
->offset
,
8681 action
->removed_bytes
);
8694 xtensa_compute_fill_extra_space (property_table_entry
*entry
)
8696 int fill_extra_space
;
8701 if ((entry
->flags
& XTENSA_PROP_UNREACHABLE
) == 0)
8704 fill_extra_space
= entry
->size
;
8705 if ((entry
->flags
& XTENSA_PROP_ALIGN
) != 0)
8707 /* Fill bytes for alignment:
8708 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
8709 int pow
= GET_XTENSA_PROP_ALIGNMENT (entry
->flags
);
8710 int nsm
= (1 << pow
) - 1;
8711 bfd_vma addr
= entry
->address
+ entry
->size
;
8712 bfd_vma align_fill
= nsm
- ((addr
+ nsm
) & nsm
);
8713 fill_extra_space
+= align_fill
;
8715 return fill_extra_space
;
8719 /* First relaxation pass. */
8721 /* If the section contains relaxable literals, check each literal to
8722 see if it has the same value as another literal that has already
8723 been seen, either in the current section or a previous one. If so,
8724 add an entry to the per-section list of removed literals. The
8725 actual changes are deferred until the next pass. */
8728 compute_removed_literals (bfd
*abfd
,
8730 struct bfd_link_info
*link_info
,
8731 value_map_hash_table
*values
)
8733 xtensa_relax_info
*relax_info
;
8735 Elf_Internal_Rela
*internal_relocs
;
8736 source_reloc
*src_relocs
, *rel
;
8737 bfd_boolean ok
= TRUE
;
8738 property_table_entry
*prop_table
= NULL
;
8741 bfd_boolean last_loc_is_prev
= FALSE
;
8742 bfd_vma last_target_offset
= 0;
8743 section_cache_t target_sec_cache
;
8744 bfd_size_type sec_size
;
8746 init_section_cache (&target_sec_cache
);
8748 /* Do nothing if it is not a relaxable literal section. */
8749 relax_info
= get_xtensa_relax_info (sec
);
8750 BFD_ASSERT (relax_info
);
8751 if (!relax_info
->is_relaxable_literal_section
)
8754 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
8755 link_info
->keep_memory
);
8757 sec_size
= bfd_get_section_limit (abfd
, sec
);
8758 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
8759 if (contents
== NULL
&& sec_size
!= 0)
8765 /* Sort the source_relocs by target offset. */
8766 src_relocs
= relax_info
->src_relocs
;
8767 qsort (src_relocs
, relax_info
->src_count
,
8768 sizeof (source_reloc
), source_reloc_compare
);
8769 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
8770 internal_reloc_compare
);
8772 ptblsize
= xtensa_read_table_entries (abfd
, sec
, &prop_table
,
8773 XTENSA_PROP_SEC_NAME
, FALSE
);
8781 for (i
= 0; i
< relax_info
->src_count
; i
++)
8783 Elf_Internal_Rela
*irel
= NULL
;
8785 rel
= &src_relocs
[i
];
8786 if (get_l32r_opcode () != rel
->opcode
)
8788 irel
= get_irel_at_offset (sec
, internal_relocs
,
8789 rel
->r_rel
.target_offset
);
8791 /* If the relocation on this is not a simple R_XTENSA_32 or
8792 R_XTENSA_PLT then do not consider it. This may happen when
8793 the difference of two symbols is used in a literal. */
8794 if (irel
&& (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_32
8795 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_PLT
))
8798 /* If the target_offset for this relocation is the same as the
8799 previous relocation, then we've already considered whether the
8800 literal can be coalesced. Skip to the next one.... */
8801 if (i
!= 0 && prev_i
!= -1
8802 && src_relocs
[i
-1].r_rel
.target_offset
== rel
->r_rel
.target_offset
)
8806 if (last_loc_is_prev
&&
8807 last_target_offset
+ 4 != rel
->r_rel
.target_offset
)
8808 last_loc_is_prev
= FALSE
;
8810 /* Check if the relocation was from an L32R that is being removed
8811 because a CALLX was converted to a direct CALL, and check if
8812 there are no other relocations to the literal. */
8813 if (is_removable_literal (rel
, i
, src_relocs
, relax_info
->src_count
,
8814 sec
, prop_table
, ptblsize
))
8816 if (!remove_dead_literal (abfd
, sec
, link_info
, internal_relocs
,
8817 irel
, rel
, prop_table
, ptblsize
))
8822 last_target_offset
= rel
->r_rel
.target_offset
;
8826 if (!identify_literal_placement (abfd
, sec
, contents
, link_info
,
8828 &last_loc_is_prev
, irel
,
8829 relax_info
->src_count
- i
, rel
,
8830 prop_table
, ptblsize
,
8831 &target_sec_cache
, rel
->is_abs_literal
))
8836 last_target_offset
= rel
->r_rel
.target_offset
;
8840 print_removed_literals (stderr
, &relax_info
->removed_list
);
8841 print_action_list (stderr
, &relax_info
->action_list
);
8847 free_section_cache (&target_sec_cache
);
8849 release_contents (sec
, contents
);
8850 release_internal_relocs (sec
, internal_relocs
);
8855 static Elf_Internal_Rela
*
8856 get_irel_at_offset (asection
*sec
,
8857 Elf_Internal_Rela
*internal_relocs
,
8861 Elf_Internal_Rela
*irel
;
8863 Elf_Internal_Rela key
;
8865 if (!internal_relocs
)
8868 key
.r_offset
= offset
;
8869 irel
= bsearch (&key
, internal_relocs
, sec
->reloc_count
,
8870 sizeof (Elf_Internal_Rela
), internal_reloc_matches
);
8874 /* bsearch does not guarantee which will be returned if there are
8875 multiple matches. We need the first that is not an alignment. */
8876 i
= irel
- internal_relocs
;
8879 if (internal_relocs
[i
-1].r_offset
!= offset
)
8883 for ( ; i
< sec
->reloc_count
; i
++)
8885 irel
= &internal_relocs
[i
];
8886 r_type
= ELF32_R_TYPE (irel
->r_info
);
8887 if (irel
->r_offset
== offset
&& r_type
!= R_XTENSA_NONE
)
8896 is_removable_literal (const source_reloc
*rel
,
8898 const source_reloc
*src_relocs
,
8901 property_table_entry
*prop_table
,
8904 const source_reloc
*curr_rel
;
8905 property_table_entry
*entry
;
8910 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8911 sec
->vma
+ rel
->r_rel
.target_offset
);
8912 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
8915 for (++i
; i
< src_count
; ++i
)
8917 curr_rel
= &src_relocs
[i
];
8918 /* If all others have the same target offset.... */
8919 if (curr_rel
->r_rel
.target_offset
!= rel
->r_rel
.target_offset
)
8922 if (!curr_rel
->is_null
8923 && !xtensa_is_property_section (curr_rel
->source_sec
)
8924 && !(curr_rel
->source_sec
->flags
& SEC_DEBUGGING
))
8932 remove_dead_literal (bfd
*abfd
,
8934 struct bfd_link_info
*link_info
,
8935 Elf_Internal_Rela
*internal_relocs
,
8936 Elf_Internal_Rela
*irel
,
8938 property_table_entry
*prop_table
,
8941 property_table_entry
*entry
;
8942 xtensa_relax_info
*relax_info
;
8944 relax_info
= get_xtensa_relax_info (sec
);
8948 entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8949 sec
->vma
+ rel
->r_rel
.target_offset
);
8951 /* Mark the unused literal so that it will be removed. */
8952 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, NULL
);
8954 text_action_add (&relax_info
->action_list
,
8955 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
8957 /* If the section is 4-byte aligned, do not add fill. */
8958 if (sec
->alignment_power
> 2)
8960 int fill_extra_space
;
8961 bfd_vma entry_sec_offset
;
8963 property_table_entry
*the_add_entry
;
8967 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
8969 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
8971 /* If the literal range is at the end of the section,
8973 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
8975 fill_extra_space
= xtensa_compute_fill_extra_space (the_add_entry
);
8977 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
8978 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
8979 -4, fill_extra_space
);
8981 adjust_fill_action (fa
, removed_diff
);
8983 text_action_add (&relax_info
->action_list
,
8984 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
8987 /* Zero out the relocation on this literal location. */
8990 if (elf_hash_table (link_info
)->dynamic_sections_created
)
8991 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
8993 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
8994 pin_internal_relocs (sec
, internal_relocs
);
8997 /* Do not modify "last_loc_is_prev". */
9003 identify_literal_placement (bfd
*abfd
,
9006 struct bfd_link_info
*link_info
,
9007 value_map_hash_table
*values
,
9008 bfd_boolean
*last_loc_is_prev_p
,
9009 Elf_Internal_Rela
*irel
,
9010 int remaining_src_rels
,
9012 property_table_entry
*prop_table
,
9014 section_cache_t
*target_sec_cache
,
9015 bfd_boolean is_abs_literal
)
9019 xtensa_relax_info
*relax_info
;
9020 bfd_boolean literal_placed
= FALSE
;
9022 unsigned long value
;
9023 bfd_boolean final_static_link
;
9024 bfd_size_type sec_size
;
9026 relax_info
= get_xtensa_relax_info (sec
);
9030 sec_size
= bfd_get_section_limit (abfd
, sec
);
9033 (!bfd_link_relocatable (link_info
)
9034 && !elf_hash_table (link_info
)->dynamic_sections_created
);
9036 /* The placement algorithm first checks to see if the literal is
9037 already in the value map. If so and the value map is reachable
9038 from all uses, then the literal is moved to that location. If
9039 not, then we identify the last location where a fresh literal was
9040 placed. If the literal can be safely moved there, then we do so.
9041 If not, then we assume that the literal is not to move and leave
9042 the literal where it is, marking it as the last literal
9045 /* Find the literal value. */
9047 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9050 BFD_ASSERT (rel
->r_rel
.target_offset
< sec_size
);
9051 value
= bfd_get_32 (abfd
, contents
+ rel
->r_rel
.target_offset
);
9053 init_literal_value (&val
, &r_rel
, value
, is_abs_literal
);
9055 /* Check if we've seen another literal with the same value that
9056 is in the same output section. */
9057 val_map
= value_map_get_cached_value (values
, &val
, final_static_link
);
9060 && (r_reloc_get_section (&val_map
->loc
)->output_section
9061 == sec
->output_section
)
9062 && relocations_reach (rel
, remaining_src_rels
, &val_map
->loc
)
9063 && coalesce_shared_literal (sec
, rel
, prop_table
, ptblsize
, val_map
))
9065 /* No change to last_loc_is_prev. */
9066 literal_placed
= TRUE
;
9069 /* For relocatable links, do not try to move literals. To do it
9070 correctly might increase the number of relocations in an input
9071 section making the default relocatable linking fail. */
9072 if (!bfd_link_relocatable (link_info
) && !literal_placed
9073 && values
->has_last_loc
&& !(*last_loc_is_prev_p
))
9075 asection
*target_sec
= r_reloc_get_section (&values
->last_loc
);
9076 if (target_sec
&& target_sec
->output_section
== sec
->output_section
)
9078 /* Increment the virtual offset. */
9079 r_reloc try_loc
= values
->last_loc
;
9080 try_loc
.virtual_offset
+= 4;
9082 /* There is a last loc that was in the same output section. */
9083 if (relocations_reach (rel
, remaining_src_rels
, &try_loc
)
9084 && move_shared_literal (sec
, link_info
, rel
,
9085 prop_table
, ptblsize
,
9086 &try_loc
, &val
, target_sec_cache
))
9088 values
->last_loc
.virtual_offset
+= 4;
9089 literal_placed
= TRUE
;
9091 val_map
= add_value_map (values
, &val
, &try_loc
,
9094 val_map
->loc
= try_loc
;
9099 if (!literal_placed
)
9101 /* Nothing worked, leave the literal alone but update the last loc. */
9102 values
->has_last_loc
= TRUE
;
9103 values
->last_loc
= rel
->r_rel
;
9105 val_map
= add_value_map (values
, &val
, &rel
->r_rel
, final_static_link
);
9107 val_map
->loc
= rel
->r_rel
;
9108 *last_loc_is_prev_p
= TRUE
;
9115 /* Check if the original relocations (presumably on L32R instructions)
9116 identified by reloc[0..N] can be changed to reference the literal
9117 identified by r_rel. If r_rel is out of range for any of the
9118 original relocations, then we don't want to coalesce the original
9119 literal with the one at r_rel. We only check reloc[0..N], where the
9120 offsets are all the same as for reloc[0] (i.e., they're all
9121 referencing the same literal) and where N is also bounded by the
9122 number of remaining entries in the "reloc" array. The "reloc" array
9123 is sorted by target offset so we know all the entries for the same
9124 literal will be contiguous. */
9127 relocations_reach (source_reloc
*reloc
,
9128 int remaining_relocs
,
9129 const r_reloc
*r_rel
)
9131 bfd_vma from_offset
, source_address
, dest_address
;
9135 if (!r_reloc_is_defined (r_rel
))
9138 sec
= r_reloc_get_section (r_rel
);
9139 from_offset
= reloc
[0].r_rel
.target_offset
;
9141 for (i
= 0; i
< remaining_relocs
; i
++)
9143 if (reloc
[i
].r_rel
.target_offset
!= from_offset
)
9146 /* Ignore relocations that have been removed. */
9147 if (reloc
[i
].is_null
)
9150 /* The original and new output section for these must be the same
9151 in order to coalesce. */
9152 if (r_reloc_get_section (&reloc
[i
].r_rel
)->output_section
9153 != sec
->output_section
)
9156 /* Absolute literals in the same output section can always be
9158 if (reloc
[i
].is_abs_literal
)
9161 /* A literal with no PC-relative relocations can be moved anywhere. */
9162 if (reloc
[i
].opnd
!= -1)
9164 /* Otherwise, check to see that it fits. */
9165 source_address
= (reloc
[i
].source_sec
->output_section
->vma
9166 + reloc
[i
].source_sec
->output_offset
9167 + reloc
[i
].r_rel
.rela
.r_offset
);
9168 dest_address
= (sec
->output_section
->vma
9169 + sec
->output_offset
9170 + r_rel
->target_offset
);
9172 if (!pcrel_reloc_fits (reloc
[i
].opcode
, reloc
[i
].opnd
,
9173 source_address
, dest_address
))
9182 /* Move a literal to another literal location because it is
9183 the same as the other literal value. */
9186 coalesce_shared_literal (asection
*sec
,
9188 property_table_entry
*prop_table
,
9192 property_table_entry
*entry
;
9194 property_table_entry
*the_add_entry
;
9196 xtensa_relax_info
*relax_info
;
9198 relax_info
= get_xtensa_relax_info (sec
);
9202 entry
= elf_xtensa_find_property_entry
9203 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9204 if (entry
&& (entry
->flags
& XTENSA_PROP_NO_TRANSFORM
))
9207 /* Mark that the literal will be coalesced. */
9208 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, &val_map
->loc
);
9210 text_action_add (&relax_info
->action_list
,
9211 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9213 /* If the section is 4-byte aligned, do not add fill. */
9214 if (sec
->alignment_power
> 2)
9216 int fill_extra_space
;
9217 bfd_vma entry_sec_offset
;
9220 entry_sec_offset
= entry
->address
- sec
->vma
+ entry
->size
;
9222 entry_sec_offset
= rel
->r_rel
.target_offset
+ 4;
9224 /* If the literal range is at the end of the section,
9226 fill_extra_space
= 0;
9227 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9229 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9230 fill_extra_space
= the_add_entry
->size
;
9232 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9233 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9234 -4, fill_extra_space
);
9236 adjust_fill_action (fa
, removed_diff
);
9238 text_action_add (&relax_info
->action_list
,
9239 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9246 /* Move a literal to another location. This may actually increase the
9247 total amount of space used because of alignments so we need to do
9248 this carefully. Also, it may make a branch go out of range. */
9251 move_shared_literal (asection
*sec
,
9252 struct bfd_link_info
*link_info
,
9254 property_table_entry
*prop_table
,
9256 const r_reloc
*target_loc
,
9257 const literal_value
*lit_value
,
9258 section_cache_t
*target_sec_cache
)
9260 property_table_entry
*the_add_entry
, *src_entry
, *target_entry
= NULL
;
9261 text_action
*fa
, *target_fa
;
9263 xtensa_relax_info
*relax_info
, *target_relax_info
;
9264 asection
*target_sec
;
9266 ebb_constraint ebb_table
;
9267 bfd_boolean relocs_fit
;
9269 /* If this routine always returns FALSE, the literals that cannot be
9270 coalesced will not be moved. */
9271 if (elf32xtensa_no_literal_movement
)
9274 relax_info
= get_xtensa_relax_info (sec
);
9278 target_sec
= r_reloc_get_section (target_loc
);
9279 target_relax_info
= get_xtensa_relax_info (target_sec
);
9281 /* Literals to undefined sections may not be moved because they
9282 must report an error. */
9283 if (bfd_is_und_section (target_sec
))
9286 src_entry
= elf_xtensa_find_property_entry
9287 (prop_table
, ptblsize
, sec
->vma
+ rel
->r_rel
.target_offset
);
9289 if (!section_cache_section (target_sec_cache
, target_sec
, link_info
))
9292 target_entry
= elf_xtensa_find_property_entry
9293 (target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9294 target_sec
->vma
+ target_loc
->target_offset
);
9299 /* Make sure that we have not broken any branches. */
9302 init_ebb_constraint (&ebb_table
);
9303 ebb
= &ebb_table
.ebb
;
9304 init_ebb (ebb
, target_sec_cache
->sec
, target_sec_cache
->contents
,
9305 target_sec_cache
->content_length
,
9306 target_sec_cache
->ptbl
, target_sec_cache
->pte_count
,
9307 target_sec_cache
->relocs
, target_sec_cache
->reloc_count
);
9309 /* Propose to add 4 bytes + worst-case alignment size increase to
9311 ebb_propose_action (&ebb_table
, EBB_NO_ALIGN
, 0,
9312 ta_fill
, target_loc
->target_offset
,
9313 -4 - (1 << target_sec
->alignment_power
), TRUE
);
9315 /* Check all of the PC-relative relocations to make sure they still fit. */
9316 relocs_fit
= check_section_ebb_pcrels_fit (target_sec
->owner
, target_sec
,
9317 target_sec_cache
->contents
,
9318 target_sec_cache
->relocs
, NULL
,
9324 text_action_add_literal (&target_relax_info
->action_list
,
9325 ta_add_literal
, target_loc
, lit_value
, -4);
9327 if (target_sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9329 /* May need to add or remove some fill to maintain alignment. */
9330 int fill_extra_space
;
9331 bfd_vma entry_sec_offset
;
9334 target_entry
->address
- target_sec
->vma
+ target_entry
->size
;
9336 /* If the literal range is at the end of the section,
9338 fill_extra_space
= 0;
9340 elf_xtensa_find_property_entry (target_sec_cache
->ptbl
,
9341 target_sec_cache
->pte_count
,
9343 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9344 fill_extra_space
= the_add_entry
->size
;
9346 target_fa
= find_fill_action (&target_relax_info
->action_list
,
9347 target_sec
, entry_sec_offset
);
9348 removed_diff
= compute_removed_action_diff (target_fa
, target_sec
,
9349 entry_sec_offset
, 4,
9352 adjust_fill_action (target_fa
, removed_diff
);
9354 text_action_add (&target_relax_info
->action_list
,
9355 ta_fill
, target_sec
, entry_sec_offset
, removed_diff
);
9358 /* Mark that the literal will be moved to the new location. */
9359 add_removed_literal (&relax_info
->removed_list
, &rel
->r_rel
, target_loc
);
9361 /* Remove the literal. */
9362 text_action_add (&relax_info
->action_list
,
9363 ta_remove_literal
, sec
, rel
->r_rel
.target_offset
, 4);
9365 /* If the section is 4-byte aligned, do not add fill. */
9366 if (sec
->alignment_power
> 2 && target_entry
!= src_entry
)
9368 int fill_extra_space
;
9369 bfd_vma entry_sec_offset
;
9372 entry_sec_offset
= src_entry
->address
- sec
->vma
+ src_entry
->size
;
9374 entry_sec_offset
= rel
->r_rel
.target_offset
+4;
9376 /* If the literal range is at the end of the section,
9378 fill_extra_space
= 0;
9379 the_add_entry
= elf_xtensa_find_property_entry (prop_table
, ptblsize
,
9381 if (the_add_entry
&& (the_add_entry
->flags
& XTENSA_PROP_UNREACHABLE
))
9382 fill_extra_space
= the_add_entry
->size
;
9384 fa
= find_fill_action (&relax_info
->action_list
, sec
, entry_sec_offset
);
9385 removed_diff
= compute_removed_action_diff (fa
, sec
, entry_sec_offset
,
9386 -4, fill_extra_space
);
9388 adjust_fill_action (fa
, removed_diff
);
9390 text_action_add (&relax_info
->action_list
,
9391 ta_fill
, sec
, entry_sec_offset
, removed_diff
);
9398 /* Second relaxation pass. */
9401 action_remove_bytes_fn (splay_tree_node node
, void *p
)
9403 bfd_size_type
*final_size
= p
;
9404 text_action
*action
= (text_action
*)node
->value
;
9406 *final_size
-= action
->removed_bytes
;
9410 /* Modify all of the relocations to point to the right spot, and if this
9411 is a relaxable section, delete the unwanted literals and fix the
9415 relax_section (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
)
9417 Elf_Internal_Rela
*internal_relocs
;
9418 xtensa_relax_info
*relax_info
;
9420 bfd_boolean ok
= TRUE
;
9422 bfd_boolean rv
= FALSE
;
9423 bfd_boolean virtual_action
;
9424 bfd_size_type sec_size
;
9426 sec_size
= bfd_get_section_limit (abfd
, sec
);
9427 relax_info
= get_xtensa_relax_info (sec
);
9428 BFD_ASSERT (relax_info
);
9430 /* First translate any of the fixes that have been added already. */
9431 translate_section_fixes (sec
);
9433 /* Handle property sections (e.g., literal tables) specially. */
9434 if (xtensa_is_property_section (sec
))
9436 BFD_ASSERT (!relax_info
->is_relaxable_literal_section
);
9437 return relax_property_section (abfd
, sec
, link_info
);
9440 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
9441 link_info
->keep_memory
);
9442 if (!internal_relocs
&& !action_list_count (&relax_info
->action_list
))
9445 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
9446 if (contents
== NULL
&& sec_size
!= 0)
9452 if (internal_relocs
)
9454 for (i
= 0; i
< sec
->reloc_count
; i
++)
9456 Elf_Internal_Rela
*irel
;
9457 xtensa_relax_info
*target_relax_info
;
9458 bfd_vma source_offset
, old_source_offset
;
9461 asection
*target_sec
;
9463 /* Locally change the source address.
9464 Translate the target to the new target address.
9465 If it points to this section and has been removed,
9469 irel
= &internal_relocs
[i
];
9470 source_offset
= irel
->r_offset
;
9471 old_source_offset
= source_offset
;
9473 r_type
= ELF32_R_TYPE (irel
->r_info
);
9474 r_reloc_init (&r_rel
, abfd
, irel
, contents
,
9475 bfd_get_section_limit (abfd
, sec
));
9477 /* If this section could have changed then we may need to
9478 change the relocation's offset. */
9480 if (relax_info
->is_relaxable_literal_section
9481 || relax_info
->is_relaxable_asm_section
)
9483 pin_internal_relocs (sec
, internal_relocs
);
9485 if (r_type
!= R_XTENSA_NONE
9486 && find_removed_literal (&relax_info
->removed_list
,
9489 /* Remove this relocation. */
9490 if (elf_hash_table (link_info
)->dynamic_sections_created
)
9491 shrink_dynamic_reloc_sections (link_info
, abfd
, sec
, irel
);
9492 irel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
9493 irel
->r_offset
= offset_with_removed_text_map
9494 (&relax_info
->action_list
, irel
->r_offset
);
9498 if (r_type
== R_XTENSA_ASM_SIMPLIFY
)
9500 text_action
*action
=
9501 find_insn_action (&relax_info
->action_list
,
9503 if (action
&& (action
->action
== ta_convert_longcall
9504 || action
->action
== ta_remove_longcall
))
9506 bfd_reloc_status_type retval
;
9507 char *error_message
= NULL
;
9509 retval
= contract_asm_expansion (contents
, sec_size
,
9510 irel
, &error_message
);
9511 if (retval
!= bfd_reloc_ok
)
9513 (*link_info
->callbacks
->reloc_dangerous
)
9514 (link_info
, error_message
, abfd
, sec
,
9518 /* Update the action so that the code that moves
9519 the contents will do the right thing. */
9520 /* ta_remove_longcall and ta_remove_insn actions are
9521 grouped together in the tree as well as
9522 ta_convert_longcall and ta_none, so that changes below
9523 can be done w/o removing and reinserting action into
9526 if (action
->action
== ta_remove_longcall
)
9527 action
->action
= ta_remove_insn
;
9529 action
->action
= ta_none
;
9530 /* Refresh the info in the r_rel. */
9531 r_reloc_init (&r_rel
, abfd
, irel
, contents
, sec_size
);
9532 r_type
= ELF32_R_TYPE (irel
->r_info
);
9536 source_offset
= offset_with_removed_text_map
9537 (&relax_info
->action_list
, irel
->r_offset
);
9538 irel
->r_offset
= source_offset
;
9541 /* If the target section could have changed then
9542 we may need to change the relocation's target offset. */
9544 target_sec
= r_reloc_get_section (&r_rel
);
9546 /* For a reference to a discarded section from a DWARF section,
9547 i.e., where action_discarded is PRETEND, the symbol will
9548 eventually be modified to refer to the kept section (at least if
9549 the kept and discarded sections are the same size). Anticipate
9550 that here and adjust things accordingly. */
9551 if (! elf_xtensa_ignore_discarded_relocs (sec
)
9552 && elf_xtensa_action_discarded (sec
) == PRETEND
9553 && sec
->sec_info_type
!= SEC_INFO_TYPE_STABS
9554 && target_sec
!= NULL
9555 && discarded_section (target_sec
))
9557 /* It would be natural to call _bfd_elf_check_kept_section
9558 here, but it's not exported from elflink.c. It's also a
9559 fairly expensive check. Adjusting the relocations to the
9560 discarded section is fairly harmless; it will only adjust
9561 some addends and difference values. If it turns out that
9562 _bfd_elf_check_kept_section fails later, it won't matter,
9563 so just compare the section names to find the right group
9565 asection
*kept
= target_sec
->kept_section
;
9568 if ((kept
->flags
& SEC_GROUP
) != 0)
9570 asection
*first
= elf_next_in_group (kept
);
9571 asection
*s
= first
;
9576 if (strcmp (s
->name
, target_sec
->name
) == 0)
9581 s
= elf_next_in_group (s
);
9588 && ((target_sec
->rawsize
!= 0
9589 ? target_sec
->rawsize
: target_sec
->size
)
9590 == (kept
->rawsize
!= 0 ? kept
->rawsize
: kept
->size
)))
9594 target_relax_info
= get_xtensa_relax_info (target_sec
);
9595 if (target_relax_info
9596 && (target_relax_info
->is_relaxable_literal_section
9597 || target_relax_info
->is_relaxable_asm_section
))
9600 target_sec
= translate_reloc (&r_rel
, &new_reloc
, target_sec
);
9602 if (r_type
== R_XTENSA_DIFF8
9603 || r_type
== R_XTENSA_DIFF16
9604 || r_type
== R_XTENSA_DIFF32
)
9606 bfd_signed_vma diff_value
= 0;
9607 bfd_vma new_end_offset
, diff_mask
= 0;
9609 if (bfd_get_section_limit (abfd
, sec
) < old_source_offset
)
9611 (*link_info
->callbacks
->reloc_dangerous
)
9612 (link_info
, _("invalid relocation address"),
9613 abfd
, sec
, old_source_offset
);
9619 case R_XTENSA_DIFF8
:
9621 bfd_get_signed_8 (abfd
, &contents
[old_source_offset
]);
9623 case R_XTENSA_DIFF16
:
9625 bfd_get_signed_16 (abfd
, &contents
[old_source_offset
]);
9627 case R_XTENSA_DIFF32
:
9629 bfd_get_signed_32 (abfd
, &contents
[old_source_offset
]);
9633 new_end_offset
= offset_with_removed_text_map
9634 (&target_relax_info
->action_list
,
9635 r_rel
.target_offset
+ diff_value
);
9636 diff_value
= new_end_offset
- new_reloc
.target_offset
;
9640 case R_XTENSA_DIFF8
:
9642 bfd_put_signed_8 (abfd
, diff_value
,
9643 &contents
[old_source_offset
]);
9645 case R_XTENSA_DIFF16
:
9647 bfd_put_signed_16 (abfd
, diff_value
,
9648 &contents
[old_source_offset
]);
9650 case R_XTENSA_DIFF32
:
9651 diff_mask
= 0x7fffffff;
9652 bfd_put_signed_32 (abfd
, diff_value
,
9653 &contents
[old_source_offset
]);
9657 /* Check for overflow. Sign bits must be all zeroes or all ones */
9658 if ((diff_value
& ~diff_mask
) != 0 &&
9659 (diff_value
& ~diff_mask
) != (-1 & ~diff_mask
))
9661 (*link_info
->callbacks
->reloc_dangerous
)
9662 (link_info
, _("overflow after relaxation"),
9663 abfd
, sec
, old_source_offset
);
9667 pin_contents (sec
, contents
);
9670 /* If the relocation still references a section in the same
9671 input file, modify the relocation directly instead of
9672 adding a "fix" record. */
9673 if (target_sec
->owner
== abfd
)
9675 unsigned r_symndx
= ELF32_R_SYM (new_reloc
.rela
.r_info
);
9676 irel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
9677 irel
->r_addend
= new_reloc
.rela
.r_addend
;
9678 pin_internal_relocs (sec
, internal_relocs
);
9682 bfd_vma addend_displacement
;
9685 addend_displacement
=
9686 new_reloc
.target_offset
+ new_reloc
.virtual_offset
;
9687 fix
= reloc_bfd_fix_init (sec
, source_offset
, r_type
,
9689 addend_displacement
, TRUE
);
9696 if ((relax_info
->is_relaxable_literal_section
9697 || relax_info
->is_relaxable_asm_section
)
9698 && action_list_count (&relax_info
->action_list
))
9700 /* Walk through the planned actions and build up a table
9701 of move, copy and fill records. Use the move, copy and
9702 fill records to perform the actions once. */
9704 bfd_size_type final_size
, copy_size
, orig_insn_size
;
9705 bfd_byte
*scratch
= NULL
;
9706 bfd_byte
*dup_contents
= NULL
;
9707 bfd_size_type orig_size
= sec
->size
;
9708 bfd_vma orig_dot
= 0;
9709 bfd_vma orig_dot_copied
= 0; /* Byte copied already from
9710 orig dot in physical memory. */
9711 bfd_vma orig_dot_vo
= 0; /* Virtual offset from orig_dot. */
9712 bfd_vma dup_dot
= 0;
9714 text_action
*action
;
9716 final_size
= sec
->size
;
9718 splay_tree_foreach (relax_info
->action_list
.tree
,
9719 action_remove_bytes_fn
, &final_size
);
9720 scratch
= (bfd_byte
*) bfd_zmalloc (final_size
);
9721 dup_contents
= (bfd_byte
*) bfd_zmalloc (final_size
);
9723 /* The dot is the current fill location. */
9725 print_action_list (stderr
, &relax_info
->action_list
);
9728 for (action
= action_first (&relax_info
->action_list
); action
;
9729 action
= action_next (&relax_info
->action_list
, action
))
9731 virtual_action
= FALSE
;
9732 if (action
->offset
> orig_dot
)
9734 orig_dot
+= orig_dot_copied
;
9735 orig_dot_copied
= 0;
9737 /* Out of the virtual world. */
9740 if (action
->offset
> orig_dot
)
9742 copy_size
= action
->offset
- orig_dot
;
9743 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9744 orig_dot
+= copy_size
;
9745 dup_dot
+= copy_size
;
9746 BFD_ASSERT (action
->offset
== orig_dot
);
9748 else if (action
->offset
< orig_dot
)
9750 if (action
->action
== ta_fill
9751 && action
->offset
- action
->removed_bytes
== orig_dot
)
9753 /* This is OK because the fill only effects the dup_dot. */
9755 else if (action
->action
== ta_add_literal
)
9757 /* TBD. Might need to handle this. */
9760 if (action
->offset
== orig_dot
)
9762 if (action
->virtual_offset
> orig_dot_vo
)
9764 if (orig_dot_vo
== 0)
9766 /* Need to copy virtual_offset bytes. Probably four. */
9767 copy_size
= action
->virtual_offset
- orig_dot_vo
;
9768 memmove (&dup_contents
[dup_dot
],
9769 &contents
[orig_dot
], copy_size
);
9770 orig_dot_copied
= copy_size
;
9771 dup_dot
+= copy_size
;
9773 virtual_action
= TRUE
;
9776 BFD_ASSERT (action
->virtual_offset
<= orig_dot_vo
);
9778 switch (action
->action
)
9780 case ta_remove_literal
:
9781 case ta_remove_insn
:
9782 BFD_ASSERT (action
->removed_bytes
>= 0);
9783 orig_dot
+= action
->removed_bytes
;
9786 case ta_narrow_insn
:
9789 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9790 BFD_ASSERT (action
->removed_bytes
== 1);
9791 rv
= narrow_instruction (scratch
, final_size
, 0);
9793 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9794 orig_dot
+= orig_insn_size
;
9795 dup_dot
+= copy_size
;
9799 if (action
->removed_bytes
>= 0)
9800 orig_dot
+= action
->removed_bytes
;
9803 /* Already zeroed in dup_contents. Just bump the
9805 dup_dot
+= (-action
->removed_bytes
);
9810 BFD_ASSERT (action
->removed_bytes
== 0);
9813 case ta_convert_longcall
:
9814 case ta_remove_longcall
:
9815 /* These will be removed or converted before we get here. */
9822 memmove (scratch
, &contents
[orig_dot
], orig_insn_size
);
9823 BFD_ASSERT (action
->removed_bytes
== -1);
9824 rv
= widen_instruction (scratch
, final_size
, 0);
9826 memmove (&dup_contents
[dup_dot
], scratch
, copy_size
);
9827 orig_dot
+= orig_insn_size
;
9828 dup_dot
+= copy_size
;
9831 case ta_add_literal
:
9834 BFD_ASSERT (action
->removed_bytes
== -4);
9835 /* TBD -- place the literal value here and insert
9837 memset (&dup_contents
[dup_dot
], 0, 4);
9838 pin_internal_relocs (sec
, internal_relocs
);
9839 pin_contents (sec
, contents
);
9841 if (!move_literal (abfd
, link_info
, sec
, dup_dot
, dup_contents
,
9842 relax_info
, &internal_relocs
, &action
->value
))
9846 orig_dot_vo
+= copy_size
;
9848 orig_dot
+= orig_insn_size
;
9849 dup_dot
+= copy_size
;
9853 /* Not implemented yet. */
9858 BFD_ASSERT (dup_dot
<= final_size
);
9859 BFD_ASSERT (orig_dot
<= orig_size
);
9862 orig_dot
+= orig_dot_copied
;
9863 orig_dot_copied
= 0;
9865 if (orig_dot
!= orig_size
)
9867 copy_size
= orig_size
- orig_dot
;
9868 BFD_ASSERT (orig_size
> orig_dot
);
9869 BFD_ASSERT (dup_dot
+ copy_size
== final_size
);
9870 memmove (&dup_contents
[dup_dot
], &contents
[orig_dot
], copy_size
);
9871 orig_dot
+= copy_size
;
9872 dup_dot
+= copy_size
;
9874 BFD_ASSERT (orig_size
== orig_dot
);
9875 BFD_ASSERT (final_size
== dup_dot
);
9877 /* Move the dup_contents back. */
9878 if (final_size
> orig_size
)
9880 /* Contents need to be reallocated. Swap the dup_contents into
9882 sec
->contents
= dup_contents
;
9884 contents
= dup_contents
;
9885 pin_contents (sec
, contents
);
9889 BFD_ASSERT (final_size
<= orig_size
);
9890 memset (contents
, 0, orig_size
);
9891 memcpy (contents
, dup_contents
, final_size
);
9892 free (dup_contents
);
9895 pin_contents (sec
, contents
);
9897 if (sec
->rawsize
== 0)
9898 sec
->rawsize
= sec
->size
;
9899 sec
->size
= final_size
;
9903 release_internal_relocs (sec
, internal_relocs
);
9904 release_contents (sec
, contents
);
9910 translate_section_fixes (asection
*sec
)
9912 xtensa_relax_info
*relax_info
;
9915 relax_info
= get_xtensa_relax_info (sec
);
9919 for (r
= relax_info
->fix_list
; r
!= NULL
; r
= r
->next
)
9920 if (!translate_reloc_bfd_fix (r
))
9927 /* Translate a fix given the mapping in the relax info for the target
9928 section. If it has already been translated, no work is required. */
9931 translate_reloc_bfd_fix (reloc_bfd_fix
*fix
)
9933 reloc_bfd_fix new_fix
;
9935 xtensa_relax_info
*relax_info
;
9936 removed_literal
*removed
;
9937 bfd_vma new_offset
, target_offset
;
9939 if (fix
->translated
)
9942 sec
= fix
->target_sec
;
9943 target_offset
= fix
->target_offset
;
9945 relax_info
= get_xtensa_relax_info (sec
);
9948 fix
->translated
= TRUE
;
9954 /* The fix does not need to be translated if the section cannot change. */
9955 if (!relax_info
->is_relaxable_literal_section
9956 && !relax_info
->is_relaxable_asm_section
)
9958 fix
->translated
= TRUE
;
9962 /* If the literal has been moved and this relocation was on an
9963 opcode, then the relocation should move to the new literal
9964 location. Otherwise, the relocation should move within the
9968 if (is_operand_relocation (fix
->src_type
))
9970 /* Check if the original relocation is against a literal being
9972 removed
= find_removed_literal (&relax_info
->removed_list
,
9980 /* The fact that there is still a relocation to this literal indicates
9981 that the literal is being coalesced, not simply removed. */
9982 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
9984 /* This was moved to some other address (possibly another section). */
9985 new_sec
= r_reloc_get_section (&removed
->to
);
9989 relax_info
= get_xtensa_relax_info (sec
);
9991 (!relax_info
->is_relaxable_literal_section
9992 && !relax_info
->is_relaxable_asm_section
))
9994 target_offset
= removed
->to
.target_offset
;
9995 new_fix
.target_sec
= new_sec
;
9996 new_fix
.target_offset
= target_offset
;
9997 new_fix
.translated
= TRUE
;
10002 target_offset
= removed
->to
.target_offset
;
10003 new_fix
.target_sec
= new_sec
;
10006 /* The target address may have been moved within its section. */
10007 new_offset
= offset_with_removed_text (&relax_info
->action_list
,
10010 new_fix
.target_offset
= new_offset
;
10011 new_fix
.target_offset
= new_offset
;
10012 new_fix
.translated
= TRUE
;
10018 /* Fix up a relocation to take account of removed literals. */
10021 translate_reloc (const r_reloc
*orig_rel
, r_reloc
*new_rel
, asection
*sec
)
10023 xtensa_relax_info
*relax_info
;
10024 removed_literal
*removed
;
10025 bfd_vma target_offset
, base_offset
;
10027 *new_rel
= *orig_rel
;
10029 if (!r_reloc_is_defined (orig_rel
))
10032 relax_info
= get_xtensa_relax_info (sec
);
10033 BFD_ASSERT (relax_info
&& (relax_info
->is_relaxable_literal_section
10034 || relax_info
->is_relaxable_asm_section
));
10036 target_offset
= orig_rel
->target_offset
;
10039 if (is_operand_relocation (ELF32_R_TYPE (orig_rel
->rela
.r_info
)))
10041 /* Check if the original relocation is against a literal being
10043 removed
= find_removed_literal (&relax_info
->removed_list
,
10046 if (removed
&& removed
->to
.abfd
)
10050 /* The fact that there is still a relocation to this literal indicates
10051 that the literal is being coalesced, not simply removed. */
10052 BFD_ASSERT (removed
->to
.abfd
!= NULL
);
10054 /* This was moved to some other address
10055 (possibly in another section). */
10056 *new_rel
= removed
->to
;
10057 new_sec
= r_reloc_get_section (new_rel
);
10058 if (new_sec
!= sec
)
10061 relax_info
= get_xtensa_relax_info (sec
);
10063 || (!relax_info
->is_relaxable_literal_section
10064 && !relax_info
->is_relaxable_asm_section
))
10067 target_offset
= new_rel
->target_offset
;
10070 /* Find the base offset of the reloc symbol, excluding any addend from the
10071 reloc or from the section contents (for a partial_inplace reloc). Then
10072 find the adjusted values of the offsets due to relaxation. The base
10073 offset is needed to determine the change to the reloc's addend; the reloc
10074 addend should not be adjusted due to relaxations located before the base
10077 base_offset
= r_reloc_get_target_offset (new_rel
) - new_rel
->rela
.r_addend
;
10078 if (base_offset
<= target_offset
)
10080 int base_removed
= removed_by_actions_map (&relax_info
->action_list
,
10081 base_offset
, FALSE
);
10082 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10083 target_offset
, FALSE
) -
10086 new_rel
->target_offset
= target_offset
- base_removed
- addend_removed
;
10087 new_rel
->rela
.r_addend
-= addend_removed
;
10091 /* Handle a negative addend. The base offset comes first. */
10092 int tgt_removed
= removed_by_actions_map (&relax_info
->action_list
,
10093 target_offset
, FALSE
);
10094 int addend_removed
= removed_by_actions_map (&relax_info
->action_list
,
10095 base_offset
, FALSE
) -
10098 new_rel
->target_offset
= target_offset
- tgt_removed
;
10099 new_rel
->rela
.r_addend
+= addend_removed
;
10106 /* For dynamic links, there may be a dynamic relocation for each
10107 literal. The number of dynamic relocations must be computed in
10108 size_dynamic_sections, which occurs before relaxation. When a
10109 literal is removed, this function checks if there is a corresponding
10110 dynamic relocation and shrinks the size of the appropriate dynamic
10111 relocation section accordingly. At this point, the contents of the
10112 dynamic relocation sections have not yet been filled in, so there's
10113 nothing else that needs to be done. */
10116 shrink_dynamic_reloc_sections (struct bfd_link_info
*info
,
10118 asection
*input_section
,
10119 Elf_Internal_Rela
*rel
)
10121 struct elf_xtensa_link_hash_table
*htab
;
10122 Elf_Internal_Shdr
*symtab_hdr
;
10123 struct elf_link_hash_entry
**sym_hashes
;
10124 unsigned long r_symndx
;
10126 struct elf_link_hash_entry
*h
;
10127 bfd_boolean dynamic_symbol
;
10129 htab
= elf_xtensa_hash_table (info
);
10133 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10134 sym_hashes
= elf_sym_hashes (abfd
);
10136 r_type
= ELF32_R_TYPE (rel
->r_info
);
10137 r_symndx
= ELF32_R_SYM (rel
->r_info
);
10139 if (r_symndx
< symtab_hdr
->sh_info
)
10142 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
10144 dynamic_symbol
= elf_xtensa_dynamic_symbol_p (h
, info
);
10146 if ((r_type
== R_XTENSA_32
|| r_type
== R_XTENSA_PLT
)
10147 && (input_section
->flags
& SEC_ALLOC
) != 0
10148 && (dynamic_symbol
|| bfd_link_pic (info
))
10149 && (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
10151 && (bfd_link_dll (info
) || info
->export_dynamic
))))
10154 bfd_boolean is_plt
= FALSE
;
10156 if (dynamic_symbol
&& r_type
== R_XTENSA_PLT
)
10158 srel
= htab
->elf
.srelplt
;
10162 srel
= htab
->elf
.srelgot
;
10164 /* Reduce size of the .rela.* section by one reloc. */
10165 BFD_ASSERT (srel
!= NULL
);
10166 BFD_ASSERT (srel
->size
>= sizeof (Elf32_External_Rela
));
10167 srel
->size
-= sizeof (Elf32_External_Rela
);
10171 asection
*splt
, *sgotplt
, *srelgot
;
10172 int reloc_index
, chunk
;
10174 /* Find the PLT reloc index of the entry being removed. This
10175 is computed from the size of ".rela.plt". It is needed to
10176 figure out which PLT chunk to resize. Usually "last index
10177 = size - 1" since the index starts at zero, but in this
10178 context, the size has just been decremented so there's no
10179 need to subtract one. */
10180 reloc_index
= srel
->size
/ sizeof (Elf32_External_Rela
);
10182 chunk
= reloc_index
/ PLT_ENTRIES_PER_CHUNK
;
10183 splt
= elf_xtensa_get_plt_section (info
, chunk
);
10184 sgotplt
= elf_xtensa_get_gotplt_section (info
, chunk
);
10185 BFD_ASSERT (splt
!= NULL
&& sgotplt
!= NULL
);
10187 /* Check if an entire PLT chunk has just been eliminated. */
10188 if (reloc_index
% PLT_ENTRIES_PER_CHUNK
== 0)
10190 /* The two magic GOT entries for that chunk can go away. */
10191 srelgot
= htab
->elf
.srelgot
;
10192 BFD_ASSERT (srelgot
!= NULL
);
10193 srelgot
->reloc_count
-= 2;
10194 srelgot
->size
-= 2 * sizeof (Elf32_External_Rela
);
10195 sgotplt
->size
-= 8;
10197 /* There should be only one entry left (and it will be
10199 BFD_ASSERT (sgotplt
->size
== 4);
10200 BFD_ASSERT (splt
->size
== PLT_ENTRY_SIZE
);
10203 BFD_ASSERT (sgotplt
->size
>= 4);
10204 BFD_ASSERT (splt
->size
>= PLT_ENTRY_SIZE
);
10206 sgotplt
->size
-= 4;
10207 splt
->size
-= PLT_ENTRY_SIZE
;
10213 /* Take an r_rel and move it to another section. This usually
10214 requires extending the interal_relocation array and pinning it. If
10215 the original r_rel is from the same BFD, we can complete this here.
10216 Otherwise, we add a fix record to let the final link fix the
10217 appropriate address. Contents and internal relocations for the
10218 section must be pinned after calling this routine. */
10221 move_literal (bfd
*abfd
,
10222 struct bfd_link_info
*link_info
,
10225 bfd_byte
*contents
,
10226 xtensa_relax_info
*relax_info
,
10227 Elf_Internal_Rela
**internal_relocs_p
,
10228 const literal_value
*lit
)
10230 Elf_Internal_Rela
*new_relocs
= NULL
;
10231 size_t new_relocs_count
= 0;
10232 Elf_Internal_Rela this_rela
;
10233 const r_reloc
*r_rel
;
10235 r_rel
= &lit
->r_rel
;
10236 BFD_ASSERT (elf_section_data (sec
)->relocs
== *internal_relocs_p
);
10238 if (r_reloc_is_const (r_rel
))
10239 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10244 reloc_bfd_fix
*fix
;
10245 unsigned insert_at
;
10247 r_type
= ELF32_R_TYPE (r_rel
->rela
.r_info
);
10249 /* This is the difficult case. We have to create a fix up. */
10250 this_rela
.r_offset
= offset
;
10251 this_rela
.r_info
= ELF32_R_INFO (0, r_type
);
10252 this_rela
.r_addend
=
10253 r_rel
->target_offset
- r_reloc_get_target_offset (r_rel
);
10254 bfd_put_32 (abfd
, lit
->value
, contents
+ offset
);
10256 /* Currently, we cannot move relocations during a relocatable link. */
10257 BFD_ASSERT (!bfd_link_relocatable (link_info
));
10258 fix
= reloc_bfd_fix_init (sec
, offset
, r_type
,
10259 r_reloc_get_section (r_rel
),
10260 r_rel
->target_offset
+ r_rel
->virtual_offset
,
10262 /* We also need to mark that relocations are needed here. */
10263 sec
->flags
|= SEC_RELOC
;
10265 translate_reloc_bfd_fix (fix
);
10266 /* This fix has not yet been translated. */
10267 add_fix (sec
, fix
);
10269 /* Add the relocation. If we have already allocated our own
10270 space for the relocations and we have room for more, then use
10271 it. Otherwise, allocate new space and move the literals. */
10272 insert_at
= sec
->reloc_count
;
10273 for (i
= 0; i
< sec
->reloc_count
; ++i
)
10275 if (this_rela
.r_offset
< (*internal_relocs_p
)[i
].r_offset
)
10282 if (*internal_relocs_p
!= relax_info
->allocated_relocs
10283 || sec
->reloc_count
+ 1 > relax_info
->allocated_relocs_count
)
10285 BFD_ASSERT (relax_info
->allocated_relocs
== NULL
10286 || sec
->reloc_count
== relax_info
->relocs_count
);
10288 if (relax_info
->allocated_relocs_count
== 0)
10289 new_relocs_count
= (sec
->reloc_count
+ 2) * 2;
10291 new_relocs_count
= (relax_info
->allocated_relocs_count
+ 2) * 2;
10293 new_relocs
= (Elf_Internal_Rela
*)
10294 bfd_zmalloc (sizeof (Elf_Internal_Rela
) * (new_relocs_count
));
10298 /* We could handle this more quickly by finding the split point. */
10299 if (insert_at
!= 0)
10300 memcpy (new_relocs
, *internal_relocs_p
,
10301 insert_at
* sizeof (Elf_Internal_Rela
));
10303 new_relocs
[insert_at
] = this_rela
;
10305 if (insert_at
!= sec
->reloc_count
)
10306 memcpy (new_relocs
+ insert_at
+ 1,
10307 (*internal_relocs_p
) + insert_at
,
10308 (sec
->reloc_count
- insert_at
)
10309 * sizeof (Elf_Internal_Rela
));
10311 if (*internal_relocs_p
!= relax_info
->allocated_relocs
)
10313 /* The first time we re-allocate, we can only free the
10314 old relocs if they were allocated with bfd_malloc.
10315 This is not true when keep_memory is in effect. */
10316 if (!link_info
->keep_memory
)
10317 free (*internal_relocs_p
);
10320 free (*internal_relocs_p
);
10321 relax_info
->allocated_relocs
= new_relocs
;
10322 relax_info
->allocated_relocs_count
= new_relocs_count
;
10323 elf_section_data (sec
)->relocs
= new_relocs
;
10324 sec
->reloc_count
++;
10325 relax_info
->relocs_count
= sec
->reloc_count
;
10326 *internal_relocs_p
= new_relocs
;
10330 if (insert_at
!= sec
->reloc_count
)
10333 for (idx
= sec
->reloc_count
; idx
> insert_at
; idx
--)
10334 (*internal_relocs_p
)[idx
] = (*internal_relocs_p
)[idx
-1];
10336 (*internal_relocs_p
)[insert_at
] = this_rela
;
10337 sec
->reloc_count
++;
10338 if (relax_info
->allocated_relocs
)
10339 relax_info
->relocs_count
= sec
->reloc_count
;
10346 /* This is similar to relax_section except that when a target is moved,
10347 we shift addresses up. We also need to modify the size. This
10348 algorithm does NOT allow for relocations into the middle of the
10349 property sections. */
10352 relax_property_section (bfd
*abfd
,
10354 struct bfd_link_info
*link_info
)
10356 Elf_Internal_Rela
*internal_relocs
;
10357 bfd_byte
*contents
;
10359 bfd_boolean ok
= TRUE
;
10360 bfd_boolean is_full_prop_section
;
10361 size_t last_zfill_target_offset
= 0;
10362 asection
*last_zfill_target_sec
= NULL
;
10363 bfd_size_type sec_size
;
10364 bfd_size_type entry_size
;
10366 sec_size
= bfd_get_section_limit (abfd
, sec
);
10367 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
10368 link_info
->keep_memory
);
10369 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
10370 if (contents
== NULL
&& sec_size
!= 0)
10376 is_full_prop_section
= xtensa_is_proptable_section (sec
);
10377 if (is_full_prop_section
)
10382 if (internal_relocs
)
10384 for (i
= 0; i
< sec
->reloc_count
; i
++)
10386 Elf_Internal_Rela
*irel
;
10387 xtensa_relax_info
*target_relax_info
;
10389 asection
*target_sec
;
10391 bfd_byte
*size_p
, *flags_p
;
10393 /* Locally change the source address.
10394 Translate the target to the new target address.
10395 If it points to this section and has been removed, MOVE IT.
10396 Also, don't forget to modify the associated SIZE at
10399 irel
= &internal_relocs
[i
];
10400 r_type
= ELF32_R_TYPE (irel
->r_info
);
10401 if (r_type
== R_XTENSA_NONE
)
10404 /* Find the literal value. */
10405 r_reloc_init (&val
.r_rel
, abfd
, irel
, contents
, sec_size
);
10406 size_p
= &contents
[irel
->r_offset
+ 4];
10408 if (is_full_prop_section
)
10409 flags_p
= &contents
[irel
->r_offset
+ 8];
10410 BFD_ASSERT (irel
->r_offset
+ entry_size
<= sec_size
);
10412 target_sec
= r_reloc_get_section (&val
.r_rel
);
10413 target_relax_info
= get_xtensa_relax_info (target_sec
);
10415 if (target_relax_info
10416 && (target_relax_info
->is_relaxable_literal_section
10417 || target_relax_info
->is_relaxable_asm_section
))
10419 /* Translate the relocation's destination. */
10420 bfd_vma old_offset
= val
.r_rel
.target_offset
;
10421 bfd_vma new_offset
;
10422 long old_size
, new_size
;
10423 int removed_by_old_offset
=
10424 removed_by_actions_map (&target_relax_info
->action_list
,
10425 old_offset
, FALSE
);
10426 new_offset
= old_offset
- removed_by_old_offset
;
10428 /* Assert that we are not out of bounds. */
10429 old_size
= bfd_get_32 (abfd
, size_p
);
10430 new_size
= old_size
;
10434 /* Only the first zero-sized unreachable entry is
10435 allowed to expand. In this case the new offset
10436 should be the offset before the fill and the new
10437 size is the expansion size. For other zero-sized
10438 entries the resulting size should be zero with an
10439 offset before or after the fill address depending
10440 on whether the expanding unreachable entry
10442 if (last_zfill_target_sec
== 0
10443 || last_zfill_target_sec
!= target_sec
10444 || last_zfill_target_offset
!= old_offset
)
10446 bfd_vma new_end_offset
= new_offset
;
10448 /* Recompute the new_offset, but this time don't
10449 include any fill inserted by relaxation. */
10450 removed_by_old_offset
=
10451 removed_by_actions_map (&target_relax_info
->action_list
,
10453 new_offset
= old_offset
- removed_by_old_offset
;
10455 /* If it is not unreachable and we have not yet
10456 seen an unreachable at this address, place it
10457 before the fill address. */
10458 if (flags_p
&& (bfd_get_32 (abfd
, flags_p
)
10459 & XTENSA_PROP_UNREACHABLE
) != 0)
10461 new_size
= new_end_offset
- new_offset
;
10463 last_zfill_target_sec
= target_sec
;
10464 last_zfill_target_offset
= old_offset
;
10470 int removed_by_old_offset_size
=
10471 removed_by_actions_map (&target_relax_info
->action_list
,
10472 old_offset
+ old_size
, TRUE
);
10473 new_size
-= removed_by_old_offset_size
- removed_by_old_offset
;
10476 if (new_size
!= old_size
)
10478 bfd_put_32 (abfd
, new_size
, size_p
);
10479 pin_contents (sec
, contents
);
10482 if (new_offset
!= old_offset
)
10484 bfd_vma diff
= new_offset
- old_offset
;
10485 irel
->r_addend
+= diff
;
10486 pin_internal_relocs (sec
, internal_relocs
);
10492 /* Combine adjacent property table entries. This is also done in
10493 finish_dynamic_sections() but at that point it's too late to
10494 reclaim the space in the output section, so we do this twice. */
10496 if (internal_relocs
&& (!bfd_link_relocatable (link_info
)
10497 || xtensa_is_littable_section (sec
)))
10499 Elf_Internal_Rela
*last_irel
= NULL
;
10500 Elf_Internal_Rela
*irel
, *next_rel
, *rel_end
;
10501 int removed_bytes
= 0;
10503 flagword predef_flags
;
10505 predef_flags
= xtensa_get_property_predef_flags (sec
);
10507 /* Walk over memory and relocations at the same time.
10508 This REQUIRES that the internal_relocs be sorted by offset. */
10509 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
10510 internal_reloc_compare
);
10512 pin_internal_relocs (sec
, internal_relocs
);
10513 pin_contents (sec
, contents
);
10515 next_rel
= internal_relocs
;
10516 rel_end
= internal_relocs
+ sec
->reloc_count
;
10518 BFD_ASSERT (sec
->size
% entry_size
== 0);
10520 for (offset
= 0; offset
< sec
->size
; offset
+= entry_size
)
10522 Elf_Internal_Rela
*offset_rel
, *extra_rel
;
10523 bfd_vma bytes_to_remove
, size
, actual_offset
;
10524 bfd_boolean remove_this_rel
;
10527 /* Find the first relocation for the entry at the current offset.
10528 Adjust the offsets of any extra relocations for the previous
10533 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10535 if ((irel
->r_offset
== offset
10536 && ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10537 || irel
->r_offset
> offset
)
10542 irel
->r_offset
-= removed_bytes
;
10546 /* Find the next relocation (if there are any left). */
10550 for (irel
= offset_rel
+ 1; irel
< rel_end
; irel
++)
10552 if (ELF32_R_TYPE (irel
->r_info
) != R_XTENSA_NONE
)
10560 /* Check if there are relocations on the current entry. There
10561 should usually be a relocation on the offset field. If there
10562 are relocations on the size or flags, then we can't optimize
10563 this entry. Also, find the next relocation to examine on the
10567 if (offset_rel
->r_offset
>= offset
+ entry_size
)
10569 next_rel
= offset_rel
;
10570 /* There are no relocations on the current entry, but we
10571 might still be able to remove it if the size is zero. */
10574 else if (offset_rel
->r_offset
> offset
10576 && extra_rel
->r_offset
< offset
+ entry_size
))
10578 /* There is a relocation on the size or flags, so we can't
10579 do anything with this entry. Continue with the next. */
10580 next_rel
= offset_rel
;
10585 BFD_ASSERT (offset_rel
->r_offset
== offset
);
10586 offset_rel
->r_offset
-= removed_bytes
;
10587 next_rel
= offset_rel
+ 1;
10593 remove_this_rel
= FALSE
;
10594 bytes_to_remove
= 0;
10595 actual_offset
= offset
- removed_bytes
;
10596 size
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 4]);
10598 if (is_full_prop_section
)
10599 flags
= bfd_get_32 (abfd
, &contents
[actual_offset
+ 8]);
10601 flags
= predef_flags
;
10604 && (flags
& XTENSA_PROP_ALIGN
) == 0
10605 && (flags
& XTENSA_PROP_UNREACHABLE
) == 0)
10607 /* Always remove entries with zero size and no alignment. */
10608 bytes_to_remove
= entry_size
;
10610 remove_this_rel
= TRUE
;
10612 else if (offset_rel
10613 && ELF32_R_TYPE (offset_rel
->r_info
) == R_XTENSA_32
)
10617 flagword old_flags
;
10619 bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
+ 4]);
10620 bfd_vma old_address
=
10621 (last_irel
->r_addend
10622 + bfd_get_32 (abfd
, &contents
[last_irel
->r_offset
]));
10623 bfd_vma new_address
=
10624 (offset_rel
->r_addend
10625 + bfd_get_32 (abfd
, &contents
[actual_offset
]));
10626 if (is_full_prop_section
)
10627 old_flags
= bfd_get_32
10628 (abfd
, &contents
[last_irel
->r_offset
+ 8]);
10630 old_flags
= predef_flags
;
10632 if ((ELF32_R_SYM (offset_rel
->r_info
)
10633 == ELF32_R_SYM (last_irel
->r_info
))
10634 && old_address
+ old_size
== new_address
10635 && old_flags
== flags
10636 && (old_flags
& XTENSA_PROP_INSN_BRANCH_TARGET
) == 0
10637 && (old_flags
& XTENSA_PROP_INSN_LOOP_TARGET
) == 0)
10639 /* Fix the old size. */
10640 bfd_put_32 (abfd
, old_size
+ size
,
10641 &contents
[last_irel
->r_offset
+ 4]);
10642 bytes_to_remove
= entry_size
;
10643 remove_this_rel
= TRUE
;
10646 last_irel
= offset_rel
;
10649 last_irel
= offset_rel
;
10652 if (remove_this_rel
)
10654 offset_rel
->r_info
= ELF32_R_INFO (0, R_XTENSA_NONE
);
10655 offset_rel
->r_offset
= 0;
10658 if (bytes_to_remove
!= 0)
10660 removed_bytes
+= bytes_to_remove
;
10661 if (offset
+ bytes_to_remove
< sec
->size
)
10662 memmove (&contents
[actual_offset
],
10663 &contents
[actual_offset
+ bytes_to_remove
],
10664 sec
->size
- offset
- bytes_to_remove
);
10670 /* Fix up any extra relocations on the last entry. */
10671 for (irel
= next_rel
; irel
< rel_end
; irel
++)
10672 irel
->r_offset
-= removed_bytes
;
10674 /* Clear the removed bytes. */
10675 memset (&contents
[sec
->size
- removed_bytes
], 0, removed_bytes
);
10677 if (sec
->rawsize
== 0)
10678 sec
->rawsize
= sec
->size
;
10679 sec
->size
-= removed_bytes
;
10681 if (xtensa_is_littable_section (sec
))
10683 asection
*sgotloc
= elf_xtensa_hash_table (link_info
)->sgotloc
;
10685 sgotloc
->size
-= removed_bytes
;
10691 release_internal_relocs (sec
, internal_relocs
);
10692 release_contents (sec
, contents
);
10697 /* Third relaxation pass. */
10699 /* Change symbol values to account for removed literals. */
10702 relax_section_symbols (bfd
*abfd
, asection
*sec
)
10704 xtensa_relax_info
*relax_info
;
10705 unsigned int sec_shndx
;
10706 Elf_Internal_Shdr
*symtab_hdr
;
10707 Elf_Internal_Sym
*isymbuf
;
10708 unsigned i
, num_syms
, num_locals
;
10710 relax_info
= get_xtensa_relax_info (sec
);
10711 BFD_ASSERT (relax_info
);
10713 if (!relax_info
->is_relaxable_literal_section
10714 && !relax_info
->is_relaxable_asm_section
)
10717 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
10719 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10720 isymbuf
= retrieve_local_syms (abfd
);
10722 num_syms
= symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
10723 num_locals
= symtab_hdr
->sh_info
;
10725 /* Adjust the local symbols defined in this section. */
10726 for (i
= 0; i
< num_locals
; i
++)
10728 Elf_Internal_Sym
*isym
= &isymbuf
[i
];
10730 if (isym
->st_shndx
== sec_shndx
)
10732 bfd_vma orig_addr
= isym
->st_value
;
10733 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10736 isym
->st_value
-= removed
;
10737 if (ELF32_ST_TYPE (isym
->st_info
) == STT_FUNC
)
10739 removed_by_actions_map (&relax_info
->action_list
,
10740 orig_addr
+ isym
->st_size
, FALSE
) -
10745 /* Now adjust the global symbols defined in this section. */
10746 for (i
= 0; i
< (num_syms
- num_locals
); i
++)
10748 struct elf_link_hash_entry
*sym_hash
;
10750 sym_hash
= elf_sym_hashes (abfd
)[i
];
10752 if (sym_hash
->root
.type
== bfd_link_hash_warning
)
10753 sym_hash
= (struct elf_link_hash_entry
*) sym_hash
->root
.u
.i
.link
;
10755 if ((sym_hash
->root
.type
== bfd_link_hash_defined
10756 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
10757 && sym_hash
->root
.u
.def
.section
== sec
)
10759 bfd_vma orig_addr
= sym_hash
->root
.u
.def
.value
;
10760 int removed
= removed_by_actions_map (&relax_info
->action_list
,
10763 sym_hash
->root
.u
.def
.value
-= removed
;
10765 if (sym_hash
->type
== STT_FUNC
)
10767 removed_by_actions_map (&relax_info
->action_list
,
10768 orig_addr
+ sym_hash
->size
, FALSE
) -
10777 /* "Fix" handling functions, called while performing relocations. */
10780 do_fix_for_relocatable_link (Elf_Internal_Rela
*rel
,
10782 asection
*input_section
,
10783 bfd_byte
*contents
)
10786 asection
*sec
, *old_sec
;
10787 bfd_vma old_offset
;
10788 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10789 reloc_bfd_fix
*fix
;
10791 if (r_type
== R_XTENSA_NONE
)
10794 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10798 r_reloc_init (&r_rel
, input_bfd
, rel
, contents
,
10799 bfd_get_section_limit (input_bfd
, input_section
));
10800 old_sec
= r_reloc_get_section (&r_rel
);
10801 old_offset
= r_rel
.target_offset
;
10803 if (!old_sec
|| !r_reloc_is_defined (&r_rel
))
10805 if (r_type
!= R_XTENSA_ASM_EXPAND
)
10808 /* xgettext:c-format */
10809 (_("%pB(%pA+%#" PRIx64
"): unexpected fix for %s relocation"),
10810 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
10811 elf_howto_table
[r_type
].name
);
10814 /* Leave it be. Resolution will happen in a later stage. */
10818 sec
= fix
->target_sec
;
10819 rel
->r_addend
+= ((sec
->output_offset
+ fix
->target_offset
)
10820 - (old_sec
->output_offset
+ old_offset
));
10827 do_fix_for_final_link (Elf_Internal_Rela
*rel
,
10829 asection
*input_section
,
10830 bfd_byte
*contents
,
10831 bfd_vma
*relocationp
)
10834 int r_type
= ELF32_R_TYPE (rel
->r_info
);
10835 reloc_bfd_fix
*fix
;
10836 bfd_vma fixup_diff
;
10838 if (r_type
== R_XTENSA_NONE
)
10841 fix
= get_bfd_fix (input_section
, rel
->r_offset
, r_type
);
10845 sec
= fix
->target_sec
;
10847 fixup_diff
= rel
->r_addend
;
10848 if (elf_howto_table
[fix
->src_type
].partial_inplace
)
10850 bfd_vma inplace_val
;
10851 BFD_ASSERT (fix
->src_offset
10852 < bfd_get_section_limit (input_bfd
, input_section
));
10853 inplace_val
= bfd_get_32 (input_bfd
, &contents
[fix
->src_offset
]);
10854 fixup_diff
+= inplace_val
;
10857 *relocationp
= (sec
->output_section
->vma
10858 + sec
->output_offset
10859 + fix
->target_offset
- fixup_diff
);
10863 /* Miscellaneous utility functions.... */
10866 elf_xtensa_get_plt_section (struct bfd_link_info
*info
, int chunk
)
10872 return elf_hash_table (info
)->splt
;
10874 dynobj
= elf_hash_table (info
)->dynobj
;
10875 sprintf (plt_name
, ".plt.%u", chunk
);
10876 return bfd_get_linker_section (dynobj
, plt_name
);
10881 elf_xtensa_get_gotplt_section (struct bfd_link_info
*info
, int chunk
)
10887 return elf_hash_table (info
)->sgotplt
;
10889 dynobj
= elf_hash_table (info
)->dynobj
;
10890 sprintf (got_name
, ".got.plt.%u", chunk
);
10891 return bfd_get_linker_section (dynobj
, got_name
);
10895 /* Get the input section for a given symbol index.
10897 . a section symbol, return the section;
10898 . a common symbol, return the common section;
10899 . an undefined symbol, return the undefined section;
10900 . an indirect symbol, follow the links;
10901 . an absolute value, return the absolute section. */
10904 get_elf_r_symndx_section (bfd
*abfd
, unsigned long r_symndx
)
10906 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10907 asection
*target_sec
= NULL
;
10908 if (r_symndx
< symtab_hdr
->sh_info
)
10910 Elf_Internal_Sym
*isymbuf
;
10911 unsigned int section_index
;
10913 isymbuf
= retrieve_local_syms (abfd
);
10914 section_index
= isymbuf
[r_symndx
].st_shndx
;
10916 if (section_index
== SHN_UNDEF
)
10917 target_sec
= bfd_und_section_ptr
;
10918 else if (section_index
== SHN_ABS
)
10919 target_sec
= bfd_abs_section_ptr
;
10920 else if (section_index
== SHN_COMMON
)
10921 target_sec
= bfd_com_section_ptr
;
10923 target_sec
= bfd_section_from_elf_index (abfd
, section_index
);
10927 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
10928 struct elf_link_hash_entry
*h
= elf_sym_hashes (abfd
)[indx
];
10930 while (h
->root
.type
== bfd_link_hash_indirect
10931 || h
->root
.type
== bfd_link_hash_warning
)
10932 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10934 switch (h
->root
.type
)
10936 case bfd_link_hash_defined
:
10937 case bfd_link_hash_defweak
:
10938 target_sec
= h
->root
.u
.def
.section
;
10940 case bfd_link_hash_common
:
10941 target_sec
= bfd_com_section_ptr
;
10943 case bfd_link_hash_undefined
:
10944 case bfd_link_hash_undefweak
:
10945 target_sec
= bfd_und_section_ptr
;
10947 default: /* New indirect warning. */
10948 target_sec
= bfd_und_section_ptr
;
10956 static struct elf_link_hash_entry
*
10957 get_elf_r_symndx_hash_entry (bfd
*abfd
, unsigned long r_symndx
)
10959 unsigned long indx
;
10960 struct elf_link_hash_entry
*h
;
10961 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10963 if (r_symndx
< symtab_hdr
->sh_info
)
10966 indx
= r_symndx
- symtab_hdr
->sh_info
;
10967 h
= elf_sym_hashes (abfd
)[indx
];
10968 while (h
->root
.type
== bfd_link_hash_indirect
10969 || h
->root
.type
== bfd_link_hash_warning
)
10970 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10975 /* Get the section-relative offset for a symbol number. */
10978 get_elf_r_symndx_offset (bfd
*abfd
, unsigned long r_symndx
)
10980 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
10981 bfd_vma offset
= 0;
10983 if (r_symndx
< symtab_hdr
->sh_info
)
10985 Elf_Internal_Sym
*isymbuf
;
10986 isymbuf
= retrieve_local_syms (abfd
);
10987 offset
= isymbuf
[r_symndx
].st_value
;
10991 unsigned long indx
= r_symndx
- symtab_hdr
->sh_info
;
10992 struct elf_link_hash_entry
*h
=
10993 elf_sym_hashes (abfd
)[indx
];
10995 while (h
->root
.type
== bfd_link_hash_indirect
10996 || h
->root
.type
== bfd_link_hash_warning
)
10997 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
10998 if (h
->root
.type
== bfd_link_hash_defined
10999 || h
->root
.type
== bfd_link_hash_defweak
)
11000 offset
= h
->root
.u
.def
.value
;
11007 is_reloc_sym_weak (bfd
*abfd
, Elf_Internal_Rela
*rel
)
11009 unsigned long r_symndx
= ELF32_R_SYM (rel
->r_info
);
11010 struct elf_link_hash_entry
*h
;
11012 h
= get_elf_r_symndx_hash_entry (abfd
, r_symndx
);
11013 if (h
&& h
->root
.type
== bfd_link_hash_defweak
)
11020 pcrel_reloc_fits (xtensa_opcode opc
,
11022 bfd_vma self_address
,
11023 bfd_vma dest_address
)
11025 xtensa_isa isa
= xtensa_default_isa
;
11026 uint32 valp
= dest_address
;
11027 if (xtensa_operand_do_reloc (isa
, opc
, opnd
, &valp
, self_address
)
11028 || xtensa_operand_encode (isa
, opc
, opnd
, &valp
))
11035 xtensa_is_property_section (asection
*sec
)
11037 if (xtensa_is_insntable_section (sec
)
11038 || xtensa_is_littable_section (sec
)
11039 || xtensa_is_proptable_section (sec
))
11047 xtensa_is_insntable_section (asection
*sec
)
11049 if (CONST_STRNEQ (sec
->name
, XTENSA_INSN_SEC_NAME
)
11050 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.x."))
11058 xtensa_is_littable_section (asection
*sec
)
11060 if (CONST_STRNEQ (sec
->name
, XTENSA_LIT_SEC_NAME
)
11061 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.p."))
11069 xtensa_is_proptable_section (asection
*sec
)
11071 if (CONST_STRNEQ (sec
->name
, XTENSA_PROP_SEC_NAME
)
11072 || CONST_STRNEQ (sec
->name
, ".gnu.linkonce.prop."))
11080 internal_reloc_compare (const void *ap
, const void *bp
)
11082 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11083 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11085 if (a
->r_offset
!= b
->r_offset
)
11086 return (a
->r_offset
- b
->r_offset
);
11088 /* We don't need to sort on these criteria for correctness,
11089 but enforcing a more strict ordering prevents unstable qsort
11090 from behaving differently with different implementations.
11091 Without the code below we get correct but different results
11092 on Solaris 2.7 and 2.8. We would like to always produce the
11093 same results no matter the host. */
11095 if (a
->r_info
!= b
->r_info
)
11096 return (a
->r_info
- b
->r_info
);
11098 return (a
->r_addend
- b
->r_addend
);
11103 internal_reloc_matches (const void *ap
, const void *bp
)
11105 const Elf_Internal_Rela
*a
= (const Elf_Internal_Rela
*) ap
;
11106 const Elf_Internal_Rela
*b
= (const Elf_Internal_Rela
*) bp
;
11108 /* Check if one entry overlaps with the other; this shouldn't happen
11109 except when searching for a match. */
11110 return (a
->r_offset
- b
->r_offset
);
11114 /* Predicate function used to look up a section in a particular group. */
11117 match_section_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *inf
)
11119 const char *gname
= inf
;
11120 const char *group_name
= elf_group_name (sec
);
11122 return (group_name
== gname
11123 || (group_name
!= NULL
11125 && strcmp (group_name
, gname
) == 0));
11130 xtensa_add_names (const char *base
, const char *suffix
)
11134 size_t base_len
= strlen (base
);
11135 size_t suffix_len
= strlen (suffix
);
11136 char *str
= bfd_malloc (base_len
+ suffix_len
+ 1);
11138 memcpy (str
, base
, base_len
);
11139 memcpy (str
+ base_len
, suffix
, suffix_len
+ 1);
11144 return strdup (base
);
11148 static int linkonce_len
= sizeof (".gnu.linkonce.") - 1;
11151 xtensa_property_section_name (asection
*sec
, const char *base_name
,
11152 bfd_boolean separate_sections
)
11154 const char *suffix
, *group_name
;
11155 char *prop_sec_name
;
11157 group_name
= elf_group_name (sec
);
11160 suffix
= strrchr (sec
->name
, '.');
11161 if (suffix
== sec
->name
)
11163 prop_sec_name
= xtensa_add_names (base_name
, suffix
);
11165 else if (strncmp (sec
->name
, ".gnu.linkonce.", linkonce_len
) == 0)
11167 char *linkonce_kind
= 0;
11169 if (strcmp (base_name
, XTENSA_INSN_SEC_NAME
) == 0)
11170 linkonce_kind
= "x.";
11171 else if (strcmp (base_name
, XTENSA_LIT_SEC_NAME
) == 0)
11172 linkonce_kind
= "p.";
11173 else if (strcmp (base_name
, XTENSA_PROP_SEC_NAME
) == 0)
11174 linkonce_kind
= "prop.";
11178 prop_sec_name
= (char *) bfd_malloc (strlen (sec
->name
)
11179 + strlen (linkonce_kind
) + 1);
11180 memcpy (prop_sec_name
, ".gnu.linkonce.", linkonce_len
);
11181 strcpy (prop_sec_name
+ linkonce_len
, linkonce_kind
);
11183 suffix
= sec
->name
+ linkonce_len
;
11184 /* For backward compatibility, replace "t." instead of inserting
11185 the new linkonce_kind (but not for "prop" sections). */
11186 if (CONST_STRNEQ (suffix
, "t.") && linkonce_kind
[1] == '.')
11188 strcat (prop_sec_name
+ linkonce_len
, suffix
);
11192 prop_sec_name
= xtensa_add_names (base_name
,
11193 separate_sections
? sec
->name
: NULL
);
11196 return prop_sec_name
;
11201 xtensa_get_separate_property_section (asection
*sec
, const char *base_name
,
11202 bfd_boolean separate_section
)
11204 char *prop_sec_name
;
11205 asection
*prop_sec
;
11207 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11209 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11210 match_section_group
,
11211 (void *) elf_group_name (sec
));
11212 free (prop_sec_name
);
11217 xtensa_get_property_section (asection
*sec
, const char *base_name
)
11219 asection
*prop_sec
;
11221 /* Try individual property section first. */
11222 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, TRUE
);
11224 /* Refer to a common property section if individual is not present. */
11226 prop_sec
= xtensa_get_separate_property_section (sec
, base_name
, FALSE
);
11233 xtensa_make_property_section (asection
*sec
, const char *base_name
)
11235 char *prop_sec_name
;
11236 asection
*prop_sec
;
11238 /* Check if the section already exists. */
11239 prop_sec_name
= xtensa_property_section_name (sec
, base_name
,
11240 elf32xtensa_separate_props
);
11241 prop_sec
= bfd_get_section_by_name_if (sec
->owner
, prop_sec_name
,
11242 match_section_group
,
11243 (void *) elf_group_name (sec
));
11244 /* If not, create it. */
11247 flagword flags
= (SEC_RELOC
| SEC_HAS_CONTENTS
| SEC_READONLY
);
11248 flags
|= (bfd_section_flags (sec
)
11249 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
));
11251 prop_sec
= bfd_make_section_anyway_with_flags
11252 (sec
->owner
, strdup (prop_sec_name
), flags
);
11256 elf_group_name (prop_sec
) = elf_group_name (sec
);
11259 free (prop_sec_name
);
11265 xtensa_get_property_predef_flags (asection
*sec
)
11267 if (xtensa_is_insntable_section (sec
))
11268 return (XTENSA_PROP_INSN
11269 | XTENSA_PROP_NO_TRANSFORM
11270 | XTENSA_PROP_INSN_NO_REORDER
);
11272 if (xtensa_is_littable_section (sec
))
11273 return (XTENSA_PROP_LITERAL
11274 | XTENSA_PROP_NO_TRANSFORM
11275 | XTENSA_PROP_INSN_NO_REORDER
);
11281 /* Other functions called directly by the linker. */
11284 xtensa_callback_required_dependence (bfd
*abfd
,
11286 struct bfd_link_info
*link_info
,
11287 deps_callback_t callback
,
11290 Elf_Internal_Rela
*internal_relocs
;
11291 bfd_byte
*contents
;
11293 bfd_boolean ok
= TRUE
;
11294 bfd_size_type sec_size
;
11296 sec_size
= bfd_get_section_limit (abfd
, sec
);
11298 /* ".plt*" sections have no explicit relocations but they contain L32R
11299 instructions that reference the corresponding ".got.plt*" sections. */
11300 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0
11301 && CONST_STRNEQ (sec
->name
, ".plt"))
11305 /* Find the corresponding ".got.plt*" section. */
11306 if (sec
->name
[4] == '\0')
11307 sgotplt
= elf_hash_table (link_info
)->sgotplt
;
11313 BFD_ASSERT (sec
->name
[4] == '.');
11314 chunk
= strtol (&sec
->name
[5], NULL
, 10);
11316 sprintf (got_name
, ".got.plt.%u", chunk
);
11317 sgotplt
= bfd_get_linker_section (sec
->owner
, got_name
);
11319 BFD_ASSERT (sgotplt
);
11321 /* Assume worst-case offsets: L32R at the very end of the ".plt"
11322 section referencing a literal at the very beginning of
11323 ".got.plt". This is very close to the real dependence, anyway. */
11324 (*callback
) (sec
, sec_size
, sgotplt
, 0, closure
);
11327 /* Only ELF files are supported for Xtensa. Check here to avoid a segfault
11328 when building uclibc, which runs "ld -b binary /dev/null". */
11329 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
11332 internal_relocs
= retrieve_internal_relocs (abfd
, sec
,
11333 link_info
->keep_memory
);
11334 if (internal_relocs
== NULL
11335 || sec
->reloc_count
== 0)
11338 /* Cache the contents for the duration of this scan. */
11339 contents
= retrieve_contents (abfd
, sec
, link_info
->keep_memory
);
11340 if (contents
== NULL
&& sec_size
!= 0)
11346 if (!xtensa_default_isa
)
11347 xtensa_default_isa
= xtensa_isa_init (0, 0);
11349 for (i
= 0; i
< sec
->reloc_count
; i
++)
11351 Elf_Internal_Rela
*irel
= &internal_relocs
[i
];
11352 if (is_l32r_relocation (abfd
, sec
, contents
, irel
))
11355 asection
*target_sec
;
11356 bfd_vma target_offset
;
11358 r_reloc_init (&l32r_rel
, abfd
, irel
, contents
, sec_size
);
11361 /* L32Rs must be local to the input file. */
11362 if (r_reloc_is_defined (&l32r_rel
))
11364 target_sec
= r_reloc_get_section (&l32r_rel
);
11365 target_offset
= l32r_rel
.target_offset
;
11367 (*callback
) (sec
, irel
->r_offset
, target_sec
, target_offset
,
11373 release_internal_relocs (sec
, internal_relocs
);
11374 release_contents (sec
, contents
);
11378 /* The default literal sections should always be marked as "code" (i.e.,
11379 SHF_EXECINSTR). This is particularly important for the Linux kernel
11380 module loader so that the literals are not placed after the text. */
11381 static const struct bfd_elf_special_section elf_xtensa_special_sections
[] =
11383 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11384 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11385 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
11386 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE
, 0 },
11387 { NULL
, 0, 0, 0, 0 }
11390 #define ELF_TARGET_ID XTENSA_ELF_DATA
11392 #define TARGET_LITTLE_SYM xtensa_elf32_le_vec
11393 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
11394 #define TARGET_BIG_SYM xtensa_elf32_be_vec
11395 #define TARGET_BIG_NAME "elf32-xtensa-be"
11396 #define ELF_ARCH bfd_arch_xtensa
11398 #define ELF_MACHINE_CODE EM_XTENSA
11399 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
11401 #define ELF_MAXPAGESIZE 0x1000
11402 #endif /* ELF_ARCH */
11404 #define elf_backend_can_gc_sections 1
11405 #define elf_backend_can_refcount 1
11406 #define elf_backend_plt_readonly 1
11407 #define elf_backend_got_header_size 4
11408 #define elf_backend_want_dynbss 0
11409 #define elf_backend_want_got_plt 1
11410 #define elf_backend_dtrel_excludes_plt 1
11412 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
11414 #define bfd_elf32_mkobject elf_xtensa_mkobject
11416 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
11417 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
11418 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
11419 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
11420 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
11421 #define bfd_elf32_bfd_reloc_name_lookup \
11422 elf_xtensa_reloc_name_lookup
11423 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
11424 #define bfd_elf32_bfd_link_hash_table_create elf_xtensa_link_hash_table_create
11426 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
11427 #define elf_backend_check_relocs elf_xtensa_check_relocs
11428 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
11429 #define elf_backend_discard_info elf_xtensa_discard_info
11430 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
11431 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
11432 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
11433 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
11434 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
11435 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
11436 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
11437 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
11438 #define elf_backend_object_p elf_xtensa_object_p
11439 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
11440 #define elf_backend_relocate_section elf_xtensa_relocate_section
11441 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
11442 #define elf_backend_always_size_sections elf_xtensa_always_size_sections
11443 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
11444 #define elf_backend_special_sections elf_xtensa_special_sections
11445 #define elf_backend_action_discarded elf_xtensa_action_discarded
11446 #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol
11448 #include "elf32-target.h"