?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gas/
[binutils.git] / bfd / elf32-xtensa.c
blobbb1983025f7172b05bd3f9a6884ff9171701d8d4
1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as
8 published by the Free Software Foundation; either version 2 of the
9 License, or (at your option) any later version.
10
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.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
19 02110-1301, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23
24 #include <stdarg.h>
25 #include <strings.h>
26
27 #include "bfdlink.h"
28 #include "libbfd.h"
29 #include "elf-bfd.h"
30 #include "elf/xtensa.h"
31 #include "xtensa-isa.h"
32 #include "xtensa-config.h"
33
34 #define XTENSA_NO_NOP_REMOVAL 0
35
36 /* Local helper functions. */
37
38 static bfd_boolean add_extra_plt_sections (bfd *, int);
39 static char *vsprint_msg (const char *, const char *, int, ...) ATTRIBUTE_PRINTF(2,4);
40 static bfd_reloc_status_type bfd_elf_xtensa_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_boolean do_fix_for_relocatable_link
43 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *);
44 static void do_fix_for_final_link
45 (Elf_Internal_Rela *, bfd *, asection *, bfd_byte *, bfd_vma *);
46
47 /* Local functions to handle Xtensa configurability. */
48
49 static bfd_boolean is_indirect_call_opcode (xtensa_opcode);
50 static bfd_boolean is_direct_call_opcode (xtensa_opcode);
51 static bfd_boolean is_windowed_call_opcode (xtensa_opcode);
52 static xtensa_opcode get_const16_opcode (void);
53 static xtensa_opcode get_l32r_opcode (void);
54 static bfd_vma l32r_offset (bfd_vma, bfd_vma);
55 static int get_relocation_opnd (xtensa_opcode, int);
56 static int get_relocation_slot (int);
57 static xtensa_opcode get_relocation_opcode
58 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
59 static bfd_boolean is_l32r_relocation
60 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *);
61 static bfd_boolean is_alt_relocation (int);
62 static bfd_boolean is_operand_relocation (int);
63 static bfd_size_type insn_decode_len
64 (bfd_byte *, bfd_size_type, bfd_size_type);
65 static xtensa_opcode insn_decode_opcode
66 (bfd_byte *, bfd_size_type, bfd_size_type, int);
67 static bfd_boolean check_branch_target_aligned
68 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
69 static bfd_boolean check_loop_aligned
70 (bfd_byte *, bfd_size_type, bfd_vma, bfd_vma);
71 static bfd_boolean check_branch_target_aligned_address (bfd_vma, int);
72 static bfd_size_type get_asm_simplify_size
73 (bfd_byte *, bfd_size_type, bfd_size_type);
74
75 /* Functions for link-time code simplifications. */
76
77 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
78 (bfd_byte *, bfd_vma, bfd_vma, char **);
79 static bfd_reloc_status_type contract_asm_expansion
80 (bfd_byte *, bfd_vma, Elf_Internal_Rela *, char **);
81 static xtensa_opcode swap_callx_for_call_opcode (xtensa_opcode);
82 static xtensa_opcode get_expanded_call_opcode (bfd_byte *, int, bfd_boolean *);
83
84 /* Access to internal relocations, section contents and symbols. */
85
86 static Elf_Internal_Rela *retrieve_internal_relocs
87 (bfd *, asection *, bfd_boolean);
88 static void pin_internal_relocs (asection *, Elf_Internal_Rela *);
89 static void release_internal_relocs (asection *, Elf_Internal_Rela *);
90 static bfd_byte *retrieve_contents (bfd *, asection *, bfd_boolean);
91 static void pin_contents (asection *, bfd_byte *);
92 static void release_contents (asection *, bfd_byte *);
93 static Elf_Internal_Sym *retrieve_local_syms (bfd *);
94
95 /* Miscellaneous utility functions. */
96
97 static asection *elf_xtensa_get_plt_section (bfd *, int);
98 static asection *elf_xtensa_get_gotplt_section (bfd *, int);
99 static asection *get_elf_r_symndx_section (bfd *, unsigned long);
100 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
101 (bfd *, unsigned long);
102 static bfd_vma get_elf_r_symndx_offset (bfd *, unsigned long);
103 static bfd_boolean is_reloc_sym_weak (bfd *, Elf_Internal_Rela *);
104 static bfd_boolean pcrel_reloc_fits (xtensa_opcode, int, bfd_vma, bfd_vma);
105 static bfd_boolean xtensa_is_property_section (asection *);
106 static bfd_boolean xtensa_is_littable_section (asection *);
107 static int internal_reloc_compare (const void *, const void *);
108 static int internal_reloc_matches (const void *, const void *);
109 extern asection *xtensa_get_property_section (asection *, const char *);
110 static flagword xtensa_get_property_predef_flags (asection *);
111
112 /* Other functions called directly by the linker. */
113
114 typedef void (*deps_callback_t)
115 (asection *, bfd_vma, asection *, bfd_vma, void *);
116 extern bfd_boolean xtensa_callback_required_dependence
117 (bfd *, asection *, struct bfd_link_info *, deps_callback_t, void *);
118
119
120 /* Globally visible flag for choosing size optimization of NOP removal
121 instead of branch-target-aware minimization for NOP removal.
122 When nonzero, narrow all instructions and remove all NOPs possible
123 around longcall expansions. */
124
125 int elf32xtensa_size_opt;
126
127
128 /* The "new_section_hook" is used to set up a per-section
129 "xtensa_relax_info" data structure with additional information used
130 during relaxation. */
131
132 typedef struct xtensa_relax_info_struct xtensa_relax_info;
133
134
135 /* Total count of PLT relocations seen during check_relocs.
136 The actual PLT code must be split into multiple sections and all
137 the sections have to be created before size_dynamic_sections,
138 where we figure out the exact number of PLT entries that will be
139 needed. It is OK if this count is an overestimate, e.g., some
140 relocations may be removed by GC. */
141
142 static int plt_reloc_count = 0;
143
144
145 /* The GNU tools do not easily allow extending interfaces to pass around
146 the pointer to the Xtensa ISA information, so instead we add a global
147 variable here (in BFD) that can be used by any of the tools that need
148 this information. */
149
150 xtensa_isa xtensa_default_isa;
151
152
153 /* When this is true, relocations may have been modified to refer to
154 symbols from other input files. The per-section list of "fix"
155 records needs to be checked when resolving relocations. */
156
157 static bfd_boolean relaxing_section = FALSE;
158
159 /* When this is true, during final links, literals that cannot be
160 coalesced and their relocations may be moved to other sections. */
161
162 int elf32xtensa_no_literal_movement = 1;
163
164 \f
165 static reloc_howto_type elf_howto_table[] =
166 {
167 HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
168 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
169 FALSE, 0x00000000, 0x00000000, FALSE),
170 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
171 bfd_elf_xtensa_reloc, "R_XTENSA_32",
172 TRUE, 0xffffffff, 0xffffffff, FALSE),
173 /* Replace a 32-bit value with a value from the runtime linker (only
174 used by linker-generated stub functions). The r_addend value is
175 special: 1 means to substitute a pointer to the runtime linker's
176 dynamic resolver function; 2 means to substitute the link map for
177 the shared object. */
178 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
179 NULL, "R_XTENSA_RTLD",
180 FALSE, 0x00000000, 0x00000000, FALSE),
181 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
182 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
183 FALSE, 0xffffffff, 0xffffffff, FALSE),
184 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
185 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
186 FALSE, 0xffffffff, 0xffffffff, FALSE),
187 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
188 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
189 FALSE, 0xffffffff, 0xffffffff, FALSE),
190 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
191 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
192 FALSE, 0xffffffff, 0xffffffff, FALSE),
193 EMPTY_HOWTO (7),
194 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
195 bfd_elf_xtensa_reloc, "R_XTENSA_OP0",
196 FALSE, 0x00000000, 0x00000000, TRUE),
197 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
198 bfd_elf_xtensa_reloc, "R_XTENSA_OP1",
199 FALSE, 0x00000000, 0x00000000, TRUE),
200 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
201 bfd_elf_xtensa_reloc, "R_XTENSA_OP2",
202 FALSE, 0x00000000, 0x00000000, TRUE),
203 /* Assembly auto-expansion. */
204 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
205 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND",
206 FALSE, 0x00000000, 0x00000000, FALSE),
207 /* Relax assembly auto-expansion. */
208 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
209 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY",
210 FALSE, 0x00000000, 0x00000000, TRUE),
211 EMPTY_HOWTO (13),
212 EMPTY_HOWTO (14),
213 /* GNU extension to record C++ vtable hierarchy. */
214 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
215 NULL, "R_XTENSA_GNU_VTINHERIT",
216 FALSE, 0x00000000, 0x00000000, FALSE),
217 /* GNU extension to record C++ vtable member usage. */
218 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
219 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
220 FALSE, 0x00000000, 0x00000000, FALSE),
221
222 /* Relocations for supporting difference of symbols. */
223 HOWTO (R_XTENSA_DIFF8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
224 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF8",
225 FALSE, 0xffffffff, 0xffffffff, FALSE),
226 HOWTO (R_XTENSA_DIFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
227 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF16",
228 FALSE, 0xffffffff, 0xffffffff, FALSE),
229 HOWTO (R_XTENSA_DIFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
230 bfd_elf_xtensa_reloc, "R_XTENSA_DIFF32",
231 FALSE, 0xffffffff, 0xffffffff, FALSE),
232
233 /* General immediate operand relocations. */
234 HOWTO (R_XTENSA_SLOT0_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
235 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_OP",
236 FALSE, 0x00000000, 0x00000000, TRUE),
237 HOWTO (R_XTENSA_SLOT1_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
238 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_OP",
239 FALSE, 0x00000000, 0x00000000, TRUE),
240 HOWTO (R_XTENSA_SLOT2_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
241 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_OP",
242 FALSE, 0x00000000, 0x00000000, TRUE),
243 HOWTO (R_XTENSA_SLOT3_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
244 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_OP",
245 FALSE, 0x00000000, 0x00000000, TRUE),
246 HOWTO (R_XTENSA_SLOT4_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
247 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_OP",
248 FALSE, 0x00000000, 0x00000000, TRUE),
249 HOWTO (R_XTENSA_SLOT5_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
250 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_OP",
251 FALSE, 0x00000000, 0x00000000, TRUE),
252 HOWTO (R_XTENSA_SLOT6_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
253 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_OP",
254 FALSE, 0x00000000, 0x00000000, TRUE),
255 HOWTO (R_XTENSA_SLOT7_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
256 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_OP",
257 FALSE, 0x00000000, 0x00000000, TRUE),
258 HOWTO (R_XTENSA_SLOT8_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
259 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_OP",
260 FALSE, 0x00000000, 0x00000000, TRUE),
261 HOWTO (R_XTENSA_SLOT9_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
262 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_OP",
263 FALSE, 0x00000000, 0x00000000, TRUE),
264 HOWTO (R_XTENSA_SLOT10_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
265 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_OP",
266 FALSE, 0x00000000, 0x00000000, TRUE),
267 HOWTO (R_XTENSA_SLOT11_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
268 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_OP",
269 FALSE, 0x00000000, 0x00000000, TRUE),
270 HOWTO (R_XTENSA_SLOT12_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
271 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_OP",
272 FALSE, 0x00000000, 0x00000000, TRUE),
273 HOWTO (R_XTENSA_SLOT13_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
274 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_OP",
275 FALSE, 0x00000000, 0x00000000, TRUE),
276 HOWTO (R_XTENSA_SLOT14_OP, 0, 0, 0, TRUE, 0, complain_overflow_dont,
277 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_OP",
278 FALSE, 0x00000000, 0x00000000, TRUE),
279
280 /* "Alternate" relocations. The meaning of these is opcode-specific. */
281 HOWTO (R_XTENSA_SLOT0_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
282 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT0_ALT",
283 FALSE, 0x00000000, 0x00000000, TRUE),
284 HOWTO (R_XTENSA_SLOT1_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
285 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT1_ALT",
286 FALSE, 0x00000000, 0x00000000, TRUE),
287 HOWTO (R_XTENSA_SLOT2_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
288 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT2_ALT",
289 FALSE, 0x00000000, 0x00000000, TRUE),
290 HOWTO (R_XTENSA_SLOT3_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
291 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT3_ALT",
292 FALSE, 0x00000000, 0x00000000, TRUE),
293 HOWTO (R_XTENSA_SLOT4_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
294 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT4_ALT",
295 FALSE, 0x00000000, 0x00000000, TRUE),
296 HOWTO (R_XTENSA_SLOT5_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
297 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT5_ALT",
298 FALSE, 0x00000000, 0x00000000, TRUE),
299 HOWTO (R_XTENSA_SLOT6_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
300 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT6_ALT",
301 FALSE, 0x00000000, 0x00000000, TRUE),
302 HOWTO (R_XTENSA_SLOT7_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
303 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT7_ALT",
304 FALSE, 0x00000000, 0x00000000, TRUE),
305 HOWTO (R_XTENSA_SLOT8_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
306 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT8_ALT",
307 FALSE, 0x00000000, 0x00000000, TRUE),
308 HOWTO (R_XTENSA_SLOT9_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
309 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT9_ALT",
310 FALSE, 0x00000000, 0x00000000, TRUE),
311 HOWTO (R_XTENSA_SLOT10_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
312 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT10_ALT",
313 FALSE, 0x00000000, 0x00000000, TRUE),
314 HOWTO (R_XTENSA_SLOT11_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
315 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT11_ALT",
316 FALSE, 0x00000000, 0x00000000, TRUE),
317 HOWTO (R_XTENSA_SLOT12_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
318 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT12_ALT",
319 FALSE, 0x00000000, 0x00000000, TRUE),
320 HOWTO (R_XTENSA_SLOT13_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
321 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT13_ALT",
322 FALSE, 0x00000000, 0x00000000, TRUE),
323 HOWTO (R_XTENSA_SLOT14_ALT, 0, 0, 0, TRUE, 0, complain_overflow_dont,
324 bfd_elf_xtensa_reloc, "R_XTENSA_SLOT14_ALT",
325 FALSE, 0x00000000, 0x00000000, TRUE)
326 };
327
328 #if DEBUG_GEN_RELOC
329 #define TRACE(str) \
330 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
331 #else
332 #define TRACE(str)
333 #endif
334
335 static reloc_howto_type *
336 elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
337 bfd_reloc_code_real_type code)
338 {
339 switch (code)
340 {
341 case BFD_RELOC_NONE:
342 TRACE ("BFD_RELOC_NONE");
343 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
344
345 case BFD_RELOC_32:
346 TRACE ("BFD_RELOC_32");
347 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
348
349 case BFD_RELOC_XTENSA_DIFF8:
350 TRACE ("BFD_RELOC_XTENSA_DIFF8");
351 return &elf_howto_table[(unsigned) R_XTENSA_DIFF8 ];
352
353 case BFD_RELOC_XTENSA_DIFF16:
354 TRACE ("BFD_RELOC_XTENSA_DIFF16");
355 return &elf_howto_table[(unsigned) R_XTENSA_DIFF16 ];
356
357 case BFD_RELOC_XTENSA_DIFF32:
358 TRACE ("BFD_RELOC_XTENSA_DIFF32");
359 return &elf_howto_table[(unsigned) R_XTENSA_DIFF32 ];
360
361 case BFD_RELOC_XTENSA_RTLD:
362 TRACE ("BFD_RELOC_XTENSA_RTLD");
363 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
364
365 case BFD_RELOC_XTENSA_GLOB_DAT:
366 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
367 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
368
369 case BFD_RELOC_XTENSA_JMP_SLOT:
370 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
371 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
372
373 case BFD_RELOC_XTENSA_RELATIVE:
374 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
375 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
376
377 case BFD_RELOC_XTENSA_PLT:
378 TRACE ("BFD_RELOC_XTENSA_PLT");
379 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
380
381 case BFD_RELOC_XTENSA_OP0:
382 TRACE ("BFD_RELOC_XTENSA_OP0");
383 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
384
385 case BFD_RELOC_XTENSA_OP1:
386 TRACE ("BFD_RELOC_XTENSA_OP1");
387 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
388
389 case BFD_RELOC_XTENSA_OP2:
390 TRACE ("BFD_RELOC_XTENSA_OP2");
391 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
392
393 case BFD_RELOC_XTENSA_ASM_EXPAND:
394 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
395 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
396
397 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
398 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
399 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
400
401 case BFD_RELOC_VTABLE_INHERIT:
402 TRACE ("BFD_RELOC_VTABLE_INHERIT");
403 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
404
405 case BFD_RELOC_VTABLE_ENTRY:
406 TRACE ("BFD_RELOC_VTABLE_ENTRY");
407 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
408
409 default:
410 if (code >= BFD_RELOC_XTENSA_SLOT0_OP
411 && code <= BFD_RELOC_XTENSA_SLOT14_OP)
412 {
413 unsigned n = (R_XTENSA_SLOT0_OP +
414 (code - BFD_RELOC_XTENSA_SLOT0_OP));
415 return &elf_howto_table[n];
416 }
417
418 if (code >= BFD_RELOC_XTENSA_SLOT0_ALT
419 && code <= BFD_RELOC_XTENSA_SLOT14_ALT)
420 {
421 unsigned n = (R_XTENSA_SLOT0_ALT +
422 (code - BFD_RELOC_XTENSA_SLOT0_ALT));
423 return &elf_howto_table[n];
424 }
425
426 break;
427 }
428
429 TRACE ("Unknown");
430 return NULL;
431 }
432
433
434 /* Given an ELF "rela" relocation, find the corresponding howto and record
435 it in the BFD internal arelent representation of the relocation. */
436
437 static void
438 elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
439 arelent *cache_ptr,
440 Elf_Internal_Rela *dst)
441 {
442 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
443
444 BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max);
445 cache_ptr->howto = &elf_howto_table[r_type];
446 }
447
448 \f
449 /* Functions for the Xtensa ELF linker. */
450
451 /* The name of the dynamic interpreter. This is put in the .interp
452 section. */
453
454 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
455
456 /* The size in bytes of an entry in the procedure linkage table.
457 (This does _not_ include the space for the literals associated with
458 the PLT entry.) */
459
460 #define PLT_ENTRY_SIZE 16
461
462 /* For _really_ large PLTs, we may need to alternate between literals
463 and code to keep the literals within the 256K range of the L32R
464 instructions in the code. It's unlikely that anyone would ever need
465 such a big PLT, but an arbitrary limit on the PLT size would be bad.
466 Thus, we split the PLT into chunks. Since there's very little
467 overhead (2 extra literals) for each chunk, the chunk size is kept
468 small so that the code for handling multiple chunks get used and
469 tested regularly. With 254 entries, there are 1K of literals for
470 each chunk, and that seems like a nice round number. */
471
472 #define PLT_ENTRIES_PER_CHUNK 254
473
474 /* PLT entries are actually used as stub functions for lazy symbol
475 resolution. Once the symbol is resolved, the stub function is never
476 invoked. Note: the 32-byte frame size used here cannot be changed
477 without a corresponding change in the runtime linker. */
478
479 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
480 {
481 0x6c, 0x10, 0x04, /* entry sp, 32 */
482 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
483 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
484 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
485 0x0a, 0x80, 0x00, /* jx a8 */
486 0 /* unused */
487 };
488
489 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
490 {
491 0x36, 0x41, 0x00, /* entry sp, 32 */
492 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
493 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
494 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
495 0xa0, 0x08, 0x00, /* jx a8 */
496 0 /* unused */
497 };
498
499
500 static inline bfd_boolean
501 xtensa_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
502 struct bfd_link_info *info)
503 {
504 /* Check if we should do dynamic things to this symbol. The
505 "ignore_protected" argument need not be set, because Xtensa code
506 does not require special handling of STV_PROTECTED to make function
507 pointer comparisons work properly. The PLT addresses are never
508 used for function pointers. */
509
510 return _bfd_elf_dynamic_symbol_p (h, info, 0);
511 }
512
513 \f
514 static int
515 property_table_compare (const void *ap, const void *bp)
516 {
517 const property_table_entry *a = (const property_table_entry *) ap;
518 const property_table_entry *b = (const property_table_entry *) bp;
519
520 if (a->address == b->address)
521 {
522 if (a->size != b->size)
523 return (a->size - b->size);
524
525 if ((a->flags & XTENSA_PROP_ALIGN) != (b->flags & XTENSA_PROP_ALIGN))
526 return ((b->flags & XTENSA_PROP_ALIGN)
527 - (a->flags & XTENSA_PROP_ALIGN));
528
529 if ((a->flags & XTENSA_PROP_ALIGN)
530 && (GET_XTENSA_PROP_ALIGNMENT (a->flags)
531 != GET_XTENSA_PROP_ALIGNMENT (b->flags)))
532 return (GET_XTENSA_PROP_ALIGNMENT (a->flags)
533 - GET_XTENSA_PROP_ALIGNMENT (b->flags));
534
535 if ((a->flags & XTENSA_PROP_UNREACHABLE)
536 != (b->flags & XTENSA_PROP_UNREACHABLE))
537 return ((b->flags & XTENSA_PROP_UNREACHABLE)
538 - (a->flags & XTENSA_PROP_UNREACHABLE));
539
540 return (a->flags - b->flags);
541 }
542
543 return (a->address - b->address);
544 }
545
546
547 static int
548 property_table_matches (const void *ap, const void *bp)
549 {
550 const property_table_entry *a = (const property_table_entry *) ap;
551 const property_table_entry *b = (const property_table_entry *) bp;
552
553 /* Check if one entry overlaps with the other. */
554 if ((b->address >= a->address && b->address < (a->address + a->size))
555 || (a->address >= b->address && a->address < (b->address + b->size)))
556 return 0;
557
558 return (a->address - b->address);
559 }
560
561
562 /* Get the literal table or property table entries for the given
563 section. Sets TABLE_P and returns the number of entries. On
564 error, returns a negative value. */
565
566 static int
567 xtensa_read_table_entries (bfd *abfd,
568 asection *section,
569 property_table_entry **table_p,
570 const char *sec_name,
571 bfd_boolean output_addr)
572 {
573 asection *table_section;
574 bfd_size_type table_size = 0;
575 bfd_byte *table_data;
576 property_table_entry *blocks;
577 int blk, block_count;
578 bfd_size_type num_records;
579 Elf_Internal_Rela *internal_relocs;
580 bfd_vma section_addr;
581 flagword predef_flags;
582 bfd_size_type table_entry_size;
583
584 if (!section
585 || !(section->flags & SEC_ALLOC)
586 || (section->flags & SEC_DEBUGGING))
587 {
588 *table_p = NULL;
589 return 0;
590 }
591
592 table_section = xtensa_get_property_section (section, sec_name);
593 if (table_section)
594 table_size = table_section->size;
595
596 if (table_size == 0)
597 {
598 *table_p = NULL;
599 return 0;
600 }
601
602 predef_flags = xtensa_get_property_predef_flags (table_section);
603 table_entry_size = 12;
604 if (predef_flags)
605 table_entry_size -= 4;
606
607 num_records = table_size / table_entry_size;
608 table_data = retrieve_contents (abfd, table_section, TRUE);
609 blocks = (property_table_entry *)
610 bfd_malloc (num_records * sizeof (property_table_entry));
611 block_count = 0;
612
613 if (output_addr)
614 section_addr = section->output_section->vma + section->output_offset;
615 else
616 section_addr = section->vma;
617
618 /* If the file has not yet been relocated, process the relocations
619 and sort out the table entries that apply to the specified section. */
620 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
621 if (internal_relocs && !table_section->reloc_done)
622 {
623 unsigned i;
624
625 for (i = 0; i < table_section->reloc_count; i++)
626 {
627 Elf_Internal_Rela *rel = &internal_relocs[i];
628 unsigned long r_symndx;
629
630 if (ELF32_R_TYPE (rel->r_info) == R_XTENSA_NONE)
631 continue;
632
633 BFD_ASSERT (ELF32_R_TYPE (rel->r_info) == R_XTENSA_32);
634 r_symndx = ELF32_R_SYM (rel->r_info);
635
636 if (get_elf_r_symndx_section (abfd, r_symndx) == section)
637 {
638 bfd_vma sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
639 BFD_ASSERT (sym_off == 0);
640 blocks[block_count].address =
641 (section_addr + sym_off + rel->r_addend
642 + bfd_get_32 (abfd, table_data + rel->r_offset));
643 blocks[block_count].size =
644 bfd_get_32 (abfd, table_data + rel->r_offset + 4);
645 if (predef_flags)
646 blocks[block_count].flags = predef_flags;
647 else
648 blocks[block_count].flags =
649 bfd_get_32 (abfd, table_data + rel->r_offset + 8);
650 block_count++;
651 }
652 }
653 }
654 else
655 {
656 /* The file has already been relocated and the addresses are
657 already in the table. */
658 bfd_vma off;
659 bfd_size_type section_limit = bfd_get_section_limit (abfd, section);
660
661 for (off = 0; off < table_size; off += table_entry_size)
662 {
663 bfd_vma address = bfd_get_32 (abfd, table_data + off);
664
665 if (address >= section_addr
666 && address < section_addr + section_limit)
667 {
668 blocks[block_count].address = address;
669 blocks[block_count].size =
670 bfd_get_32 (abfd, table_data + off + 4);
671 if (predef_flags)
672 blocks[block_count].flags = predef_flags;
673 else
674 blocks[block_count].flags =
675 bfd_get_32 (abfd, table_data + off + 8);
676 block_count++;
677 }
678 }
679 }
680
681 release_contents (table_section, table_data);
682 release_internal_relocs (table_section, internal_relocs);
683
684 if (block_count > 0)
685 {
686 /* Now sort them into address order for easy reference. */
687 qsort (blocks, block_count, sizeof (property_table_entry),
688 property_table_compare);
689
690 /* Check that the table contents are valid. Problems may occur,
691 for example, if an unrelocated object file is stripped. */
692 for (blk = 1; blk < block_count; blk++)
693 {
694 /* The only circumstance where two entries may legitimately
695 have the same address is when one of them is a zero-size
696 placeholder to mark a place where fill can be inserted.
697 The zero-size entry should come first. */
698 if (blocks[blk - 1].address == blocks[blk].address &&
699 blocks[blk - 1].size != 0)
700 {
701 (*_bfd_error_handler) (_("%B(%A): invalid property table"),
702 abfd, section);
703 bfd_set_error (bfd_error_bad_value);
704 free (blocks);
705 return -1;
706 }
707 }
708 }
709
710 *table_p = blocks;
711 return block_count;
712 }
713
714
715 static property_table_entry *
716 elf_xtensa_find_property_entry (property_table_entry *property_table,
717 int property_table_size,
718 bfd_vma addr)
719 {
720 property_table_entry entry;
721 property_table_entry *rv;
722
723 if (property_table_size == 0)
724 return NULL;
725
726 entry.address = addr;
727 entry.size = 1;
728 entry.flags = 0;
729
730 rv = bsearch (&entry, property_table, property_table_size,
731 sizeof (property_table_entry), property_table_matches);
732 return rv;
733 }
734
735
736 static bfd_boolean
737 elf_xtensa_in_literal_pool (property_table_entry *lit_table,
738 int lit_table_size,
739 bfd_vma addr)
740 {
741 if (elf_xtensa_find_property_entry (lit_table, lit_table_size, addr))
742 return TRUE;
743
744 return FALSE;
745 }
746
747 \f
748 /* Look through the relocs for a section during the first phase, and
749 calculate needed space in the dynamic reloc sections. */
750
751 static bfd_boolean
752 elf_xtensa_check_relocs (bfd *abfd,
753 struct bfd_link_info *info,
754 asection *sec,
755 const Elf_Internal_Rela *relocs)
756 {
757 Elf_Internal_Shdr *symtab_hdr;
758 struct elf_link_hash_entry **sym_hashes;
759 const Elf_Internal_Rela *rel;
760 const Elf_Internal_Rela *rel_end;
761
762 if (info->relocatable)
763 return TRUE;
764
765 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
766 sym_hashes = elf_sym_hashes (abfd);
767
768 rel_end = relocs + sec->reloc_count;
769 for (rel = relocs; rel < rel_end; rel++)
770 {
771 unsigned int r_type;
772 unsigned long r_symndx;
773 struct elf_link_hash_entry *h;
774
775 r_symndx = ELF32_R_SYM (rel->r_info);
776 r_type = ELF32_R_TYPE (rel->r_info);
777
778 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
779 {
780 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
781 abfd, r_symndx);
782 return FALSE;
783 }
784
785 if (r_symndx < symtab_hdr->sh_info)
786 h = NULL;
787 else
788 {
789 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
790 while (h->root.type == bfd_link_hash_indirect
791 || h->root.type == bfd_link_hash_warning)
792 h = (struct elf_link_hash_entry *) h->root.u.i.link;
793 }
794
795 switch (r_type)
796 {
797 case R_XTENSA_32:
798 if (h == NULL)
799 goto local_literal;
800
801 if ((sec->flags & SEC_ALLOC) != 0)
802 {
803 if (h->got.refcount <= 0)
804 h->got.refcount = 1;
805 else
806 h->got.refcount += 1;
807 }
808 break;
809
810 case R_XTENSA_PLT:
811 /* If this relocation is against a local symbol, then it's
812 exactly the same as a normal local GOT entry. */
813 if (h == NULL)
814 goto local_literal;
815
816 if ((sec->flags & SEC_ALLOC) != 0)
817 {
818 if (h->plt.refcount <= 0)
819 {
820 h->needs_plt = 1;
821 h->plt.refcount = 1;
822 }
823 else
824 h->plt.refcount += 1;
825
826 /* Keep track of the total PLT relocation count even if we
827 don't yet know whether the dynamic sections will be
828 created. */
829 plt_reloc_count += 1;
830
831 if (elf_hash_table (info)->dynamic_sections_created)
832 {
833 if (!add_extra_plt_sections (elf_hash_table (info)->dynobj,
834 plt_reloc_count))
835 return FALSE;
836 }
837 }
838 break;
839
840 local_literal:
841 if ((sec->flags & SEC_ALLOC) != 0)
842 {
843 bfd_signed_vma *local_got_refcounts;
844
845 /* This is a global offset table entry for a local symbol. */
846 local_got_refcounts = elf_local_got_refcounts (abfd);
847 if (local_got_refcounts == NULL)
848 {
849 bfd_size_type size;
850
851 size = symtab_hdr->sh_info;
852 size *= sizeof (bfd_signed_vma);
853 local_got_refcounts =
854 (bfd_signed_vma *) bfd_zalloc (abfd, size);
855 if (local_got_refcounts == NULL)
856 return FALSE;
857 elf_local_got_refcounts (abfd) = local_got_refcounts;
858 }
859 local_got_refcounts[r_symndx] += 1;
860 }
861 break;
862
863 case R_XTENSA_OP0:
864 case R_XTENSA_OP1:
865 case R_XTENSA_OP2:
866 case R_XTENSA_SLOT0_OP:
867 case R_XTENSA_SLOT1_OP:
868 case R_XTENSA_SLOT2_OP:
869 case R_XTENSA_SLOT3_OP:
870 case R_XTENSA_SLOT4_OP:
871 case R_XTENSA_SLOT5_OP:
872 case R_XTENSA_SLOT6_OP:
873 case R_XTENSA_SLOT7_OP:
874 case R_XTENSA_SLOT8_OP:
875 case R_XTENSA_SLOT9_OP:
876 case R_XTENSA_SLOT10_OP:
877 case R_XTENSA_SLOT11_OP:
878 case R_XTENSA_SLOT12_OP:
879 case R_XTENSA_SLOT13_OP:
880 case R_XTENSA_SLOT14_OP:
881 case R_XTENSA_SLOT0_ALT:
882 case R_XTENSA_SLOT1_ALT:
883 case R_XTENSA_SLOT2_ALT:
884 case R_XTENSA_SLOT3_ALT:
885 case R_XTENSA_SLOT4_ALT:
886 case R_XTENSA_SLOT5_ALT:
887 case R_XTENSA_SLOT6_ALT:
888 case R_XTENSA_SLOT7_ALT:
889 case R_XTENSA_SLOT8_ALT:
890 case R_XTENSA_SLOT9_ALT:
891 case R_XTENSA_SLOT10_ALT:
892 case R_XTENSA_SLOT11_ALT:
893 case R_XTENSA_SLOT12_ALT:
894 case R_XTENSA_SLOT13_ALT:
895 case R_XTENSA_SLOT14_ALT:
896 case R_XTENSA_ASM_EXPAND:
897 case R_XTENSA_ASM_SIMPLIFY:
898 case R_XTENSA_DIFF8:
899 case R_XTENSA_DIFF16:
900 case R_XTENSA_DIFF32:
901 /* Nothing to do for these. */
902 break;
903
904 case R_XTENSA_GNU_VTINHERIT:
905 /* This relocation describes the C++ object vtable hierarchy.
906 Reconstruct it for later use during GC. */
907 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
908 return FALSE;
909 break;
910
911 case R_XTENSA_GNU_VTENTRY:
912 /* This relocation describes which C++ vtable entries are actually
913 used. Record for later use during GC. */
914 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
915 return FALSE;
916 break;
917
918 default:
919 break;
920 }
921 }
922
923 return TRUE;
924 }
925
926
927 static void
928 elf_xtensa_make_sym_local (struct bfd_link_info *info,
929 struct elf_link_hash_entry *h)
930 {
931 if (info->shared)
932 {
933 if (h->plt.refcount > 0)
934 {
935 /* Will use RELATIVE relocs instead of JMP_SLOT relocs. */
936 if (h->got.refcount < 0)
937 h->got.refcount = 0;
938 h->got.refcount += h->plt.refcount;
939 h->plt.refcount = 0;
940 }
941 }
942 else
943 {
944 /* Don't need any dynamic relocations at all. */
945 h->plt.refcount = 0;
946 h->got.refcount = 0;
947 }
948 }
949
950
951 static void
952 elf_xtensa_hide_symbol (struct bfd_link_info *info,
953 struct elf_link_hash_entry *h,
954 bfd_boolean force_local)
955 {
956 /* For a shared link, move the plt refcount to the got refcount to leave
957 space for RELATIVE relocs. */
958 elf_xtensa_make_sym_local (info, h);
959
960 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
961 }
962
963
964 /* Return the section that should be marked against GC for a given
965 relocation. */
966
967 static asection *
968 elf_xtensa_gc_mark_hook (asection *sec,
969 struct bfd_link_info *info,
970 Elf_Internal_Rela *rel,
971 struct elf_link_hash_entry *h,
972 Elf_Internal_Sym *sym)
973 {
974 if (h != NULL)
975 switch (ELF32_R_TYPE (rel->r_info))
976 {
977 case R_XTENSA_GNU_VTINHERIT:
978 case R_XTENSA_GNU_VTENTRY:
979 return NULL;
980 }
981
982 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
983 }
984
985
986 /* Update the GOT & PLT entry reference counts
987 for the section being removed. */
988
989 static bfd_boolean
990 elf_xtensa_gc_sweep_hook (bfd *abfd,
991 struct bfd_link_info *info ATTRIBUTE_UNUSED,
992 asection *sec,
993 const Elf_Internal_Rela *relocs)
994 {
995 Elf_Internal_Shdr *symtab_hdr;
996 struct elf_link_hash_entry **sym_hashes;
997 bfd_signed_vma *local_got_refcounts;
998 const Elf_Internal_Rela *rel, *relend;
999
1000 if ((sec->flags & SEC_ALLOC) == 0)
1001 return TRUE;
1002
1003 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1004 sym_hashes = elf_sym_hashes (abfd);
1005 local_got_refcounts = elf_local_got_refcounts (abfd);
1006
1007 relend = relocs + sec->reloc_count;
1008 for (rel = relocs; rel < relend; rel++)
1009 {
1010 unsigned long r_symndx;
1011 unsigned int r_type;
1012 struct elf_link_hash_entry *h = NULL;
1013
1014 r_symndx = ELF32_R_SYM (rel->r_info);
1015 if (r_symndx >= symtab_hdr->sh_info)
1016 {
1017 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1018 while (h->root.type == bfd_link_hash_indirect
1019 || h->root.type == bfd_link_hash_warning)
1020 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1021 }
1022
1023 r_type = ELF32_R_TYPE (rel->r_info);
1024 switch (r_type)
1025 {
1026 case R_XTENSA_32:
1027 if (h == NULL)
1028 goto local_literal;
1029 if (h->got.refcount > 0)
1030 h->got.refcount--;
1031 break;
1032
1033 case R_XTENSA_PLT:
1034 if (h == NULL)
1035 goto local_literal;
1036 if (h->plt.refcount > 0)
1037 h->plt.refcount--;
1038 break;
1039
1040 local_literal:
1041 if (local_got_refcounts[r_symndx] > 0)
1042 local_got_refcounts[r_symndx] -= 1;
1043 break;
1044
1045 default:
1046 break;
1047 }
1048 }
1049
1050 return TRUE;
1051 }
1052
1053
1054 /* Create all the dynamic sections. */
1055
1056 static bfd_boolean
1057 elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1058 {
1059 flagword flags, noalloc_flags;
1060 asection *s;
1061
1062 /* First do all the standard stuff. */
1063 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
1064 return FALSE;
1065
1066 /* Create any extra PLT sections in case check_relocs has already
1067 been called on all the non-dynamic input files. */
1068 if (!add_extra_plt_sections (dynobj, plt_reloc_count))
1069 return FALSE;
1070
1071 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
1072 | SEC_LINKER_CREATED | SEC_READONLY);
1073 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
1074
1075 /* Mark the ".got.plt" section READONLY. */
1076 s = bfd_get_section_by_name (dynobj, ".got.plt");
1077 if (s == NULL
1078 || ! bfd_set_section_flags (dynobj, s, flags))
1079 return FALSE;
1080
1081 /* Create ".rela.got". */
1082 s = bfd_make_section_with_flags (dynobj, ".rela.got", flags);
1083 if (s == NULL
1084 || ! bfd_set_section_alignment (dynobj, s, 2))
1085 return FALSE;
1086
1087 /* Create ".got.loc" (literal tables for use by dynamic linker). */
1088 s = bfd_make_section_with_flags (dynobj, ".got.loc", flags);
1089 if (s == NULL
1090 || ! bfd_set_section_alignment (dynobj, s, 2))
1091 return FALSE;
1092
1093 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
1094 s = bfd_make_section_with_flags (dynobj, ".xt.lit.plt",
1095 noalloc_flags);
1096 if (s == NULL
1097 || ! bfd_set_section_alignment (dynobj, s, 2))
1098 return FALSE;
1099
1100 return TRUE;
1101 }
1102
1103
1104 static bfd_boolean
1105 add_extra_plt_sections (bfd *dynobj, int count)
1106 {
1107 int chunk;
1108
1109 /* Iterate over all chunks except 0 which uses the standard ".plt" and
1110 ".got.plt" sections. */
1111 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
1112 {
1113 char *sname;
1114 flagword flags;
1115 asection *s;
1116
1117 /* Stop when we find a section has already been created. */
1118 if (elf_xtensa_get_plt_section (dynobj, chunk))
1119 break;
1120
1121 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1122 | SEC_LINKER_CREATED | SEC_READONLY);
1123
1124 sname = (char *) bfd_malloc (10);
1125 sprintf (sname, ".plt.%u", chunk);
1126 s = bfd_make_section_with_flags (dynobj, sname, flags | SEC_CODE);
1127 if (s == NULL
1128 || ! bfd_set_section_alignment (dynobj, s, 2))
1129 return FALSE;
1130
1131 sname = (char *) bfd_malloc (14);
1132 sprintf (sname, ".got.plt.%u", chunk);
1133 s = bfd_make_section_with_flags (dynobj, sname, flags);
1134 if (s == NULL
1135 || ! bfd_set_section_alignment (dynobj, s, 2))
1136 return FALSE;
1137 }
1138
1139 return TRUE;
1140 }
1141
1142
1143 /* Adjust a symbol defined by a dynamic object and referenced by a
1144 regular object. The current definition is in some section of the
1145 dynamic object, but we're not including those sections. We have to
1146 change the definition to something the rest of the link can
1147 understand. */
1148
1149 static bfd_boolean
1150 elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1151 struct elf_link_hash_entry *h)
1152 {
1153 /* If this is a weak symbol, and there is a real definition, the
1154 processor independent code will have arranged for us to see the
1155 real definition first, and we can just use the same value. */
1156 if (h->u.weakdef)
1157 {
1158 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1159 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1160 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1161 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1162 return TRUE;
1163 }
1164
1165 /* This is a reference to a symbol defined by a dynamic object. The
1166 reference must go through the GOT, so there's no need for COPY relocs,
1167 .dynbss, etc. */
1168
1169 return TRUE;
1170 }
1171
1172
1173 static bfd_boolean
1174 elf_xtensa_fix_refcounts (struct elf_link_hash_entry *h, void *arg)
1175 {
1176 struct bfd_link_info *info = (struct bfd_link_info *) arg;
1177
1178 if (h->root.type == bfd_link_hash_warning)
1179 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1180
1181 if (! xtensa_elf_dynamic_symbol_p (h, info))
1182 elf_xtensa_make_sym_local (info, h);
1183
1184 return TRUE;
1185 }
1186
1187
1188 static bfd_boolean
1189 elf_xtensa_allocate_plt_size (struct elf_link_hash_entry *h, void *arg)
1190 {
1191 asection *srelplt = (asection *) arg;
1192
1193 if (h->root.type == bfd_link_hash_warning)
1194 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1195
1196 if (h->plt.refcount > 0)
1197 srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1198
1199 return TRUE;
1200 }
1201
1202
1203 static bfd_boolean
1204 elf_xtensa_allocate_got_size (struct elf_link_hash_entry *h, void *arg)
1205 {
1206 asection *srelgot = (asection *) arg;
1207
1208 if (h->root.type == bfd_link_hash_warning)
1209 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1210
1211 if (h->got.refcount > 0)
1212 srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela));
1213
1214 return TRUE;
1215 }
1216
1217
1218 static void
1219 elf_xtensa_allocate_local_got_size (struct bfd_link_info *info,
1220 asection *srelgot)
1221 {
1222 bfd *i;
1223
1224 for (i = info->input_bfds; i; i = i->link_next)
1225 {
1226 bfd_signed_vma *local_got_refcounts;
1227 bfd_size_type j, cnt;
1228 Elf_Internal_Shdr *symtab_hdr;
1229
1230 local_got_refcounts = elf_local_got_refcounts (i);
1231 if (!local_got_refcounts)
1232 continue;
1233
1234 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1235 cnt = symtab_hdr->sh_info;
1236
1237 for (j = 0; j < cnt; ++j)
1238 {
1239 if (local_got_refcounts[j] > 0)
1240 srelgot->size += (local_got_refcounts[j]
1241 * sizeof (Elf32_External_Rela));
1242 }
1243 }
1244 }
1245
1246
1247 /* Set the sizes of the dynamic sections. */
1248
1249 static bfd_boolean
1250 elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1251 struct bfd_link_info *info)
1252 {
1253 bfd *dynobj, *abfd;
1254 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1255 bfd_boolean relplt, relgot;
1256 int plt_entries, plt_chunks, chunk;
1257
1258 plt_entries = 0;
1259 plt_chunks = 0;
1260 srelgot = 0;
1261
1262 dynobj = elf_hash_table (info)->dynobj;
1263 if (dynobj == NULL)
1264 abort ();
1265
1266 if (elf_hash_table (info)->dynamic_sections_created)
1267 {
1268 /* Set the contents of the .interp section to the interpreter. */
1269 if (info->executable)
1270 {
1271 s = bfd_get_section_by_name (dynobj, ".interp");
1272 if (s == NULL)
1273 abort ();
1274 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1275 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1276 }
1277
1278 /* Allocate room for one word in ".got". */
1279 s = bfd_get_section_by_name (dynobj, ".got");
1280 if (s == NULL)
1281 abort ();
1282 s->size = 4;
1283
1284 /* Adjust refcounts for symbols that we now know are not "dynamic". */
1285 elf_link_hash_traverse (elf_hash_table (info),
1286 elf_xtensa_fix_refcounts,
1287 (void *) info);
1288
1289 /* Allocate space in ".rela.got" for literals that reference
1290 global symbols. */
1291 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1292 if (srelgot == NULL)
1293 abort ();
1294 elf_link_hash_traverse (elf_hash_table (info),
1295 elf_xtensa_allocate_got_size,
1296 (void *) srelgot);
1297
1298 /* If we are generating a shared object, we also need space in
1299 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1300 reference local symbols. */
1301 if (info->shared)
1302 elf_xtensa_allocate_local_got_size (info, srelgot);
1303
1304 /* Allocate space in ".rela.plt" for literals that have PLT entries. */
1305 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1306 if (srelplt == NULL)
1307 abort ();
1308 elf_link_hash_traverse (elf_hash_table (info),
1309 elf_xtensa_allocate_plt_size,
1310 (void *) srelplt);
1311
1312 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1313 each PLT entry, we need the PLT code plus a 4-byte literal.
1314 For each chunk of ".plt", we also need two more 4-byte
1315 literals, two corresponding entries in ".rela.got", and an
1316 8-byte entry in ".xt.lit.plt". */
1317 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
1318 if (spltlittbl == NULL)
1319 abort ();
1320
1321 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
1322 plt_chunks =
1323 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1324
1325 /* Iterate over all the PLT chunks, including any extra sections
1326 created earlier because the initial count of PLT relocations
1327 was an overestimate. */
1328 for (chunk = 0;
1329 (splt = elf_xtensa_get_plt_section (dynobj, chunk)) != NULL;
1330 chunk++)
1331 {
1332 int chunk_entries;
1333
1334 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1335 if (sgotplt == NULL)
1336 abort ();
1337
1338 if (chunk < plt_chunks - 1)
1339 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1340 else if (chunk == plt_chunks - 1)
1341 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1342 else
1343 chunk_entries = 0;
1344
1345 if (chunk_entries != 0)
1346 {
1347 sgotplt->size = 4 * (chunk_entries + 2);
1348 splt->size = PLT_ENTRY_SIZE * chunk_entries;
1349 srelgot->size += 2 * sizeof (Elf32_External_Rela);
1350 spltlittbl->size += 8;
1351 }
1352 else
1353 {
1354 sgotplt->size = 0;
1355 splt->size = 0;
1356 }
1357 }
1358
1359 /* Allocate space in ".got.loc" to match the total size of all the
1360 literal tables. */
1361 sgotloc = bfd_get_section_by_name (dynobj, ".got.loc");
1362 if (sgotloc == NULL)
1363 abort ();
1364 sgotloc->size = spltlittbl->size;
1365 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1366 {
1367 if (abfd->flags & DYNAMIC)
1368 continue;
1369 for (s = abfd->sections; s != NULL; s = s->next)
1370 {
1371 if (! elf_discarded_section (s)
1372 && xtensa_is_littable_section (s)
1373 && s != spltlittbl)
1374 sgotloc->size += s->size;
1375 }
1376 }
1377 }
1378
1379 /* Allocate memory for dynamic sections. */
1380 relplt = FALSE;
1381 relgot = FALSE;
1382 for (s = dynobj->sections; s != NULL; s = s->next)
1383 {
1384 const char *name;
1385
1386 if ((s->flags & SEC_LINKER_CREATED) == 0)
1387 continue;
1388
1389 /* It's OK to base decisions on the section name, because none
1390 of the dynobj section names depend upon the input files. */
1391 name = bfd_get_section_name (dynobj, s);
1392
1393 if (CONST_STRNEQ (name, ".rela"))
1394 {
1395 if (s->size != 0)
1396 {
1397 if (strcmp (name, ".rela.plt") == 0)
1398 relplt = TRUE;
1399 else if (strcmp (name, ".rela.got") == 0)
1400 relgot = TRUE;
1401
1402 /* We use the reloc_count field as a counter if we need
1403 to copy relocs into the output file. */
1404 s->reloc_count = 0;
1405 }
1406 }
1407 else if (! CONST_STRNEQ (name, ".plt.")
1408 && ! CONST_STRNEQ (name, ".got.plt.")
1409 && strcmp (name, ".got") != 0
1410 && strcmp (name, ".plt") != 0
1411 && strcmp (name, ".got.plt") != 0
1412 && strcmp (name, ".xt.lit.plt") != 0
1413 && strcmp (name, ".got.loc") != 0)
1414 {
1415 /* It's not one of our sections, so don't allocate space. */
1416 continue;
1417 }
1418
1419 if (s->size == 0)
1420 {
1421 /* If we don't need this section, strip it from the output
1422 file. We must create the ".plt*" and ".got.plt*"
1423 sections in create_dynamic_sections and/or check_relocs
1424 based on a conservative estimate of the PLT relocation
1425 count, because the sections must be created before the
1426 linker maps input sections to output sections. The
1427 linker does that before size_dynamic_sections, where we
1428 compute the exact size of the PLT, so there may be more
1429 of these sections than are actually needed. */
1430 s->flags |= SEC_EXCLUDE;
1431 }
1432 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
1433 {
1434 /* Allocate memory for the section contents. */
1435 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1436 if (s->contents == NULL)
1437 return FALSE;
1438 }
1439 }
1440
1441 if (elf_hash_table (info)->dynamic_sections_created)
1442 {
1443 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1444 known until finish_dynamic_sections, but we need to get the relocs
1445 in place before they are sorted. */
1446 if (srelgot == NULL)
1447 abort ();
1448 for (chunk = 0; chunk < plt_chunks; chunk++)
1449 {
1450 Elf_Internal_Rela irela;
1451 bfd_byte *loc;
1452
1453 irela.r_offset = 0;
1454 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1455 irela.r_addend = 0;
1456
1457 loc = (srelgot->contents
1458 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1459 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1460 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1461 loc + sizeof (Elf32_External_Rela));
1462 srelgot->reloc_count += 2;
1463 }
1464
1465 /* Add some entries to the .dynamic section. We fill in the
1466 values later, in elf_xtensa_finish_dynamic_sections, but we
1467 must add the entries now so that we get the correct size for
1468 the .dynamic section. The DT_DEBUG entry is filled in by the
1469 dynamic linker and used by the debugger. */
1470 #define add_dynamic_entry(TAG, VAL) \
1471 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1472
1473 if (info->executable)
1474 {
1475 if (!add_dynamic_entry (DT_DEBUG, 0))
1476 return FALSE;
1477 }
1478
1479 if (relplt)
1480 {
1481 if (!add_dynamic_entry (DT_PLTGOT, 0)
1482 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1483 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1484 || !add_dynamic_entry (DT_JMPREL, 0))
1485 return FALSE;
1486 }
1487
1488 if (relgot)
1489 {
1490 if (!add_dynamic_entry (DT_RELA, 0)
1491 || !add_dynamic_entry (DT_RELASZ, 0)
1492 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1493 return FALSE;
1494 }
1495
1496 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1497 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1498 return FALSE;
1499 }
1500 #undef add_dynamic_entry
1501
1502 return TRUE;
1503 }
1504
1505 \f
1506 /* Perform the specified relocation. The instruction at (contents + address)
1507 is modified to set one operand to represent the value in "relocation". The
1508 operand position is determined by the relocation type recorded in the
1509 howto. */
1510
1511 #define CALL_SEGMENT_BITS (30)
1512 #define CALL_SEGMENT_SIZE (1 << CALL_SEGMENT_BITS)
1513
1514 static bfd_reloc_status_type
1515 elf_xtensa_do_reloc (reloc_howto_type *howto,
1516 bfd *abfd,
1517 asection *input_section,
1518 bfd_vma relocation,
1519 bfd_byte *contents,
1520 bfd_vma address,
1521 bfd_boolean is_weak_undef,
1522 char **error_message)
1523 {
1524 xtensa_format fmt;
1525 xtensa_opcode opcode;
1526 xtensa_isa isa = xtensa_default_isa;
1527 static xtensa_insnbuf ibuff = NULL;
1528 static xtensa_insnbuf sbuff = NULL;
1529 bfd_vma self_address = 0;
1530 bfd_size_type input_size;
1531 int opnd, slot;
1532 uint32 newval;
1533
1534 if (!ibuff)
1535 {
1536 ibuff = xtensa_insnbuf_alloc (isa);
1537 sbuff = xtensa_insnbuf_alloc (isa);
1538 }
1539
1540 input_size = bfd_get_section_limit (abfd, input_section);
1541
1542 switch (howto->type)
1543 {
1544 case R_XTENSA_NONE:
1545 case R_XTENSA_DIFF8:
1546 case R_XTENSA_DIFF16:
1547 case R_XTENSA_DIFF32:
1548 return bfd_reloc_ok;
1549
1550 case R_XTENSA_ASM_EXPAND:
1551 if (!is_weak_undef)
1552 {
1553 /* Check for windowed CALL across a 1GB boundary. */
1554 xtensa_opcode opcode =
1555 get_expanded_call_opcode (contents + address,
1556 input_size - address, 0);
1557 if (is_windowed_call_opcode (opcode))
1558 {
1559 self_address = (input_section->output_section->vma
1560 + input_section->output_offset
1561 + address);
1562 if ((self_address >> CALL_SEGMENT_BITS)
1563 != (relocation >> CALL_SEGMENT_BITS))
1564 {
1565 *error_message = "windowed longcall crosses 1GB boundary; "
1566 "return may fail";
1567 return bfd_reloc_dangerous;
1568 }
1569 }
1570 }
1571 return bfd_reloc_ok;
1572
1573 case R_XTENSA_ASM_SIMPLIFY:
1574 {
1575 /* Convert the L32R/CALLX to CALL. */
1576 bfd_reloc_status_type retval =
1577 elf_xtensa_do_asm_simplify (contents, address, input_size,
1578 error_message);
1579 if (retval != bfd_reloc_ok)
1580 return bfd_reloc_dangerous;
1581
1582 /* The CALL needs to be relocated. Continue below for that part. */
1583 address += 3;
1584 howto = &elf_howto_table[(unsigned) R_XTENSA_SLOT0_OP ];
1585 }
1586 break;
1587
1588 case R_XTENSA_32:
1589 case R_XTENSA_PLT:
1590 {
1591 bfd_vma x;
1592 x = bfd_get_32 (abfd, contents + address);
1593 x = x + relocation;
1594 bfd_put_32 (abfd, x, contents + address);
1595 }
1596 return bfd_reloc_ok;
1597 }
1598
1599 /* Only instruction slot-specific relocations handled below.... */
1600 slot = get_relocation_slot (howto->type);
1601 if (slot == XTENSA_UNDEFINED)
1602 {
1603 *error_message = "unexpected relocation";
1604 return bfd_reloc_dangerous;
1605 }
1606
1607 /* Read the instruction into a buffer and decode the opcode. */
1608 xtensa_insnbuf_from_chars (isa, ibuff, contents + address,
1609 input_size - address);
1610 fmt = xtensa_format_decode (isa, ibuff);
1611 if (fmt == XTENSA_UNDEFINED)
1612 {
1613 *error_message = "cannot decode instruction format";
1614 return bfd_reloc_dangerous;
1615 }
1616
1617 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
1618
1619 opcode = xtensa_opcode_decode (isa, fmt, slot, sbuff);
1620 if (opcode == XTENSA_UNDEFINED)
1621 {
1622 *error_message = "cannot decode instruction opcode";
1623 return bfd_reloc_dangerous;
1624 }
1625
1626 /* Check for opcode-specific "alternate" relocations. */
1627 if (is_alt_relocation (howto->type))
1628 {
1629 if (opcode == get_l32r_opcode ())
1630 {
1631 /* Handle the special-case of non-PC-relative L32R instructions. */
1632 bfd *output_bfd = input_section->output_section->owner;
1633 asection *lit4_sec = bfd_get_section_by_name (output_bfd, ".lit4");
1634 if (!lit4_sec)
1635 {
1636 *error_message = "relocation references missing .lit4 section";
1637 return bfd_reloc_dangerous;
1638 }
1639 self_address = ((lit4_sec->vma & ~0xfff)
1640 + 0x40000 - 3); /* -3 to compensate for do_reloc */
1641 newval = relocation;
1642 opnd = 1;
1643 }
1644 else if (opcode == get_const16_opcode ())
1645 {
1646 /* ALT used for high 16 bits. */
1647 newval = relocation >> 16;
1648 opnd = 1;
1649 }
1650 else
1651 {
1652 /* No other "alternate" relocations currently defined. */
1653 *error_message = "unexpected relocation";
1654 return bfd_reloc_dangerous;
1655 }
1656 }
1657 else /* Not an "alternate" relocation.... */
1658 {
1659 if (opcode == get_const16_opcode ())
1660 {
1661 newval = relocation & 0xffff;
1662 opnd = 1;
1663 }
1664 else
1665 {
1666 /* ...normal PC-relative relocation.... */
1667
1668 /* Determine which operand is being relocated. */
1669 opnd = get_relocation_opnd (opcode, howto->type);
1670 if (opnd == XTENSA_UNDEFINED)
1671 {
1672 *error_message = "unexpected relocation";
1673 return bfd_reloc_dangerous;
1674 }
1675
1676 if (!howto->pc_relative)
1677 {
1678 *error_message = "expected PC-relative relocation";
1679 return bfd_reloc_dangerous;
1680 }
1681
1682 /* Calculate the PC address for this instruction. */
1683 self_address = (input_section->output_section->vma
1684 + input_section->output_offset
1685 + address);
1686
1687 newval = relocation;
1688 }
1689 }
1690
1691 /* Apply the relocation. */
1692 if (xtensa_operand_do_reloc (isa, opcode, opnd, &newval, self_address)
1693 || xtensa_operand_encode (isa, opcode, opnd, &newval)
1694 || xtensa_operand_set_field (isa, opcode, opnd, fmt, slot,
1695 sbuff, newval))
1696 {
1697 const char *opname = xtensa_opcode_name (isa, opcode);
1698 const char *msg;
1699
1700 msg = "cannot encode";
1701 if (is_direct_call_opcode (opcode))
1702 {
1703 if ((relocation & 0x3) != 0)
1704 msg = "misaligned call target";
1705 else
1706 msg = "call target out of range";
1707 }
1708 else if (opcode == get_l32r_opcode ())
1709 {
1710 if ((relocation & 0x3) != 0)
1711 msg = "misaligned literal target";
1712 else if (is_alt_relocation (howto->type))
1713 msg = "literal target out of range (too many literals)";
1714 else if (self_address > relocation)
1715 msg = "literal target out of range (try using text-section-literals)";
1716 else
1717 msg = "literal placed after use";
1718 }
1719
1720 *error_message = vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
1721 return bfd_reloc_dangerous;
1722 }
1723
1724 /* Check for calls across 1GB boundaries. */
1725 if (is_direct_call_opcode (opcode)
1726 && is_windowed_call_opcode (opcode))
1727 {
1728 if ((self_address >> CALL_SEGMENT_BITS)
1729 != (relocation >> CALL_SEGMENT_BITS))
1730 {
1731 *error_message =
1732 "windowed call crosses 1GB boundary; return may fail";
1733 return bfd_reloc_dangerous;
1734 }
1735 }
1736
1737 /* Write the modified instruction back out of the buffer. */
1738 xtensa_format_set_slot (isa, fmt, slot, ibuff, sbuff);
1739 xtensa_insnbuf_to_chars (isa, ibuff, contents + address,
1740 input_size - address);
1741 return bfd_reloc_ok;
1742 }
1743
1744
1745 static char *
1746 vsprint_msg (const char *origmsg, const char *fmt, int arglen, ...)
1747 {
1748 /* To reduce the size of the memory leak,
1749 we only use a single message buffer. */
1750 static bfd_size_type alloc_size = 0;
1751 static char *message = NULL;
1752 bfd_size_type orig_len, len = 0;
1753 bfd_boolean is_append;
1754
1755 VA_OPEN (ap, arglen);
1756 VA_FIXEDARG (ap, const char *, origmsg);
1757
1758 is_append = (origmsg == message);
1759
1760 orig_len = strlen (origmsg);
1761 len = orig_len + strlen (fmt) + arglen + 20;
1762 if (len > alloc_size)
1763 {
1764 message = (char *) bfd_realloc (message, len);
1765 alloc_size = len;
1766 }
1767 if (!is_append)
1768 memcpy (message, origmsg, orig_len);
1769 vsprintf (message + orig_len, fmt, ap);
1770 VA_CLOSE (ap);
1771 return message;
1772 }
1773
1774
1775 /* This function is registered as the "special_function" in the
1776 Xtensa howto for handling simplify operations.
1777 bfd_perform_relocation / bfd_install_relocation use it to
1778 perform (install) the specified relocation. Since this replaces the code
1779 in bfd_perform_relocation, it is basically an Xtensa-specific,
1780 stripped-down version of bfd_perform_relocation. */
1781
1782 static bfd_reloc_status_type
1783 bfd_elf_xtensa_reloc (bfd *abfd,
1784 arelent *reloc_entry,
1785 asymbol *symbol,
1786 void *data,
1787 asection *input_section,
1788 bfd *output_bfd,
1789 char **error_message)
1790 {
1791 bfd_vma relocation;
1792 bfd_reloc_status_type flag;
1793 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1794 bfd_vma output_base = 0;
1795 reloc_howto_type *howto = reloc_entry->howto;
1796 asection *reloc_target_output_section;
1797 bfd_boolean is_weak_undef;
1798
1799 if (!xtensa_default_isa)
1800 xtensa_default_isa = xtensa_isa_init (0, 0);
1801
1802 /* ELF relocs are against symbols. If we are producing relocatable
1803 output, and the reloc is against an external symbol, the resulting
1804 reloc will also be against the same symbol. In such a case, we
1805 don't want to change anything about the way the reloc is handled,
1806 since it will all be done at final link time. This test is similar
1807 to what bfd_elf_generic_reloc does except that it lets relocs with
1808 howto->partial_inplace go through even if the addend is non-zero.
1809 (The real problem is that partial_inplace is set for XTENSA_32
1810 relocs to begin with, but that's a long story and there's little we
1811 can do about it now....) */
1812
1813 if (output_bfd && (symbol->flags & BSF_SECTION_SYM) == 0)
1814 {
1815 reloc_entry->address += input_section->output_offset;
1816 return bfd_reloc_ok;
1817 }
1818
1819 /* Is the address of the relocation really within the section? */
1820 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
1821 return bfd_reloc_outofrange;
1822
1823 /* Work out which section the relocation is targeted at and the
1824 initial relocation command value. */
1825
1826 /* Get symbol value. (Common symbols are special.) */
1827 if (bfd_is_com_section (symbol->section))
1828 relocation = 0;
1829 else
1830 relocation = symbol->value;
1831
1832 reloc_target_output_section = symbol->section->output_section;
1833
1834 /* Convert input-section-relative symbol value to absolute. */
1835 if ((output_bfd && !howto->partial_inplace)
1836 || reloc_target_output_section == NULL)
1837 output_base = 0;
1838 else
1839 output_base = reloc_target_output_section->vma;
1840
1841 relocation += output_base + symbol->section->output_offset;
1842
1843 /* Add in supplied addend. */
1844 relocation += reloc_entry->addend;
1845
1846 /* Here the variable relocation holds the final address of the
1847 symbol we are relocating against, plus any addend. */
1848 if (output_bfd)
1849 {
1850 if (!howto->partial_inplace)
1851 {
1852 /* This is a partial relocation, and we want to apply the relocation
1853 to the reloc entry rather than the raw data. Everything except
1854 relocations against section symbols has already been handled
1855 above. */
1856
1857 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
1858 reloc_entry->addend = relocation;
1859 reloc_entry->address += input_section->output_offset;
1860 return bfd_reloc_ok;
1861 }
1862 else
1863 {
1864 reloc_entry->address += input_section->output_offset;
1865 reloc_entry->addend = 0;
1866 }
1867 }
1868
1869 is_weak_undef = (bfd_is_und_section (symbol->section)
1870 && (symbol->flags & BSF_WEAK) != 0);
1871 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
1872 (bfd_byte *) data, (bfd_vma) octets,
1873 is_weak_undef, error_message);
1874
1875 if (flag == bfd_reloc_dangerous)
1876 {
1877 /* Add the symbol name to the error message. */
1878 if (! *error_message)
1879 *error_message = "";
1880 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
1881 strlen (symbol->name) + 17,
1882 symbol->name,
1883 (unsigned long) reloc_entry->addend);
1884 }
1885
1886 return flag;
1887 }
1888
1889
1890 /* Set up an entry in the procedure linkage table. */
1891
1892 static bfd_vma
1893 elf_xtensa_create_plt_entry (bfd *dynobj,
1894 bfd *output_bfd,
1895 unsigned reloc_index)
1896 {
1897 asection *splt, *sgotplt;
1898 bfd_vma plt_base, got_base;
1899 bfd_vma code_offset, lit_offset;
1900 int chunk;
1901
1902 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
1903 splt = elf_xtensa_get_plt_section (dynobj, chunk);
1904 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1905 BFD_ASSERT (splt != NULL && sgotplt != NULL);
1906
1907 plt_base = splt->output_section->vma + splt->output_offset;
1908 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1909
1910 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
1911 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
1912
1913 /* Fill in the literal entry. This is the offset of the dynamic
1914 relocation entry. */
1915 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
1916 sgotplt->contents + lit_offset);
1917
1918 /* Fill in the entry in the procedure linkage table. */
1919 memcpy (splt->contents + code_offset,
1920 (bfd_big_endian (output_bfd)
1921 ? elf_xtensa_be_plt_entry
1922 : elf_xtensa_le_plt_entry),
1923 PLT_ENTRY_SIZE);
1924 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
1925 plt_base + code_offset + 3),
1926 splt->contents + code_offset + 4);
1927 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
1928 plt_base + code_offset + 6),
1929 splt->contents + code_offset + 7);
1930 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
1931 plt_base + code_offset + 9),
1932 splt->contents + code_offset + 10);
1933
1934 return plt_base + code_offset;
1935 }
1936
1937
1938 /* Relocate an Xtensa ELF section. This is invoked by the linker for
1939 both relocatable and final links. */
1940
1941 static bfd_boolean
1942 elf_xtensa_relocate_section (bfd *output_bfd,
1943 struct bfd_link_info *info,
1944 bfd *input_bfd,
1945 asection *input_section,
1946 bfd_byte *contents,
1947 Elf_Internal_Rela *relocs,
1948 Elf_Internal_Sym *local_syms,
1949 asection **local_sections)
1950 {
1951 Elf_Internal_Shdr *symtab_hdr;
1952 Elf_Internal_Rela *rel;
1953 Elf_Internal_Rela *relend;
1954 struct elf_link_hash_entry **sym_hashes;
1955 asection *srelgot, *srelplt;
1956 bfd *dynobj;
1957 property_table_entry *lit_table = 0;
1958 int ltblsize = 0;
1959 char *error_message = NULL;
1960 bfd_size_type input_size;
1961
1962 if (!xtensa_default_isa)
1963 xtensa_default_isa = xtensa_isa_init (0, 0);
1964
1965 dynobj = elf_hash_table (info)->dynobj;
1966 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1967 sym_hashes = elf_sym_hashes (input_bfd);
1968
1969 srelgot = NULL;
1970 srelplt = NULL;
1971 if (dynobj)
1972 {
1973 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
1974 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1975 }
1976
1977 if (elf_hash_table (info)->dynamic_sections_created)
1978 {
1979 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
1980 &lit_table, XTENSA_LIT_SEC_NAME,
1981 TRUE);
1982 if (ltblsize < 0)
1983 return FALSE;
1984 }
1985
1986 input_size = bfd_get_section_limit (input_bfd, input_section);
1987
1988 rel = relocs;
1989 relend = relocs + input_section->reloc_count;
1990 for (; rel < relend; rel++)
1991 {
1992 int r_type;
1993 reloc_howto_type *howto;
1994 unsigned long r_symndx;
1995 struct elf_link_hash_entry *h;
1996 Elf_Internal_Sym *sym;
1997 asection *sec;
1998 bfd_vma relocation;
1999 bfd_reloc_status_type r;
2000 bfd_boolean is_weak_undef;
2001 bfd_boolean unresolved_reloc;
2002 bfd_boolean warned;
2003
2004 r_type = ELF32_R_TYPE (rel->r_info);
2005 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
2006 || r_type == (int) R_XTENSA_GNU_VTENTRY)
2007 continue;
2008
2009 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
2010 {
2011 bfd_set_error (bfd_error_bad_value);
2012 return FALSE;
2013 }
2014 howto = &elf_howto_table[r_type];
2015
2016 r_symndx = ELF32_R_SYM (rel->r_info);
2017
2018 if (info->relocatable)
2019 {
2020 /* This is a relocatable link.
2021 1) If the reloc is against a section symbol, adjust
2022 according to the output section.
2023 2) If there is a new target for this relocation,
2024 the new target will be in the same output section.
2025 We adjust the relocation by the output section
2026 difference. */
2027
2028 if (relaxing_section)
2029 {
2030 /* Check if this references a section in another input file. */
2031 if (!do_fix_for_relocatable_link (rel, input_bfd, input_section,
2032 contents))
2033 return FALSE;
2034 r_type = ELF32_R_TYPE (rel->r_info);
2035 }
2036
2037 if (r_type == R_XTENSA_ASM_SIMPLIFY)
2038 {
2039 char *error_message = NULL;
2040 /* Convert ASM_SIMPLIFY into the simpler relocation
2041 so that they never escape a relaxing link. */
2042 r = contract_asm_expansion (contents, input_size, rel,
2043 &error_message);
2044 if (r != bfd_reloc_ok)
2045 {
2046 if (!((*info->callbacks->reloc_dangerous)
2047 (info, error_message, input_bfd, input_section,
2048 rel->r_offset)))
2049 return FALSE;
2050 }
2051 r_type = ELF32_R_TYPE (rel->r_info);
2052 }
2053
2054 /* This is a relocatable link, so we don't have to change
2055 anything unless the reloc is against a section symbol,
2056 in which case we have to adjust according to where the
2057 section symbol winds up in the output section. */
2058 if (r_symndx < symtab_hdr->sh_info)
2059 {
2060 sym = local_syms + r_symndx;
2061 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2062 {
2063 sec = local_sections[r_symndx];
2064 rel->r_addend += sec->output_offset + sym->st_value;
2065 }
2066 }
2067
2068 /* If there is an addend with a partial_inplace howto,
2069 then move the addend to the contents. This is a hack
2070 to work around problems with DWARF in relocatable links
2071 with some previous version of BFD. Now we can't easily get
2072 rid of the hack without breaking backward compatibility.... */
2073 if (rel->r_addend)
2074 {
2075 howto = &elf_howto_table[r_type];
2076 if (howto->partial_inplace)
2077 {
2078 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2079 rel->r_addend, contents,
2080 rel->r_offset, FALSE,
2081 &error_message);
2082 if (r != bfd_reloc_ok)
2083 {
2084 if (!((*info->callbacks->reloc_dangerous)
2085 (info, error_message, input_bfd, input_section,
2086 rel->r_offset)))
2087 return FALSE;
2088 }
2089 rel->r_addend = 0;
2090 }
2091 }
2092
2093 /* Done with work for relocatable link; continue with next reloc. */
2094 continue;
2095 }
2096
2097 /* This is a final link. */
2098
2099 h = NULL;
2100 sym = NULL;
2101 sec = NULL;
2102 is_weak_undef = FALSE;
2103 unresolved_reloc = FALSE;
2104 warned = FALSE;
2105
2106 if (howto->partial_inplace)
2107 {
2108 /* Because R_XTENSA_32 was made partial_inplace to fix some
2109 problems with DWARF info in partial links, there may be
2110 an addend stored in the contents. Take it out of there
2111 and move it back into the addend field of the reloc. */
2112 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
2113 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
2114 }
2115
2116 if (r_symndx < symtab_hdr->sh_info)
2117 {
2118 sym = local_syms + r_symndx;
2119 sec = local_sections[r_symndx];
2120 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2121 }
2122 else
2123 {
2124 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2125 r_symndx, symtab_hdr, sym_hashes,
2126 h, sec, relocation,
2127 unresolved_reloc, warned);
2128
2129 if (relocation == 0
2130 && !unresolved_reloc
2131 && h->root.type == bfd_link_hash_undefweak)
2132 is_weak_undef = TRUE;
2133 }
2134
2135 if (relaxing_section)
2136 {
2137 /* Check if this references a section in another input file. */
2138 do_fix_for_final_link (rel, input_bfd, input_section, contents,
2139 &relocation);
2140
2141 /* Update some already cached values. */
2142 r_type = ELF32_R_TYPE (rel->r_info);
2143 howto = &elf_howto_table[r_type];
2144 }
2145
2146 /* Sanity check the address. */
2147 if (rel->r_offset >= input_size
2148 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
2149 {
2150 (*_bfd_error_handler)
2151 (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"),
2152 input_bfd, input_section, rel->r_offset, input_size);
2153 bfd_set_error (bfd_error_bad_value);
2154 return FALSE;
2155 }
2156
2157 /* Generate dynamic relocations. */
2158 if (elf_hash_table (info)->dynamic_sections_created)
2159 {
2160 bfd_boolean dynamic_symbol = xtensa_elf_dynamic_symbol_p (h, info);
2161
2162 if (dynamic_symbol && is_operand_relocation (r_type))
2163 {
2164 /* This is an error. The symbol's real value won't be known
2165 until runtime and it's likely to be out of range anyway. */
2166 const char *name = h->root.root.string;
2167 error_message = vsprint_msg ("invalid relocation for dynamic "
2168 "symbol", ": %s",
2169 strlen (name) + 2, name);
2170 if (!((*info->callbacks->reloc_dangerous)
2171 (info, error_message, input_bfd, input_section,
2172 rel->r_offset)))
2173 return FALSE;
2174 }
2175 else if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
2176 && (input_section->flags & SEC_ALLOC) != 0
2177 && (dynamic_symbol || info->shared))
2178 {
2179 Elf_Internal_Rela outrel;
2180 bfd_byte *loc;
2181 asection *srel;
2182
2183 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2184 srel = srelplt;
2185 else
2186 srel = srelgot;
2187
2188 BFD_ASSERT (srel != NULL);
2189
2190 outrel.r_offset =
2191 _bfd_elf_section_offset (output_bfd, info,
2192 input_section, rel->r_offset);
2193
2194 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2195 memset (&outrel, 0, sizeof outrel);
2196 else
2197 {
2198 outrel.r_offset += (input_section->output_section->vma
2199 + input_section->output_offset);
2200
2201 /* Complain if the relocation is in a read-only section
2202 and not in a literal pool. */
2203 if ((input_section->flags & SEC_READONLY) != 0
2204 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
2205 outrel.r_offset))
2206 {
2207 error_message =
2208 _("dynamic relocation in read-only section");
2209 if (!((*info->callbacks->reloc_dangerous)
2210 (info, error_message, input_bfd, input_section,
2211 rel->r_offset)))
2212 return FALSE;
2213 }
2214
2215 if (dynamic_symbol)
2216 {
2217 outrel.r_addend = rel->r_addend;
2218 rel->r_addend = 0;
2219
2220 if (r_type == R_XTENSA_32)
2221 {
2222 outrel.r_info =
2223 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2224 relocation = 0;
2225 }
2226 else /* r_type == R_XTENSA_PLT */
2227 {
2228 outrel.r_info =
2229 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2230
2231 /* Create the PLT entry and set the initial
2232 contents of the literal entry to the address of
2233 the PLT entry. */
2234 relocation =
2235 elf_xtensa_create_plt_entry (dynobj, output_bfd,
2236 srel->reloc_count);
2237 }
2238 unresolved_reloc = FALSE;
2239 }
2240 else
2241 {
2242 /* Generate a RELATIVE relocation. */
2243 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2244 outrel.r_addend = 0;
2245 }
2246 }
2247
2248 loc = (srel->contents
2249 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2250 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2251 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2252 <= srel->size);
2253 }
2254 }
2255
2256 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2257 because such sections are not SEC_ALLOC and thus ld.so will
2258 not process them. */
2259 if (unresolved_reloc
2260 && !((input_section->flags & SEC_DEBUGGING) != 0
2261 && h->def_dynamic))
2262 {
2263 (*_bfd_error_handler)
2264 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2265 input_bfd,
2266 input_section,
2267 (long) rel->r_offset,
2268 howto->name,
2269 h->root.root.string);
2270 return FALSE;
2271 }
2272
2273 if (r_symndx == 0)
2274 {
2275 /* r_symndx will be zero only for relocs against symbols from
2276 removed linkonce sections, or sections discarded by a linker
2277 script. For these relocs, we just want the section contents
2278 zeroed. Avoid any special processing. */
2279 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2280 continue;
2281 }
2282
2283 /* There's no point in calling bfd_perform_relocation here.
2284 Just go directly to our "special function". */
2285 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2286 relocation + rel->r_addend,
2287 contents, rel->r_offset, is_weak_undef,
2288 &error_message);
2289
2290 if (r != bfd_reloc_ok && !warned)
2291 {
2292 const char *name;
2293
2294 BFD_ASSERT (r == bfd_reloc_dangerous || r == bfd_reloc_other);
2295 BFD_ASSERT (error_message != NULL);
2296
2297 if (h)
2298 name = h->root.root.string;
2299 else
2300 {
2301 name = bfd_elf_string_from_elf_section
2302 (input_bfd, symtab_hdr->sh_link, sym->st_name);
2303 if (name && *name == '\0')
2304 name = bfd_section_name (input_bfd, sec);
2305 }
2306 if (name)
2307 {
2308 if (rel->r_addend == 0)
2309 error_message = vsprint_msg (error_message, ": %s",
2310 strlen (name) + 2, name);
2311 else
2312 error_message = vsprint_msg (error_message, ": (%s+0x%x)",
2313 strlen (name) + 22,
2314 name, (int)rel->r_addend);
2315 }
2316
2317 if (!((*info->callbacks->reloc_dangerous)
2318 (info, error_message, input_bfd, input_section,
2319 rel->r_offset)))
2320 return FALSE;
2321 }
2322 }
2323
2324 if (lit_table)
2325 free (lit_table);
2326
2327 input_section->reloc_done = TRUE;
2328
2329 return TRUE;
2330 }
2331
2332
2333 /* Finish up dynamic symbol handling. There's not much to do here since
2334 the PLT and GOT entries are all set up by relocate_section. */
2335
2336 static bfd_boolean
2337 elf_xtensa_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
2338 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2339 struct elf_link_hash_entry *h,
2340 Elf_Internal_Sym *sym)
2341 {
2342 if (h->needs_plt && !h->def_regular)
2343 {
2344 /* Mark the symbol as undefined, rather than as defined in
2345 the .plt section. Leave the value alone. */
2346 sym->st_shndx = SHN_UNDEF;
2347 /* If the symbol is weak, we do need to clear the value.
2348 Otherwise, the PLT entry would provide a definition for
2349 the symbol even if the symbol wasn't defined anywhere,
2350 and so the symbol would never be NULL. */
2351 if (!h->ref_regular_nonweak)
2352 sym->st_value = 0;
2353 }
2354
2355 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2356 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2357 || h == elf_hash_table (info)->hgot)
2358 sym->st_shndx = SHN_ABS;
2359
2360 return TRUE;
2361 }
2362
2363
2364 /* Combine adjacent literal table entries in the output. Adjacent
2365 entries within each input section may have been removed during
2366 relaxation, but we repeat the process here, even though it's too late
2367 to shrink the output section, because it's important to minimize the
2368 number of literal table entries to reduce the start-up work for the
2369 runtime linker. Returns the number of remaining table entries or -1
2370 on error. */
2371
2372 static int
2373 elf_xtensa_combine_prop_entries (bfd *output_bfd,
2374 asection *sxtlit,
2375 asection *sgotloc)
2376 {
2377 bfd_byte *contents;
2378 property_table_entry *table;
2379 bfd_size_type section_size, sgotloc_size;
2380 bfd_vma offset;
2381 int n, m, num;
2382
2383 section_size = sxtlit->size;
2384 BFD_ASSERT (section_size % 8 == 0);
2385 num = section_size / 8;
2386
2387 sgotloc_size = sgotloc->size;
2388 if (sgotloc_size != section_size)
2389 {
2390 (*_bfd_error_handler)
2391 (_("internal inconsistency in size of .got.loc section"));
2392 return -1;
2393 }
2394
2395 table = bfd_malloc (num * sizeof (property_table_entry));
2396 if (table == 0)
2397 return -1;
2398
2399 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
2400 propagates to the output section, where it doesn't really apply and
2401 where it breaks the following call to bfd_malloc_and_get_section. */
2402 sxtlit->flags &= ~SEC_IN_MEMORY;
2403
2404 if (!bfd_malloc_and_get_section (output_bfd, sxtlit, &contents))
2405 {
2406 if (contents != 0)
2407 free (contents);
2408 free (table);
2409 return -1;
2410 }
2411
2412 /* There should never be any relocations left at this point, so this
2413 is quite a bit easier than what is done during relaxation. */
2414
2415 /* Copy the raw contents into a property table array and sort it. */
2416 offset = 0;
2417 for (n = 0; n < num; n++)
2418 {
2419 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
2420 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
2421 offset += 8;
2422 }
2423 qsort (table, num, sizeof (property_table_entry), property_table_compare);
2424
2425 for (n = 0; n < num; n++)
2426 {
2427 bfd_boolean remove = FALSE;
2428
2429 if (table[n].size == 0)
2430 remove = TRUE;
2431 else if (n > 0 &&
2432 (table[n-1].address + table[n-1].size == table[n].address))
2433 {
2434 table[n-1].size += table[n].size;
2435 remove = TRUE;
2436 }
2437
2438 if (remove)
2439 {
2440 for (m = n; m < num - 1; m++)
2441 {
2442 table[m].address = table[m+1].address;
2443 table[m].size = table[m+1].size;
2444 }
2445
2446 n--;
2447 num--;
2448 }
2449 }
2450
2451 /* Copy the data back to the raw contents. */
2452 offset = 0;
2453 for (n = 0; n < num; n++)
2454 {
2455 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
2456 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
2457 offset += 8;
2458 }
2459
2460 /* Clear the removed bytes. */
2461 if ((bfd_size_type) (num * 8) < section_size)
2462 memset (&contents[num * 8], 0, section_size - num * 8);
2463
2464 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
2465 section_size))
2466 return -1;
2467
2468 /* Copy the contents to ".got.loc". */
2469 memcpy (sgotloc->contents, contents, section_size);
2470
2471 free (contents);
2472 free (table);
2473 return num;
2474 }
2475
2476
2477 /* Finish up the dynamic sections. */
2478
2479 static bfd_boolean
2480 elf_xtensa_finish_dynamic_sections (bfd *output_bfd,
2481 struct bfd_link_info *info)
2482 {
2483 bfd *dynobj;
2484 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
2485 Elf32_External_Dyn *dyncon, *dynconend;
2486 int num_xtlit_entries;
2487
2488 if (! elf_hash_table (info)->dynamic_sections_created)
2489 return TRUE;
2490
2491 dynobj = elf_hash_table (info)->dynobj;
2492 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2493 BFD_ASSERT (sdyn != NULL);
2494
2495 /* Set the first entry in the global offset table to the address of
2496 the dynamic section. */
2497 sgot = bfd_get_section_by_name (dynobj, ".got");
2498 if (sgot)
2499 {
2500 BFD_ASSERT (sgot->size == 4);
2501 if (sdyn == NULL)
2502 bfd_put_32 (output_bfd, 0, sgot->contents);
2503 else
2504 bfd_put_32 (output_bfd,
2505 sdyn->output_section->vma + sdyn->output_offset,
2506 sgot->contents);
2507 }
2508
2509 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
2510 if (srelplt && srelplt->size != 0)
2511 {
2512 asection *sgotplt, *srelgot, *spltlittbl;
2513 int chunk, plt_chunks, plt_entries;
2514 Elf_Internal_Rela irela;
2515 bfd_byte *loc;
2516 unsigned rtld_reloc;
2517
2518 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
2519 BFD_ASSERT (srelgot != NULL);
2520
2521 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
2522 BFD_ASSERT (spltlittbl != NULL);
2523
2524 /* Find the first XTENSA_RTLD relocation. Presumably the rest
2525 of them follow immediately after.... */
2526 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
2527 {
2528 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2529 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2530 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
2531 break;
2532 }
2533 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
2534
2535 plt_entries = srelplt->size / sizeof (Elf32_External_Rela);
2536 plt_chunks =
2537 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
2538
2539 for (chunk = 0; chunk < plt_chunks; chunk++)
2540 {
2541 int chunk_entries = 0;
2542
2543 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
2544 BFD_ASSERT (sgotplt != NULL);
2545
2546 /* Emit special RTLD relocations for the first two entries in
2547 each chunk of the .got.plt section. */
2548
2549 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2550 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2551 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2552 irela.r_offset = (sgotplt->output_section->vma
2553 + sgotplt->output_offset);
2554 irela.r_addend = 1; /* tell rtld to set value to resolver function */
2555 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2556 rtld_reloc += 1;
2557 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2558
2559 /* Next literal immediately follows the first. */
2560 loc += sizeof (Elf32_External_Rela);
2561 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2562 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2563 irela.r_offset = (sgotplt->output_section->vma
2564 + sgotplt->output_offset + 4);
2565 /* Tell rtld to set value to object's link map. */
2566 irela.r_addend = 2;
2567 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2568 rtld_reloc += 1;
2569 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2570
2571 /* Fill in the literal table. */
2572 if (chunk < plt_chunks - 1)
2573 chunk_entries = PLT_ENTRIES_PER_CHUNK;
2574 else
2575 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
2576
2577 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->size);
2578 bfd_put_32 (output_bfd,
2579 sgotplt->output_section->vma + sgotplt->output_offset,
2580 spltlittbl->contents + (chunk * 8) + 0);
2581 bfd_put_32 (output_bfd,
2582 8 + (chunk_entries * 4),
2583 spltlittbl->contents + (chunk * 8) + 4);
2584 }
2585
2586 /* All the dynamic relocations have been emitted at this point.
2587 Make sure the relocation sections are the correct size. */
2588 if (srelgot->size != (sizeof (Elf32_External_Rela)
2589 * srelgot->reloc_count)
2590 || srelplt->size != (sizeof (Elf32_External_Rela)
2591 * srelplt->reloc_count))
2592 abort ();
2593
2594 /* The .xt.lit.plt section has just been modified. This must
2595 happen before the code below which combines adjacent literal
2596 table entries, and the .xt.lit.plt contents have to be forced to
2597 the output here. */
2598 if (! bfd_set_section_contents (output_bfd,
2599 spltlittbl->output_section,
2600 spltlittbl->contents,
2601 spltlittbl->output_offset,
2602 spltlittbl->size))
2603 return FALSE;
2604 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
2605 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
2606 }
2607
2608 /* Combine adjacent literal table entries. */
2609 BFD_ASSERT (! info->relocatable);
2610 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
2611 sgotloc = bfd_get_section_by_name (dynobj, ".got.loc");
2612 BFD_ASSERT (sxtlit && sgotloc);
2613 num_xtlit_entries =
2614 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
2615 if (num_xtlit_entries < 0)
2616 return FALSE;
2617
2618 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2619 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2620 for (; dyncon < dynconend; dyncon++)
2621 {
2622 Elf_Internal_Dyn dyn;
2623 const char *name;
2624 asection *s;
2625
2626 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2627
2628 switch (dyn.d_tag)
2629 {
2630 default:
2631 break;
2632
2633 case DT_XTENSA_GOT_LOC_SZ:
2634 dyn.d_un.d_val = num_xtlit_entries;
2635 break;
2636
2637 case DT_XTENSA_GOT_LOC_OFF:
2638 name = ".got.loc";
2639 goto get_vma;
2640 case DT_PLTGOT:
2641 name = ".got";
2642 goto get_vma;
2643 case DT_JMPREL:
2644 name = ".rela.plt";
2645 get_vma:
2646 s = bfd_get_section_by_name (output_bfd, name);
2647 BFD_ASSERT (s);
2648 dyn.d_un.d_ptr = s->vma;
2649 break;
2650
2651 case DT_PLTRELSZ:
2652 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2653 BFD_ASSERT (s);
2654 dyn.d_un.d_val = s->size;
2655 break;
2656
2657 case DT_RELASZ:
2658 /* Adjust RELASZ to not include JMPREL. This matches what
2659 glibc expects and what is done for several other ELF
2660 targets (e.g., i386, alpha), but the "correct" behavior
2661 seems to be unresolved. Since the linker script arranges
2662 for .rela.plt to follow all other relocation sections, we
2663 don't have to worry about changing the DT_RELA entry. */
2664 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2665 if (s)
2666 dyn.d_un.d_val -= s->size;
2667 break;
2668 }
2669
2670 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2671 }
2672
2673 return TRUE;
2674 }
2675
2676 \f
2677 /* Functions for dealing with the e_flags field. */
2678
2679 /* Merge backend specific data from an object file to the output
2680 object file when linking. */
2681
2682 static bfd_boolean
2683 elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2684 {
2685 unsigned out_mach, in_mach;
2686 flagword out_flag, in_flag;
2687
2688 /* Check if we have the same endianess. */
2689 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
2690 return FALSE;
2691
2692 /* Don't even pretend to support mixed-format linking. */
2693 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2694 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2695 return FALSE;
2696
2697 out_flag = elf_elfheader (obfd)->e_flags;
2698 in_flag = elf_elfheader (ibfd)->e_flags;
2699
2700 out_mach = out_flag & EF_XTENSA_MACH;
2701 in_mach = in_flag & EF_XTENSA_MACH;
2702 if (out_mach != in_mach)
2703 {
2704 (*_bfd_error_handler)
2705 (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"),
2706 ibfd, out_mach, in_mach);
2707 bfd_set_error (bfd_error_wrong_format);
2708 return FALSE;
2709 }
2710
2711 if (! elf_flags_init (obfd))
2712 {
2713 elf_flags_init (obfd) = TRUE;
2714 elf_elfheader (obfd)->e_flags = in_flag;
2715
2716 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2717 && bfd_get_arch_info (obfd)->the_default)
2718 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2719 bfd_get_mach (ibfd));
2720
2721 return TRUE;
2722 }
2723
2724 if ((out_flag & EF_XTENSA_XT_INSN) != (in_flag & EF_XTENSA_XT_INSN))
2725 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
2726
2727 if ((out_flag & EF_XTENSA_XT_LIT) != (in_flag & EF_XTENSA_XT_LIT))
2728 elf_elfheader (obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
2729
2730 return TRUE;
2731 }
2732
2733
2734 static bfd_boolean
2735 elf_xtensa_set_private_flags (bfd *abfd, flagword flags)
2736 {
2737 BFD_ASSERT (!elf_flags_init (abfd)
2738 || elf_elfheader (abfd)->e_flags == flags);
2739
2740 elf_elfheader (abfd)->e_flags |= flags;
2741 elf_flags_init (abfd) = TRUE;
2742
2743 return TRUE;
2744 }
2745
2746
2747 static bfd_boolean
2748 elf_xtensa_print_private_bfd_data (bfd *abfd, void *farg)
2749 {
2750 FILE *f = (FILE *) farg;
2751 flagword e_flags = elf_elfheader (abfd)->e_flags;
2752
2753 fprintf (f, "\nXtensa header:\n");
2754 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
2755 fprintf (f, "\nMachine = Base\n");
2756 else
2757 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
2758
2759 fprintf (f, "Insn tables = %s\n",
2760 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
2761
2762 fprintf (f, "Literal tables = %s\n",
2763 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
2764
2765 return _bfd_elf_print_private_bfd_data (abfd, farg);
2766 }
2767
2768
2769 /* Set the right machine number for an Xtensa ELF file. */
2770
2771 static bfd_boolean
2772 elf_xtensa_object_p (bfd *abfd)
2773 {
2774 int mach;
2775 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
2776
2777 switch (arch)
2778 {
2779 case E_XTENSA_MACH:
2780 mach = bfd_mach_xtensa;
2781 break;
2782 default:
2783 return FALSE;
2784 }
2785
2786 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
2787 return TRUE;
2788 }
2789
2790
2791 /* The final processing done just before writing out an Xtensa ELF object
2792 file. This gets the Xtensa architecture right based on the machine
2793 number. */
2794
2795 static void
2796 elf_xtensa_final_write_processing (bfd *abfd,
2797 bfd_boolean linker ATTRIBUTE_UNUSED)
2798 {
2799 int mach;
2800 unsigned long val;
2801
2802 switch (mach = bfd_get_mach (abfd))
2803 {
2804 case bfd_mach_xtensa:
2805 val = E_XTENSA_MACH;
2806 break;
2807 default:
2808 return;
2809 }
2810
2811 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
2812 elf_elfheader (abfd)->e_flags |= val;
2813 }
2814
2815
2816 static enum elf_reloc_type_class
2817 elf_xtensa_reloc_type_class (const Elf_Internal_Rela *rela)
2818 {
2819 switch ((int) ELF32_R_TYPE (rela->r_info))
2820 {
2821 case R_XTENSA_RELATIVE:
2822 return reloc_class_relative;
2823 case R_XTENSA_JMP_SLOT:
2824 return reloc_class_plt;
2825 default:
2826 return reloc_class_normal;
2827 }
2828 }
2829
2830 \f
2831 static bfd_boolean
2832 elf_xtensa_discard_info_for_section (bfd *abfd,
2833 struct elf_reloc_cookie *cookie,
2834 struct bfd_link_info *info,
2835 asection *sec)
2836 {
2837 bfd_byte *contents;
2838 bfd_vma section_size;
2839 bfd_vma offset, actual_offset;
2840 size_t removed_bytes = 0;
2841
2842 section_size = sec->size;
2843 if (section_size == 0 || section_size % 8 != 0)
2844 return FALSE;
2845
2846 if (sec->output_section
2847 && bfd_is_abs_section (sec->output_section))
2848 return FALSE;
2849
2850 contents = retrieve_contents (abfd, sec, info->keep_memory);
2851 if (!contents)
2852 return FALSE;
2853
2854 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
2855 if (!cookie->rels)
2856 {
2857 release_contents (sec, contents);
2858 return FALSE;
2859 }
2860
2861 cookie->rel = cookie->rels;
2862 cookie->relend = cookie->rels + sec->reloc_count;
2863
2864 for (offset = 0; offset < section_size; offset += 8)
2865 {
2866 actual_offset = offset - removed_bytes;
2867
2868 /* The ...symbol_deleted_p function will skip over relocs but it
2869 won't adjust their offsets, so do that here. */
2870 while (cookie->rel < cookie->relend
2871 && cookie->rel->r_offset < offset)
2872 {
2873 cookie->rel->r_offset -= removed_bytes;
2874 cookie->rel++;
2875 }
2876
2877 while (cookie->rel < cookie->relend
2878 && cookie->rel->r_offset == offset)
2879 {
2880 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
2881 {
2882 /* Remove the table entry. (If the reloc type is NONE, then
2883 the entry has already been merged with another and deleted
2884 during relaxation.) */
2885 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
2886 {
2887 /* Shift the contents up. */
2888 if (offset + 8 < section_size)
2889 memmove (&contents[actual_offset],
2890 &contents[actual_offset+8],
2891 section_size - offset - 8);
2892 removed_bytes += 8;
2893 }
2894
2895 /* Remove this relocation. */
2896 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
2897 }
2898
2899 /* Adjust the relocation offset for previous removals. This
2900 should not be done before calling ...symbol_deleted_p
2901 because it might mess up the offset comparisons there.
2902 Make sure the offset doesn't underflow in the case where
2903 the first entry is removed. */
2904 if (cookie->rel->r_offset >= removed_bytes)
2905 cookie->rel->r_offset -= removed_bytes;
2906 else
2907 cookie->rel->r_offset = 0;
2908
2909 cookie->rel++;
2910 }
2911 }
2912
2913 if (removed_bytes != 0)
2914 {
2915 /* Adjust any remaining relocs (shouldn't be any). */
2916 for (; cookie->rel < cookie->relend; cookie->rel++)
2917 {
2918 if (cookie->rel->r_offset >= removed_bytes)
2919 cookie->rel->r_offset -= removed_bytes;
2920 else
2921 cookie->rel->r_offset = 0;
2922 }
2923
2924 /* Clear the removed bytes. */
2925 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
2926
2927 pin_contents (sec, contents);
2928 pin_internal_relocs (sec, cookie->rels);
2929
2930 /* Shrink size. */
2931 sec->size = section_size - removed_bytes;
2932
2933 if (xtensa_is_littable_section (sec))
2934 {
2935 bfd *dynobj = elf_hash_table (info)->dynobj;
2936 if (dynobj)
2937 {
2938 asection *sgotloc =
2939 bfd_get_section_by_name (dynobj, ".got.loc");
2940 if (sgotloc)
2941 sgotloc->size -= removed_bytes;
2942 }
2943 }
2944 }
2945 else
2946 {
2947 release_contents (sec, contents);
2948 release_internal_relocs (sec, cookie->rels);
2949 }
2950
2951 return (removed_bytes != 0);
2952 }
2953
2954
2955 static bfd_boolean
2956 elf_xtensa_discard_info (bfd *abfd,
2957 struct elf_reloc_cookie *cookie,
2958 struct bfd_link_info *info)
2959 {
2960 asection *sec;
2961 bfd_boolean changed = FALSE;
2962
2963 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2964 {
2965 if (xtensa_is_property_section (sec))
2966 {
2967 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
2968 changed = TRUE;
2969 }
2970 }
2971
2972 return changed;
2973 }
2974
2975
2976 static bfd_boolean
2977 elf_xtensa_ignore_discarded_relocs (asection *sec)
2978 {
2979 return xtensa_is_property_section (sec);
2980 }
2981
2982
2983 static unsigned int
2984 elf_xtensa_action_discarded (asection *sec)
2985 {
2986 if (strcmp (".xt_except_table", sec->name) == 0)
2987 return 0;
2988
2989 if (strcmp (".xt_except_desc", sec->name) == 0)
2990 return 0;
2991
2992 return _bfd_elf_default_action_discarded (sec);
2993 }
2994
2995 \f
2996 /* Support for core dump NOTE sections. */
2997
2998 static bfd_boolean
2999 elf_xtensa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3000 {
3001 int offset;
3002 unsigned int size;
3003
3004 /* The size for Xtensa is variable, so don't try to recognize the format
3005 based on the size. Just assume this is GNU/Linux. */
3006
3007 /* pr_cursig */
3008 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3009
3010 /* pr_pid */
3011 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
3012
3013 /* pr_reg */
3014 offset = 72;
3015 size = note->descsz - offset - 4;
3016
3017 /* Make a ".reg/999" section. */
3018 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3019 size, note->descpos + offset);
3020 }
3021
3022
3023 static bfd_boolean
3024 elf_xtensa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3025 {
3026 switch (note->descsz)
3027 {
3028 default:
3029 return FALSE;
3030
3031 case 128: /* GNU/Linux elf_prpsinfo */
3032 elf_tdata (abfd)->core_program
3033 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
3034 elf_tdata (abfd)->core_command
3035 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
3036 }
3037
3038 /* Note that for some reason, a spurious space is tacked
3039 onto the end of the args in some (at least one anyway)
3040 implementations, so strip it off if it exists. */
3041
3042 {
3043 char *command = elf_tdata (abfd)->core_command;
3044 int n = strlen (command);
3045
3046 if (0 < n && command[n - 1] == ' ')
3047 command[n - 1] = '\0';
3048 }
3049
3050 return TRUE;
3051 }
3052
3053 \f
3054 /* Generic Xtensa configurability stuff. */
3055
3056 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
3057 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
3058 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
3059 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
3060 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
3061 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
3062 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
3063 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
3064
3065 static void
3066 init_call_opcodes (void)
3067 {
3068 if (callx0_op == XTENSA_UNDEFINED)
3069 {
3070 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
3071 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
3072 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
3073 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
3074 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
3075 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
3076 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
3077 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
3078 }
3079 }
3080
3081
3082 static bfd_boolean
3083 is_indirect_call_opcode (xtensa_opcode opcode)
3084 {
3085 init_call_opcodes ();
3086 return (opcode == callx0_op
3087 || opcode == callx4_op
3088 || opcode == callx8_op
3089 || opcode == callx12_op);
3090 }
3091
3092
3093 static bfd_boolean
3094 is_direct_call_opcode (xtensa_opcode opcode)
3095 {
3096 init_call_opcodes ();
3097 return (opcode == call0_op
3098 || opcode == call4_op
3099 || opcode == call8_op
3100 || opcode == call12_op);
3101 }
3102
3103
3104 static bfd_boolean
3105 is_windowed_call_opcode (xtensa_opcode opcode)
3106 {
3107 init_call_opcodes ();
3108 return (opcode == call4_op
3109 || opcode == call8_op
3110 || opcode == call12_op
3111 || opcode == callx4_op
3112 || opcode == callx8_op
3113 || opcode == callx12_op);
3114 }
3115
3116
3117 static xtensa_opcode
3118 get_const16_opcode (void)
3119 {
3120 static bfd_boolean done_lookup = FALSE;
3121 static xtensa_opcode const16_opcode = XTENSA_UNDEFINED;
3122 if (!done_lookup)
3123 {
3124 const16_opcode = xtensa_opcode_lookup (xtensa_default_isa, "const16");
3125 done_lookup = TRUE;
3126 }
3127 return const16_opcode;
3128 }
3129
3130
3131 static xtensa_opcode
3132 get_l32r_opcode (void)
3133 {
3134 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
3135 static bfd_boolean done_lookup = FALSE;
3136
3137 if (!done_lookup)
3138 {
3139 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
3140 done_lookup = TRUE;
3141 }
3142 return l32r_opcode;
3143 }
3144
3145
3146 static bfd_vma
3147 l32r_offset (bfd_vma addr, bfd_vma pc)
3148 {
3149 bfd_vma offset;
3150
3151 offset = addr - ((pc+3) & -4);
3152 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
3153 offset = (signed int) offset >> 2;
3154 BFD_ASSERT ((signed int) offset >> 16 == -1);
3155 return offset;
3156 }
3157
3158
3159 static int
3160 get_relocation_opnd (xtensa_opcode opcode, int r_type)
3161 {
3162 xtensa_isa isa = xtensa_default_isa;
3163 int last_immed, last_opnd, opi;
3164
3165 if (opcode == XTENSA_UNDEFINED)
3166 return XTENSA_UNDEFINED;
3167
3168 /* Find the last visible PC-relative immediate operand for the opcode.
3169 If there are no PC-relative immediates, then choose the last visible
3170 immediate; otherwise, fail and return XTENSA_UNDEFINED. */
3171 last_immed = XTENSA_UNDEFINED;
3172 last_opnd = xtensa_opcode_num_operands (isa, opcode);
3173 for (opi = last_opnd - 1; opi >= 0; opi--)
3174 {
3175 if (xtensa_operand_is_visible (isa, opcode, opi) == 0)
3176 continue;
3177 if (xtensa_operand_is_PCrelative (isa, opcode, opi) == 1)
3178 {
3179 last_immed = opi;
3180 break;
3181 }
3182 if (last_immed == XTENSA_UNDEFINED
3183 && xtensa_operand_is_register (isa, opcode, opi) == 0)
3184 last_immed = opi;
3185 }
3186 if (last_immed < 0)
3187 return XTENSA_UNDEFINED;
3188
3189 /* If the operand number was specified in an old-style relocation,
3190 check for consistency with the operand computed above. */
3191 if (r_type >= R_XTENSA_OP0 && r_type <= R_XTENSA_OP2)
3192 {
3193 int reloc_opnd = r_type - R_XTENSA_OP0;
3194 if (reloc_opnd != last_immed)
3195 return XTENSA_UNDEFINED;
3196 }
3197
3198 return last_immed;
3199 }
3200
3201
3202 int
3203 get_relocation_slot (int r_type)
3204 {
3205 switch (r_type)
3206 {
3207 case R_XTENSA_OP0:
3208 case R_XTENSA_OP1:
3209 case R_XTENSA_OP2:
3210 return 0;
3211
3212 default:
3213 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
3214 return r_type - R_XTENSA_SLOT0_OP;
3215 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
3216 return r_type - R_XTENSA_SLOT0_ALT;
3217 break;
3218 }
3219
3220 return XTENSA_UNDEFINED;
3221 }
3222
3223
3224 /* Get the opcode for a relocation. */
3225
3226 static xtensa_opcode
3227 get_relocation_opcode (bfd *abfd,
3228 asection *sec,
3229 bfd_byte *contents,
3230 Elf_Internal_Rela *irel)
3231 {
3232 static xtensa_insnbuf ibuff = NULL;
3233 static xtensa_insnbuf sbuff = NULL;
3234 xtensa_isa isa = xtensa_default_isa;
3235 xtensa_format fmt;
3236 int slot;
3237
3238 if (contents == NULL)
3239 return XTENSA_UNDEFINED;
3240
3241 if (bfd_get_section_limit (abfd, sec) <= irel->r_offset)
3242 return XTENSA_UNDEFINED;
3243
3244 if (ibuff == NULL)
3245 {
3246 ibuff = xtensa_insnbuf_alloc (isa);
3247 sbuff = xtensa_insnbuf_alloc (isa);
3248 }
3249
3250 /* Decode the instruction. */
3251 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset],
3252 sec->size - irel->r_offset);
3253 fmt = xtensa_format_decode (isa, ibuff);
3254 slot = get_relocation_slot (ELF32_R_TYPE (irel->r_info));
3255 if (slot == XTENSA_UNDEFINED)
3256 return XTENSA_UNDEFINED;
3257 xtensa_format_get_slot (isa, fmt, slot, ibuff, sbuff);
3258 return xtensa_opcode_decode (isa, fmt, slot, sbuff);
3259 }
3260
3261
3262 bfd_boolean
3263 is_l32r_relocation (bfd *abfd,
3264 asection *sec,
3265 bfd_byte *contents,
3266 Elf_Internal_Rela *irel)
3267 {
3268 xtensa_opcode opcode;
3269 if (!is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
3270 return FALSE;
3271 opcode = get_relocation_opcode (abfd, sec, contents, irel);
3272 return (opcode == get_l32r_opcode ());
3273 }
3274
3275
3276 static bfd_size_type
3277 get_asm_simplify_size (bfd_byte *contents,
3278 bfd_size_type content_len,
3279 bfd_size_type offset)
3280 {
3281 bfd_size_type insnlen, size = 0;
3282
3283 /* Decode the size of the next two instructions. */
3284 insnlen = insn_decode_len (contents, content_len, offset);
3285 if (insnlen == 0)
3286 return 0;
3287
3288 size += insnlen;
3289
3290 insnlen = insn_decode_len (contents, content_len, offset + size);
3291 if (insnlen == 0)
3292 return 0;
3293
3294 size += insnlen;
3295 return size;
3296 }
3297
3298
3299 bfd_boolean
3300 is_alt_relocation (int r_type)
3301 {
3302 return (r_type >= R_XTENSA_SLOT0_ALT
3303 && r_type <= R_XTENSA_SLOT14_ALT);
3304 }
3305
3306
3307 bfd_boolean
3308 is_operand_relocation (int r_type)
3309 {
3310 switch (r_type)
3311 {
3312 case R_XTENSA_OP0:
3313 case R_XTENSA_OP1:
3314 case R_XTENSA_OP2:
3315 return TRUE;
3316
3317 default:
3318 if (r_type >= R_XTENSA_SLOT0_OP && r_type <= R_XTENSA_SLOT14_OP)
3319 return TRUE;
3320 if (r_type >= R_XTENSA_SLOT0_ALT && r_type <= R_XTENSA_SLOT14_ALT)
3321 return TRUE;
3322 break;
3323 }
3324
3325 return FALSE;
3326 }
3327
3328
3329 #define MIN_INSN_LENGTH 2
3330
3331 /* Return 0 if it fails to decode. */
3332
3333 bfd_size_type
3334 insn_decode_len (bfd_byte *contents,
3335 bfd_size_type content_len,
3336 bfd_size_type offset)
3337 {
3338 int insn_len;
3339 xtensa_isa isa = xtensa_default_isa;
3340 xtensa_format fmt;
3341 static xtensa_insnbuf ibuff = NULL;
3342
3343 if (offset + MIN_INSN_LENGTH > content_len)
3344 return 0;
3345
3346 if (ibuff == NULL)
3347 ibuff = xtensa_insnbuf_alloc (isa);
3348 xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset],
3349 content_len - offset);
3350 fmt = xtensa_format_decode (isa, ibuff);
3351 if (fmt == XTENSA_UNDEFINED)
3352 return 0;
3353 insn_len = xtensa_format_length (isa, fmt);
3354 if (insn_len == XTENSA_UNDEFINED)
3355 return 0;
3356 return insn_len;
3357 }
3358
3359
3360 /* Decode the opcode for a single slot instruction.
3361 Return 0 if it fails to decode or the instruction is multi-slot. */
3362
3363 xtensa_opcode
3364 insn_decode_opcode (bfd_byte *contents,
3365 bfd_size_type content_len,
3366 bfd_size_type offset,
3367 int slot)
3368 {
3369 xtensa_isa isa = xtensa_default_isa;
3370 xtensa_format fmt;
3371 static xtensa_insnbuf insnbuf = NULL;
3372 static xtensa_insnbuf slotbuf = NULL;
3373
3374 if (offset + MIN_INSN_LENGTH > content_len)
3375 return XTENSA_UNDEFINED;
3376
3377 if (insnbuf == NULL)
3378 {
3379 insnbuf = xtensa_insnbuf_alloc (isa);
3380 slotbuf = xtensa_insnbuf_alloc (isa);
3381 }
3382
3383 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
3384 content_len - offset);
3385 fmt = xtensa_format_decode (isa, insnbuf);
3386 if (fmt == XTENSA_UNDEFINED)
3387 return XTENSA_UNDEFINED;
3388
3389 if (slot >= xtensa_format_num_slots (isa, fmt))
3390 return XTENSA_UNDEFINED;
3391
3392 xtensa_format_get_slot (isa, fmt, slot, insnbuf, slotbuf);
3393 return xtensa_opcode_decode (isa, fmt, slot, slotbuf);
3394 }
3395
3396
3397 /* The offset is the offset in the contents.
3398 The address is the address of that offset. */
3399
3400 static bfd_boolean
3401 check_branch_target_aligned (bfd_byte *contents,
3402 bfd_size_type content_length,
3403 bfd_vma offset,
3404 bfd_vma address)
3405 {
3406 bfd_size_type insn_len = insn_decode_len (contents, content_length, offset);
3407 if (insn_len == 0)
3408 return FALSE;
3409 return check_branch_target_aligned_address (address, insn_len);
3410 }
3411
3412
3413 static bfd_boolean
3414 check_loop_aligned (bfd_byte *contents,
3415 bfd_size_type content_length,
3416 bfd_vma offset,
3417 bfd_vma address)
3418 {
3419 bfd_size_type loop_len, insn_len;
3420 xtensa_opcode opcode;
3421
3422 opcode = insn_decode_opcode (contents, content_length, offset, 0);
3423 if (opcode == XTENSA_UNDEFINED
3424 || xtensa_opcode_is_loop (xtensa_default_isa, opcode) != 1)
3425 {
3426 BFD_ASSERT (FALSE);
3427 return FALSE;
3428 }
3429
3430 loop_len = insn_decode_len (contents, content_length, offset);
3431 insn_len = insn_decode_len (contents, content_length, offset + loop_len);
3432 if (loop_len == 0 || insn_len == 0)
3433 {
3434 BFD_ASSERT (FALSE);
3435 return FALSE;
3436 }
3437
3438 return check_branch_target_aligned_address (address + loop_len, insn_len);
3439 }
3440
3441
3442 static bfd_boolean
3443 check_branch_target_aligned_address (bfd_vma addr, int len)
3444 {
3445 if (len == 8)
3446 return (addr % 8 == 0);
3447 return ((addr >> 2) == ((addr + len - 1) >> 2));
3448 }
3449
3450 \f
3451 /* Instruction widening and narrowing. */
3452
3453 /* When FLIX is available we need to access certain instructions only
3454 when they are 16-bit or 24-bit instructions. This table caches
3455 information about such instructions by walking through all the
3456 opcodes and finding the smallest single-slot format into which each
3457 can be encoded. */
3458
3459 static xtensa_format *op_single_fmt_table = NULL;
3460
3461
3462 static void
3463 init_op_single_format_table (void)
3464 {
3465 xtensa_isa isa = xtensa_default_isa;
3466 xtensa_insnbuf ibuf;
3467 xtensa_opcode opcode;
3468 xtensa_format fmt;
3469 int num_opcodes;
3470
3471 if (op_single_fmt_table)
3472 return;
3473
3474 ibuf = xtensa_insnbuf_alloc (isa);
3475 num_opcodes = xtensa_isa_num_opcodes (isa);
3476
3477 op_single_fmt_table = (xtensa_format *)
3478 bfd_malloc (sizeof (xtensa_format) * num_opcodes);
3479 for (opcode = 0; opcode < num_opcodes; opcode++)
3480 {
3481 op_single_fmt_table[opcode] = XTENSA_UNDEFINED;
3482 for (fmt = 0; fmt < xtensa_isa_num_formats (isa); fmt++)
3483 {
3484 if (xtensa_format_num_slots (isa, fmt) == 1
3485 && xtensa_opcode_encode (isa, fmt, 0, ibuf, opcode) == 0)
3486 {
3487 xtensa_opcode old_fmt = op_single_fmt_table[opcode];
3488 int fmt_length = xtensa_format_length (isa, fmt);
3489 if (old_fmt == XTENSA_UNDEFINED
3490 || fmt_length < xtensa_format_length (isa, old_fmt))
3491 op_single_fmt_table[opcode] = fmt;
3492 }
3493 }
3494 }
3495 xtensa_insnbuf_free (isa, ibuf);
3496 }
3497
3498
3499 static xtensa_format
3500 get_single_format (xtensa_opcode opcode)
3501 {
3502 init_op_single_format_table ();
3503 return op_single_fmt_table[opcode];
3504 }
3505
3506
3507 /* For the set of narrowable instructions we do NOT include the
3508 narrowings beqz -> beqz.n or bnez -> bnez.n because of complexities
3509 involved during linker relaxation that may require these to
3510 re-expand in some conditions. Also, the narrowing "or" -> mov.n
3511 requires special case code to ensure it only works when op1 == op2. */
3512
3513 struct string_pair
3514 {
3515 const char *wide;
3516 const char *narrow;
3517 };
3518
3519 struct string_pair narrowable[] =
3520 {
3521 { "add", "add.n" },
3522 { "addi", "addi.n" },
3523 { "addmi", "addi.n" },
3524 { "l32i", "l32i.n" },
3525 { "movi", "movi.n" },
3526 { "ret", "ret.n" },
3527 { "retw", "retw.n" },
3528 { "s32i", "s32i.n" },
3529 { "or", "mov.n" } /* special case only when op1 == op2 */
3530 };
3531
3532 struct string_pair widenable[] =
3533 {
3534 { "add", "add.n" },
3535 { "addi", "addi.n" },
3536 { "addmi", "addi.n" },
3537 { "beqz", "beqz.n" },
3538 { "bnez", "bnez.n" },
3539 { "l32i", "l32i.n" },
3540 { "movi", "movi.n" },
3541 { "ret", "ret.n" },
3542 { "retw", "retw.n" },
3543 { "s32i", "s32i.n" },
3544 { "or", "mov.n" } /* special case only when op1 == op2 */
3545 };
3546
3547
3548 /* Check if an instruction can be "narrowed", i.e., changed from a standard
3549 3-byte instruction to a 2-byte "density" instruction. If it is valid,
3550 return the instruction buffer holding the narrow instruction. Otherwise,
3551 return 0. The set of valid narrowing are specified by a string table
3552 but require some special case operand checks in some cases. */
3553
3554 static xtensa_insnbuf
3555 can_narrow_instruction (xtensa_insnbuf slotbuf,
3556 xtensa_format fmt,
3557 xtensa_opcode opcode)
3558 {
3559 xtensa_isa isa = xtensa_default_isa;
3560 xtensa_format o_fmt;
3561 unsigned opi;
3562
3563 static xtensa_insnbuf o_insnbuf = NULL;
3564 static xtensa_insnbuf o_slotbuf = NULL;
3565
3566 if (o_insnbuf == NULL)
3567 {
3568 o_insnbuf = xtensa_insnbuf_alloc (isa);
3569 o_slotbuf = xtensa_insnbuf_alloc (isa);
3570 }
3571
3572 for (opi = 0; opi < (sizeof (narrowable)/sizeof (struct string_pair)); opi++)
3573 {
3574 bfd_boolean is_or = (strcmp ("or", narrowable[opi].wide) == 0);
3575
3576 if (opcode == xtensa_opcode_lookup (isa, narrowable[opi].wide))
3577 {
3578 uint32 value, newval;
3579 int i, operand_count, o_operand_count;
3580 xtensa_opcode o_opcode;
3581
3582 /* Address does not matter in this case. We might need to
3583 fix it to handle branches/jumps. */
3584 bfd_vma self_address = 0;
3585
3586 o_opcode = xtensa_opcode_lookup (isa, narrowable[opi].narrow);
3587 if (o_opcode == XTENSA_UNDEFINED)
3588 return 0;
3589 o_fmt = get_single_format (o_opcode);
3590 if (o_fmt == XTENSA_UNDEFINED)
3591 return 0;
3592
3593 if (xtensa_format_length (isa, fmt) != 3
3594 || xtensa_format_length (isa, o_fmt) != 2)
3595 return 0;
3596
3597 xtensa_format_encode (isa, o_fmt, o_insnbuf);
3598 operand_count = xtensa_opcode_num_operands (isa, opcode);
3599 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
3600
3601 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
3602 return 0;
3603
3604 if (!is_or)
3605 {
3606 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
3607 return 0;
3608 }
3609 else
3610 {
3611 uint32 rawval0, rawval1, rawval2;
3612
3613 if (o_operand_count + 1 != operand_count
3614 || xtensa_operand_get_field (isa, opcode, 0,
3615 fmt, 0, slotbuf, &rawval0) != 0
3616 || xtensa_operand_get_field (isa, opcode, 1,
3617 fmt, 0, slotbuf, &rawval1) != 0
3618 || xtensa_operand_get_field (isa, opcode, 2,
3619 fmt, 0, slotbuf, &rawval2) != 0
3620 || rawval1 != rawval2
3621 || rawval0 == rawval1 /* it is a nop */)
3622 return 0;
3623 }
3624
3625 for (i = 0; i < o_operand_count; ++i)
3626 {
3627 if (xtensa_operand_get_field (isa, opcode, i, fmt, 0,
3628 slotbuf, &value)
3629 || xtensa_operand_decode (isa, opcode, i, &value))
3630 return 0;
3631
3632 /* PC-relative branches need adjustment, but
3633 the PC-rel operand will always have a relocation. */
3634 newval = value;
3635 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
3636 self_address)
3637 || xtensa_operand_encode (isa, o_opcode, i, &newval)
3638 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
3639 o_slotbuf, newval))
3640 return 0;
3641 }
3642
3643 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
3644 return 0;
3645
3646 return o_insnbuf;
3647 }
3648 }
3649 return 0;
3650 }
3651
3652
3653 /* Attempt to narrow an instruction. If the narrowing is valid, perform
3654 the action in-place directly into the contents and return TRUE. Otherwise,
3655 the return value is FALSE and the contents are not modified. */
3656
3657 static bfd_boolean
3658 narrow_instruction (bfd_byte *contents,
3659 bfd_size_type content_length,
3660 bfd_size_type offset)
3661 {
3662 xtensa_opcode opcode;
3663 bfd_size_type insn_len;
3664 xtensa_isa isa = xtensa_default_isa;
3665 xtensa_format fmt;
3666 xtensa_insnbuf o_insnbuf;
3667
3668 static xtensa_insnbuf insnbuf = NULL;
3669 static xtensa_insnbuf slotbuf = NULL;
3670
3671 if (insnbuf == NULL)
3672 {
3673 insnbuf = xtensa_insnbuf_alloc (isa);
3674 slotbuf = xtensa_insnbuf_alloc (isa);
3675 }
3676
3677 BFD_ASSERT (offset < content_length);
3678
3679 if (content_length < 2)
3680 return FALSE;
3681
3682 /* We will hand-code a few of these for a little while.
3683 These have all been specified in the assembler aleady. */
3684 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
3685 content_length - offset);
3686 fmt = xtensa_format_decode (isa, insnbuf);
3687 if (xtensa_format_num_slots (isa, fmt) != 1)
3688 return FALSE;
3689
3690 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
3691 return FALSE;
3692
3693 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
3694 if (opcode == XTENSA_UNDEFINED)
3695 return FALSE;
3696 insn_len = xtensa_format_length (isa, fmt);
3697 if (insn_len > content_length)
3698 return FALSE;
3699
3700 o_insnbuf = can_narrow_instruction (slotbuf, fmt, opcode);
3701 if (o_insnbuf)
3702 {
3703 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
3704 content_length - offset);
3705 return TRUE;
3706 }
3707
3708 return FALSE;
3709 }
3710
3711
3712 /* Check if an instruction can be "widened", i.e., changed from a 2-byte
3713 "density" instruction to a standard 3-byte instruction. If it is valid,
3714 return the instruction buffer holding the wide instruction. Otherwise,
3715 return 0. The set of valid widenings are specified by a string table
3716 but require some special case operand checks in some cases. */
3717
3718 static xtensa_insnbuf
3719 can_widen_instruction (xtensa_insnbuf slotbuf,
3720 xtensa_format fmt,
3721 xtensa_opcode opcode)
3722 {
3723 xtensa_isa isa = xtensa_default_isa;
3724 xtensa_format o_fmt;
3725 unsigned opi;
3726
3727 static xtensa_insnbuf o_insnbuf = NULL;
3728 static xtensa_insnbuf o_slotbuf = NULL;
3729
3730 if (o_insnbuf == NULL)
3731 {
3732 o_insnbuf = xtensa_insnbuf_alloc (isa);
3733 o_slotbuf = xtensa_insnbuf_alloc (isa);
3734 }
3735
3736 for (opi = 0; opi < (sizeof (widenable)/sizeof (struct string_pair)); opi++)
3737 {
3738 bfd_boolean is_or = (strcmp ("or", widenable[opi].wide) == 0);
3739 bfd_boolean is_branch = (strcmp ("beqz", widenable[opi].wide) == 0
3740 || strcmp ("bnez", widenable[opi].wide) == 0);
3741
3742 if (opcode == xtensa_opcode_lookup (isa, widenable[opi].narrow))
3743 {
3744 uint32 value, newval;
3745 int i, operand_count, o_operand_count, check_operand_count;
3746 xtensa_opcode o_opcode;
3747
3748 /* Address does not matter in this case. We might need to fix it
3749 to handle branches/jumps. */
3750 bfd_vma self_address = 0;
3751
3752 o_opcode = xtensa_opcode_lookup (isa, widenable[opi].wide);
3753 if (o_opcode == XTENSA_UNDEFINED)
3754 return 0;
3755 o_fmt = get_single_format (o_opcode);
3756 if (o_fmt == XTENSA_UNDEFINED)
3757 return 0;
3758
3759 if (xtensa_format_length (isa, fmt) != 2
3760 || xtensa_format_length (isa, o_fmt) != 3)
3761 return 0;
3762
3763 xtensa_format_encode (isa, o_fmt, o_insnbuf);
3764 operand_count = xtensa_opcode_num_operands (isa, opcode);
3765 o_operand_count = xtensa_opcode_num_operands (isa, o_opcode);
3766 check_operand_count = o_operand_count;
3767
3768 if (xtensa_opcode_encode (isa, o_fmt, 0, o_slotbuf, o_opcode) != 0)
3769 return 0;
3770
3771 if (!is_or)
3772 {
3773 if (xtensa_opcode_num_operands (isa, o_opcode) != operand_count)
3774 return 0;
3775 }
3776 else
3777 {
3778 uint32 rawval0, rawval1;
3779
3780 if (o_operand_count != operand_count + 1
3781 || xtensa_operand_get_field (isa, opcode, 0,
3782 fmt, 0, slotbuf, &rawval0) != 0
3783 || xtensa_operand_get_field (isa, opcode, 1,
3784 fmt, 0, slotbuf, &rawval1) != 0
3785 || rawval0 == rawval1 /* it is a nop */)
3786 return 0;
3787 }
3788 if (is_branch)
3789 check_operand_count--;
3790
3791 for (i = 0; i < check_operand_count; i++)
3792 {
3793 int new_i = i;
3794 if (is_or && i == o_operand_count - 1)
3795 new_i = i - 1;
3796 if (xtensa_operand_get_field (isa, opcode, new_i, fmt, 0,
3797 slotbuf, &value)
3798 || xtensa_operand_decode (isa, opcode, new_i, &value))
3799 return 0;
3800
3801 /* PC-relative branches need adjustment, but
3802 the PC-rel operand will always have a relocation. */
3803 newval = value;
3804 if (xtensa_operand_do_reloc (isa, o_opcode, i, &newval,
3805 self_address)
3806 || xtensa_operand_encode (isa, o_opcode, i, &newval)
3807 || xtensa_operand_set_field (isa, o_opcode, i, o_fmt, 0,
3808 o_slotbuf, newval))
3809 return 0;
3810 }
3811
3812 if (xtensa_format_set_slot (isa, o_fmt, 0, o_insnbuf, o_slotbuf))
3813 return 0;
3814
3815 return o_insnbuf;
3816 }
3817 }
3818 return 0;
3819 }
3820
3821
3822 /* Attempt to widen an instruction. If the widening is valid, perform
3823 the action in-place directly into the contents and return TRUE. Otherwise,
3824 the return value is FALSE and the contents are not modified. */
3825
3826 static bfd_boolean
3827 widen_instruction (bfd_byte *contents,
3828 bfd_size_type content_length,
3829 bfd_size_type offset)
3830 {
3831 xtensa_opcode opcode;
3832 bfd_size_type insn_len;
3833 xtensa_isa isa = xtensa_default_isa;
3834 xtensa_format fmt;
3835 xtensa_insnbuf o_insnbuf;
3836
3837 static xtensa_insnbuf insnbuf = NULL;
3838 static xtensa_insnbuf slotbuf = NULL;
3839
3840 if (insnbuf == NULL)
3841 {
3842 insnbuf = xtensa_insnbuf_alloc (isa);
3843 slotbuf = xtensa_insnbuf_alloc (isa);
3844 }
3845
3846 BFD_ASSERT (offset < content_length);
3847
3848 if (content_length < 2)
3849 return FALSE;
3850
3851 /* We will hand-code a few of these for a little while.
3852 These have all been specified in the assembler aleady. */
3853 xtensa_insnbuf_from_chars (isa, insnbuf, &contents[offset],
3854 content_length - offset);
3855 fmt = xtensa_format_decode (isa, insnbuf);
3856 if (xtensa_format_num_slots (isa, fmt) != 1)
3857 return FALSE;
3858
3859 if (xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf) != 0)
3860 return FALSE;
3861
3862 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
3863 if (opcode == XTENSA_UNDEFINED)
3864 return FALSE;
3865 insn_len = xtensa_format_length (isa, fmt);
3866 if (insn_len > content_length)
3867 return FALSE;
3868
3869 o_insnbuf = can_widen_instruction (slotbuf, fmt, opcode);
3870 if (o_insnbuf)
3871 {
3872 xtensa_insnbuf_to_chars (isa, o_insnbuf, contents + offset,
3873 content_length - offset);
3874 return TRUE;
3875 }
3876 return FALSE;
3877 }
3878
3879 \f
3880 /* Code for transforming CALLs at link-time. */
3881
3882 static bfd_reloc_status_type
3883 elf_xtensa_do_asm_simplify (bfd_byte *contents,
3884 bfd_vma address,
3885 bfd_vma content_length,
3886 char **error_message)
3887 {
3888 static xtensa_insnbuf insnbuf = NULL;
3889 static xtensa_insnbuf slotbuf = NULL;
3890 xtensa_format core_format = XTENSA_UNDEFINED;
3891 xtensa_opcode opcode;
3892 xtensa_opcode direct_call_opcode;
3893 xtensa_isa isa = xtensa_default_isa;
3894 bfd_byte *chbuf = contents + address;
3895 int opn;
3896
3897 if (insnbuf == NULL)
3898 {
3899 insnbuf = xtensa_insnbuf_alloc (isa);
3900 slotbuf = xtensa_insnbuf_alloc (isa);
3901 }
3902
3903 if (content_length < address)
3904 {
3905 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
3906 return bfd_reloc_other;
3907 }
3908
3909 opcode = get_expanded_call_opcode (chbuf, content_length - address, 0);
3910 direct_call_opcode = swap_callx_for_call_opcode (opcode);
3911 if (direct_call_opcode == XTENSA_UNDEFINED)
3912 {
3913 *error_message = _("Attempt to convert L32R/CALLX to CALL failed");
3914 return bfd_reloc_other;
3915 }
3916
3917 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
3918 core_format = xtensa_format_lookup (isa, "x24");
3919 opcode = xtensa_opcode_lookup (isa, "or");
3920 xtensa_opcode_encode (isa, core_format, 0, slotbuf, opcode);
3921 for (opn = 0; opn < 3; opn++)
3922 {
3923 uint32 regno = 1;
3924 xtensa_operand_encode (isa, opcode, opn, &regno);
3925 xtensa_operand_set_field (isa, opcode, opn, core_format, 0,
3926 slotbuf, regno);
3927 }
3928 xtensa_format_encode (isa, core_format, insnbuf);
3929 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
3930 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf, content_length - address);
3931
3932 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
3933 xtensa_opcode_encode (isa, core_format, 0, slotbuf, direct_call_opcode);
3934 xtensa_operand_set_field (isa, opcode, 0, core_format, 0, slotbuf, 0);
3935
3936 xtensa_format_encode (isa, core_format, insnbuf);
3937 xtensa_format_set_slot (isa, core_format, 0, insnbuf, slotbuf);
3938 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3,
3939 content_length - address - 3);
3940
3941 return bfd_reloc_ok;
3942 }
3943
3944
3945 static bfd_reloc_status_type
3946 contract_asm_expansion (bfd_byte *contents,
3947 bfd_vma content_length,
3948 Elf_Internal_Rela *irel,
3949 char **error_message)
3950 {
3951 bfd_reloc_status_type retval =
3952 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length,
3953 error_message);
3954
3955 if (retval != bfd_reloc_ok)
3956 return bfd_reloc_dangerous;
3957
3958 /* Update the irel->r_offset field so that the right immediate and
3959 the right instruction are modified during the relocation. */
3960 irel->r_offset += 3;
3961 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_SLOT0_OP);
3962 return bfd_reloc_ok;
3963 }
3964
3965
3966 static xtensa_opcode
3967 swap_callx_for_call_opcode (xtensa_opcode opcode)
3968 {
3969 init_call_opcodes ();
3970
3971 if (opcode == callx0_op) return call0_op;
3972 if (opcode == callx4_op) return call4_op;
3973 if (opcode == callx8_op) return call8_op;
3974 if (opcode == callx12_op) return call12_op;
3975
3976 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
3977 return XTENSA_UNDEFINED;
3978 }
3979
3980
3981 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" or "CONST16 aN;
3982 CONST16 aN; CALLX aN" sequence, and if so, return the CALLX opcode.
3983 If not, return XTENSA_UNDEFINED. */
3984
3985 #define L32R_TARGET_REG_OPERAND 0
3986 #define CONST16_TARGET_REG_OPERAND 0
3987 #define CALLN_SOURCE_OPERAND 0
3988
3989 static xtensa_opcode
3990 get_expanded_call_opcode (bfd_byte *buf, int bufsize, bfd_boolean *p_uses_l32r)
3991 {
3992 static xtensa_insnbuf insnbuf = NULL;
3993 static xtensa_insnbuf slotbuf = NULL;
3994 xtensa_format fmt;
3995 xtensa_opcode opcode;
3996 xtensa_isa isa = xtensa_default_isa;
3997 uint32 regno, const16_regno, call_regno;
3998 int offset = 0;
3999
4000 if (insnbuf == NULL)
4001 {
4002 insnbuf = xtensa_insnbuf_alloc (isa);
4003 slotbuf = xtensa_insnbuf_alloc (isa);
4004 }
4005
4006 xtensa_insnbuf_from_chars (isa, insnbuf, buf, bufsize);
4007 fmt = xtensa_format_decode (isa, insnbuf);
4008 if (fmt == XTENSA_UNDEFINED
4009 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4010 return XTENSA_UNDEFINED;
4011
4012 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4013 if (opcode == XTENSA_UNDEFINED)
4014 return XTENSA_UNDEFINED;
4015
4016 if (opcode == get_l32r_opcode ())
4017 {
4018 if (p_uses_l32r)
4019 *p_uses_l32r = TRUE;
4020 if (xtensa_operand_get_field (isa, opcode, L32R_TARGET_REG_OPERAND,
4021 fmt, 0, slotbuf, &regno)
4022 || xtensa_operand_decode (isa, opcode, L32R_TARGET_REG_OPERAND,
4023 &regno))
4024 return XTENSA_UNDEFINED;
4025 }
4026 else if (opcode == get_const16_opcode ())
4027 {
4028 if (p_uses_l32r)
4029 *p_uses_l32r = FALSE;
4030 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4031 fmt, 0, slotbuf, &regno)
4032 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4033 &regno))
4034 return XTENSA_UNDEFINED;
4035
4036 /* Check that the next instruction is also CONST16. */
4037 offset += xtensa_format_length (isa, fmt);
4038 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4039 fmt = xtensa_format_decode (isa, insnbuf);
4040 if (fmt == XTENSA_UNDEFINED
4041 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4042 return XTENSA_UNDEFINED;
4043 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4044 if (opcode != get_const16_opcode ())
4045 return XTENSA_UNDEFINED;
4046
4047 if (xtensa_operand_get_field (isa, opcode, CONST16_TARGET_REG_OPERAND,
4048 fmt, 0, slotbuf, &const16_regno)
4049 || xtensa_operand_decode (isa, opcode, CONST16_TARGET_REG_OPERAND,
4050 &const16_regno)
4051 || const16_regno != regno)
4052 return XTENSA_UNDEFINED;
4053 }
4054 else
4055 return XTENSA_UNDEFINED;
4056
4057 /* Next instruction should be an CALLXn with operand 0 == regno. */
4058 offset += xtensa_format_length (isa, fmt);
4059 xtensa_insnbuf_from_chars (isa, insnbuf, buf + offset, bufsize - offset);
4060 fmt = xtensa_format_decode (isa, insnbuf);
4061 if (fmt == XTENSA_UNDEFINED
4062 || xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf))
4063 return XTENSA_UNDEFINED;
4064 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
4065 if (opcode == XTENSA_UNDEFINED
4066 || !is_indirect_call_opcode (opcode))
4067 return XTENSA_UNDEFINED;
4068
4069 if (xtensa_operand_get_field (isa, opcode, CALLN_SOURCE_OPERAND,
4070 fmt, 0, slotbuf, &call_regno)
4071 || xtensa_operand_decode (isa, opcode, CALLN_SOURCE_OPERAND,
4072 &call_regno))
4073 return XTENSA_UNDEFINED;
4074
4075 if (call_regno != regno)
4076 return XTENSA_UNDEFINED;
4077
4078 return opcode;
4079 }
4080
4081 \f
4082 /* Data structures used during relaxation. */
4083
4084 /* r_reloc: relocation values. */
4085
4086 /* Through the relaxation process, we need to keep track of the values
4087 that will result from evaluating relocations. The standard ELF
4088 relocation structure is not sufficient for this purpose because we're
4089 operating on multiple input files at once, so we need to know which
4090 input file a relocation refers to. The r_reloc structure thus
4091 records both the input file (bfd) and ELF relocation.
4092
4093 For efficiency, an r_reloc also contains a "target_offset" field to
4094 cache the target-section-relative offset value that is represented by
4095 the relocation.
4096
4097 The r_reloc also contains a virtual offset that allows multiple
4098 inserted literals to be placed at the same "address" with
4099 different offsets. */
4100
4101 typedef struct r_reloc_struct r_reloc;
4102
4103 struct r_reloc_struct
4104 {
4105 bfd *abfd;
4106 Elf_Internal_Rela rela;
4107 bfd_vma target_offset;
4108 bfd_vma virtual_offset;
4109 };
4110
4111
4112 /* The r_reloc structure is included by value in literal_value, but not
4113 every literal_value has an associated relocation -- some are simple
4114 constants. In such cases, we set all the fields in the r_reloc
4115 struct to zero. The r_reloc_is_const function should be used to
4116 detect this case. */
4117
4118 static bfd_boolean
4119 r_reloc_is_const (const r_reloc *r_rel)
4120 {
4121 return (r_rel->abfd == NULL);
4122 }
4123
4124
4125 static bfd_vma
4126 r_reloc_get_target_offset (const r_reloc *r_rel)
4127 {
4128 bfd_vma target_offset;
4129 unsigned long r_symndx;
4130
4131 BFD_ASSERT (!r_reloc_is_const (r_rel));
4132 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4133 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
4134 return (target_offset + r_rel->rela.r_addend);
4135 }
4136
4137
4138 static struct elf_link_hash_entry *
4139 r_reloc_get_hash_entry (const r_reloc *r_rel)
4140 {
4141 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4142 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
4143 }
4144
4145
4146 static asection *
4147 r_reloc_get_section (const r_reloc *r_rel)
4148 {
4149 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
4150 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
4151 }
4152
4153
4154 static bfd_boolean
4155 r_reloc_is_defined (const r_reloc *r_rel)
4156 {
4157 asection *sec;
4158 if (r_rel == NULL)
4159 return FALSE;
4160
4161 sec = r_reloc_get_section (r_rel);
4162 if (sec == bfd_abs_section_ptr
4163 || sec == bfd_com_section_ptr
4164 || sec == bfd_und_section_ptr)
4165 return FALSE;
4166 return TRUE;
4167 }
4168
4169
4170 static void
4171 r_reloc_init (r_reloc *r_rel,
4172 bfd *abfd,
4173 Elf_Internal_Rela *irel,
4174 bfd_byte *contents,
4175 bfd_size_type content_length)
4176 {
4177 int r_type;
4178 reloc_howto_type *howto;
4179
4180 if (irel)
4181 {
4182 r_rel->rela = *irel;
4183 r_rel->abfd = abfd;
4184 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
4185 r_rel->virtual_offset = 0;
4186 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
4187 howto = &elf_howto_table[r_type];
4188 if (howto->partial_inplace)
4189 {
4190 bfd_vma inplace_val;
4191 BFD_ASSERT (r_rel->rela.r_offset < content_length);
4192
4193 inplace_val = bfd_get_32 (abfd, &contents[r_rel->rela.r_offset]);
4194 r_rel->target_offset += inplace_val;
4195 }
4196 }
4197 else
4198 memset (r_rel, 0, sizeof (r_reloc));
4199 }
4200
4201
4202 #if DEBUG
4203
4204 static void
4205 print_r_reloc (FILE *fp, const r_reloc *r_rel)
4206 {
4207 if (r_reloc_is_defined (r_rel))
4208 {
4209 asection *sec = r_reloc_get_section (r_rel);
4210 fprintf (fp, " %s(%s + ", sec->owner->filename, sec->name);
4211 }
4212 else if (r_reloc_get_hash_entry (r_rel))
4213 fprintf (fp, " %s + ", r_reloc_get_hash_entry (r_rel)->root.root.string);
4214 else
4215 fprintf (fp, " ?? + ");
4216
4217 fprintf_vma (fp, r_rel->target_offset);
4218 if (r_rel->virtual_offset)
4219 {
4220 fprintf (fp, " + ");
4221 fprintf_vma (fp, r_rel->virtual_offset);
4222 }
4223
4224 fprintf (fp, ")");
4225 }
4226
4227 #endif /* DEBUG */
4228
4229 \f
4230 /* source_reloc: relocations that reference literals. */
4231
4232 /* To determine whether literals can be coalesced, we need to first
4233 record all the relocations that reference the literals. The
4234 source_reloc structure below is used for this purpose. The
4235 source_reloc entries are kept in a per-literal-section array, sorted
4236 by offset within the literal section (i.e., target offset).
4237
4238 The source_sec and r_rel.rela.r_offset fields identify the source of
4239 the relocation. The r_rel field records the relocation value, i.e.,
4240 the offset of the literal being referenced. The opnd field is needed
4241 to determine the range of the immediate field to which the relocation
4242 applies, so we can determine whether another literal with the same
4243 value is within range. The is_null field is true when the relocation
4244 is being removed (e.g., when an L32R is being removed due to a CALLX
4245 that is converted to a direct CALL). */
4246
4247 typedef struct source_reloc_struct source_reloc;
4248
4249 struct source_reloc_struct
4250 {
4251 asection *source_sec;
4252 r_reloc r_rel;
4253 xtensa_opcode opcode;
4254 int opnd;
4255 bfd_boolean is_null;
4256 bfd_boolean is_abs_literal;
4257 };
4258
4259
4260 static void
4261 init_source_reloc (source_reloc *reloc,
4262 asection *source_sec,
4263 const r_reloc *r_rel,
4264 xtensa_opcode opcode,
4265 int opnd,
4266 bfd_boolean is_abs_literal)
4267 {
4268 reloc->source_sec = source_sec;
4269 reloc->r_rel = *r_rel;
4270 reloc->opcode = opcode;
4271 reloc->opnd = opnd;
4272 reloc->is_null = FALSE;
4273 reloc->is_abs_literal = is_abs_literal;
4274 }
4275
4276
4277 /* Find the source_reloc for a particular source offset and relocation
4278 type. Note that the array is sorted by _target_ offset, so this is
4279 just a linear search. */
4280
4281 static source_reloc *
4282 find_source_reloc (source_reloc *src_relocs,
4283 int src_count,
4284 asection *sec,
4285 Elf_Internal_Rela *irel)
4286 {
4287 int i;
4288
4289 for (i = 0; i < src_count; i++)
4290 {
4291 if (src_relocs[i].source_sec == sec
4292 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
4293 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
4294 == ELF32_R_TYPE (irel->r_info)))
4295 return &src_relocs[i];
4296 }
4297
4298 return NULL;
4299 }
4300
4301
4302 static int
4303 source_reloc_compare (const void *ap, const void *bp)
4304 {
4305 const source_reloc *a = (const source_reloc *) ap;
4306 const source_reloc *b = (const source_reloc *) bp;
4307
4308 if (a->r_rel.target_offset != b->r_rel.target_offset)
4309 return (a->r_rel.target_offset - b->r_rel.target_offset);
4310
4311 /* We don't need to sort on these criteria for correctness,
4312 but enforcing a more strict ordering prevents unstable qsort
4313 from behaving differently with different implementations.
4314 Without the code below we get correct but different results
4315 on Solaris 2.7 and 2.8. We would like to always produce the
4316 same results no matter the host. */
4317
4318 if ((!a->is_null) - (!b->is_null))
4319 return ((!a->is_null) - (!b->is_null));
4320 return internal_reloc_compare (&a->r_rel.rela, &b->r_rel.rela);
4321 }
4322
4323 \f
4324 /* Literal values and value hash tables. */
4325
4326 /* Literals with the same value can be coalesced. The literal_value
4327 structure records the value of a literal: the "r_rel" field holds the
4328 information from the relocation on the literal (if there is one) and
4329 the "value" field holds the contents of the literal word itself.
4330
4331 The value_map structure records a literal value along with the
4332 location of a literal holding that value. The value_map hash table
4333 is indexed by the literal value, so that we can quickly check if a
4334 particular literal value has been seen before and is thus a candidate
4335 for coalescing. */
4336
4337 typedef struct literal_value_struct literal_value;
4338 typedef struct value_map_struct value_map;
4339 typedef struct value_map_hash_table_struct value_map_hash_table;
4340
4341 struct literal_value_struct
4342 {
4343 r_reloc r_rel;
4344 unsigned long value;
4345 bfd_boolean is_abs_literal;
4346 };
4347
4348 struct value_map_struct
4349 {
4350 literal_value val; /* The literal value. */
4351 r_reloc loc; /* Location of the literal. */
4352 value_map *next;
4353 };
4354
4355 struct value_map_hash_table_struct
4356 {
4357 unsigned bucket_count;
4358 value_map **buckets;
4359 unsigned count;
4360 bfd_boolean has_last_loc;
4361 r_reloc last_loc;
4362 };
4363
4364
4365 static void
4366 init_literal_value (literal_value *lit,
4367 const r_reloc *r_rel,
4368 unsigned long value,
4369 bfd_boolean is_abs_literal)
4370 {
4371 lit->r_rel = *r_rel;
4372 lit->value = value;
4373 lit->is_abs_literal = is_abs_literal;
4374 }
4375
4376
4377 static bfd_boolean
4378 literal_value_equal (const literal_value *src1,
4379 const literal_value *src2,
4380 bfd_boolean final_static_link)
4381 {
4382 struct elf_link_hash_entry *h1, *h2;
4383
4384 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
4385 return FALSE;
4386
4387 if (r_reloc_is_const (&src1->r_rel))
4388 return (src1->value == src2->value);
4389
4390 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
4391 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
4392 return FALSE;
4393
4394 if (src1->r_rel.target_offset != src2->r_rel.target_offset)
4395 return FALSE;
4396
4397 if (src1->r_rel.virtual_offset != src2->r_rel.virtual_offset)
4398 return FALSE;
4399
4400 if (src1->value != src2->value)
4401 return FALSE;
4402
4403 /* Now check for the same section (if defined) or the same elf_hash
4404 (if undefined or weak). */
4405 h1 = r_reloc_get_hash_entry (&src1->r_rel);
4406 h2 = r_reloc_get_hash_entry (&src2->r_rel);
4407 if (r_reloc_is_defined (&src1->r_rel)
4408 && (final_static_link
4409 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
4410 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
4411 {
4412 if (r_reloc_get_section (&src1->r_rel)
4413 != r_reloc_get_section (&src2->r_rel))
4414 return FALSE;
4415 }
4416 else
4417 {
4418 /* Require that the hash entries (i.e., symbols) be identical. */
4419 if (h1 != h2 || h1 == 0)
4420 return FALSE;
4421 }
4422
4423 if (src1->is_abs_literal != src2->is_abs_literal)
4424 return FALSE;
4425
4426 return TRUE;
4427 }
4428
4429
4430 /* Must be power of 2. */
4431 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
4432
4433 static value_map_hash_table *
4434 value_map_hash_table_init (void)
4435 {
4436 value_map_hash_table *values;
4437
4438 values = (value_map_hash_table *)
4439 bfd_zmalloc (sizeof (value_map_hash_table));
4440 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
4441 values->count = 0;
4442 values->buckets = (value_map **)
4443 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
4444 if (values->buckets == NULL)
4445 {
4446 free (values);
4447 return NULL;
4448 }
4449 values->has_last_loc = FALSE;
4450
4451 return values;
4452 }
4453
4454
4455 static void
4456 value_map_hash_table_delete (value_map_hash_table *table)
4457 {
4458 free (table->buckets);
4459 free (table);
4460 }
4461
4462
4463 static unsigned
4464 hash_bfd_vma (bfd_vma val)
4465 {
4466 return (val >> 2) + (val >> 10);
4467 }
4468
4469
4470 static unsigned
4471 literal_value_hash (const literal_value *src)
4472 {
4473 unsigned hash_val;
4474
4475 hash_val = hash_bfd_vma (src->value);
4476 if (!r_reloc_is_const (&src->r_rel))
4477 {
4478 void *sec_or_hash;
4479
4480 hash_val += hash_bfd_vma (src->is_abs_literal * 1000);
4481 hash_val += hash_bfd_vma (src->r_rel.target_offset);
4482 hash_val += hash_bfd_vma (src->r_rel.virtual_offset);
4483
4484 /* Now check for the same section and the same elf_hash. */
4485 if (r_reloc_is_defined (&src->r_rel))
4486 sec_or_hash = r_reloc_get_section (&src->r_rel);
4487 else
4488 sec_or_hash = r_reloc_get_hash_entry (&src->r_rel);
4489 hash_val += hash_bfd_vma ((bfd_vma) (size_t) sec_or_hash);
4490 }
4491 return hash_val;
4492 }
4493
4494
4495 /* Check if the specified literal_value has been seen before. */
4496
4497 static value_map *
4498 value_map_get_cached_value (value_map_hash_table *map,
4499 const literal_value *val,
4500 bfd_boolean final_static_link)
4501 {
4502 value_map *map_e;
4503 value_map *bucket;
4504 unsigned idx;
4505
4506 idx = literal_value_hash (val);
4507 idx = idx & (map->bucket_count - 1);
4508 bucket = map->buckets[idx];
4509 for (map_e = bucket; map_e; map_e = map_e->next)
4510 {
4511 if (literal_value_equal (&map_e->val, val, final_static_link))
4512 return map_e;
4513 }
4514 return NULL;
4515 }
4516
4517
4518 /* Record a new literal value. It is illegal to call this if VALUE
4519 already has an entry here. */
4520
4521 static value_map *
4522 add_value_map (value_map_hash_table *map,
4523 const literal_value *val,
4524 const r_reloc *loc,
4525 bfd_boolean final_static_link)
4526 {
4527 value_map **bucket_p;
4528 unsigned idx;
4529
4530 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
4531 if (val_e == NULL)
4532 {
4533 bfd_set_error (bfd_error_no_memory);
4534 return NULL;
4535 }
4536
4537 BFD_ASSERT (!value_map_get_cached_value (map, val, final_static_link));
4538 val_e->val = *val;
4539 val_e->loc = *loc;
4540
4541 idx = literal_value_hash (val);
4542 idx = idx & (map->bucket_count - 1);
4543 bucket_p = &map->buckets[idx];
4544
4545 val_e->next = *bucket_p;
4546 *bucket_p = val_e;
4547 map->count++;
4548 /* FIXME: Consider resizing the hash table if we get too many entries. */
4549
4550 return val_e;
4551 }
4552
4553 \f
4554 /* Lists of text actions (ta_) for narrowing, widening, longcall
4555 conversion, space fill, code & literal removal, etc. */
4556
4557 /* The following text actions are generated:
4558
4559 "ta_remove_insn" remove an instruction or instructions
4560 "ta_remove_longcall" convert longcall to call
4561 "ta_convert_longcall" convert longcall to nop/call
4562 "ta_narrow_insn" narrow a wide instruction
4563 "ta_widen" widen a narrow instruction
4564 "ta_fill" add fill or remove fill
4565 removed < 0 is a fill; branches to the fill address will be
4566 changed to address + fill size (e.g., address - removed)
4567 removed >= 0 branches to the fill address will stay unchanged
4568 "ta_remove_literal" remove a literal; this action is
4569 indicated when a literal is removed
4570 or replaced.
4571 "ta_add_literal" insert a new literal; this action is
4572 indicated when a literal has been moved.
4573 It may use a virtual_offset because
4574 multiple literals can be placed at the
4575 same location.
4576
4577 For each of these text actions, we also record the number of bytes
4578 removed by performing the text action. In the case of a "ta_widen"
4579 or a "ta_fill" that adds space, the removed_bytes will be negative. */
4580
4581 typedef struct text_action_struct text_action;
4582 typedef struct text_action_list_struct text_action_list;
4583 typedef enum text_action_enum_t text_action_t;
4584
4585 enum text_action_enum_t
4586 {
4587 ta_none,
4588 ta_remove_insn, /* removed = -size */
4589 ta_remove_longcall, /* removed = -size */
4590 ta_convert_longcall, /* removed = 0 */
4591 ta_narrow_insn, /* removed = -1 */
4592 ta_widen_insn, /* removed = +1 */
4593 ta_fill, /* removed = +size */
4594 ta_remove_literal,
4595 ta_add_literal
4596 };
4597
4598
4599 /* Structure for a text action record. */
4600 struct text_action_struct
4601 {
4602 text_action_t action;
4603 asection *sec; /* Optional */
4604 bfd_vma offset;
4605 bfd_vma virtual_offset; /* Zero except for adding literals. */
4606 int removed_bytes;
4607 literal_value value; /* Only valid when adding literals. */
4608
4609 text_action *next;
4610 };
4611
4612
4613 /* List of all of the actions taken on a text section. */
4614 struct text_action_list_struct
4615 {
4616 text_action *head;
4617 };
4618
4619
4620 static text_action *
4621 find_fill_action (text_action_list *l, asection *sec, bfd_vma offset)
4622 {
4623 text_action **m_p;
4624
4625 /* It is not necessary to fill at the end of a section. */
4626 if (sec->size == offset)
4627 return NULL;
4628
4629 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
4630 {
4631 text_action *t = *m_p;
4632 /* When the action is another fill at the same address,
4633 just increase the size. */
4634 if (t->offset == offset && t->action == ta_fill)
4635 return t;
4636 }
4637 return NULL;
4638 }
4639
4640
4641 static int
4642 compute_removed_action_diff (const text_action *ta,
4643 asection *sec,
4644 bfd_vma offset,
4645 int removed,
4646 int removable_space)
4647 {
4648 int new_removed;
4649 int current_removed = 0;
4650
4651 if (ta)
4652 current_removed = ta->removed_bytes;
4653
4654 BFD_ASSERT (ta == NULL || ta->offset == offset);
4655 BFD_ASSERT (ta == NULL || ta->action == ta_fill);
4656
4657 /* It is not necessary to fill at the end of a section. Clean this up. */
4658 if (sec->size == offset)
4659 new_removed = removable_space - 0;
4660 else
4661 {
4662 int space;
4663 int added = -removed - current_removed;
4664 /* Ignore multiples of the section alignment. */
4665 added = ((1 << sec->alignment_power) - 1) & added;
4666 new_removed = (-added);
4667
4668 /* Modify for removable. */
4669 space = removable_space - new_removed;
4670 new_removed = (removable_space
4671 - (((1 << sec->alignment_power) - 1) & space));
4672 }
4673 return (new_removed - current_removed);
4674 }
4675
4676
4677 static void
4678 adjust_fill_action (text_action *ta, int fill_diff)
4679 {
4680 ta->removed_bytes += fill_diff;
4681 }
4682
4683
4684 /* Add a modification action to the text. For the case of adding or
4685 removing space, modify any current fill and assume that
4686 "unreachable_space" bytes can be freely contracted. Note that a
4687 negative removed value is a fill. */
4688
4689 static void
4690 text_action_add (text_action_list *l,
4691 text_action_t action,
4692 asection *sec,
4693 bfd_vma offset,
4694 int removed)
4695 {
4696 text_action **m_p;
4697 text_action *ta;
4698
4699 /* It is not necessary to fill at the end of a section. */
4700 if (action == ta_fill && sec->size == offset)
4701 return;
4702
4703 /* It is not necessary to fill 0 bytes. */
4704 if (action == ta_fill && removed == 0)
4705 return;
4706
4707 for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next)
4708 {
4709 text_action *t = *m_p;
4710 /* When the action is another fill at the same address,
4711 just increase the size. */
4712 if (t->offset == offset && t->action == ta_fill && action == ta_fill)
4713 {
4714 t->removed_bytes += removed;
4715 return;
4716 }
4717 }
4718
4719 /* Create a new record and fill it up. */
4720 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
4721 ta->action = action;
4722 ta->sec = sec;
4723 ta->offset = offset;
4724 ta->removed_bytes = removed;
4725 ta->next = (*m_p);
4726 *m_p = ta;
4727 }
4728
4729
4730 static void
4731 text_action_add_literal (text_action_list *l,
4732 text_action_t action,
4733 const r_reloc *loc,
4734 const literal_value *value,
4735 int removed)
4736 {
4737 text_action **m_p;
4738 text_action *ta;
4739 asection *sec = r_reloc_get_section (loc);
4740 bfd_vma offset = loc->target_offset;
4741 bfd_vma virtual_offset = loc->virtual_offset;
4742
4743 BFD_ASSERT (action == ta_add_literal);
4744
4745 for (m_p = &l->head; *m_p != NULL; m_p = &(*m_p)->next)
4746 {
4747 if ((*m_p)->offset > offset
4748 && ((*m_p)->offset != offset
4749 || (*m_p)->virtual_offset > virtual_offset))
4750 break;
4751 }
4752
4753 /* Create a new record and fill it up. */
4754 ta = (text_action *) bfd_zmalloc (sizeof (text_action));
4755 ta->action = action;
4756 ta->sec = sec;
4757 ta->offset = offset;
4758 ta->virtual_offset = virtual_offset;
4759 ta->value = *value;
4760 ta->removed_bytes = removed;
4761 ta->next = (*m_p);
4762 *m_p = ta;
4763 }
4764
4765
4766 static bfd_vma
4767 offset_with_removed_text (text_action_list *action_list, bfd_vma offset)
4768 {
4769 text_action *r;
4770 int removed = 0;
4771
4772 for (r = action_list->head; r && r->offset <= offset; r = r->next)
4773 {
4774 if (r->offset < offset
4775 || (r->action == ta_fill && r->removed_bytes < 0))
4776 removed += r->removed_bytes;
4777 }
4778
4779 return (offset - removed);
4780 }
4781
4782
4783 static unsigned
4784 action_list_count (text_action_list *action_list)
4785 {
4786 text_action *r = action_list->head;
4787 unsigned count = 0;
4788 for (r = action_list->head; r != NULL; r = r->next)
4789 {
4790 count++;
4791 }
4792 return count;
4793 }
4794
4795
4796 static bfd_vma
4797 offset_with_removed_text_before_fill (text_action_list *action_list,
4798 bfd_vma offset)
4799 {
4800 text_action *r;
4801 int removed = 0;
4802
4803 for (r = action_list->head; r && r->offset < offset; r = r->next)
4804 removed += r->removed_bytes;
4805
4806 return (offset - removed);
4807 }
4808
4809
4810 /* The find_insn_action routine will only find non-fill actions. */
4811
4812 static text_action *
4813 find_insn_action (text_action_list *action_list, bfd_vma offset)
4814 {
4815 text_action *t;
4816 for (t = action_list->head; t; t = t->next)
4817 {
4818 if (t->offset == offset)
4819 {
4820 switch (t->action)
4821 {
4822 case ta_none:
4823 case ta_fill:
4824 break;
4825 case ta_remove_insn:
4826 case ta_remove_longcall:
4827 case ta_convert_longcall:
4828 case ta_narrow_insn:
4829 case ta_widen_insn:
4830 return t;
4831 case ta_remove_literal:
4832 case ta_add_literal:
4833 BFD_ASSERT (0);
4834 break;
4835 }
4836 }
4837 }
4838 return NULL;
4839 }
4840
4841
4842 #if DEBUG
4843
4844 static void
4845 print_action_list (FILE *fp, text_action_list *action_list)
4846 {
4847 text_action *r;
4848
4849 fprintf (fp, "Text Action\n");
4850 for (r = action_list->head; r != NULL; r = r->next)
4851 {
4852 const char *t = "unknown";
4853 switch (r->action)
4854 {
4855 case ta_remove_insn:
4856 t = "remove_insn"; break;
4857 case ta_remove_longcall:
4858 t = "remove_longcall"; break;
4859 case ta_convert_longcall:
4860 t = "remove_longcall"; break;
4861 case ta_narrow_insn:
4862 t = "narrow_insn"; break;
4863 case ta_widen_insn:
4864 t = "widen_insn"; break;
4865 case ta_fill:
4866 t = "fill"; break;
4867 case ta_none:
4868 t = "none"; break;
4869 case ta_remove_literal:
4870 t = "remove_literal"; break;
4871 case ta_add_literal:
4872 t = "add_literal"; break;
4873 }
4874
4875 fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n",
4876 r->sec->owner->filename,
4877 r->sec->name, r->offset, t, r->removed_bytes);
4878 }
4879 }
4880
4881 #endif /* DEBUG */
4882
4883 \f
4884 /* Lists of literals being coalesced or removed. */
4885
4886 /* In the usual case, the literal identified by "from" is being
4887 coalesced with another literal identified by "to". If the literal is
4888 unused and is being removed altogether, "to.abfd" will be NULL.
4889 The removed_literal entries are kept on a per-section list, sorted
4890 by the "from" offset field. */
4891
4892 typedef struct removed_literal_struct removed_literal;
4893 typedef struct removed_literal_list_struct removed_literal_list;
4894
4895 struct removed_literal_struct
4896 {
4897 r_reloc from;
4898 r_reloc to;
4899 removed_literal *next;
4900 };
4901
4902 struct removed_literal_list_struct
4903 {
4904 removed_literal *head;
4905 removed_literal *tail;
4906 };
4907
4908
4909 /* Record that the literal at "from" is being removed. If "to" is not
4910 NULL, the "from" literal is being coalesced with the "to" literal. */
4911
4912 static void
4913 add_removed_literal (removed_literal_list *removed_list,
4914 const r_reloc *from,
4915 const r_reloc *to)
4916 {
4917 removed_literal *r, *new_r, *next_r;
4918
4919 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
4920
4921 new_r->from = *from;
4922 if (to)
4923 new_r->to = *to;
4924 else
4925 new_r->to.abfd = NULL;
4926 new_r->next = NULL;
4927
4928 r = removed_list->head;
4929 if (r == NULL)
4930 {
4931 removed_list->head = new_r;
4932 removed_list->tail = new_r;
4933 }
4934 /* Special check for common case of append. */
4935 else if (removed_list->tail->from.target_offset < from->target_offset)
4936 {
4937 removed_list->tail->next = new_r;
4938 removed_list->tail = new_r;
4939 }
4940 else
4941 {
4942 while (r->from.target_offset < from->target_offset && r->next)
4943 {
4944 r = r->next;
4945 }
4946 next_r = r->next;
4947 r->next = new_r;
4948 new_r->next = next_r;
4949 if (next_r == NULL)
4950 removed_list->tail = new_r;
4951 }
4952 }
4953
4954
4955 /* Check if the list of removed literals contains an entry for the
4956 given address. Return the entry if found. */
4957
4958 static removed_literal *
4959 find_removed_literal (removed_literal_list *removed_list, bfd_vma addr)
4960 {
4961 removed_literal *r = removed_list->head;
4962 while (r && r->from.target_offset < addr)
4963 r = r->next;
4964 if (r && r->from.target_offset == addr)
4965 return r;
4966 return NULL;
4967 }
4968
4969
4970 #if DEBUG
4971
4972 static void
4973 print_removed_literals (FILE *fp, removed_literal_list *removed_list)
4974 {
4975 removed_literal *r;
4976 r = removed_list->head;
4977 if (r)
4978 fprintf (fp, "Removed Literals\n");
4979 for (; r != NULL; r = r->next)
4980 {
4981 print_r_reloc (fp, &r->from);
4982 fprintf (fp, " => ");
4983 if (r->to.abfd == NULL)
4984 fprintf (fp, "REMOVED");
4985 else
4986 print_r_reloc (fp, &r->to);
4987 fprintf (fp, "\n");
4988 }
4989 }
4990
4991 #endif /* DEBUG */
4992
4993 \f
4994 /* Per-section data for relaxation. */
4995
4996 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
4997
4998 struct xtensa_relax_info_struct
4999 {
5000 bfd_boolean is_relaxable_literal_section;
5001 bfd_boolean is_relaxable_asm_section;
5002 int visited; /* Number of times visited. */
5003
5004 source_reloc *src_relocs; /* Array[src_count]. */
5005 int src_count;
5006 int src_next; /* Next src_relocs entry to assign. */
5007
5008 removed_literal_list removed_list;
5009 text_action_list action_list;
5010
5011 reloc_bfd_fix *fix_list;
5012 reloc_bfd_fix *fix_array;
5013 unsigned fix_array_count;
5014
5015 /* Support for expanding the reloc array that is stored
5016 in the section structure. If the relocations have been
5017 reallocated, the newly allocated relocations will be referenced
5018 here along with the actual size allocated. The relocation
5019 count will always be found in the section structure. */
5020 Elf_Internal_Rela *allocated_relocs;
5021 unsigned relocs_count;
5022 unsigned allocated_relocs_count;
5023 };
5024
5025 struct elf_xtensa_section_data
5026 {
5027 struct bfd_elf_section_data elf;
5028 xtensa_relax_info relax_info;
5029 };
5030
5031
5032 static bfd_boolean
5033 elf_xtensa_new_section_hook (bfd *abfd, asection *sec)
5034 {
5035 if (!sec->used_by_bfd)
5036 {
5037 struct elf_xtensa_section_data *sdata;
5038 bfd_size_type amt = sizeof (*sdata);
5039
5040 sdata = bfd_zalloc (abfd, amt);
5041 if (sdata == NULL)
5042 return FALSE;
5043 sec->used_by_bfd = sdata;
5044 }
5045
5046 return _bfd_elf_new_section_hook (abfd, sec);
5047 }
5048
5049
5050 static xtensa_relax_info *
5051 get_xtensa_relax_info (asection *sec)
5052 {
5053 struct elf_xtensa_section_data *section_data;
5054
5055 /* No info available if no section or if it is an output section. */
5056 if (!sec || sec == sec->output_section)
5057 return NULL;
5058
5059 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
5060 return &section_data->relax_info;
5061 }
5062
5063
5064 static void
5065 init_xtensa_relax_info (asection *sec)
5066 {
5067 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5068
5069 relax_info->is_relaxable_literal_section = FALSE;
5070 relax_info->is_relaxable_asm_section = FALSE;
5071 relax_info->visited = 0;
5072
5073 relax_info->src_relocs = NULL;
5074 relax_info->src_count = 0;
5075 relax_info->src_next = 0;
5076
5077 relax_info->removed_list.head = NULL;
5078 relax_info->removed_list.tail = NULL;
5079
5080 relax_info->action_list.head = NULL;
5081
5082 relax_info->fix_list = NULL;
5083 relax_info->fix_array = NULL;
5084 relax_info->fix_array_count = 0;
5085
5086 relax_info->allocated_relocs = NULL;
5087 relax_info->relocs_count = 0;
5088 relax_info->allocated_relocs_count = 0;
5089 }
5090
5091 \f
5092 /* Coalescing literals may require a relocation to refer to a section in
5093 a different input file, but the standard relocation information
5094 cannot express that. Instead, the reloc_bfd_fix structures are used
5095 to "fix" the relocations that refer to sections in other input files.
5096 These structures are kept on per-section lists. The "src_type" field
5097 records the relocation type in case there are multiple relocations on
5098 the same location. FIXME: This is ugly; an alternative might be to
5099 add new symbols with the "owner" field to some other input file. */
5100
5101 struct reloc_bfd_fix_struct
5102 {
5103 asection *src_sec;
5104 bfd_vma src_offset;
5105 unsigned src_type; /* Relocation type. */
5106
5107 bfd *target_abfd;
5108 asection *target_sec;
5109 bfd_vma target_offset;
5110 bfd_boolean translated;
5111
5112 reloc_bfd_fix *next;
5113 };
5114
5115
5116 static reloc_bfd_fix *
5117 reloc_bfd_fix_init (asection *src_sec,
5118 bfd_vma src_offset,
5119 unsigned src_type,
5120 bfd *target_abfd,
5121 asection *target_sec,
5122 bfd_vma target_offset,
5123 bfd_boolean translated)
5124 {
5125 reloc_bfd_fix *fix;
5126
5127 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
5128 fix->src_sec = src_sec;
5129 fix->src_offset = src_offset;
5130 fix->src_type = src_type;
5131 fix->target_abfd = target_abfd;
5132 fix->target_sec = target_sec;
5133 fix->target_offset = target_offset;
5134 fix->translated = translated;
5135
5136 return fix;
5137 }
5138
5139
5140 static void
5141 add_fix (asection *src_sec, reloc_bfd_fix *fix)
5142 {
5143 xtensa_relax_info *relax_info;
5144
5145 relax_info = get_xtensa_relax_info (src_sec);
5146 fix->next = relax_info->fix_list;
5147 relax_info->fix_list = fix;
5148 }
5149
5150
5151 static int
5152 fix_compare (const void *ap, const void *bp)
5153 {
5154 const reloc_bfd_fix *a = (const reloc_bfd_fix *) ap;
5155 const reloc_bfd_fix *b = (const reloc_bfd_fix *) bp;
5156
5157 if (a->src_offset != b->src_offset)
5158 return (a->src_offset - b->src_offset);
5159 return (a->src_type - b->src_type);
5160 }
5161
5162
5163 static void
5164 cache_fix_array (asection *sec)
5165 {
5166 unsigned i, count = 0;
5167 reloc_bfd_fix *r;
5168 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5169
5170 if (relax_info == NULL)
5171 return;
5172 if (relax_info->fix_list == NULL)
5173 return;
5174
5175 for (r = relax_info->fix_list; r != NULL; r = r->next)
5176 count++;
5177
5178 relax_info->fix_array =
5179 (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix) * count);
5180 relax_info->fix_array_count = count;
5181
5182 r = relax_info->fix_list;
5183 for (i = 0; i < count; i++, r = r->next)
5184 {
5185 relax_info->fix_array[count - 1 - i] = *r;
5186 relax_info->fix_array[count - 1 - i].next = NULL;
5187 }
5188
5189 qsort (relax_info->fix_array, relax_info->fix_array_count,
5190 sizeof (reloc_bfd_fix), fix_compare);
5191 }
5192
5193
5194 static reloc_bfd_fix *
5195 get_bfd_fix (asection *sec, bfd_vma offset, unsigned type)
5196 {
5197 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
5198 reloc_bfd_fix *rv;
5199 reloc_bfd_fix key;
5200
5201 if (relax_info == NULL)
5202 return NULL;
5203 if (relax_info->fix_list == NULL)
5204 return NULL;
5205
5206 if (relax_info->fix_array == NULL)
5207 cache_fix_array (sec);
5208
5209 key.src_offset = offset;
5210 key.src_type = type;
5211 rv = bsearch (&key, relax_info->fix_array, relax_info->fix_array_count,
5212 sizeof (reloc_bfd_fix), fix_compare);
5213 return rv;
5214 }
5215
5216 \f
5217 /* Section caching. */
5218
5219 typedef struct section_cache_struct section_cache_t;
5220
5221 struct section_cache_struct
5222 {
5223 asection *sec;
5224
5225 bfd_byte *contents; /* Cache of the section contents. */
5226 bfd_size_type content_length;
5227
5228 property_table_entry *ptbl; /* Cache of the section property table. */
5229 unsigned pte_count;
5230
5231 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
5232 unsigned reloc_count;
5233 };
5234
5235
5236 static void
5237 init_section_cache (section_cache_t *sec_cache)
5238 {
5239 memset (sec_cache, 0, sizeof (*sec_cache));
5240 }
5241
5242
5243 static void
5244 clear_section_cache (section_cache_t *sec_cache)
5245 {
5246 if (sec_cache->sec)
5247 {
5248 release_contents (sec_cache->sec, sec_cache->contents);
5249 release_internal_relocs (sec_cache->sec, sec_cache->relocs);
5250 if (sec_cache->ptbl)
5251 free (sec_cache->ptbl);
5252 memset (sec_cache, 0, sizeof (sec_cache));
5253 }
5254 }
5255
5256
5257 static bfd_boolean
5258 section_cache_section (section_cache_t *sec_cache,
5259 asection *sec,
5260 struct bfd_link_info *link_info)
5261 {
5262 bfd *abfd;
5263 property_table_entry *prop_table = NULL;
5264 int ptblsize = 0;
5265 bfd_byte *contents = NULL;
5266 Elf_Internal_Rela *internal_relocs = NULL;
5267 bfd_size_type sec_size;
5268
5269 if (sec == NULL)
5270 return FALSE;
5271 if (sec == sec_cache->sec)
5272 return TRUE;
5273
5274 abfd = sec->owner;
5275 sec_size = bfd_get_section_limit (abfd, sec);
5276
5277 /* Get the contents. */
5278 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5279 if (contents == NULL && sec_size != 0)
5280 goto err;
5281
5282 /* Get the relocations. */
5283 internal_relocs = retrieve_internal_relocs (abfd, sec,
5284 link_info->keep_memory);
5285
5286 /* Get the entry table. */
5287 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
5288 XTENSA_PROP_SEC_NAME, FALSE);
5289 if (ptblsize < 0)
5290 goto err;
5291
5292 /* Fill in the new section cache. */
5293 clear_section_cache (sec_cache);
5294 memset (sec_cache, 0, sizeof (sec_cache));
5295
5296 sec_cache->sec = sec;
5297 sec_cache->contents = contents;
5298 sec_cache->content_length = sec_size;
5299 sec_cache->relocs = internal_relocs;
5300 sec_cache->reloc_count = sec->reloc_count;
5301 sec_cache->pte_count = ptblsize;
5302 sec_cache->ptbl = prop_table;
5303
5304 return TRUE;
5305
5306 err:
5307 release_contents (sec, contents);
5308 release_internal_relocs (sec, internal_relocs);
5309 if (prop_table)
5310 free (prop_table);
5311 return FALSE;
5312 }
5313
5314 \f
5315 /* Extended basic blocks. */
5316
5317 /* An ebb_struct represents an Extended Basic Block. Within this
5318 range, we guarantee that all instructions are decodable, the
5319 property table entries are contiguous, and no property table
5320 specifies a segment that cannot have instructions moved. This
5321 structure contains caches of the contents, property table and
5322 relocations for the specified section for easy use. The range is
5323 specified by ranges of indices for the byte offset, property table
5324 offsets and relocation offsets. These must be consistent. */
5325
5326 typedef struct ebb_struct ebb_t;
5327
5328 struct ebb_struct
5329 {
5330 asection *sec;
5331
5332 bfd_byte *contents; /* Cache of the section contents. */
5333 bfd_size_type content_length;
5334
5335 property_table_entry *ptbl; /* Cache of the section property table. */
5336 unsigned pte_count;
5337
5338 Elf_Internal_Rela *relocs; /* Cache of the section relocations. */
5339 unsigned reloc_count;
5340
5341 bfd_vma start_offset; /* Offset in section. */
5342 unsigned start_ptbl_idx; /* Offset in the property table. */
5343 unsigned start_reloc_idx; /* Offset in the relocations. */
5344
5345 bfd_vma end_offset;
5346 unsigned end_ptbl_idx;
5347 unsigned end_reloc_idx;
5348
5349 bfd_boolean ends_section; /* Is this the last ebb in a section? */
5350
5351 /* The unreachable property table at the end of this set of blocks;
5352 NULL if the end is not an unreachable block. */
5353 property_table_entry *ends_unreachable;
5354 };
5355
5356
5357 enum ebb_target_enum
5358 {
5359 EBB_NO_ALIGN = 0,
5360 EBB_DESIRE_TGT_ALIGN,
5361 EBB_REQUIRE_TGT_ALIGN,
5362 EBB_REQUIRE_LOOP_ALIGN,
5363 EBB_REQUIRE_ALIGN
5364 };
5365
5366
5367 /* proposed_action_struct is similar to the text_action_struct except
5368 that is represents a potential transformation, not one that will
5369 occur. We build a list of these for an extended basic block
5370 and use them to compute the actual actions desired. We must be
5371 careful that the entire set of actual actions we perform do not
5372 break any relocations that would fit if the actions were not
5373 performed. */
5374
5375 typedef struct proposed_action_struct proposed_action;
5376
5377 struct proposed_action_struct
5378 {
5379 enum ebb_target_enum align_type; /* for the target alignment */
5380 bfd_vma alignment_pow;
5381 text_action_t action;
5382 bfd_vma offset;
5383 int removed_bytes;
5384 bfd_boolean do_action; /* If false, then we will not perform the action. */
5385 };
5386
5387
5388 /* The ebb_constraint_struct keeps a set of proposed actions for an
5389 extended basic block. */
5390
5391 typedef struct ebb_constraint_struct ebb_constraint;
5392
5393 struct ebb_constraint_struct
5394 {
5395 ebb_t ebb;
5396 bfd_boolean start_movable;
5397
5398 /* Bytes of extra space at the beginning if movable. */
5399 int start_extra_space;
5400
5401 enum ebb_target_enum start_align;
5402
5403 bfd_boolean end_movable;
5404
5405 /* Bytes of extra space at the end if movable. */
5406 int end_extra_space;
5407
5408 unsigned action_count;
5409 unsigned action_allocated;
5410
5411 /* Array of proposed actions. */
5412 proposed_action *actions;
5413
5414 /* Action alignments -- one for each proposed action. */
5415 enum ebb_target_enum *action_aligns;
5416 };
5417
5418
5419 static void
5420 init_ebb_constraint (ebb_constraint *c)
5421 {
5422 memset (c, 0, sizeof (ebb_constraint));
5423 }
5424
5425
5426 static void
5427 free_ebb_constraint (ebb_constraint *c)
5428 {
5429 if (c->actions)
5430 free (c->actions);
5431 }
5432
5433
5434 static void
5435 init_ebb (ebb_t *ebb,
5436 asection *sec,
5437 bfd_byte *contents,
5438 bfd_size_type content_length,
5439 property_table_entry *prop_table,
5440 unsigned ptblsize,
5441 Elf_Internal_Rela *internal_relocs,
5442 unsigned reloc_count)
5443 {
5444 memset (ebb, 0, sizeof (ebb_t));
5445 ebb->sec = sec;
5446 ebb->contents = contents;
5447 ebb->content_length = content_length;
5448 ebb->ptbl = prop_table;
5449 ebb->pte_count = ptblsize;
5450 ebb->relocs = internal_relocs;
5451 ebb->reloc_count = reloc_count;
5452 ebb->start_offset = 0;
5453 ebb->end_offset = ebb->content_length - 1;
5454 ebb->start_ptbl_idx = 0;
5455 ebb->end_ptbl_idx = ptblsize;
5456 ebb->start_reloc_idx = 0;
5457 ebb->end_reloc_idx = reloc_count;
5458 }
5459
5460
5461 /* Extend the ebb to all decodable contiguous sections. The algorithm
5462 for building a basic block around an instruction is to push it
5463 forward until we hit the end of a section, an unreachable block or
5464 a block that cannot be transformed. Then we push it backwards
5465 searching for similar conditions. */
5466
5467 static bfd_boolean extend_ebb_bounds_forward (ebb_t *);
5468 static bfd_boolean extend_ebb_bounds_backward (ebb_t *);
5469 static bfd_size_type insn_block_decodable_len
5470 (bfd_byte *, bfd_size_type, bfd_vma, bfd_size_type);
5471
5472 static bfd_boolean
5473 extend_ebb_bounds (ebb_t *ebb)
5474 {
5475 if (!extend_ebb_bounds_forward (ebb))
5476 return FALSE;
5477 if (!extend_ebb_bounds_backward (ebb))
5478 return FALSE;
5479 return TRUE;
5480 }
5481
5482
5483 static bfd_boolean
5484 extend_ebb_bounds_forward (ebb_t *ebb)
5485 {
5486 property_table_entry *the_entry, *new_entry;
5487
5488 the_entry = &ebb->ptbl[ebb->end_ptbl_idx];
5489
5490 /* Stop when (1) we cannot decode an instruction, (2) we are at
5491 the end of the property tables, (3) we hit a non-contiguous property
5492 table entry, (4) we hit a NO_TRANSFORM region. */
5493
5494 while (1)
5495 {
5496 bfd_vma entry_end;
5497 bfd_size_type insn_block_len;
5498
5499 entry_end = the_entry->address - ebb->sec->vma + the_entry->size;
5500 insn_block_len =
5501 insn_block_decodable_len (ebb->contents, ebb->content_length,
5502 ebb->end_offset,
5503 entry_end - ebb->end_offset);
5504 if (insn_block_len != (entry_end - ebb->end_offset))
5505 {
5506 (*_bfd_error_handler)
5507 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
5508 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
5509 return FALSE;
5510 }
5511 ebb->end_offset += insn_block_len;
5512
5513 if (ebb->end_offset == ebb->sec->size)
5514 ebb->ends_section = TRUE;
5515
5516 /* Update the reloc counter. */
5517 while (ebb->end_reloc_idx + 1 < ebb->reloc_count
5518 && (ebb->relocs[ebb->end_reloc_idx + 1].r_offset
5519 < ebb->end_offset))
5520 {
5521 ebb->end_reloc_idx++;
5522 }
5523
5524 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
5525 return TRUE;
5526
5527 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
5528 if (((new_entry->flags & XTENSA_PROP_INSN) == 0)
5529 || ((new_entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) != 0)
5530 || ((the_entry->flags & XTENSA_PROP_ALIGN) != 0))
5531 break;
5532
5533 if (the_entry->address + the_entry->size != new_entry->address)
5534 break;
5535
5536 the_entry = new_entry;
5537 ebb->end_ptbl_idx++;
5538 }
5539
5540 /* Quick check for an unreachable or end of file just at the end. */
5541 if (ebb->end_ptbl_idx + 1 == ebb->pte_count)
5542 {
5543 if (ebb->end_offset == ebb->content_length)
5544 ebb->ends_section = TRUE;
5545 }
5546 else
5547 {
5548 new_entry = &ebb->ptbl[ebb->end_ptbl_idx + 1];
5549 if ((new_entry->flags & XTENSA_PROP_UNREACHABLE) != 0
5550 && the_entry->address + the_entry->size == new_entry->address)
5551 ebb->ends_unreachable = new_entry;
5552 }
5553
5554 /* Any other ending requires exact alignment. */
5555 return TRUE;
5556 }
5557
5558
5559 static bfd_boolean
5560 extend_ebb_bounds_backward (ebb_t *ebb)
5561 {
5562 property_table_entry *the_entry, *new_entry;
5563
5564 the_entry = &ebb->ptbl[ebb->start_ptbl_idx];
5565
5566 /* Stop when (1) we cannot decode the instructions in the current entry.
5567 (2) we are at the beginning of the property tables, (3) we hit a
5568 non-contiguous property table entry, (4) we hit a NO_TRANSFORM region. */
5569
5570 while (1)
5571 {
5572 bfd_vma block_begin;
5573 bfd_size_type insn_block_len;
5574
5575 block_begin = the_entry->address - ebb->sec->vma;
5576 insn_block_len =
5577 insn_block_decodable_len (ebb->contents, ebb->content_length,
5578 block_begin,
5579 ebb->start_offset - block_begin);
5580 if (insn_block_len != ebb->start_offset - block_begin)
5581 {
5582 (*_bfd_error_handler)
5583 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
5584 ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len);
5585 return FALSE;
5586 }
5587 ebb->start_offset -= insn_block_len;
5588
5589 /* Update the reloc counter. */
5590 while (ebb->start_reloc_idx > 0
5591 && (ebb->relocs[ebb->start_reloc_idx - 1].r_offset
5592 >= ebb->start_offset))
5593 {
5594 ebb->start_reloc_idx--;
5595 }
5596
5597 if (ebb->start_ptbl_idx == 0)
5598 return TRUE;
5599
5600 new_entry = &ebb->ptbl[ebb->start_ptbl_idx - 1];
5601 if ((new_entry->flags & XTENSA_PROP_INSN) == 0
5602 || ((new_entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) != 0)
5603 || ((new_entry->flags & XTENSA_PROP_ALIGN) != 0))
5604 return TRUE;
5605 if (new_entry->address + new_entry->size != the_entry->address)
5606 return TRUE;
5607
5608 the_entry = new_entry;
5609 ebb->start_ptbl_idx--;
5610 }
5611 return TRUE;
5612 }
5613
5614
5615 static bfd_size_type
5616 insn_block_decodable_len (bfd_byte *contents,
5617 bfd_size_type content_len,
5618 bfd_vma block_offset,
5619 bfd_size_type block_len)
5620 {
5621 bfd_vma offset = block_offset;
5622
5623 while (offset < block_offset + block_len)
5624 {
5625 bfd_size_type insn_len = 0;
5626
5627 insn_len = insn_decode_len (contents, content_len, offset);
5628 if (insn_len == 0)
5629 return (offset - block_offset);
5630 offset += insn_len;
5631 }
5632 return (offset - block_offset);
5633 }
5634
5635
5636 static void
5637 ebb_propose_action (ebb_constraint *c,
5638 enum ebb_target_enum align_type,
5639 bfd_vma alignment_pow,
5640 text_action_t action,
5641 bfd_vma offset,
5642 int removed_bytes,
5643 bfd_boolean do_action)
5644 {
5645 proposed_action *act;
5646
5647 if (c->action_allocated <= c->action_count)
5648 {
5649 unsigned new_allocated, i;
5650 proposed_action *new_actions;
5651
5652 new_allocated = (c->action_count + 2) * 2;
5653 new_actions = (proposed_action *)
5654 bfd_zmalloc (sizeof (proposed_action) * new_allocated);
5655
5656 for (i = 0; i < c->action_count; i++)
5657 new_actions[i] = c->actions[i];
5658 if (c->actions)
5659 free (c->actions);
5660 c->actions = new_actions;
5661 c->action_allocated = new_allocated;
5662 }
5663
5664 act = &c->actions[c->action_count];
5665 act->align_type = align_type;
5666 act->alignment_pow = alignment_pow;
5667 act->action = action;
5668 act->offset = offset;
5669 act->removed_bytes = removed_bytes;
5670 act->do_action = do_action;
5671
5672 c->action_count++;
5673 }
5674
5675 \f
5676 /* Access to internal relocations, section contents and symbols. */
5677
5678 /* During relaxation, we need to modify relocations, section contents,
5679 and symbol definitions, and we need to keep the original values from
5680 being reloaded from the input files, i.e., we need to "pin" the
5681 modified values in memory. We also want to continue to observe the
5682 setting of the "keep-memory" flag. The following functions wrap the
5683 standard BFD functions to take care of this for us. */
5684
5685 static Elf_Internal_Rela *
5686 retrieve_internal_relocs (bfd *abfd, asection *sec, bfd_boolean keep_memory)
5687 {
5688 Elf_Internal_Rela *internal_relocs;
5689
5690 if ((sec->flags & SEC_LINKER_CREATED) != 0)
5691 return NULL;
5692
5693 internal_relocs = elf_section_data (sec)->relocs;
5694 if (internal_relocs == NULL)
5695 internal_relocs = (_bfd_elf_link_read_relocs
5696 (abfd, sec, NULL, NULL, keep_memory));
5697 return internal_relocs;
5698 }
5699
5700
5701 static void
5702 pin_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
5703 {
5704 elf_section_data (sec)->relocs = internal_relocs;
5705 }
5706
5707
5708 static void
5709 release_internal_relocs (asection *sec, Elf_Internal_Rela *internal_relocs)
5710 {
5711 if (internal_relocs
5712 && elf_section_data (sec)->relocs != internal_relocs)
5713 free (internal_relocs);
5714 }
5715
5716
5717 static bfd_byte *
5718 retrieve_contents (bfd *abfd, asection *sec, bfd_boolean keep_memory)
5719 {
5720 bfd_byte *contents;
5721 bfd_size_type sec_size;
5722
5723 sec_size = bfd_get_section_limit (abfd, sec);
5724 contents = elf_section_data (sec)->this_hdr.contents;
5725
5726 if (contents == NULL && sec_size != 0)
5727 {
5728 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
5729 {
5730 if (contents)
5731 free (contents);
5732 return NULL;
5733 }
5734 if (keep_memory)
5735 elf_section_data (sec)->this_hdr.contents = contents;
5736 }
5737 return contents;
5738 }
5739
5740
5741 static void
5742 pin_contents (asection *sec, bfd_byte *contents)
5743 {
5744 elf_section_data (sec)->this_hdr.contents = contents;
5745 }
5746
5747
5748 static void
5749 release_contents (asection *sec, bfd_byte *contents)
5750 {
5751 if (contents && elf_section_data (sec)->this_hdr.contents != contents)
5752 free (contents);
5753 }
5754
5755
5756 static Elf_Internal_Sym *
5757 retrieve_local_syms (bfd *input_bfd)
5758 {
5759 Elf_Internal_Shdr *symtab_hdr;
5760 Elf_Internal_Sym *isymbuf;
5761 size_t locsymcount;
5762
5763 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5764 locsymcount = symtab_hdr->sh_info;
5765
5766 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5767 if (isymbuf == NULL && locsymcount != 0)
5768 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
5769 NULL, NULL, NULL);
5770
5771 /* Save the symbols for this input file so they won't be read again. */
5772 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
5773 symtab_hdr->contents = (unsigned char *) isymbuf;
5774
5775 return isymbuf;
5776 }
5777
5778 \f
5779 /* Code for link-time relaxation. */
5780
5781 /* Initialization for relaxation: */
5782 static bfd_boolean analyze_relocations (struct bfd_link_info *);
5783 static bfd_boolean find_relaxable_sections
5784 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
5785 static bfd_boolean collect_source_relocs
5786 (bfd *, asection *, struct bfd_link_info *);
5787 static bfd_boolean is_resolvable_asm_expansion
5788 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, struct bfd_link_info *,
5789 bfd_boolean *);
5790 static Elf_Internal_Rela *find_associated_l32r_irel
5791 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Rela *);
5792 static bfd_boolean compute_text_actions
5793 (bfd *, asection *, struct bfd_link_info *);
5794 static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *);
5795 static bfd_boolean compute_ebb_actions (ebb_constraint *);
5796 static bfd_boolean check_section_ebb_pcrels_fit
5797 (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, const ebb_constraint *,
5798 const xtensa_opcode *);
5799 static bfd_boolean check_section_ebb_reduces (const ebb_constraint *);
5800 static void text_action_add_proposed
5801 (text_action_list *, const ebb_constraint *, asection *);
5802 static int compute_fill_extra_space (property_table_entry *);
5803
5804 /* First pass: */
5805 static bfd_boolean compute_removed_literals
5806 (bfd *, asection *, struct bfd_link_info *, value_map_hash_table *);
5807 static Elf_Internal_Rela *get_irel_at_offset
5808 (asection *, Elf_Internal_Rela *, bfd_vma);
5809 static bfd_boolean is_removable_literal
5810 (const source_reloc *, int, const source_reloc *, int);
5811 static bfd_boolean remove_dead_literal
5812 (bfd *, asection *, struct bfd_link_info *, Elf_Internal_Rela *,
5813 Elf_Internal_Rela *, source_reloc *, property_table_entry *, int);
5814 static bfd_boolean identify_literal_placement
5815 (bfd *, asection *, bfd_byte *, struct bfd_link_info *,
5816 value_map_hash_table *, bfd_boolean *, Elf_Internal_Rela *, int,
5817 source_reloc *, property_table_entry *, int, section_cache_t *,
5818 bfd_boolean);
5819 static bfd_boolean relocations_reach (source_reloc *, int, const r_reloc *);
5820 static bfd_boolean coalesce_shared_literal
5821 (asection *, source_reloc *, property_table_entry *, int, value_map *);
5822 static bfd_boolean move_shared_literal
5823 (asection *, struct bfd_link_info *, source_reloc *, property_table_entry *,
5824 int, const r_reloc *, const literal_value *, section_cache_t *);
5825
5826 /* Second pass: */
5827 static bfd_boolean relax_section (bfd *, asection *, struct bfd_link_info *);
5828 static bfd_boolean translate_section_fixes (asection *);
5829 static bfd_boolean translate_reloc_bfd_fix (reloc_bfd_fix *);
5830 static void translate_reloc (const r_reloc *, r_reloc *);
5831 static void shrink_dynamic_reloc_sections
5832 (struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *);
5833 static bfd_boolean move_literal
5834 (bfd *, struct bfd_link_info *, asection *, bfd_vma, bfd_byte *,
5835 xtensa_relax_info *, Elf_Internal_Rela **, const literal_value *);
5836 static bfd_boolean relax_property_section
5837 (bfd *, asection *, struct bfd_link_info *);
5838
5839 /* Third pass: */
5840 static bfd_boolean relax_section_symbols (bfd *, asection *);
5841
5842
5843 static bfd_boolean
5844 elf_xtensa_relax_section (bfd *abfd,
5845 asection *sec,
5846 struct bfd_link_info *link_info,
5847 bfd_boolean *again)
5848 {
5849 static value_map_hash_table *values = NULL;
5850 static bfd_boolean relocations_analyzed = FALSE;
5851 xtensa_relax_info *relax_info;
5852
5853 if (!relocations_analyzed)
5854 {
5855 /* Do some overall initialization for relaxation. */
5856 values = value_map_hash_table_init ();
5857 if (values == NULL)
5858 return FALSE;
5859 relaxing_section = TRUE;
5860 if (!analyze_relocations (link_info))
5861 return FALSE;
5862 relocations_analyzed = TRUE;
5863 }
5864 *again = FALSE;
5865
5866 /* Don't mess with linker-created sections. */
5867 if ((sec->flags & SEC_LINKER_CREATED) != 0)
5868 return TRUE;
5869
5870 relax_info = get_xtensa_relax_info (sec);
5871 BFD_ASSERT (relax_info != NULL);
5872
5873 switch (relax_info->visited)
5874 {
5875 case 0:
5876 /* Note: It would be nice to fold this pass into
5877 analyze_relocations, but it is important for this step that the
5878 sections be examined in link order. */
5879 if (!compute_removed_literals (abfd, sec, link_info, values))
5880 return FALSE;
5881 *again = TRUE;
5882 break;
5883
5884 case 1:
5885 if (values)
5886 value_map_hash_table_delete (values);
5887 values = NULL;
5888 if (!relax_section (abfd, sec, link_info))
5889 return FALSE;
5890 *again = TRUE;
5891 break;
5892
5893 case 2:
5894 if (!relax_section_symbols (abfd, sec))
5895 return FALSE;
5896 break;
5897 }
5898
5899 relax_info->visited++;
5900 return TRUE;
5901 }
5902
5903 \f
5904 /* Initialization for relaxation. */
5905
5906 /* This function is called once at the start of relaxation. It scans
5907 all the input sections and marks the ones that are relaxable (i.e.,
5908 literal sections with L32R relocations against them), and then
5909 collects source_reloc information for all the relocations against
5910 those relaxable sections. During this process, it also detects
5911 longcalls, i.e., calls relaxed by the assembler into indirect
5912 calls, that can be optimized back into direct calls. Within each
5913 extended basic block (ebb) containing an optimized longcall, it
5914 computes a set of "text actions" that can be performed to remove
5915 the L32R associated with the longcall while optionally preserving
5916 branch target alignments. */
5917
5918 static bfd_boolean
5919 analyze_relocations (struct bfd_link_info *link_info)
5920 {
5921 bfd *abfd;
5922 asection *sec;
5923 bfd_boolean is_relaxable = FALSE;
5924
5925 /* Initialize the per-section relaxation info. */
5926 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5927 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5928 {
5929 init_xtensa_relax_info (sec);
5930 }
5931
5932 /* Mark relaxable sections (and count relocations against each one). */
5933 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5934 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5935 {
5936 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
5937 return FALSE;
5938 }
5939
5940 /* Bail out if there are no relaxable sections. */
5941 if (!is_relaxable)
5942 return TRUE;
5943
5944 /* Allocate space for source_relocs. */
5945 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5946 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5947 {
5948 xtensa_relax_info *relax_info;
5949
5950 relax_info = get_xtensa_relax_info (sec);
5951 if (relax_info->is_relaxable_literal_section
5952 || relax_info->is_relaxable_asm_section)
5953 {
5954 relax_info->src_relocs = (source_reloc *)
5955 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
5956 }
5957 }
5958
5959 /* Collect info on relocations against each relaxable section. */
5960 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5961 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5962 {
5963 if (!collect_source_relocs (abfd, sec, link_info))
5964 return FALSE;
5965 }
5966
5967 /* Compute the text actions. */
5968 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
5969 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5970 {
5971 if (!compute_text_actions (abfd, sec, link_info))
5972 return FALSE;
5973 }
5974
5975 return TRUE;
5976 }
5977
5978
5979 /* Find all the sections that might be relaxed. The motivation for
5980 this pass is that collect_source_relocs() needs to record _all_ the
5981 relocations that target each relaxable section. That is expensive
5982 and unnecessary unless the target section is actually going to be
5983 relaxed. This pass identifies all such sections by checking if
5984 they have L32Rs pointing to them. In the process, the total number
5985 of relocations targeting each section is also counted so that we
5986 know how much space to allocate for source_relocs against each
5987 relaxable literal section. */
5988
5989 static bfd_boolean
5990 find_relaxable_sections (bfd *abfd,
5991 asection *sec,
5992 struct bfd_link_info *link_info,
5993 bfd_boolean *is_relaxable_p)
5994 {
5995 Elf_Internal_Rela *internal_relocs;
5996 bfd_byte *contents;
5997 bfd_boolean ok = TRUE;
5998 unsigned i;
5999 xtensa_relax_info *source_relax_info;
6000
6001 internal_relocs = retrieve_internal_relocs (abfd, sec,
6002 link_info->keep_memory);
6003 if (internal_relocs == NULL)
6004 return ok;
6005
6006 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6007 if (contents == NULL && sec->size != 0)
6008 {
6009 ok = FALSE;
6010 goto error_return;
6011 }
6012
6013 source_relax_info = get_xtensa_relax_info (sec);
6014 for (i = 0; i < sec->reloc_count; i++)
6015 {
6016 Elf_Internal_Rela *irel = &internal_relocs[i];
6017 r_reloc r_rel;
6018 asection *target_sec;
6019 xtensa_relax_info *target_relax_info;
6020
6021 /* If this section has not already been marked as "relaxable", and
6022 if it contains any ASM_EXPAND relocations (marking expanded
6023 longcalls) that can be optimized into direct calls, then mark
6024 the section as "relaxable". */
6025 if (source_relax_info
6026 && !source_relax_info->is_relaxable_asm_section
6027 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_EXPAND)
6028 {
6029 bfd_boolean is_reachable = FALSE;
6030 if (is_resolvable_asm_expansion (abfd, sec, contents, irel,
6031 link_info, &is_reachable)
6032 && is_reachable)
6033 {
6034 source_relax_info->is_relaxable_asm_section = TRUE;
6035 *is_relaxable_p = TRUE;
6036 }
6037 }
6038
6039 r_reloc_init (&r_rel, abfd, irel, contents,
6040 bfd_get_section_limit (abfd, sec));
6041
6042 target_sec = r_reloc_get_section (&r_rel);
6043 target_relax_info = get_xtensa_relax_info (target_sec);
6044 if (!target_relax_info)
6045 continue;
6046
6047 /* Count PC-relative operand relocations against the target section.
6048 Note: The conditions tested here must match the conditions under
6049 which init_source_reloc is called in collect_source_relocs(). */
6050 if (is_operand_relocation (ELF32_R_TYPE (irel->r_info))
6051 && (!is_alt_relocation (ELF32_R_TYPE (irel->r_info))
6052 || is_l32r_relocation (abfd, sec, contents, irel)))
6053 target_relax_info->src_count++;
6054
6055 if (is_l32r_relocation (abfd, sec, contents, irel)
6056 && r_reloc_is_defined (&r_rel))
6057 {
6058 /* Mark the target section as relaxable. */
6059 target_relax_info->is_relaxable_literal_section = TRUE;
6060 *is_relaxable_p = TRUE;
6061 }
6062 }
6063
6064 error_return:
6065 release_contents (sec, contents);
6066 release_internal_relocs (sec, internal_relocs);
6067 return ok;
6068 }
6069
6070
6071 /* Record _all_ the relocations that point to relaxable sections, and
6072 get rid of ASM_EXPAND relocs by either converting them to
6073 ASM_SIMPLIFY or by removing them. */
6074
6075 static bfd_boolean
6076 collect_source_relocs (bfd *abfd,
6077 asection *sec,
6078 struct bfd_link_info *link_info)
6079 {
6080 Elf_Internal_Rela *internal_relocs;
6081 bfd_byte *contents;
6082 bfd_boolean ok = TRUE;
6083 unsigned i;
6084 bfd_size_type sec_size;
6085
6086 internal_relocs = retrieve_internal_relocs (abfd, sec,
6087 link_info->keep_memory);
6088 if (internal_relocs == NULL)
6089 return ok;
6090
6091 sec_size = bfd_get_section_limit (abfd, sec);
6092 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6093 if (contents == NULL && sec_size != 0)
6094 {
6095 ok = FALSE;
6096 goto error_return;
6097 }
6098
6099 /* Record relocations against relaxable literal sections. */
6100 for (i = 0; i < sec->reloc_count; i++)
6101 {
6102 Elf_Internal_Rela *irel = &internal_relocs[i];
6103 r_reloc r_rel;
6104 asection *target_sec;
6105 xtensa_relax_info *target_relax_info;
6106
6107 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6108
6109 target_sec = r_reloc_get_section (&r_rel);
6110 target_relax_info = get_xtensa_relax_info (target_sec);
6111
6112 if (target_relax_info
6113 && (target_relax_info->is_relaxable_literal_section
6114 || target_relax_info->is_relaxable_asm_section))
6115 {
6116 xtensa_opcode opcode = XTENSA_UNDEFINED;
6117 int opnd = -1;
6118 bfd_boolean is_abs_literal = FALSE;
6119
6120 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
6121 {
6122 /* None of the current alternate relocs are PC-relative,
6123 and only PC-relative relocs matter here. However, we
6124 still need to record the opcode for literal
6125 coalescing. */
6126 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6127 if (opcode == get_l32r_opcode ())
6128 {
6129 is_abs_literal = TRUE;
6130 opnd = 1;
6131 }
6132 else
6133 opcode = XTENSA_UNDEFINED;
6134 }
6135 else if (is_operand_relocation (ELF32_R_TYPE (irel->r_info)))
6136 {
6137 opcode = get_relocation_opcode (abfd, sec, contents, irel);
6138 opnd = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
6139 }
6140
6141 if (opcode != XTENSA_UNDEFINED)
6142 {
6143 int src_next = target_relax_info->src_next++;
6144 source_reloc *s_reloc = &target_relax_info->src_relocs[src_next];
6145
6146 init_source_reloc (s_reloc, sec, &r_rel, opcode, opnd,
6147 is_abs_literal);
6148 }
6149 }
6150 }
6151
6152 /* Now get rid of ASM_EXPAND relocations. At this point, the
6153 src_relocs array for the target literal section may still be
6154 incomplete, but it must at least contain the entries for the L32R
6155 relocations associated with ASM_EXPANDs because they were just
6156 added in the preceding loop over the relocations. */
6157
6158 for (i = 0; i < sec->reloc_count; i++)
6159 {
6160 Elf_Internal_Rela *irel = &internal_relocs[i];
6161 bfd_boolean is_reachable;
6162
6163 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
6164 &is_reachable))
6165 continue;
6166
6167 if (is_reachable)
6168 {
6169 Elf_Internal_Rela *l32r_irel;
6170 r_reloc r_rel;
6171 asection *target_sec;
6172 xtensa_relax_info *target_relax_info;
6173
6174 /* Mark the source_reloc for the L32R so that it will be
6175 removed in compute_removed_literals(), along with the
6176 associated literal. */
6177 l32r_irel = find_associated_l32r_irel (abfd, sec, contents,
6178 irel, internal_relocs);
6179 if (l32r_irel == NULL)
6180 continue;
6181
6182 r_reloc_init (&r_rel, abfd, l32r_irel, contents, sec_size);
6183
6184 target_sec = r_reloc_get_section (&r_rel);
6185 target_relax_info = get_xtensa_relax_info (target_sec);
6186
6187 if (target_relax_info
6188 && (target_relax_info->is_relaxable_literal_section
6189 || target_relax_info->is_relaxable_asm_section))
6190 {
6191 source_reloc *s_reloc;
6192
6193 /* Search the source_relocs for the entry corresponding to
6194 the l32r_irel. Note: The src_relocs array is not yet
6195 sorted, but it wouldn't matter anyway because we're
6196 searching by source offset instead of target offset. */
6197 s_reloc = find_source_reloc (target_relax_info->src_relocs,
6198 target_relax_info->src_next,
6199 sec, l32r_irel);
6200 BFD_ASSERT (s_reloc);
6201 s_reloc->is_null = TRUE;
6202 }
6203
6204 /* Convert this reloc to ASM_SIMPLIFY. */
6205 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
6206 R_XTENSA_ASM_SIMPLIFY);
6207 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
6208
6209 pin_internal_relocs (sec, internal_relocs);
6210 }
6211 else
6212 {
6213 /* It is resolvable but doesn't reach. We resolve now
6214 by eliminating the relocation -- the call will remain
6215 expanded into L32R/CALLX. */
6216 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
6217 pin_internal_relocs (sec, internal_relocs);
6218 }
6219 }
6220
6221 error_return:
6222 release_contents (sec, contents);
6223 release_internal_relocs (sec, internal_relocs);
6224 return ok;
6225 }
6226
6227
6228 /* Return TRUE if the asm expansion can be resolved. Generally it can
6229 be resolved on a final link or when a partial link locates it in the
6230 same section as the target. Set "is_reachable" flag if the target of
6231 the call is within the range of a direct call, given the current VMA
6232 for this section and the target section. */
6233
6234 bfd_boolean
6235 is_resolvable_asm_expansion (bfd *abfd,
6236 asection *sec,
6237 bfd_byte *contents,
6238 Elf_Internal_Rela *irel,
6239 struct bfd_link_info *link_info,
6240 bfd_boolean *is_reachable_p)
6241 {
6242 asection *target_sec;
6243 bfd_vma target_offset;
6244 r_reloc r_rel;
6245 xtensa_opcode opcode, direct_call_opcode;
6246 bfd_vma self_address;
6247 bfd_vma dest_address;
6248 bfd_boolean uses_l32r;
6249 bfd_size_type sec_size;
6250
6251 *is_reachable_p = FALSE;
6252
6253 if (contents == NULL)
6254 return FALSE;
6255
6256 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
6257 return FALSE;
6258
6259 sec_size = bfd_get_section_limit (abfd, sec);
6260 opcode = get_expanded_call_opcode (contents + irel->r_offset,
6261 sec_size - irel->r_offset, &uses_l32r);
6262 /* Optimization of longcalls that use CONST16 is not yet implemented. */
6263 if (!uses_l32r)
6264 return FALSE;
6265
6266 direct_call_opcode = swap_callx_for_call_opcode (opcode);
6267 if (direct_call_opcode == XTENSA_UNDEFINED)
6268 return FALSE;
6269
6270 /* Check and see that the target resolves. */
6271 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
6272 if (!r_reloc_is_defined (&r_rel))
6273 return FALSE;
6274
6275 target_sec = r_reloc_get_section (&r_rel);
6276 target_offset = r_rel.target_offset;
6277
6278 /* If the target is in a shared library, then it doesn't reach. This
6279 isn't supposed to come up because the compiler should never generate
6280 non-PIC calls on systems that use shared libraries, but the linker
6281 shouldn't crash regardless. */
6282 if (!target_sec->output_section)
6283 return FALSE;
6284
6285 /* For relocatable sections, we can only simplify when the output
6286 section of the target is the same as the output section of the
6287 source. */
6288 if (link_info->relocatable
6289 && (target_sec->output_section != sec->output_section
6290 || is_reloc_sym_weak (abfd, irel)))
6291 return FALSE;
6292
6293 self_address = (sec->output_section->vma
6294 + sec->output_offset + irel->r_offset + 3);
6295 dest_address = (target_sec->output_section->vma
6296 + target_sec->output_offset + target_offset);
6297
6298 *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0,
6299 self_address, dest_address);
6300
6301 if ((self_address >> CALL_SEGMENT_BITS) !=
6302 (dest_address >> CALL_SEGMENT_BITS))
6303 return FALSE;
6304
6305 return TRUE;
6306 }
6307
6308
6309 static Elf_Internal_Rela *
6310 find_associated_l32r_irel (bfd *abfd,
6311 asection *sec,
6312 bfd_byte *contents,
6313 Elf_Internal_Rela *other_irel,
6314 Elf_Internal_Rela *internal_relocs)
6315 {
6316 unsigned i;
6317
6318 for (i = 0; i < sec->reloc_count; i++)
6319 {
6320 Elf_Internal_Rela *irel = &internal_relocs[i];
6321
6322 if (irel == other_irel)
6323 continue;
6324 if (irel->r_offset != other_irel->r_offset)
6325 continue;
6326 if (is_l32r_relocation (abfd, sec, contents, irel))
6327 return irel;
6328 }
6329
6330 return NULL;
6331 }
6332
6333
6334 static xtensa_opcode *
6335 build_reloc_opcodes (bfd *abfd,
6336 asection *sec,
6337 bfd_byte *contents,
6338 Elf_Internal_Rela *internal_relocs)
6339 {
6340 unsigned i;
6341 xtensa_opcode *reloc_opcodes =
6342 (xtensa_opcode *) bfd_malloc (sizeof (xtensa_opcode) * sec->reloc_count);
6343 for (i = 0; i < sec->reloc_count; i++)
6344 {
6345 Elf_Internal_Rela *irel = &internal_relocs[i];
6346 reloc_opcodes[i] = get_relocation_opcode (abfd, sec, contents, irel);
6347 }
6348 return reloc_opcodes;
6349 }
6350
6351
6352 /* The compute_text_actions function will build a list of potential
6353 transformation actions for code in the extended basic block of each
6354 longcall that is optimized to a direct call. From this list we
6355 generate a set of actions to actually perform that optimizes for
6356 space and, if not using size_opt, maintains branch target
6357 alignments.
6358
6359 These actions to be performed are placed on a per-section list.
6360 The actual changes are performed by relax_section() in the second
6361 pass. */
6362
6363 bfd_boolean
6364 compute_text_actions (bfd *abfd,
6365 asection *sec,
6366 struct bfd_link_info *link_info)
6367 {
6368 xtensa_opcode *reloc_opcodes = NULL;
6369 xtensa_relax_info *relax_info;
6370 bfd_byte *contents;
6371 Elf_Internal_Rela *internal_relocs;
6372 bfd_boolean ok = TRUE;
6373 unsigned i;
6374 property_table_entry *prop_table = 0;
6375 int ptblsize = 0;
6376 bfd_size_type sec_size;
6377 static bfd_boolean no_insn_move = FALSE;
6378
6379 if (no_insn_move)
6380 return ok;
6381
6382 /* Do nothing if the section contains no optimized longcalls. */
6383 relax_info = get_xtensa_relax_info (sec);
6384 BFD_ASSERT (relax_info);
6385 if (!relax_info->is_relaxable_asm_section)
6386 return ok;
6387
6388 internal_relocs = retrieve_internal_relocs (abfd, sec,
6389 link_info->keep_memory);
6390
6391 if (internal_relocs)
6392 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
6393 internal_reloc_compare);
6394
6395 sec_size = bfd_get_section_limit (abfd, sec);
6396 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
6397 if (contents == NULL && sec_size != 0)
6398 {
6399 ok = FALSE;
6400 goto error_return;
6401 }
6402
6403 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
6404 XTENSA_PROP_SEC_NAME, FALSE);
6405 if (ptblsize < 0)
6406 {
6407 ok = FALSE;
6408 goto error_return;
6409 }
6410
6411 for (i = 0; i < sec->reloc_count; i++)
6412 {
6413 Elf_Internal_Rela *irel = &internal_relocs[i];
6414 bfd_vma r_offset;
6415 property_table_entry *the_entry;
6416 int ptbl_idx;
6417 ebb_t *ebb;
6418 ebb_constraint ebb_table;
6419 bfd_size_type simplify_size;
6420
6421 if (irel && ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_SIMPLIFY)
6422 continue;
6423 r_offset = irel->r_offset;
6424
6425 simplify_size = get_asm_simplify_size (contents, sec_size, r_offset);
6426 if (simplify_size == 0)
6427 {
6428 (*_bfd_error_handler)
6429 (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"),
6430 sec->owner, sec, r_offset);
6431 continue;
6432 }
6433
6434 /* If the instruction table is not around, then don't do this
6435 relaxation. */
6436 the_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
6437 sec->vma + irel->r_offset);
6438 if (the_entry == NULL || XTENSA_NO_NOP_REMOVAL)
6439 {
6440 text_action_add (&relax_info->action_list,
6441 ta_convert_longcall, sec, r_offset,
6442 0);
6443 continue;
6444 }
6445
6446 /* If the next longcall happens to be at the same address as an
6447 unreachable section of size 0, then skip forward. */
6448 ptbl_idx = the_entry - prop_table;
6449 while ((the_entry->flags & XTENSA_PROP_UNREACHABLE)
6450 && the_entry->size == 0
6451 && ptbl_idx + 1 < ptblsize
6452 && (prop_table[ptbl_idx + 1].address
6453 == prop_table[ptbl_idx].address))
6454 {
6455 ptbl_idx++;
6456 the_entry++;
6457 }
6458
6459 if (the_entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM)
6460 /* NO_REORDER is OK */
6461 continue;
6462
6463 init_ebb_constraint (&ebb_table);
6464 ebb = &ebb_table.ebb;
6465 init_ebb (ebb, sec, contents, sec_size, prop_table, ptblsize,
6466 internal_relocs, sec->reloc_count);
6467 ebb->start_offset = r_offset + simplify_size;
6468 ebb->end_offset = r_offset + simplify_size;
6469 ebb->start_ptbl_idx = ptbl_idx;
6470 ebb->end_ptbl_idx = ptbl_idx;
6471 ebb->start_reloc_idx = i;
6472 ebb->end_reloc_idx = i;
6473
6474 /* Precompute the opcode for each relocation. */
6475 if (reloc_opcodes == NULL)
6476 reloc_opcodes = build_reloc_opcodes (abfd, sec, contents,
6477 internal_relocs);
6478
6479 if (!extend_ebb_bounds (ebb)
6480 || !compute_ebb_proposed_actions (&ebb_table)
6481 || !compute_ebb_actions (&ebb_table)
6482 || !check_section_ebb_pcrels_fit (abfd, sec, contents,
6483 internal_relocs, &ebb_table,
6484 reloc_opcodes)
6485 || !check_section_ebb_reduces (&ebb_table))
6486 {
6487 /* If anything goes wrong or we get unlucky and something does
6488 not fit, with our plan because of expansion between
6489 critical branches, just convert to a NOP. */
6490
6491 text_action_add (&relax_info->action_list,
6492 ta_convert_longcall, sec, r_offset, 0);
6493 i = ebb_table.ebb.end_reloc_idx;
6494 free_ebb_constraint (&ebb_table);
6495 continue;
6496 }
6497
6498 text_action_add_proposed (&relax_info->action_list, &ebb_table, sec);
6499
6500 /* Update the index so we do not go looking at the relocations
6501 we have already processed. */
6502 i = ebb_table.ebb.end_reloc_idx;
6503 free_ebb_constraint (&ebb_table);
6504 }
6505
6506 #if DEBUG
6507 if (relax_info->action_list.head)
6508 print_action_list (stderr, &relax_info->action_list);
6509 #endif
6510
6511 error_return:
6512 release_contents (sec, contents);
6513 release_internal_relocs (sec, internal_relocs);
6514 if (prop_table)
6515 free (prop_table);
6516 if (reloc_opcodes)
6517 free (reloc_opcodes);
6518
6519 return ok;
6520 }
6521
6522
6523 /* Do not widen an instruction if it is preceeded by a
6524 loop opcode. It might cause misalignment. */
6525
6526 static bfd_boolean
6527 prev_instr_is_a_loop (bfd_byte *contents,
6528 bfd_size_type content_length,
6529 bfd_size_type offset)
6530 {
6531 xtensa_opcode prev_opcode;
6532
6533 if (offset < 3)
6534 return FALSE;
6535 prev_opcode = insn_decode_opcode (contents, content_length, offset-3, 0);
6536 return (xtensa_opcode_is_loop (xtensa_default_isa, prev_opcode) == 1);
6537 }
6538
6539
6540 /* Find all of the possible actions for an extended basic block. */
6541
6542 bfd_boolean
6543 compute_ebb_proposed_actions (ebb_constraint *ebb_table)
6544 {
6545 const ebb_t *ebb = &ebb_table->ebb;
6546 unsigned rel_idx = ebb->start_reloc_idx;
6547 property_table_entry *entry, *start_entry, *end_entry;
6548 bfd_vma offset = 0;
6549 xtensa_isa isa = xtensa_default_isa;
6550 xtensa_format fmt;
6551 static xtensa_insnbuf insnbuf = NULL;
6552 static xtensa_insnbuf slotbuf = NULL;
6553
6554 if (insnbuf == NULL)
6555 {
6556 insnbuf = xtensa_insnbuf_alloc (isa);
6557 slotbuf = xtensa_insnbuf_alloc (isa);
6558 }
6559
6560 start_entry = &ebb->ptbl[ebb->start_ptbl_idx];
6561 end_entry = &ebb->ptbl[ebb->end_ptbl_idx];
6562
6563 for (entry = start_entry; entry <= end_entry; entry++)
6564 {
6565 bfd_vma start_offset, end_offset;
6566 bfd_size_type insn_len;
6567
6568 start_offset = entry->address - ebb->sec->vma;
6569 end_offset = entry->address + entry->size - ebb->sec->vma;
6570
6571 if (entry == start_entry)
6572 start_offset = ebb->start_offset;
6573 if (entry == end_entry)
6574 end_offset = ebb->end_offset;
6575 offset = start_offset;
6576
6577 if (offset == entry->address - ebb->sec->vma
6578 && (entry->flags & XTENSA_PROP_INSN_BRANCH_TARGET) != 0)
6579 {
6580 enum ebb_target_enum align_type = EBB_DESIRE_TGT_ALIGN;
6581 BFD_ASSERT (offset != end_offset);
6582 if (offset == end_offset)
6583 return FALSE;
6584
6585 insn_len = insn_decode_len (ebb->contents, ebb->content_length,
6586 offset);
6587 if (insn_len == 0)
6588 goto decode_error;
6589
6590 if (check_branch_target_aligned_address (offset, insn_len))
6591 align_type = EBB_REQUIRE_TGT_ALIGN;
6592
6593 ebb_propose_action (ebb_table, align_type, 0,
6594 ta_none, offset, 0, TRUE);
6595 }
6596
6597 while (offset != end_offset)
6598 {
6599 Elf_Internal_Rela *irel;
6600 xtensa_opcode opcode;
6601
6602 while (rel_idx < ebb->end_reloc_idx
6603 && (ebb->relocs[rel_idx].r_offset < offset
6604 || (ebb->relocs[rel_idx].r_offset == offset
6605 && (ELF32_R_TYPE (ebb->relocs[rel_idx].r_info)
6606 != R_XTENSA_ASM_SIMPLIFY))))
6607 rel_idx++;
6608
6609 /* Check for longcall. */
6610 irel = &ebb->relocs[rel_idx];
6611 if (irel->r_offset == offset
6612 && ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY)
6613 {
6614 bfd_size_type simplify_size;
6615
6616 simplify_size = get_asm_simplify_size (ebb->contents,
6617 ebb->content_length,
6618 irel->r_offset);
6619 if (simplify_size == 0)
6620 goto decode_error;
6621
6622 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6623 ta_convert_longcall, offset, 0, TRUE);
6624
6625 offset += simplify_size;
6626 continue;
6627 }
6628
6629 if (offset + MIN_INSN_LENGTH > ebb->content_length)
6630 goto decode_error;
6631 xtensa_insnbuf_from_chars (isa, insnbuf, &ebb->contents[offset],
6632 ebb->content_length - offset);
6633 fmt = xtensa_format_decode (isa, insnbuf);
6634 if (fmt == XTENSA_UNDEFINED)
6635 goto decode_error;
6636 insn_len = xtensa_format_length (isa, fmt);
6637 if (insn_len == (bfd_size_type) XTENSA_UNDEFINED)
6638 goto decode_error;
6639
6640 if (xtensa_format_num_slots (isa, fmt) != 1)
6641 {
6642 offset += insn_len;
6643 continue;
6644 }
6645
6646 xtensa_format_get_slot (isa, fmt, 0, insnbuf, slotbuf);
6647 opcode = xtensa_opcode_decode (isa, fmt, 0, slotbuf);
6648 if (opcode == XTENSA_UNDEFINED)
6649 goto decode_error;
6650
6651 if ((entry->flags & XTENSA_PROP_INSN_NO_DENSITY) == 0
6652 && (entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) == 0
6653 && can_narrow_instruction (slotbuf, fmt, opcode) != 0)
6654 {
6655 /* Add an instruction narrow action. */
6656 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6657 ta_narrow_insn, offset, 0, FALSE);
6658 }
6659 else if ((entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM) == 0
6660 && can_widen_instruction (slotbuf, fmt, opcode) != 0
6661 && ! prev_instr_is_a_loop (ebb->contents,
6662 ebb->content_length, offset))
6663 {
6664 /* Add an instruction widen action. */
6665 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6666 ta_widen_insn, offset, 0, FALSE);
6667 }
6668 else if (xtensa_opcode_is_loop (xtensa_default_isa, opcode) == 1)
6669 {
6670 /* Check for branch targets. */
6671 ebb_propose_action (ebb_table, EBB_REQUIRE_LOOP_ALIGN, 0,
6672 ta_none, offset, 0, TRUE);
6673 }
6674
6675 offset += insn_len;
6676 }
6677 }
6678
6679 if (ebb->ends_unreachable)
6680 {
6681 ebb_propose_action (ebb_table, EBB_NO_ALIGN, 0,
6682 ta_fill, ebb->end_offset, 0, TRUE);
6683 }
6684
6685 return TRUE;
6686
6687 decode_error:
6688 (*_bfd_error_handler)
6689 (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"),
6690 ebb->sec->owner, ebb->sec, offset);
6691 return FALSE;
6692 }
6693
6694
6695 /* After all of the information has collected about the
6696 transformations possible in an EBB, compute the appropriate actions
6697 here in compute_ebb_actions. We still must check later to make
6698 sure that the actions do not break any relocations. The algorithm
6699 used here is pretty greedy. Basically, it removes as many no-ops
6700 as possible so that the end of the EBB has the same alignment
6701 characteristics as the original. First, it uses narrowing, then
6702 fill space at the end of the EBB, and finally widenings. If that
6703 does not work, it tries again with one fewer no-op removed. The
6704 optimization will only be performed if all of the branch targets
6705 that were aligned before transformation are also aligned after the
6706 transformation.
6707
6708 When the size_opt flag is set, ignore the branch target alignments,
6709 narrow all wide instructions, and remove all no-ops unless the end
6710 of the EBB prevents it. */
6711
6712 bfd_boolean
6713 compute_ebb_actions (ebb_constraint *ebb_table)
6714 {
6715 unsigned i = 0;
6716 unsigned j;
6717 int removed_bytes = 0;
6718 ebb_t *ebb = &ebb_table->ebb;
6719 unsigned seg_idx_start = 0;
6720 unsigned seg_idx_end = 0;
6721
6722 /* We perform this like the assembler relaxation algorithm: Start by
6723 assuming all instructions are narrow and all no-ops removed; then
6724 walk through.... */
6725
6726 /* For each segment of this that has a solid constraint, check to
6727 see if there are any combinations that will keep the constraint.
6728 If so, use it. */
6729 for (seg_idx_end = 0; seg_idx_end < ebb_table->action_count; seg_idx_end++)
6730 {
6731 bfd_boolean requires_text_end_align = FALSE;
6732 unsigned longcall_count = 0;
6733 unsigned longcall_convert_count = 0;
6734 unsigned narrowable_count = 0;
6735 unsigned narrowable_convert_count = 0;
6736 unsigned widenable_count = 0;
6737 unsigned widenable_convert_count = 0;
6738
6739 proposed_action *action = NULL;
6740 int align = (1 << ebb_table->ebb.sec->alignment_power);
6741
6742 seg_idx_start = seg_idx_end;
6743
6744 for (i = seg_idx_start; i < ebb_table->action_count; i++)
6745 {
6746 action = &ebb_table->actions[i];
6747 if (action->action == ta_convert_longcall)
6748 longcall_count++;
6749 if (action->action == ta_narrow_insn)
6750 narrowable_count++;
6751 if (action->action == ta_widen_insn)
6752 widenable_count++;
6753 if (action->action == ta_fill)
6754 break;
6755 if (action->align_type == EBB_REQUIRE_LOOP_ALIGN)
6756 break;
6757 if (action->align_type == EBB_REQUIRE_TGT_ALIGN
6758 && !elf32xtensa_size_opt)
6759 break;
6760 }
6761 seg_idx_end = i;
6762
6763 if (seg_idx_end == ebb_table->action_count && !ebb->ends_unreachable)
6764 requires_text_end_align = TRUE;
6765
6766 if (elf32xtensa_size_opt && !requires_text_end_align
6767 && action->align_type != EBB_REQUIRE_LOOP_ALIGN
6768 && action->align_type != EBB_REQUIRE_TGT_ALIGN)
6769 {
6770 longcall_convert_count = longcall_count;
6771 narrowable_convert_count = narrowable_count;
6772 widenable_convert_count = 0;
6773 }
6774 else
6775 {
6776 /* There is a constraint. Convert the max number of longcalls. */
6777 narrowable_convert_count = 0;
6778 longcall_convert_count = 0;
6779 widenable_convert_count = 0;
6780
6781 for (j = 0; j < longcall_count; j++)
6782 {
6783 int removed = (longcall_count - j) * 3 & (align - 1);
6784 unsigned desire_narrow = (align - removed) & (align - 1);
6785 unsigned desire_widen = removed;
6786 if (desire_narrow <= narrowable_count)
6787 {
6788 narrowable_convert_count = desire_narrow;
6789 narrowable_convert_count +=
6790 (align * ((narrowable_count - narrowable_convert_count)
6791 / align));
6792 longcall_convert_count = (longcall_count - j);
6793 widenable_convert_count = 0;
6794 break;
6795 }
6796 if (desire_widen <= widenable_count && !elf32xtensa_size_opt)
6797 {
6798 narrowable_convert_count = 0;
6799 longcall_convert_count = longcall_count - j;
6800 widenable_convert_count = desire_widen;
6801 break;
6802 }
6803 }
6804 }
6805
6806 /* Now the number of conversions are saved. Do them. */
6807 for (i = seg_idx_start; i < seg_idx_end; i++)
6808 {
6809 action = &ebb_table->actions[i];
6810 switch (action->action)
6811 {
6812 case ta_convert_longcall:
6813 if (longcall_convert_count != 0)
6814 {
6815 action->action = ta_remove_longcall;
6816 action->do_action = TRUE;
6817 action->removed_bytes += 3;
6818 longcall_convert_count--;
6819 }
6820 break;
6821 case ta_narrow_insn:
6822 if (narrowable_convert_count != 0)
6823 {
6824 action->do_action = TRUE;
6825 action->removed_bytes += 1;
6826 narrowable_convert_count--;
6827 }
6828 break;
6829 case ta_widen_insn:
6830 if (widenable_convert_count != 0)
6831 {
6832 action->do_action = TRUE;
6833 action->removed_bytes -= 1;
6834 widenable_convert_count--;
6835 }
6836 break;
6837 default:
6838 break;
6839 }
6840 }
6841 }
6842
6843 /* Now we move on to some local opts. Try to remove each of the
6844 remaining longcalls. */
6845
6846 if (ebb_table->ebb.ends_section || ebb_table->ebb.ends_unreachable)
6847 {
6848 removed_bytes = 0;
6849 for (i = 0; i < ebb_table->action_count; i++)
6850 {
6851 int old_removed_bytes = removed_bytes;
6852 proposed_action *action = &ebb_table->actions[i];
6853
6854 if (action->do_action && action->action == ta_convert_longcall)
6855 {
6856 bfd_boolean bad_alignment = FALSE;
6857 removed_bytes += 3;
6858 for (j = i + 1; j < ebb_table->action_count; j++)
6859 {
6860 proposed_action *new_action = &ebb_table->actions[j];
6861 bfd_vma offset = new_action->offset;
6862 if (new_action->align_type == EBB_REQUIRE_TGT_ALIGN)
6863 {
6864 if (!check_branch_target_aligned
6865 (ebb_table->ebb.contents,
6866 ebb_table->ebb.content_length,
6867 offset, offset - removed_bytes))
6868 {
6869 bad_alignment = TRUE;
6870 break;
6871 }
6872 }
6873 if (new_action->align_type == EBB_REQUIRE_LOOP_ALIGN)
6874 {
6875 if (!check_loop_aligned (ebb_table->ebb.contents,
6876 ebb_table->ebb.content_length,
6877 offset,
6878 offset - removed_bytes))
6879 {
6880 bad_alignment = TRUE;
6881 break;
6882 }
6883 }
6884 if (new_action->action == ta_narrow_insn
6885 && !new_action->do_action
6886 && ebb_table->ebb.sec->alignment_power == 2)
6887 {
6888 /* Narrow an instruction and we are done. */
6889 new_action->do_action = TRUE;
6890 new_action->removed_bytes += 1;
6891 bad_alignment = FALSE;
6892 break;
6893 }
6894 if (new_action->action == ta_widen_insn
6895 && new_action->do_action
6896 && ebb_table->ebb.sec->alignment_power == 2)
6897 {
6898 /* Narrow an instruction and we are done. */
6899 new_action->do_action = FALSE;
6900 new_action->removed_bytes += 1;
6901 bad_alignment = FALSE;
6902 break;
6903 }
6904 }
6905 if (!bad_alignment)
6906 {
6907 action->removed_bytes += 3;
6908 action->action = ta_remove_longcall;
6909 action->do_action = TRUE;
6910 }
6911 }
6912 removed_bytes = old_removed_bytes;
6913 if (action->do_action)
6914 removed_bytes += action->removed_bytes;
6915 }
6916 }
6917
6918 removed_bytes = 0;
6919 for (i = 0; i < ebb_table->action_count; ++i)
6920 {
6921 proposed_action *action = &ebb_table->actions[i];
6922 if (action->do_action)
6923 removed_bytes += action->removed_bytes;
6924 }
6925
6926 if ((removed_bytes % (1 << ebb_table->ebb.sec->alignment_power)) != 0
6927 && ebb->ends_unreachable)
6928 {
6929 proposed_action *action;
6930 int br;
6931 int extra_space;
6932
6933 BFD_ASSERT (ebb_table->action_count != 0);
6934 action = &ebb_table->actions[ebb_table->action_count - 1];
6935 BFD_ASSERT (action->action == ta_fill);
6936 BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE);
6937
6938 extra_space = compute_fill_extra_space (ebb->ends_unreachable);
6939 br = action->removed_bytes + removed_bytes + extra_space;
6940 br = br & ((1 << ebb->sec->alignment_power ) - 1);
6941
6942 action->removed_bytes = extra_space - br;
6943 }
6944 return TRUE;
6945 }
6946
6947
6948 /* The xlate_map is a sorted array of address mappings designed to
6949 answer the offset_with_removed_text() query with a binary search instead
6950 of a linear search through the section's action_list. */
6951
6952 typedef struct xlate_map_entry xlate_map_entry_t;
6953 typedef struct xlate_map xlate_map_t;
6954
6955 struct xlate_map_entry
6956 {
6957 unsigned orig_address;
6958 unsigned new_address;
6959 unsigned size;
6960 };
6961
6962 struct xlate_map
6963 {
6964 unsigned entry_count;
6965 xlate_map_entry_t *entry;
6966 };
6967
6968
6969 static int
6970 xlate_compare (const void *a_v, const void *b_v)
6971 {
6972 const xlate_map_entry_t *a = (const xlate_map_entry_t *) a_v;
6973 const xlate_map_entry_t *b = (const xlate_map_entry_t *) b_v;
6974 if (a->orig_address < b->orig_address)
6975 return -1;
6976 if (a->orig_address > (b->orig_address + b->size - 1))
6977 return 1;
6978 return 0;
6979 }
6980
6981
6982 static bfd_vma
6983 xlate_offset_with_removed_text (const xlate_map_t *map,
6984 text_action_list *action_list,
6985 bfd_vma offset)
6986 {
6987 xlate_map_entry_t tmp;
6988 void *r;
6989 xlate_map_entry_t *e;
6990
6991 if (map == NULL)
6992 return offset_with_removed_text (action_list, offset);
6993
6994 if (map->entry_count == 0)
6995 return offset;
6996
6997 tmp.orig_address = offset;
6998 tmp.new_address = offset;
6999 tmp.size = 1;
7000
7001 r = bsearch (&offset, map->entry, map->entry_count,
7002 sizeof (xlate_map_entry_t), &xlate_compare);
7003 e = (xlate_map_entry_t *) r;
7004
7005 BFD_ASSERT (e != NULL);
7006 if (e == NULL)
7007 return offset;
7008 return e->new_address - e->orig_address + offset;
7009 }
7010
7011
7012 /* Build a binary searchable offset translation map from a section's
7013 action list. */
7014
7015 static xlate_map_t *
7016 build_xlate_map (asection *sec, xtensa_relax_info *relax_info)
7017 {
7018 xlate_map_t *map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t));
7019 text_action_list *action_list = &relax_info->action_list;
7020 unsigned num_actions = 0;
7021 text_action *r;
7022 int removed;
7023 xlate_map_entry_t *current_entry;
7024
7025 if (map == NULL)
7026 return NULL;
7027
7028 num_actions = action_list_count (action_list);
7029 map->entry = (xlate_map_entry_t *)
7030 bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1));
7031 if (map->entry == NULL)
7032 {
7033 free (map);
7034 return NULL;
7035 }
7036 map->entry_count = 0;
7037
7038 removed = 0;
7039 current_entry = &map->entry[0];
7040
7041 current_entry->orig_address = 0;
7042 current_entry->new_address = 0;
7043 current_entry->size = 0;
7044
7045 for (r = action_list->head; r != NULL; r = r->next)
7046 {
7047 unsigned orig_size = 0;
7048 switch (r->action)
7049 {
7050 case ta_none:
7051 case ta_remove_insn:
7052 case ta_convert_longcall:
7053 case ta_remove_literal:
7054 case ta_add_literal:
7055 break;
7056 case ta_remove_longcall:
7057 orig_size = 6;
7058 break;
7059 case ta_narrow_insn:
7060 orig_size = 3;
7061 break;
7062 case ta_widen_insn:
7063 orig_size = 2;
7064 break;
7065 case ta_fill:
7066 break;
7067 }
7068 current_entry->size =
7069 r->offset + orig_size - current_entry->orig_address;
7070 if (current_entry->size != 0)
7071 {
7072 current_entry++;
7073 map->entry_count++;
7074 }
7075 current_entry->orig_address = r->offset + orig_size;
7076 removed += r->removed_bytes;
7077 current_entry->new_address = r->offset + orig_size - removed;
7078 current_entry->size = 0;
7079 }
7080
7081 current_entry->size = (bfd_get_section_limit (sec->owner, sec)
7082 - current_entry->orig_address);
7083 if (current_entry->size != 0)
7084 map->entry_count++;
7085
7086 return map;
7087 }
7088
7089
7090 /* Free an offset translation map. */
7091
7092 static void
7093 free_xlate_map (xlate_map_t *map)
7094 {
7095 if (map && map->entry)
7096 free (map->entry);
7097 if (map)
7098 free (map);
7099 }
7100
7101
7102 /* Use check_section_ebb_pcrels_fit to make sure that all of the
7103 relocations in a section will fit if a proposed set of actions
7104 are performed. */
7105
7106 static bfd_boolean
7107 check_section_ebb_pcrels_fit (bfd *abfd,
7108 asection *sec,
7109 bfd_byte *contents,
7110 Elf_Internal_Rela *internal_relocs,
7111 const ebb_constraint *constraint,
7112 const xtensa_opcode *reloc_opcodes)
7113 {
7114 unsigned i, j;
7115 Elf_Internal_Rela *irel;
7116 xlate_map_t *xmap = NULL;
7117 bfd_boolean ok = TRUE;
7118 xtensa_relax_info *relax_info;
7119
7120 relax_info = get_xtensa_relax_info (sec);
7121
7122 if (relax_info && sec->reloc_count > 100)
7123 {
7124 xmap = build_xlate_map (sec, relax_info);
7125 /* NULL indicates out of memory, but the slow version
7126 can still be used. */
7127 }
7128
7129 for (i = 0; i < sec->reloc_count; i++)
7130 {
7131 r_reloc r_rel;
7132 bfd_vma orig_self_offset, orig_target_offset;
7133 bfd_vma self_offset, target_offset;
7134 int r_type;
7135 reloc_howto_type *howto;
7136 int self_removed_bytes, target_removed_bytes;
7137
7138 irel = &internal_relocs[i];
7139 r_type = ELF32_R_TYPE (irel->r_info);
7140
7141 howto = &elf_howto_table[r_type];
7142 /* We maintain the required invariant: PC-relative relocations
7143 that fit before linking must fit after linking. Thus we only
7144 need to deal with relocations to the same section that are
7145 PC-relative. */
7146 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_ASM_SIMPLIFY
7147 || !howto->pc_relative)
7148 continue;
7149
7150 r_reloc_init (&r_rel, abfd, irel, contents,
7151 bfd_get_section_limit (abfd, sec));
7152
7153 if (r_reloc_get_section (&r_rel) != sec)
7154 continue;
7155
7156 orig_self_offset = irel->r_offset;
7157 orig_target_offset = r_rel.target_offset;
7158
7159 self_offset = orig_self_offset;
7160 target_offset = orig_target_offset;
7161
7162 if (relax_info)
7163 {
7164 self_offset =
7165 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
7166 orig_self_offset);
7167 target_offset =
7168 xlate_offset_with_removed_text (xmap, &relax_info->action_list,
7169 orig_target_offset);
7170 }
7171
7172 self_removed_bytes = 0;
7173 target_removed_bytes = 0;
7174
7175 for (j = 0; j < constraint->action_count; ++j)
7176 {
7177 proposed_action *action = &constraint->actions[j];
7178 bfd_vma offset = action->offset;
7179 int removed_bytes = action->removed_bytes;
7180 if (offset < orig_self_offset
7181 || (offset == orig_self_offset && action->action == ta_fill
7182 && action->removed_bytes < 0))
7183 self_removed_bytes += removed_bytes;
7184 if (offset < orig_target_offset
7185 || (offset == orig_target_offset && action->action == ta_fill
7186 && action->removed_bytes < 0))
7187 target_removed_bytes += removed_bytes;
7188 }
7189 self_offset -= self_removed_bytes;
7190 target_offset -= target_removed_bytes;
7191
7192 /* Try to encode it. Get the operand and check. */
7193 if (is_alt_relocation (ELF32_R_TYPE (irel->r_info)))
7194 {
7195 /* None of the current alternate relocs are PC-relative,
7196 and only PC-relative relocs matter here. */
7197 }
7198 else
7199 {
7200 xtensa_opcode opcode;
7201 int opnum;
7202
7203 if (reloc_opcodes)
7204 opcode = reloc_opcodes[i];
7205 else
7206 opcode = get_relocation_opcode (abfd, sec, contents, irel);
7207 if (opcode == XTENSA_UNDEFINED)
7208 {
7209 ok = FALSE;
7210 break;
7211 }
7212
7213 opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info));
7214 if (opnum == XTENSA_UNDEFINED)
7215 {
7216 ok = FALSE;
7217 break;
7218 }
7219
7220 if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset))
7221 {
7222 ok = FALSE;
7223 break;
7224 }
7225 }
7226 }
7227
7228 if (xmap)
7229 free_xlate_map (xmap);
7230
7231 return ok;
7232 }
7233
7234
7235 static bfd_boolean
7236 check_section_ebb_reduces (const ebb_constraint *constraint)
7237 {
7238 int removed = 0;
7239 unsigned i;
7240
7241 for (i = 0; i < constraint->action_count; i++)
7242 {
7243 const proposed_action *action = &constraint->actions[i];
7244 if (action->do_action)
7245 removed += action->removed_bytes;
7246 }
7247 if (removed < 0)
7248 return FALSE;
7249
7250 return TRUE;
7251 }
7252
7253
7254 void
7255 text_action_add_proposed (text_action_list *l,
7256 const ebb_constraint *ebb_table,
7257 asection *sec)
7258 {
7259 unsigned i;
7260
7261 for (i = 0; i < ebb_table->action_count; i++)
7262 {
7263 proposed_action *action = &ebb_table->actions[i];
7264
7265 if (!action->do_action)
7266 continue;
7267 switch (action->action)
7268 {
7269 case ta_remove_insn:
7270 case ta_remove_longcall:
7271 case ta_convert_longcall:
7272 case ta_narrow_insn:
7273 case ta_widen_insn:
7274 case ta_fill:
7275 case ta_remove_literal:
7276 text_action_add (l, action->action, sec, action->offset,
7277 action->removed_bytes);
7278 break;
7279 case ta_none:
7280 break;
7281 default:
7282 BFD_ASSERT (0);
7283 break;
7284 }
7285 }
7286 }
7287
7288
7289 int
7290 compute_fill_extra_space (property_table_entry *entry)
7291 {
7292 int fill_extra_space;
7293
7294 if (!entry)
7295 return 0;
7296
7297 if ((entry->flags & XTENSA_PROP_UNREACHABLE) == 0)
7298 return 0;
7299
7300 fill_extra_space = entry->size;
7301 if ((entry->flags & XTENSA_PROP_ALIGN) != 0)
7302 {
7303 /* Fill bytes for alignment:
7304 (2**n)-1 - (addr + (2**n)-1) & (2**n -1) */
7305 int pow = GET_XTENSA_PROP_ALIGNMENT (entry->flags);
7306 int nsm = (1 << pow) - 1;
7307 bfd_vma addr = entry->address + entry->size;
7308 bfd_vma align_fill = nsm - ((addr + nsm) & nsm);
7309 fill_extra_space += align_fill;
7310 }
7311 return fill_extra_space;
7312 }
7313
7314 \f
7315 /* First relaxation pass. */
7316
7317 /* If the section contains relaxable literals, check each literal to
7318 see if it has the same value as another literal that has already
7319 been seen, either in the current section or a previous one. If so,
7320 add an entry to the per-section list of removed literals. The
7321 actual changes are deferred until the next pass. */
7322
7323 static bfd_boolean
7324 compute_removed_literals (bfd *abfd,
7325 asection *sec,
7326 struct bfd_link_info *link_info,
7327 value_map_hash_table *values)
7328 {
7329 xtensa_relax_info *relax_info;
7330 bfd_byte *contents;
7331 Elf_Internal_Rela *internal_relocs;
7332 source_reloc *src_relocs, *rel;
7333 bfd_boolean ok = TRUE;
7334 property_table_entry *prop_table = NULL;
7335 int ptblsize;
7336 int i, prev_i;
7337 bfd_boolean last_loc_is_prev = FALSE;
7338 bfd_vma last_target_offset = 0;
7339 section_cache_t target_sec_cache;
7340 bfd_size_type sec_size;
7341
7342 init_section_cache (&target_sec_cache);
7343
7344 /* Do nothing if it is not a relaxable literal section. */
7345 relax_info = get_xtensa_relax_info (sec);
7346 BFD_ASSERT (relax_info);
7347 if (!relax_info->is_relaxable_literal_section)
7348 return ok;
7349
7350 internal_relocs = retrieve_internal_relocs (abfd, sec,
7351 link_info->keep_memory);
7352
7353 sec_size = bfd_get_section_limit (abfd, sec);
7354 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
7355 if (contents == NULL && sec_size != 0)
7356 {
7357 ok = FALSE;
7358 goto error_return;
7359 }
7360
7361 /* Sort the source_relocs by target offset. */
7362 src_relocs = relax_info->src_relocs;
7363 qsort (src_relocs, relax_info->src_count,
7364 sizeof (source_reloc), source_reloc_compare);
7365 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
7366 internal_reloc_compare);
7367
7368 ptblsize = xtensa_read_table_entries (abfd, sec, &prop_table,
7369 XTENSA_PROP_SEC_NAME, FALSE);
7370 if (ptblsize < 0)
7371 {
7372 ok = FALSE;
7373 goto error_return;
7374 }
7375
7376 prev_i = -1;
7377 for (i = 0; i < relax_info->src_count; i++)
7378 {
7379 Elf_Internal_Rela *irel = NULL;
7380
7381 rel = &src_relocs[i];
7382 if (get_l32r_opcode () != rel->opcode)
7383 continue;
7384 irel = get_irel_at_offset (sec, internal_relocs,
7385 rel->r_rel.target_offset);
7386
7387 /* If the relocation on this is not a simple R_XTENSA_32 or
7388 R_XTENSA_PLT then do not consider it. This may happen when
7389 the difference of two symbols is used in a literal. */
7390 if (irel && (ELF32_R_TYPE (irel->r_info) != R_XTENSA_32
7391 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_PLT))
7392 continue;
7393
7394 /* If the target_offset for this relocation is the same as the
7395 previous relocation, then we've already considered whether the
7396 literal can be coalesced. Skip to the next one.... */
7397 if (i != 0 && prev_i != -1
7398 && src_relocs[i-1].r_rel.target_offset == rel->r_rel.target_offset)
7399 continue;
7400 prev_i = i;
7401
7402 if (last_loc_is_prev &&
7403 last_target_offset + 4 != rel->r_rel.target_offset)
7404 last_loc_is_prev = FALSE;
7405
7406 /* Check if the relocation was from an L32R that is being removed
7407 because a CALLX was converted to a direct CALL, and check if
7408 there are no other relocations to the literal. */
7409 if (is_removable_literal (rel, i, src_relocs, relax_info->src_count))
7410 {
7411 if (!remove_dead_literal (abfd, sec, link_info, internal_relocs,
7412 irel, rel, prop_table, ptblsize))
7413 {
7414 ok = FALSE;
7415 goto error_return;
7416 }
7417 last_target_offset = rel->r_rel.target_offset;
7418 continue;
7419 }
7420
7421 if (!identify_literal_placement (abfd, sec, contents, link_info,
7422 values,
7423 &last_loc_is_prev, irel,
7424 relax_info->src_count - i, rel,
7425 prop_table, ptblsize,
7426 &target_sec_cache, rel->is_abs_literal))
7427 {
7428 ok = FALSE;
7429 goto error_return;
7430 }
7431 last_target_offset = rel->r_rel.target_offset;
7432 }
7433
7434 #if DEBUG
7435 print_removed_literals (stderr, &relax_info->removed_list);
7436 print_action_list (stderr, &relax_info->action_list);
7437 #endif /* DEBUG */
7438
7439 error_return:
7440 if (prop_table) free (prop_table);
7441 clear_section_cache (&target_sec_cache);
7442
7443 release_contents (sec, contents);
7444 release_internal_relocs (sec, internal_relocs);
7445 return ok;
7446 }
7447
7448
7449 static Elf_Internal_Rela *
7450 get_irel_at_offset (asection *sec,
7451 Elf_Internal_Rela *internal_relocs,
7452 bfd_vma offset)
7453 {
7454 unsigned i;
7455 Elf_Internal_Rela *irel;
7456 unsigned r_type;
7457 Elf_Internal_Rela key;
7458
7459 if (!internal_relocs)
7460 return NULL;
7461
7462 key.r_offset = offset;
7463 irel = bsearch (&key, internal_relocs, sec->reloc_count,
7464 sizeof (Elf_Internal_Rela), internal_reloc_matches);
7465 if (!irel)
7466 return NULL;
7467
7468 /* bsearch does not guarantee which will be returned if there are
7469 multiple matches. We need the first that is not an alignment. */
7470 i = irel - internal_relocs;
7471 while (i > 0)
7472 {
7473 if (internal_relocs[i-1].r_offset != offset)
7474 break;
7475 i--;
7476 }
7477 for ( ; i < sec->reloc_count; i++)
7478 {
7479 irel = &internal_relocs[i];
7480 r_type = ELF32_R_TYPE (irel->r_info);
7481 if (irel->r_offset == offset && r_type != R_XTENSA_NONE)
7482 return irel;
7483 }
7484
7485 return NULL;
7486 }
7487
7488
7489 bfd_boolean
7490 is_removable_literal (const source_reloc *rel,
7491 int i,
7492 const source_reloc *src_relocs,
7493 int src_count)
7494 {
7495 const source_reloc *curr_rel;
7496 if (!rel->is_null)
7497 return FALSE;
7498
7499 for (++i; i < src_count; ++i)
7500 {
7501 curr_rel = &src_relocs[i];
7502 /* If all others have the same target offset.... */
7503 if (curr_rel->r_rel.target_offset != rel->r_rel.target_offset)
7504 return TRUE;
7505
7506 if (!curr_rel->is_null
7507 && !xtensa_is_property_section (curr_rel->source_sec)
7508 && !(curr_rel->source_sec->flags & SEC_DEBUGGING))
7509 return FALSE;
7510 }
7511 return TRUE;
7512 }
7513
7514
7515 bfd_boolean
7516 remove_dead_literal (bfd *abfd,
7517 asection *sec,
7518 struct bfd_link_info *link_info,
7519 Elf_Internal_Rela *internal_relocs,
7520 Elf_Internal_Rela *irel,
7521 source_reloc *rel,
7522 property_table_entry *prop_table,
7523 int ptblsize)
7524 {
7525 property_table_entry *entry;
7526 xtensa_relax_info *relax_info;
7527
7528 relax_info = get_xtensa_relax_info (sec);
7529 if (!relax_info)
7530 return FALSE;
7531
7532 entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7533 sec->vma + rel->r_rel.target_offset);
7534
7535 /* Mark the unused literal so that it will be removed. */
7536 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
7537
7538 text_action_add (&relax_info->action_list,
7539 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7540
7541 /* If the section is 4-byte aligned, do not add fill. */
7542 if (sec->alignment_power > 2)
7543 {
7544 int fill_extra_space;
7545 bfd_vma entry_sec_offset;
7546 text_action *fa;
7547 property_table_entry *the_add_entry;
7548 int removed_diff;
7549
7550 if (entry)
7551 entry_sec_offset = entry->address - sec->vma + entry->size;
7552 else
7553 entry_sec_offset = rel->r_rel.target_offset + 4;
7554
7555 /* If the literal range is at the end of the section,
7556 do not add fill. */
7557 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7558 entry_sec_offset);
7559 fill_extra_space = compute_fill_extra_space (the_add_entry);
7560
7561 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7562 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7563 -4, fill_extra_space);
7564 if (fa)
7565 adjust_fill_action (fa, removed_diff);
7566 else
7567 text_action_add (&relax_info->action_list,
7568 ta_fill, sec, entry_sec_offset, removed_diff);
7569 }
7570
7571 /* Zero out the relocation on this literal location. */
7572 if (irel)
7573 {
7574 if (elf_hash_table (link_info)->dynamic_sections_created)
7575 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
7576
7577 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
7578 pin_internal_relocs (sec, internal_relocs);
7579 }
7580
7581 /* Do not modify "last_loc_is_prev". */
7582 return TRUE;
7583 }
7584
7585
7586 bfd_boolean
7587 identify_literal_placement (bfd *abfd,
7588 asection *sec,
7589 bfd_byte *contents,
7590 struct bfd_link_info *link_info,
7591 value_map_hash_table *values,
7592 bfd_boolean *last_loc_is_prev_p,
7593 Elf_Internal_Rela *irel,
7594 int remaining_src_rels,
7595 source_reloc *rel,
7596 property_table_entry *prop_table,
7597 int ptblsize,
7598 section_cache_t *target_sec_cache,
7599 bfd_boolean is_abs_literal)
7600 {
7601 literal_value val;
7602 value_map *val_map;
7603 xtensa_relax_info *relax_info;
7604 bfd_boolean literal_placed = FALSE;
7605 r_reloc r_rel;
7606 unsigned long value;
7607 bfd_boolean final_static_link;
7608 bfd_size_type sec_size;
7609
7610 relax_info = get_xtensa_relax_info (sec);
7611 if (!relax_info)
7612 return FALSE;
7613
7614 sec_size = bfd_get_section_limit (abfd, sec);
7615
7616 final_static_link =
7617 (!link_info->relocatable
7618 && !elf_hash_table (link_info)->dynamic_sections_created);
7619
7620 /* The placement algorithm first checks to see if the literal is
7621 already in the value map. If so and the value map is reachable
7622 from all uses, then the literal is moved to that location. If
7623 not, then we identify the last location where a fresh literal was
7624 placed. If the literal can be safely moved there, then we do so.
7625 If not, then we assume that the literal is not to move and leave
7626 the literal where it is, marking it as the last literal
7627 location. */
7628
7629 /* Find the literal value. */
7630 value = 0;
7631 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
7632 if (!irel)
7633 {
7634 BFD_ASSERT (rel->r_rel.target_offset < sec_size);
7635 value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
7636 }
7637 init_literal_value (&val, &r_rel, value, is_abs_literal);
7638
7639 /* Check if we've seen another literal with the same value that
7640 is in the same output section. */
7641 val_map = value_map_get_cached_value (values, &val, final_static_link);
7642
7643 if (val_map
7644 && (r_reloc_get_section (&val_map->loc)->output_section
7645 == sec->output_section)
7646 && relocations_reach (rel, remaining_src_rels, &val_map->loc)
7647 && coalesce_shared_literal (sec, rel, prop_table, ptblsize, val_map))
7648 {
7649 /* No change to last_loc_is_prev. */
7650 literal_placed = TRUE;
7651 }
7652
7653 /* For relocatable links, do not try to move literals. To do it
7654 correctly might increase the number of relocations in an input
7655 section making the default relocatable linking fail. */
7656 if (!link_info->relocatable && !literal_placed
7657 && values->has_last_loc && !(*last_loc_is_prev_p))
7658 {
7659 asection *target_sec = r_reloc_get_section (&values->last_loc);
7660 if (target_sec && target_sec->output_section == sec->output_section)
7661 {
7662 /* Increment the virtual offset. */
7663 r_reloc try_loc = values->last_loc;
7664 try_loc.virtual_offset += 4;
7665
7666 /* There is a last loc that was in the same output section. */
7667 if (relocations_reach (rel, remaining_src_rels, &try_loc)
7668 && move_shared_literal (sec, link_info, rel,
7669 prop_table, ptblsize,
7670 &try_loc, &val, target_sec_cache))
7671 {
7672 values->last_loc.virtual_offset += 4;
7673 literal_placed = TRUE;
7674 if (!val_map)
7675 val_map = add_value_map (values, &val, &try_loc,
7676 final_static_link);
7677 else
7678 val_map->loc = try_loc;
7679 }
7680 }
7681 }
7682
7683 if (!literal_placed)
7684 {
7685 /* Nothing worked, leave the literal alone but update the last loc. */
7686 values->has_last_loc = TRUE;
7687 values->last_loc = rel->r_rel;
7688 if (!val_map)
7689 val_map = add_value_map (values, &val, &rel->r_rel, final_static_link);
7690 else
7691 val_map->loc = rel->r_rel;
7692 *last_loc_is_prev_p = TRUE;
7693 }
7694
7695 return TRUE;
7696 }
7697
7698
7699 /* Check if the original relocations (presumably on L32R instructions)
7700 identified by reloc[0..N] can be changed to reference the literal
7701 identified by r_rel. If r_rel is out of range for any of the
7702 original relocations, then we don't want to coalesce the original
7703 literal with the one at r_rel. We only check reloc[0..N], where the
7704 offsets are all the same as for reloc[0] (i.e., they're all
7705 referencing the same literal) and where N is also bounded by the
7706 number of remaining entries in the "reloc" array. The "reloc" array
7707 is sorted by target offset so we know all the entries for the same
7708 literal will be contiguous. */
7709
7710 static bfd_boolean
7711 relocations_reach (source_reloc *reloc,
7712 int remaining_relocs,
7713 const r_reloc *r_rel)
7714 {
7715 bfd_vma from_offset, source_address, dest_address;
7716 asection *sec;
7717 int i;
7718
7719 if (!r_reloc_is_defined (r_rel))
7720 return FALSE;
7721
7722 sec = r_reloc_get_section (r_rel);
7723 from_offset = reloc[0].r_rel.target_offset;
7724
7725 for (i = 0; i < remaining_relocs; i++)
7726 {
7727 if (reloc[i].r_rel.target_offset != from_offset)
7728 break;
7729
7730 /* Ignore relocations that have been removed. */
7731 if (reloc[i].is_null)
7732 continue;
7733
7734 /* The original and new output section for these must be the same
7735 in order to coalesce. */
7736 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
7737 != sec->output_section)
7738 return FALSE;
7739
7740 /* Absolute literals in the same output section can always be
7741 combined. */
7742 if (reloc[i].is_abs_literal)
7743 continue;
7744
7745 /* A literal with no PC-relative relocations can be moved anywhere. */
7746 if (reloc[i].opnd != -1)
7747 {
7748 /* Otherwise, check to see that it fits. */
7749 source_address = (reloc[i].source_sec->output_section->vma
7750 + reloc[i].source_sec->output_offset
7751 + reloc[i].r_rel.rela.r_offset);
7752 dest_address = (sec->output_section->vma
7753 + sec->output_offset
7754 + r_rel->target_offset);
7755
7756 if (!pcrel_reloc_fits (reloc[i].opcode, reloc[i].opnd,
7757 source_address, dest_address))
7758 return FALSE;
7759 }
7760 }
7761
7762 return TRUE;
7763 }
7764
7765
7766 /* Move a literal to another literal location because it is
7767 the same as the other literal value. */
7768
7769 static bfd_boolean
7770 coalesce_shared_literal (asection *sec,
7771 source_reloc *rel,
7772 property_table_entry *prop_table,
7773 int ptblsize,
7774 value_map *val_map)
7775 {
7776 property_table_entry *entry;
7777 text_action *fa;
7778 property_table_entry *the_add_entry;
7779 int removed_diff;
7780 xtensa_relax_info *relax_info;
7781
7782 relax_info = get_xtensa_relax_info (sec);
7783 if (!relax_info)
7784 return FALSE;
7785
7786 entry = elf_xtensa_find_property_entry
7787 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
7788 if (entry && (entry->flags & XTENSA_PROP_INSN_NO_TRANSFORM))
7789 return TRUE;
7790
7791 /* Mark that the literal will be coalesced. */
7792 add_removed_literal (&relax_info->removed_list, &rel->r_rel, &val_map->loc);
7793
7794 text_action_add (&relax_info->action_list,
7795 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7796
7797 /* If the section is 4-byte aligned, do not add fill. */
7798 if (sec->alignment_power > 2)
7799 {
7800 int fill_extra_space;
7801 bfd_vma entry_sec_offset;
7802
7803 if (entry)
7804 entry_sec_offset = entry->address - sec->vma + entry->size;
7805 else
7806 entry_sec_offset = rel->r_rel.target_offset + 4;
7807
7808 /* If the literal range is at the end of the section,
7809 do not add fill. */
7810 fill_extra_space = 0;
7811 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7812 entry_sec_offset);
7813 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7814 fill_extra_space = the_add_entry->size;
7815
7816 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7817 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7818 -4, fill_extra_space);
7819 if (fa)
7820 adjust_fill_action (fa, removed_diff);
7821 else
7822 text_action_add (&relax_info->action_list,
7823 ta_fill, sec, entry_sec_offset, removed_diff);
7824 }
7825
7826 return TRUE;
7827 }
7828
7829
7830 /* Move a literal to another location. This may actually increase the
7831 total amount of space used because of alignments so we need to do
7832 this carefully. Also, it may make a branch go out of range. */
7833
7834 static bfd_boolean
7835 move_shared_literal (asection *sec,
7836 struct bfd_link_info *link_info,
7837 source_reloc *rel,
7838 property_table_entry *prop_table,
7839 int ptblsize,
7840 const r_reloc *target_loc,
7841 const literal_value *lit_value,
7842 section_cache_t *target_sec_cache)
7843 {
7844 property_table_entry *the_add_entry, *src_entry, *target_entry = NULL;
7845 text_action *fa, *target_fa;
7846 int removed_diff;
7847 xtensa_relax_info *relax_info, *target_relax_info;
7848 asection *target_sec;
7849 ebb_t *ebb;
7850 ebb_constraint ebb_table;
7851 bfd_boolean relocs_fit;
7852
7853 /* If this routine always returns FALSE, the literals that cannot be
7854 coalesced will not be moved. */
7855 if (elf32xtensa_no_literal_movement)
7856 return FALSE;
7857
7858 relax_info = get_xtensa_relax_info (sec);
7859 if (!relax_info)
7860 return FALSE;
7861
7862 target_sec = r_reloc_get_section (target_loc);
7863 target_relax_info = get_xtensa_relax_info (target_sec);
7864
7865 /* Literals to undefined sections may not be moved because they
7866 must report an error. */
7867 if (bfd_is_und_section (target_sec))
7868 return FALSE;
7869
7870 src_entry = elf_xtensa_find_property_entry
7871 (prop_table, ptblsize, sec->vma + rel->r_rel.target_offset);
7872
7873 if (!section_cache_section (target_sec_cache, target_sec, link_info))
7874 return FALSE;
7875
7876 target_entry = elf_xtensa_find_property_entry
7877 (target_sec_cache->ptbl, target_sec_cache->pte_count,
7878 target_sec->vma + target_loc->target_offset);
7879
7880 if (!target_entry)
7881 return FALSE;
7882
7883 /* Make sure that we have not broken any branches. */
7884 relocs_fit = FALSE;
7885
7886 init_ebb_constraint (&ebb_table);
7887 ebb = &ebb_table.ebb;
7888 init_ebb (ebb, target_sec_cache->sec, target_sec_cache->contents,
7889 target_sec_cache->content_length,
7890 target_sec_cache->ptbl, target_sec_cache->pte_count,
7891 target_sec_cache->relocs, target_sec_cache->reloc_count);
7892
7893 /* Propose to add 4 bytes + worst-case alignment size increase to
7894 destination. */
7895 ebb_propose_action (&ebb_table, EBB_NO_ALIGN, 0,
7896 ta_fill, target_loc->target_offset,
7897 -4 - (1 << target_sec->alignment_power), TRUE);
7898
7899 /* Check all of the PC-relative relocations to make sure they still fit. */
7900 relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec,
7901 target_sec_cache->contents,
7902 target_sec_cache->relocs,
7903 &ebb_table, NULL);
7904
7905 if (!relocs_fit)
7906 return FALSE;
7907
7908 text_action_add_literal (&target_relax_info->action_list,
7909 ta_add_literal, target_loc, lit_value, -4);
7910
7911 if (target_sec->alignment_power > 2 && target_entry != src_entry)
7912 {
7913 /* May need to add or remove some fill to maintain alignment. */
7914 int fill_extra_space;
7915 bfd_vma entry_sec_offset;
7916
7917 entry_sec_offset =
7918 target_entry->address - target_sec->vma + target_entry->size;
7919
7920 /* If the literal range is at the end of the section,
7921 do not add fill. */
7922 fill_extra_space = 0;
7923 the_add_entry =
7924 elf_xtensa_find_property_entry (target_sec_cache->ptbl,
7925 target_sec_cache->pte_count,
7926 entry_sec_offset);
7927 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7928 fill_extra_space = the_add_entry->size;
7929
7930 target_fa = find_fill_action (&target_relax_info->action_list,
7931 target_sec, entry_sec_offset);
7932 removed_diff = compute_removed_action_diff (target_fa, target_sec,
7933 entry_sec_offset, 4,
7934 fill_extra_space);
7935 if (target_fa)
7936 adjust_fill_action (target_fa, removed_diff);
7937 else
7938 text_action_add (&target_relax_info->action_list,
7939 ta_fill, target_sec, entry_sec_offset, removed_diff);
7940 }
7941
7942 /* Mark that the literal will be moved to the new location. */
7943 add_removed_literal (&relax_info->removed_list, &rel->r_rel, target_loc);
7944
7945 /* Remove the literal. */
7946 text_action_add (&relax_info->action_list,
7947 ta_remove_literal, sec, rel->r_rel.target_offset, 4);
7948
7949 /* If the section is 4-byte aligned, do not add fill. */
7950 if (sec->alignment_power > 2 && target_entry != src_entry)
7951 {
7952 int fill_extra_space;
7953 bfd_vma entry_sec_offset;
7954
7955 if (src_entry)
7956 entry_sec_offset = src_entry->address - sec->vma + src_entry->size;
7957 else
7958 entry_sec_offset = rel->r_rel.target_offset+4;
7959
7960 /* If the literal range is at the end of the section,
7961 do not add fill. */
7962 fill_extra_space = 0;
7963 the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize,
7964 entry_sec_offset);
7965 if (the_add_entry && (the_add_entry->flags & XTENSA_PROP_UNREACHABLE))
7966 fill_extra_space = the_add_entry->size;
7967
7968 fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset);
7969 removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset,
7970 -4, fill_extra_space);
7971 if (fa)
7972 adjust_fill_action (fa, removed_diff);
7973 else
7974 text_action_add (&relax_info->action_list,
7975 ta_fill, sec, entry_sec_offset, removed_diff);
7976 }
7977
7978 return TRUE;
7979 }
7980
7981 \f
7982 /* Second relaxation pass. */
7983
7984 /* Modify all of the relocations to point to the right spot, and if this
7985 is a relaxable section, delete the unwanted literals and fix the
7986 section size. */
7987
7988 bfd_boolean
7989 relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info)
7990 {
7991 Elf_Internal_Rela *internal_relocs;
7992 xtensa_relax_info *relax_info;
7993 bfd_byte *contents;
7994 bfd_boolean ok = TRUE;
7995 unsigned i;
7996 bfd_boolean rv = FALSE;
7997 bfd_boolean virtual_action;
7998 bfd_size_type sec_size;
7999
8000 sec_size = bfd_get_section_limit (abfd, sec);
8001 relax_info = get_xtensa_relax_info (sec);
8002 BFD_ASSERT (relax_info);
8003
8004 /* First translate any of the fixes that have been added already. */
8005 translate_section_fixes (sec);
8006
8007 /* Handle property sections (e.g., literal tables) specially. */
8008 if (xtensa_is_property_section (sec))
8009 {
8010 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
8011 return relax_property_section (abfd, sec, link_info);
8012 }
8013
8014 internal_relocs = retrieve_internal_relocs (abfd, sec,
8015 link_info->keep_memory);
8016 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8017 if (contents == NULL && sec_size != 0)
8018 {
8019 ok = FALSE;
8020 goto error_return;
8021 }
8022
8023 if (internal_relocs)
8024 {
8025 for (i = 0; i < sec->reloc_count; i++)
8026 {
8027 Elf_Internal_Rela *irel;
8028 xtensa_relax_info *target_relax_info;
8029 bfd_vma source_offset, old_source_offset;
8030 r_reloc r_rel;
8031 unsigned r_type;
8032 asection *target_sec;
8033
8034 /* Locally change the source address.
8035 Translate the target to the new target address.
8036 If it points to this section and has been removed,
8037 NULLify it.
8038 Write it back. */
8039
8040 irel = &internal_relocs[i];
8041 source_offset = irel->r_offset;
8042 old_source_offset = source_offset;
8043
8044 r_type = ELF32_R_TYPE (irel->r_info);
8045 r_reloc_init (&r_rel, abfd, irel, contents,
8046 bfd_get_section_limit (abfd, sec));
8047
8048 /* If this section could have changed then we may need to
8049 change the relocation's offset. */
8050
8051 if (relax_info->is_relaxable_literal_section
8052 || relax_info->is_relaxable_asm_section)
8053 {
8054 if (r_type != R_XTENSA_NONE
8055 && find_removed_literal (&relax_info->removed_list,
8056 irel->r_offset))
8057 {
8058 /* Remove this relocation. */
8059 if (elf_hash_table (link_info)->dynamic_sections_created)
8060 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
8061 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
8062 irel->r_offset = offset_with_removed_text
8063 (&relax_info->action_list, irel->r_offset);
8064 pin_internal_relocs (sec, internal_relocs);
8065 continue;
8066 }
8067
8068 if (r_type == R_XTENSA_ASM_SIMPLIFY)
8069 {
8070 text_action *action =
8071 find_insn_action (&relax_info->action_list,
8072 irel->r_offset);
8073 if (action && (action->action == ta_convert_longcall
8074 || action->action == ta_remove_longcall))
8075 {
8076 bfd_reloc_status_type retval;
8077 char *error_message = NULL;
8078
8079 retval = contract_asm_expansion (contents, sec_size,
8080 irel, &error_message);
8081 if (retval != bfd_reloc_ok)
8082 {
8083 (*link_info->callbacks->reloc_dangerous)
8084 (link_info, error_message, abfd, sec,
8085 irel->r_offset);
8086 goto error_return;
8087 }
8088 /* Update the action so that the code that moves
8089 the contents will do the right thing. */
8090 if (action->action == ta_remove_longcall)
8091 action->action = ta_remove_insn;
8092 else
8093 action->action = ta_none;
8094 /* Refresh the info in the r_rel. */
8095 r_reloc_init (&r_rel, abfd, irel, contents, sec_size);
8096 r_type = ELF32_R_TYPE (irel->r_info);
8097 }
8098 }
8099
8100 source_offset = offset_with_removed_text
8101 (&relax_info->action_list, irel->r_offset);
8102 irel->r_offset = source_offset;
8103 }
8104
8105 /* If the target section could have changed then
8106 we may need to change the relocation's target offset. */
8107
8108 target_sec = r_reloc_get_section (&r_rel);
8109 target_relax_info = get_xtensa_relax_info (target_sec);
8110
8111 if (target_relax_info
8112 && (target_relax_info->is_relaxable_literal_section
8113 || target_relax_info->is_relaxable_asm_section))
8114 {
8115 r_reloc new_reloc;
8116 reloc_bfd_fix *fix;
8117 bfd_vma addend_displacement;
8118
8119 translate_reloc (&r_rel, &new_reloc);
8120
8121 if (r_type == R_XTENSA_DIFF8
8122 || r_type == R_XTENSA_DIFF16
8123 || r_type == R_XTENSA_DIFF32)
8124 {
8125 bfd_vma diff_value = 0, new_end_offset, diff_mask = 0;
8126
8127 if (bfd_get_section_limit (abfd, sec) < old_source_offset)
8128 {
8129 (*link_info->callbacks->reloc_dangerous)
8130 (link_info, _("invalid relocation address"),
8131 abfd, sec, old_source_offset);
8132 goto error_return;
8133 }
8134
8135 switch (r_type)
8136 {
8137 case R_XTENSA_DIFF8:
8138 diff_value =
8139 bfd_get_8 (abfd, &contents[old_source_offset]);
8140 break;
8141 case R_XTENSA_DIFF16:
8142 diff_value =
8143 bfd_get_16 (abfd, &contents[old_source_offset]);
8144 break;
8145 case R_XTENSA_DIFF32:
8146 diff_value =
8147 bfd_get_32 (abfd, &contents[old_source_offset]);
8148 break;
8149 }
8150
8151 new_end_offset = offset_with_removed_text
8152 (&target_relax_info->action_list,
8153 r_rel.target_offset + diff_value);
8154 diff_value = new_end_offset - new_reloc.target_offset;
8155
8156 switch (r_type)
8157 {
8158 case R_XTENSA_DIFF8:
8159 diff_mask = 0xff;
8160 bfd_put_8 (abfd, diff_value,
8161 &contents[old_source_offset]);
8162 break;
8163 case R_XTENSA_DIFF16:
8164 diff_mask = 0xffff;
8165 bfd_put_16 (abfd, diff_value,
8166 &contents[old_source_offset]);
8167 break;
8168 case R_XTENSA_DIFF32:
8169 diff_mask = 0xffffffff;
8170 bfd_put_32 (abfd, diff_value,
8171 &contents[old_source_offset]);
8172 break;
8173 }
8174
8175 /* Check for overflow. */
8176 if ((diff_value & ~diff_mask) != 0)
8177 {
8178 (*link_info->callbacks->reloc_dangerous)
8179 (link_info, _("overflow after relaxation"),
8180 abfd, sec, old_source_offset);
8181 goto error_return;
8182 }
8183
8184 pin_contents (sec, contents);
8185 }
8186
8187 /* FIXME: If the relocation still references a section in
8188 the same input file, the relocation should be modified
8189 directly instead of adding a "fix" record. */
8190
8191 addend_displacement =
8192 new_reloc.target_offset + new_reloc.virtual_offset;
8193
8194 fix = reloc_bfd_fix_init (sec, source_offset, r_type, 0,
8195 r_reloc_get_section (&new_reloc),
8196 addend_displacement, TRUE);
8197 add_fix (sec, fix);
8198 }
8199
8200 pin_internal_relocs (sec, internal_relocs);
8201 }
8202 }
8203
8204 if ((relax_info->is_relaxable_literal_section
8205 || relax_info->is_relaxable_asm_section)
8206 && relax_info->action_list.head)
8207 {
8208 /* Walk through the planned actions and build up a table
8209 of move, copy and fill records. Use the move, copy and
8210 fill records to perform the actions once. */
8211
8212 bfd_size_type size = sec->size;
8213 int removed = 0;
8214 bfd_size_type final_size, copy_size, orig_insn_size;
8215 bfd_byte *scratch = NULL;
8216 bfd_byte *dup_contents = NULL;
8217 bfd_size_type orig_size = size;
8218 bfd_vma orig_dot = 0;
8219 bfd_vma orig_dot_copied = 0; /* Byte copied already from
8220 orig dot in physical memory. */
8221 bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */
8222 bfd_vma dup_dot = 0;
8223
8224 text_action *action = relax_info->action_list.head;
8225
8226 final_size = sec->size;
8227 for (action = relax_info->action_list.head; action;
8228 action = action->next)
8229 {
8230 final_size -= action->removed_bytes;
8231 }
8232
8233 scratch = (bfd_byte *) bfd_zmalloc (final_size);
8234 dup_contents = (bfd_byte *) bfd_zmalloc (final_size);
8235
8236 /* The dot is the current fill location. */
8237 #if DEBUG
8238 print_action_list (stderr, &relax_info->action_list);
8239 #endif
8240
8241 for (action = relax_info->action_list.head; action;
8242 action = action->next)
8243 {
8244 virtual_action = FALSE;
8245 if (action->offset > orig_dot)
8246 {
8247 orig_dot += orig_dot_copied;
8248 orig_dot_copied = 0;
8249 orig_dot_vo = 0;
8250 /* Out of the virtual world. */
8251 }
8252
8253 if (action->offset > orig_dot)
8254 {
8255 copy_size = action->offset - orig_dot;
8256 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
8257 orig_dot += copy_size;
8258 dup_dot += copy_size;
8259 BFD_ASSERT (action->offset == orig_dot);
8260 }
8261 else if (action->offset < orig_dot)
8262 {
8263 if (action->action == ta_fill
8264 && action->offset - action->removed_bytes == orig_dot)
8265 {
8266 /* This is OK because the fill only effects the dup_dot. */
8267 }
8268 else if (action->action == ta_add_literal)
8269 {
8270 /* TBD. Might need to handle this. */
8271 }
8272 }
8273 if (action->offset == orig_dot)
8274 {
8275 if (action->virtual_offset > orig_dot_vo)
8276 {
8277 if (orig_dot_vo == 0)
8278 {
8279 /* Need to copy virtual_offset bytes. Probably four. */
8280 copy_size = action->virtual_offset - orig_dot_vo;
8281 memmove (&dup_contents[dup_dot],
8282 &contents[orig_dot], copy_size);
8283 orig_dot_copied = copy_size;
8284 dup_dot += copy_size;
8285 }
8286 virtual_action = TRUE;
8287 }
8288 else
8289 BFD_ASSERT (action->virtual_offset <= orig_dot_vo);
8290 }
8291 switch (action->action)
8292 {
8293 case ta_remove_literal:
8294 case ta_remove_insn:
8295 BFD_ASSERT (action->removed_bytes >= 0);
8296 orig_dot += action->removed_bytes;
8297 break;
8298
8299 case ta_narrow_insn:
8300 orig_insn_size = 3;
8301 copy_size = 2;
8302 memmove (scratch, &contents[orig_dot], orig_insn_size);
8303 BFD_ASSERT (action->removed_bytes == 1);
8304 rv = narrow_instruction (scratch, final_size, 0);
8305 BFD_ASSERT (rv);
8306 memmove (&dup_contents[dup_dot], scratch, copy_size);
8307 orig_dot += orig_insn_size;
8308 dup_dot += copy_size;
8309 break;
8310
8311 case ta_fill:
8312 if (action->removed_bytes >= 0)
8313 orig_dot += action->removed_bytes;
8314 else
8315 {
8316 /* Already zeroed in dup_contents. Just bump the
8317 counters. */
8318 dup_dot += (-action->removed_bytes);
8319 }
8320 break;
8321
8322 case ta_none:
8323 BFD_ASSERT (action->removed_bytes == 0);
8324 break;
8325
8326 case ta_convert_longcall:
8327 case ta_remove_longcall:
8328 /* These will be removed or converted before we get here. */
8329 BFD_ASSERT (0);
8330 break;
8331
8332 case ta_widen_insn:
8333 orig_insn_size = 2;
8334 copy_size = 3;
8335 memmove (scratch, &contents[orig_dot], orig_insn_size);
8336 BFD_ASSERT (action->removed_bytes == -1);
8337 rv = widen_instruction (scratch, final_size, 0);
8338 BFD_ASSERT (rv);
8339 memmove (&dup_contents[dup_dot], scratch, copy_size);
8340 orig_dot += orig_insn_size;
8341 dup_dot += copy_size;
8342 break;
8343
8344 case ta_add_literal:
8345 orig_insn_size = 0;
8346 copy_size = 4;
8347 BFD_ASSERT (action->removed_bytes == -4);
8348 /* TBD -- place the literal value here and insert
8349 into the table. */
8350 memset (&dup_contents[dup_dot], 0, 4);
8351 pin_internal_relocs (sec, internal_relocs);
8352 pin_contents (sec, contents);
8353
8354 if (!move_literal (abfd, link_info, sec, dup_dot, dup_contents,
8355 relax_info, &internal_relocs, &action->value))
8356 goto error_return;
8357
8358 if (virtual_action)
8359 orig_dot_vo += copy_size;
8360
8361 orig_dot += orig_insn_size;
8362 dup_dot += copy_size;
8363 break;
8364
8365 default:
8366 /* Not implemented yet. */
8367 BFD_ASSERT (0);
8368 break;
8369 }
8370
8371 size -= action->removed_bytes;
8372 removed += action->removed_bytes;
8373 BFD_ASSERT (dup_dot <= final_size);
8374 BFD_ASSERT (orig_dot <= orig_size);
8375 }
8376
8377 orig_dot += orig_dot_copied;
8378 orig_dot_copied = 0;
8379
8380 if (orig_dot != orig_size)
8381 {
8382 copy_size = orig_size - orig_dot;
8383 BFD_ASSERT (orig_size > orig_dot);
8384 BFD_ASSERT (dup_dot + copy_size == final_size);
8385 memmove (&dup_contents[dup_dot], &contents[orig_dot], copy_size);
8386 orig_dot += copy_size;
8387 dup_dot += copy_size;
8388 }
8389 BFD_ASSERT (orig_size == orig_dot);
8390 BFD_ASSERT (final_size == dup_dot);
8391
8392 /* Move the dup_contents back. */
8393 if (final_size > orig_size)
8394 {
8395 /* Contents need to be reallocated. Swap the dup_contents into
8396 contents. */
8397 sec->contents = dup_contents;
8398 free (contents);
8399 contents = dup_contents;
8400 pin_contents (sec, contents);
8401 }
8402 else
8403 {
8404 BFD_ASSERT (final_size <= orig_size);
8405 memset (contents, 0, orig_size);
8406 memcpy (contents, dup_contents, final_size);
8407 free (dup_contents);
8408 }
8409 free (scratch);
8410 pin_contents (sec, contents);
8411
8412 sec->size = final_size;
8413 }
8414
8415 error_return:
8416 release_internal_relocs (sec, internal_relocs);
8417 release_contents (sec, contents);
8418 return ok;
8419 }
8420
8421
8422 static bfd_boolean
8423 translate_section_fixes (asection *sec)
8424 {
8425 xtensa_relax_info *relax_info;
8426 reloc_bfd_fix *r;
8427
8428 relax_info = get_xtensa_relax_info (sec);
8429 if (!relax_info)
8430 return TRUE;
8431
8432 for (r = relax_info->fix_list; r != NULL; r = r->next)
8433 if (!translate_reloc_bfd_fix (r))
8434 return FALSE;
8435
8436 return TRUE;
8437 }
8438
8439
8440 /* Translate a fix given the mapping in the relax info for the target
8441 section. If it has already been translated, no work is required. */
8442
8443 static bfd_boolean
8444 translate_reloc_bfd_fix (reloc_bfd_fix *fix)
8445 {
8446 reloc_bfd_fix new_fix;
8447 asection *sec;
8448 xtensa_relax_info *relax_info;
8449 removed_literal *removed;
8450 bfd_vma new_offset, target_offset;
8451
8452 if (fix->translated)
8453 return TRUE;
8454
8455 sec = fix->target_sec;
8456 target_offset = fix->target_offset;
8457
8458 relax_info = get_xtensa_relax_info (sec);
8459 if (!relax_info)
8460 {
8461 fix->translated = TRUE;
8462 return TRUE;
8463 }
8464
8465 new_fix = *fix;
8466
8467 /* The fix does not need to be translated if the section cannot change. */
8468 if (!relax_info->is_relaxable_literal_section
8469 && !relax_info->is_relaxable_asm_section)
8470 {
8471 fix->translated = TRUE;
8472 return TRUE;
8473 }
8474
8475 /* If the literal has been moved and this relocation was on an
8476 opcode, then the relocation should move to the new literal
8477 location. Otherwise, the relocation should move within the
8478 section. */
8479
8480 removed = FALSE;
8481 if (is_operand_relocation (fix->src_type))
8482 {
8483 /* Check if the original relocation is against a literal being
8484 removed. */
8485 removed = find_removed_literal (&relax_info->removed_list,
8486 target_offset);
8487 }
8488
8489 if (removed)
8490 {
8491 asection *new_sec;
8492
8493 /* The fact that there is still a relocation to this literal indicates
8494 that the literal is being coalesced, not simply removed. */
8495 BFD_ASSERT (removed->to.abfd != NULL);
8496
8497 /* This was moved to some other address (possibly another section). */
8498 new_sec = r_reloc_get_section (&removed->to);
8499 if (new_sec != sec)
8500 {
8501 sec = new_sec;
8502 relax_info = get_xtensa_relax_info (sec);
8503 if (!relax_info ||
8504 (!relax_info->is_relaxable_literal_section
8505 && !relax_info->is_relaxable_asm_section))
8506 {
8507 target_offset = removed->to.target_offset;
8508 new_fix.target_sec = new_sec;
8509 new_fix.target_offset = target_offset;
8510 new_fix.translated = TRUE;
8511 *fix = new_fix;
8512 return TRUE;
8513 }
8514 }
8515 target_offset = removed->to.target_offset;
8516 new_fix.target_sec = new_sec;
8517 }
8518
8519 /* The target address may have been moved within its section. */
8520 new_offset = offset_with_removed_text (&relax_info->action_list,
8521 target_offset);
8522
8523 new_fix.target_offset = new_offset;
8524 new_fix.target_offset = new_offset;
8525 new_fix.translated = TRUE;
8526 *fix = new_fix;
8527 return TRUE;
8528 }
8529
8530
8531 /* Fix up a relocation to take account of removed literals. */
8532
8533 static void
8534 translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel)
8535 {
8536 asection *sec;
8537 xtensa_relax_info *relax_info;
8538 removed_literal *removed;
8539 bfd_vma new_offset, target_offset, removed_bytes;
8540
8541 *new_rel = *orig_rel;
8542
8543 if (!r_reloc_is_defined (orig_rel))
8544 return;
8545 sec = r_reloc_get_section (orig_rel);
8546
8547 relax_info = get_xtensa_relax_info (sec);
8548 BFD_ASSERT (relax_info);
8549
8550 if (!relax_info->is_relaxable_literal_section
8551 && !relax_info->is_relaxable_asm_section)
8552 return;
8553
8554 target_offset = orig_rel->target_offset;
8555
8556 removed = FALSE;
8557 if (is_operand_relocation (ELF32_R_TYPE (orig_rel->rela.r_info)))
8558 {
8559 /* Check if the original relocation is against a literal being
8560 removed. */
8561 removed = find_removed_literal (&relax_info->removed_list,
8562 target_offset);
8563 }
8564 if (removed && removed->to.abfd)
8565 {
8566 asection *new_sec;
8567
8568 /* The fact that there is still a relocation to this literal indicates
8569 that the literal is being coalesced, not simply removed. */
8570 BFD_ASSERT (removed->to.abfd != NULL);
8571
8572 /* This was moved to some other address
8573 (possibly in another section). */
8574 *new_rel = removed->to;
8575 new_sec = r_reloc_get_section (new_rel);
8576 if (new_sec != sec)
8577 {
8578 sec = new_sec;
8579 relax_info = get_xtensa_relax_info (sec);
8580 if (!relax_info
8581 || (!relax_info->is_relaxable_literal_section
8582 && !relax_info->is_relaxable_asm_section))
8583 return;
8584 }
8585 target_offset = new_rel->target_offset;
8586 }
8587
8588 /* ...and the target address may have been moved within its section. */
8589 new_offset = offset_with_removed_text (&relax_info->action_list,
8590 target_offset);
8591
8592 /* Modify the offset and addend. */
8593 removed_bytes = target_offset - new_offset;
8594 new_rel->target_offset = new_offset;
8595 new_rel->rela.r_addend -= removed_bytes;
8596 }
8597
8598
8599 /* For dynamic links, there may be a dynamic relocation for each
8600 literal. The number of dynamic relocations must be computed in
8601 size_dynamic_sections, which occurs before relaxation. When a
8602 literal is removed, this function checks if there is a corresponding
8603 dynamic relocation and shrinks the size of the appropriate dynamic
8604 relocation section accordingly. At this point, the contents of the
8605 dynamic relocation sections have not yet been filled in, so there's
8606 nothing else that needs to be done. */
8607
8608 static void
8609 shrink_dynamic_reloc_sections (struct bfd_link_info *info,
8610 bfd *abfd,
8611 asection *input_section,
8612 Elf_Internal_Rela *rel)
8613 {
8614 Elf_Internal_Shdr *symtab_hdr;
8615 struct elf_link_hash_entry **sym_hashes;
8616 unsigned long r_symndx;
8617 int r_type;
8618 struct elf_link_hash_entry *h;
8619 bfd_boolean dynamic_symbol;
8620
8621 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
8622 sym_hashes = elf_sym_hashes (abfd);
8623
8624 r_type = ELF32_R_TYPE (rel->r_info);
8625 r_symndx = ELF32_R_SYM (rel->r_info);
8626
8627 if (r_symndx < symtab_hdr->sh_info)
8628 h = NULL;
8629 else
8630 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8631
8632 dynamic_symbol = xtensa_elf_dynamic_symbol_p (h, info);
8633
8634 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
8635 && (input_section->flags & SEC_ALLOC) != 0
8636 && (dynamic_symbol || info->shared))
8637 {
8638 bfd *dynobj;
8639 const char *srel_name;
8640 asection *srel;
8641 bfd_boolean is_plt = FALSE;
8642
8643 dynobj = elf_hash_table (info)->dynobj;
8644 BFD_ASSERT (dynobj != NULL);
8645
8646 if (dynamic_symbol && r_type == R_XTENSA_PLT)
8647 {
8648 srel_name = ".rela.plt";
8649 is_plt = TRUE;
8650 }
8651 else
8652 srel_name = ".rela.got";
8653
8654 /* Reduce size of the .rela.* section by one reloc. */
8655 srel = bfd_get_section_by_name (dynobj, srel_name);
8656 BFD_ASSERT (srel != NULL);
8657 BFD_ASSERT (srel->size >= sizeof (Elf32_External_Rela));
8658 srel->size -= sizeof (Elf32_External_Rela);
8659
8660 if (is_plt)
8661 {
8662 asection *splt, *sgotplt, *srelgot;
8663 int reloc_index, chunk;
8664
8665 /* Find the PLT reloc index of the entry being removed. This
8666 is computed from the size of ".rela.plt". It is needed to
8667 figure out which PLT chunk to resize. Usually "last index
8668 = size - 1" since the index starts at zero, but in this
8669 context, the size has just been decremented so there's no
8670 need to subtract one. */
8671 reloc_index = srel->size / sizeof (Elf32_External_Rela);
8672
8673 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
8674 splt = elf_xtensa_get_plt_section (dynobj, chunk);
8675 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
8676 BFD_ASSERT (splt != NULL && sgotplt != NULL);
8677
8678 /* Check if an entire PLT chunk has just been eliminated. */
8679 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
8680 {
8681 /* The two magic GOT entries for that chunk can go away. */
8682 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
8683 BFD_ASSERT (srelgot != NULL);
8684 srelgot->reloc_count -= 2;
8685 srelgot->size -= 2 * sizeof (Elf32_External_Rela);
8686 sgotplt->size -= 8;
8687
8688 /* There should be only one entry left (and it will be
8689 removed below). */
8690 BFD_ASSERT (sgotplt->size == 4);
8691 BFD_ASSERT (splt->size == PLT_ENTRY_SIZE);
8692 }
8693
8694 BFD_ASSERT (sgotplt->size >= 4);
8695 BFD_ASSERT (splt->size >= PLT_ENTRY_SIZE);
8696
8697 sgotplt->size -= 4;
8698 splt->size -= PLT_ENTRY_SIZE;
8699 }
8700 }
8701 }
8702
8703
8704 /* Take an r_rel and move it to another section. This usually
8705 requires extending the interal_relocation array and pinning it. If
8706 the original r_rel is from the same BFD, we can complete this here.
8707 Otherwise, we add a fix record to let the final link fix the
8708 appropriate address. Contents and internal relocations for the
8709 section must be pinned after calling this routine. */
8710
8711 static bfd_boolean
8712 move_literal (bfd *abfd,
8713 struct bfd_link_info *link_info,
8714 asection *sec,
8715 bfd_vma offset,
8716 bfd_byte *contents,
8717 xtensa_relax_info *relax_info,
8718 Elf_Internal_Rela **internal_relocs_p,
8719 const literal_value *lit)
8720 {
8721 Elf_Internal_Rela *new_relocs = NULL;
8722 size_t new_relocs_count = 0;
8723 Elf_Internal_Rela this_rela;
8724 const r_reloc *r_rel;
8725
8726 r_rel = &lit->r_rel;
8727 BFD_ASSERT (elf_section_data (sec)->relocs == *internal_relocs_p);
8728
8729 if (r_reloc_is_const (r_rel))
8730 bfd_put_32 (abfd, lit->value, contents + offset);
8731 else
8732 {
8733 int r_type;
8734 unsigned i;
8735 asection *target_sec;
8736 reloc_bfd_fix *fix;
8737 unsigned insert_at;
8738
8739 r_type = ELF32_R_TYPE (r_rel->rela.r_info);
8740 target_sec = r_reloc_get_section (r_rel);
8741
8742 /* This is the difficult case. We have to create a fix up. */
8743 this_rela.r_offset = offset;
8744 this_rela.r_info = ELF32_R_INFO (0, r_type);
8745 this_rela.r_addend =
8746 r_rel->target_offset - r_reloc_get_target_offset (r_rel);
8747 bfd_put_32 (abfd, lit->value, contents + offset);
8748
8749 /* Currently, we cannot move relocations during a relocatable link. */
8750 BFD_ASSERT (!link_info->relocatable);
8751 fix = reloc_bfd_fix_init (sec, offset, r_type, r_rel->abfd,
8752 r_reloc_get_section (r_rel),
8753 r_rel->target_offset + r_rel->virtual_offset,
8754 FALSE);
8755 /* We also need to mark that relocations are needed here. */
8756 sec->flags |= SEC_RELOC;
8757
8758 translate_reloc_bfd_fix (fix);
8759 /* This fix has not yet been translated. */
8760 add_fix (sec, fix);
8761
8762 /* Add the relocation. If we have already allocated our own
8763 space for the relocations and we have room for more, then use
8764 it. Otherwise, allocate new space and move the literals. */
8765 insert_at = sec->reloc_count;
8766 for (i = 0; i < sec->reloc_count; ++i)
8767 {
8768 if (this_rela.r_offset < (*internal_relocs_p)[i].r_offset)
8769 {
8770 insert_at = i;
8771 break;
8772 }
8773 }
8774
8775 if (*internal_relocs_p != relax_info->allocated_relocs
8776 || sec->reloc_count + 1 > relax_info->allocated_relocs_count)
8777 {
8778 BFD_ASSERT (relax_info->allocated_relocs == NULL
8779 || sec->reloc_count == relax_info->relocs_count);
8780
8781 if (relax_info->allocated_relocs_count == 0)
8782 new_relocs_count = (sec->reloc_count + 2) * 2;
8783 else
8784 new_relocs_count = (relax_info->allocated_relocs_count + 2) * 2;
8785
8786 new_relocs = (Elf_Internal_Rela *)
8787 bfd_zmalloc (sizeof (Elf_Internal_Rela) * (new_relocs_count));
8788 if (!new_relocs)
8789 return FALSE;
8790
8791 /* We could handle this more quickly by finding the split point. */
8792 if (insert_at != 0)
8793 memcpy (new_relocs, *internal_relocs_p,
8794 insert_at * sizeof (Elf_Internal_Rela));
8795
8796 new_relocs[insert_at] = this_rela;
8797
8798 if (insert_at != sec->reloc_count)
8799 memcpy (new_relocs + insert_at + 1,
8800 (*internal_relocs_p) + insert_at,
8801 (sec->reloc_count - insert_at)
8802 * sizeof (Elf_Internal_Rela));
8803
8804 if (*internal_relocs_p != relax_info->allocated_relocs)
8805 {
8806 /* The first time we re-allocate, we can only free the
8807 old relocs if they were allocated with bfd_malloc.
8808 This is not true when keep_memory is in effect. */
8809 if (!link_info->keep_memory)
8810 free (*internal_relocs_p);
8811 }
8812 else
8813 free (*internal_relocs_p);
8814 relax_info->allocated_relocs = new_relocs;
8815 relax_info->allocated_relocs_count = new_relocs_count;
8816 elf_section_data (sec)->relocs = new_relocs;
8817 sec->reloc_count++;
8818 relax_info->relocs_count = sec->reloc_count;
8819 *internal_relocs_p = new_relocs;
8820 }
8821 else
8822 {
8823 if (insert_at != sec->reloc_count)
8824 {
8825 unsigned idx;
8826 for (idx = sec->reloc_count; idx > insert_at; idx--)
8827 (*internal_relocs_p)[idx] = (*internal_relocs_p)[idx-1];
8828 }
8829 (*internal_relocs_p)[insert_at] = this_rela;
8830 sec->reloc_count++;
8831 if (relax_info->allocated_relocs)
8832 relax_info->relocs_count = sec->reloc_count;
8833 }
8834 }
8835 return TRUE;
8836 }
8837
8838
8839 /* This is similar to relax_section except that when a target is moved,
8840 we shift addresses up. We also need to modify the size. This
8841 algorithm does NOT allow for relocations into the middle of the
8842 property sections. */
8843
8844 static bfd_boolean
8845 relax_property_section (bfd *abfd,
8846 asection *sec,
8847 struct bfd_link_info *link_info)
8848 {
8849 Elf_Internal_Rela *internal_relocs;
8850 bfd_byte *contents;
8851 unsigned i, nexti;
8852 bfd_boolean ok = TRUE;
8853 bfd_boolean is_full_prop_section;
8854 size_t last_zfill_target_offset = 0;
8855 asection *last_zfill_target_sec = NULL;
8856 bfd_size_type sec_size;
8857
8858 sec_size = bfd_get_section_limit (abfd, sec);
8859 internal_relocs = retrieve_internal_relocs (abfd, sec,
8860 link_info->keep_memory);
8861 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
8862 if (contents == NULL && sec_size != 0)
8863 {
8864 ok = FALSE;
8865 goto error_return;
8866 }
8867
8868 is_full_prop_section =
8869 ( CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME)
8870 || CONST_STRNEQ (sec->name, ".gnu.linkonce.prop."));
8871
8872 if (internal_relocs)
8873 {
8874 for (i = 0; i < sec->reloc_count; i++)
8875 {
8876 Elf_Internal_Rela *irel;
8877 xtensa_relax_info *target_relax_info;
8878 unsigned r_type;
8879 asection *target_sec;
8880 literal_value val;
8881 bfd_byte *size_p, *flags_p;
8882
8883 /* Locally change the source address.
8884 Translate the target to the new target address.
8885 If it points to this section and has been removed, MOVE IT.
8886 Also, don't forget to modify the associated SIZE at
8887 (offset + 4). */
8888
8889 irel = &internal_relocs[i];
8890 r_type = ELF32_R_TYPE (irel->r_info);
8891 if (r_type == R_XTENSA_NONE)
8892 continue;
8893
8894 /* Find the literal value. */
8895 r_reloc_init (&val.r_rel, abfd, irel, contents, sec_size);
8896 size_p = &contents[irel->r_offset + 4];
8897 flags_p = NULL;
8898 if (is_full_prop_section)
8899 {
8900 flags_p = &contents[irel->r_offset + 8];
8901 BFD_ASSERT (irel->r_offset + 12 <= sec_size);
8902 }
8903 else
8904 BFD_ASSERT (irel->r_offset + 8 <= sec_size);
8905
8906 target_sec = r_reloc_get_section (&val.r_rel);
8907 target_relax_info = get_xtensa_relax_info (target_sec);
8908
8909 if (target_relax_info
8910 && (target_relax_info->is_relaxable_literal_section
8911 || target_relax_info->is_relaxable_asm_section ))
8912 {
8913 /* Translate the relocation's destination. */
8914 bfd_vma new_offset, new_end_offset;
8915 long old_size, new_size;
8916
8917 new_offset = offset_with_removed_text
8918 (&target_relax_info->action_list, val.r_rel.target_offset);
8919
8920 /* Assert that we are not out of bounds. */
8921 old_size = bfd_get_32 (abfd, size_p);
8922
8923 if (old_size == 0)
8924 {
8925 /* Only the first zero-sized unreachable entry is
8926 allowed to expand. In this case the new offset
8927 should be the offset before the fill and the new
8928 size is the expansion size. For other zero-sized
8929 entries the resulting size should be zero with an
8930 offset before or after the fill address depending
8931 on whether the expanding unreachable entry
8932 preceeds it. */
8933 if (last_zfill_target_sec
8934 && last_zfill_target_sec == target_sec
8935 && last_zfill_target_offset == val.r_rel.target_offset)
8936 new_end_offset = new_offset;
8937 else
8938 {
8939 new_end_offset = new_offset;
8940 new_offset = offset_with_removed_text_before_fill
8941 (&target_relax_info->action_list,
8942 val.r_rel.target_offset);
8943
8944 /* If it is not unreachable and we have not yet
8945 seen an unreachable at this address, place it
8946 before the fill address. */
8947 if (!flags_p
8948 || (bfd_get_32 (abfd, flags_p)
8949 & XTENSA_PROP_UNREACHABLE) == 0)
8950 new_end_offset = new_offset;
8951 else
8952 {
8953 last_zfill_target_sec = target_sec;
8954 last_zfill_target_offset = val.r_rel.target_offset;
8955 }
8956 }
8957 }
8958 else
8959 {
8960 new_end_offset = offset_with_removed_text_before_fill
8961 (&target_relax_info->action_list,
8962 val.r_rel.target_offset + old_size);
8963 }
8964
8965 new_size = new_end_offset - new_offset;
8966
8967 if (new_size != old_size)
8968 {
8969 bfd_put_32 (abfd, new_size, size_p);
8970 pin_contents (sec, contents);
8971 }
8972
8973 if (new_offset != val.r_rel.target_offset)
8974 {
8975 bfd_vma diff = new_offset - val.r_rel.target_offset;
8976 irel->r_addend += diff;
8977 pin_internal_relocs (sec, internal_relocs);
8978 }
8979 }
8980 }
8981 }
8982
8983 /* Combine adjacent property table entries. This is also done in
8984 finish_dynamic_sections() but at that point it's too late to
8985 reclaim the space in the output section, so we do this twice. */
8986
8987 if (internal_relocs && (!link_info->relocatable
8988 || strcmp (sec->name, XTENSA_LIT_SEC_NAME) == 0))
8989 {
8990 Elf_Internal_Rela *last_irel = NULL;
8991 int removed_bytes = 0;
8992 bfd_vma offset, last_irel_offset;
8993 bfd_vma section_size;
8994 bfd_size_type entry_size;
8995 flagword predef_flags;
8996
8997 if (is_full_prop_section)
8998 entry_size = 12;
8999 else
9000 entry_size = 8;
9001
9002 predef_flags = xtensa_get_property_predef_flags (sec);
9003
9004 /* Walk over memory and irels at the same time.
9005 This REQUIRES that the internal_relocs be sorted by offset. */
9006 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
9007 internal_reloc_compare);
9008 nexti = 0; /* Index into internal_relocs. */
9009
9010 pin_internal_relocs (sec, internal_relocs);
9011 pin_contents (sec, contents);
9012
9013 last_irel_offset = (bfd_vma) -1;
9014 section_size = sec->size;
9015 BFD_ASSERT (section_size % entry_size == 0);
9016
9017 for (offset = 0; offset < section_size; offset += entry_size)
9018 {
9019 Elf_Internal_Rela *irel, *next_irel;
9020 bfd_vma bytes_to_remove, size, actual_offset;
9021 bfd_boolean remove_this_irel;
9022 flagword flags;
9023
9024 irel = NULL;
9025 next_irel = NULL;
9026
9027 /* Find the next two relocations (if there are that many left),
9028 skipping over any R_XTENSA_NONE relocs. On entry, "nexti" is
9029 the starting reloc index. After these two loops, "i"
9030 is the index of the first non-NONE reloc past that starting
9031 index, and "nexti" is the index for the next non-NONE reloc
9032 after "i". */
9033
9034 for (i = nexti; i < sec->reloc_count; i++)
9035 {
9036 if (ELF32_R_TYPE (internal_relocs[i].r_info) != R_XTENSA_NONE)
9037 {
9038 irel = &internal_relocs[i];
9039 break;
9040 }
9041 internal_relocs[i].r_offset -= removed_bytes;
9042 }
9043
9044 for (nexti = i + 1; nexti < sec->reloc_count; nexti++)
9045 {
9046 if (ELF32_R_TYPE (internal_relocs[nexti].r_info)
9047 != R_XTENSA_NONE)
9048 {
9049 next_irel = &internal_relocs[nexti];
9050 break;
9051 }
9052 internal_relocs[nexti].r_offset -= removed_bytes;
9053 }
9054
9055 remove_this_irel = FALSE;
9056 bytes_to_remove = 0;
9057 actual_offset = offset - removed_bytes;
9058 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
9059
9060 if (is_full_prop_section)
9061 flags = bfd_get_32 (abfd, &contents[actual_offset + 8]);
9062 else
9063 flags = predef_flags;
9064
9065 /* Check that the irels are sorted by offset,
9066 with only one per address. */
9067 BFD_ASSERT (!irel || (int) irel->r_offset > (int) last_irel_offset);
9068 BFD_ASSERT (!next_irel || next_irel->r_offset > irel->r_offset);
9069
9070 /* Make sure there aren't relocs on the size or flag fields. */
9071 if ((irel && irel->r_offset == offset + 4)
9072 || (is_full_prop_section
9073 && irel && irel->r_offset == offset + 8))
9074 {
9075 irel->r_offset -= removed_bytes;
9076 last_irel_offset = irel->r_offset;
9077 }
9078 else if (next_irel && (next_irel->r_offset == offset + 4
9079 || (is_full_prop_section
9080 && next_irel->r_offset == offset + 8)))
9081 {
9082 nexti += 1;
9083 irel->r_offset -= removed_bytes;
9084 next_irel->r_offset -= removed_bytes;
9085 last_irel_offset = next_irel->r_offset;
9086 }
9087 else if (size == 0 && (flags & XTENSA_PROP_ALIGN) == 0
9088 && (flags & XTENSA_PROP_UNREACHABLE) == 0)
9089 {
9090 /* Always remove entries with zero size and no alignment. */
9091 bytes_to_remove = entry_size;
9092 if (irel && irel->r_offset == offset)
9093 {
9094 remove_this_irel = TRUE;
9095
9096 irel->r_offset -= removed_bytes;
9097 last_irel_offset = irel->r_offset;
9098 }
9099 }
9100 else if (irel && irel->r_offset == offset)
9101 {
9102 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32)
9103 {
9104 if (last_irel)
9105 {
9106 flagword old_flags;
9107 bfd_vma old_size =
9108 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
9109 bfd_vma old_address =
9110 (last_irel->r_addend
9111 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
9112 bfd_vma new_address =
9113 (irel->r_addend
9114 + bfd_get_32 (abfd, &contents[actual_offset]));
9115 if (is_full_prop_section)
9116 old_flags = bfd_get_32
9117 (abfd, &contents[last_irel->r_offset + 8]);
9118 else
9119 old_flags = predef_flags;
9120
9121 if ((ELF32_R_SYM (irel->r_info)
9122 == ELF32_R_SYM (last_irel->r_info))
9123 && old_address + old_size == new_address
9124 && old_flags == flags
9125 && (old_flags & XTENSA_PROP_INSN_BRANCH_TARGET) == 0
9126 && (old_flags & XTENSA_PROP_INSN_LOOP_TARGET) == 0)
9127 {
9128 /* Fix the old size. */
9129 bfd_put_32 (abfd, old_size + size,
9130 &contents[last_irel->r_offset + 4]);
9131 bytes_to_remove = entry_size;
9132 remove_this_irel = TRUE;
9133 }
9134 else
9135 last_irel = irel;
9136 }
9137 else
9138 last_irel = irel;
9139 }
9140
9141 irel->r_offset -= removed_bytes;
9142 last_irel_offset = irel->r_offset;
9143 }
9144
9145 if (remove_this_irel)
9146 {
9147 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
9148 irel->r_offset -= bytes_to_remove;
9149 }
9150
9151 if (bytes_to_remove != 0)
9152 {
9153 removed_bytes += bytes_to_remove;
9154 if (offset + bytes_to_remove < section_size)
9155 memmove (&contents[actual_offset],
9156 &contents[actual_offset + bytes_to_remove],
9157 section_size - offset - bytes_to_remove);
9158 }
9159 }
9160
9161 if (removed_bytes)
9162 {
9163 /* Clear the removed bytes. */
9164 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
9165
9166 sec->size = section_size - removed_bytes;
9167
9168 if (xtensa_is_littable_section (sec))
9169 {
9170 bfd *dynobj = elf_hash_table (link_info)->dynobj;
9171 if (dynobj)
9172 {
9173 asection *sgotloc =
9174 bfd_get_section_by_name (dynobj, ".got.loc");
9175 if (sgotloc)
9176 sgotloc->size -= removed_bytes;
9177 }
9178 }
9179 }
9180 }
9181
9182 error_return:
9183 release_internal_relocs (sec, internal_relocs);
9184 release_contents (sec, contents);
9185 return ok;
9186 }
9187
9188 \f
9189 /* Third relaxation pass. */
9190
9191 /* Change symbol values to account for removed literals. */
9192
9193 bfd_boolean
9194 relax_section_symbols (bfd *abfd, asection *sec)
9195 {
9196 xtensa_relax_info *relax_info;
9197 unsigned int sec_shndx;
9198 Elf_Internal_Shdr *symtab_hdr;
9199 Elf_Internal_Sym *isymbuf;
9200 unsigned i, num_syms, num_locals;
9201
9202 relax_info = get_xtensa_relax_info (sec);
9203 BFD_ASSERT (relax_info);
9204
9205 if (!relax_info->is_relaxable_literal_section
9206 && !relax_info->is_relaxable_asm_section)
9207 return TRUE;
9208
9209 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
9210
9211 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9212 isymbuf = retrieve_local_syms (abfd);
9213
9214 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
9215 num_locals = symtab_hdr->sh_info;
9216
9217 /* Adjust the local symbols defined in this section. */
9218 for (i = 0; i < num_locals; i++)
9219 {
9220 Elf_Internal_Sym *isym = &isymbuf[i];
9221
9222 if (isym->st_shndx == sec_shndx)
9223 {
9224 bfd_vma new_address = offset_with_removed_text
9225 (&relax_info->action_list, isym->st_value);
9226 bfd_vma new_size = isym->st_size;
9227
9228 if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC)
9229 {
9230 bfd_vma new_end = offset_with_removed_text
9231 (&relax_info->action_list, isym->st_value + isym->st_size);
9232 new_size = new_end - new_address;
9233 }
9234
9235 isym->st_value = new_address;
9236 isym->st_size = new_size;
9237 }
9238 }
9239
9240 /* Now adjust the global symbols defined in this section. */
9241 for (i = 0; i < (num_syms - num_locals); i++)
9242 {
9243 struct elf_link_hash_entry *sym_hash;
9244
9245 sym_hash = elf_sym_hashes (abfd)[i];
9246
9247 if (sym_hash->root.type == bfd_link_hash_warning)
9248 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
9249
9250 if ((sym_hash->root.type == bfd_link_hash_defined
9251 || sym_hash->root.type == bfd_link_hash_defweak)
9252 && sym_hash->root.u.def.section == sec)
9253 {
9254 bfd_vma new_address = offset_with_removed_text
9255 (&relax_info->action_list, sym_hash->root.u.def.value);
9256 bfd_vma new_size = sym_hash->size;
9257
9258 if (sym_hash->type == STT_FUNC)
9259 {
9260 bfd_vma new_end = offset_with_removed_text
9261 (&relax_info->action_list,
9262 sym_hash->root.u.def.value + sym_hash->size);
9263 new_size = new_end - new_address;
9264 }
9265
9266 sym_hash->root.u.def.value = new_address;
9267 sym_hash->size = new_size;
9268 }
9269 }
9270
9271 return TRUE;
9272 }
9273
9274 \f
9275 /* "Fix" handling functions, called while performing relocations. */
9276
9277 static bfd_boolean
9278 do_fix_for_relocatable_link (Elf_Internal_Rela *rel,
9279 bfd *input_bfd,
9280 asection *input_section,
9281 bfd_byte *contents)
9282 {
9283 r_reloc r_rel;
9284 asection *sec, *old_sec;
9285 bfd_vma old_offset;
9286 int r_type = ELF32_R_TYPE (rel->r_info);
9287 reloc_bfd_fix *fix;
9288
9289 if (r_type == R_XTENSA_NONE)
9290 return TRUE;
9291
9292 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
9293 if (!fix)
9294 return TRUE;
9295
9296 r_reloc_init (&r_rel, input_bfd, rel, contents,
9297 bfd_get_section_limit (input_bfd, input_section));
9298 old_sec = r_reloc_get_section (&r_rel);
9299 old_offset = r_rel.target_offset;
9300
9301 if (!old_sec || !r_reloc_is_defined (&r_rel))
9302 {
9303 if (r_type != R_XTENSA_ASM_EXPAND)
9304 {
9305 (*_bfd_error_handler)
9306 (_("%B(%A+0x%lx): unexpected fix for %s relocation"),
9307 input_bfd, input_section, rel->r_offset,
9308 elf_howto_table[r_type].name);
9309 return FALSE;
9310 }
9311 /* Leave it be. Resolution will happen in a later stage. */
9312 }
9313 else
9314 {
9315 sec = fix->target_sec;
9316 rel->r_addend += ((sec->output_offset + fix->target_offset)
9317 - (old_sec->output_offset + old_offset));
9318 }
9319 return TRUE;
9320 }
9321
9322
9323 static void
9324 do_fix_for_final_link (Elf_Internal_Rela *rel,
9325 bfd *input_bfd,
9326 asection *input_section,
9327 bfd_byte *contents,
9328 bfd_vma *relocationp)
9329 {
9330 asection *sec;
9331 int r_type = ELF32_R_TYPE (rel->r_info);
9332 reloc_bfd_fix *fix;
9333 bfd_vma fixup_diff;
9334
9335 if (r_type == R_XTENSA_NONE)
9336 return;
9337
9338 fix = get_bfd_fix (input_section, rel->r_offset, r_type);
9339 if (!fix)
9340 return;
9341
9342 sec = fix->target_sec;
9343
9344 fixup_diff = rel->r_addend;
9345 if (elf_howto_table[fix->src_type].partial_inplace)
9346 {
9347 bfd_vma inplace_val;
9348 BFD_ASSERT (fix->src_offset
9349 < bfd_get_section_limit (input_bfd, input_section));
9350 inplace_val = bfd_get_32 (input_bfd, &contents[fix->src_offset]);
9351 fixup_diff += inplace_val;
9352 }
9353
9354 *relocationp = (sec->output_section->vma
9355 + sec->output_offset
9356 + fix->target_offset - fixup_diff);
9357 }
9358
9359 \f
9360 /* Miscellaneous utility functions.... */
9361
9362 static asection *
9363 elf_xtensa_get_plt_section (bfd *dynobj, int chunk)
9364 {
9365 char plt_name[10];
9366
9367 if (chunk == 0)
9368 return bfd_get_section_by_name (dynobj, ".plt");
9369
9370 sprintf (plt_name, ".plt.%u", chunk);
9371 return bfd_get_section_by_name (dynobj, plt_name);
9372 }
9373
9374
9375 static asection *
9376 elf_xtensa_get_gotplt_section (bfd *dynobj, int chunk)
9377 {
9378 char got_name[14];
9379
9380 if (chunk == 0)
9381 return bfd_get_section_by_name (dynobj, ".got.plt");
9382
9383 sprintf (got_name, ".got.plt.%u", chunk);
9384 return bfd_get_section_by_name (dynobj, got_name);
9385 }
9386
9387
9388 /* Get the input section for a given symbol index.
9389 If the symbol is:
9390 . a section symbol, return the section;
9391 . a common symbol, return the common section;
9392 . an undefined symbol, return the undefined section;
9393 . an indirect symbol, follow the links;
9394 . an absolute value, return the absolute section. */
9395
9396 static asection *
9397 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
9398 {
9399 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9400 asection *target_sec = NULL;
9401 if (r_symndx < symtab_hdr->sh_info)
9402 {
9403 Elf_Internal_Sym *isymbuf;
9404 unsigned int section_index;
9405
9406 isymbuf = retrieve_local_syms (abfd);
9407 section_index = isymbuf[r_symndx].st_shndx;
9408
9409 if (section_index == SHN_UNDEF)
9410 target_sec = bfd_und_section_ptr;
9411 else if (section_index > 0 && section_index < SHN_LORESERVE)
9412 target_sec = bfd_section_from_elf_index (abfd, section_index);
9413 else if (section_index == SHN_ABS)
9414 target_sec = bfd_abs_section_ptr;
9415 else if (section_index == SHN_COMMON)
9416 target_sec = bfd_com_section_ptr;
9417 else
9418 /* Who knows? */
9419 target_sec = NULL;
9420 }
9421 else
9422 {
9423 unsigned long indx = r_symndx - symtab_hdr->sh_info;
9424 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
9425
9426 while (h->root.type == bfd_link_hash_indirect
9427 || h->root.type == bfd_link_hash_warning)
9428 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9429
9430 switch (h->root.type)
9431 {
9432 case bfd_link_hash_defined:
9433 case bfd_link_hash_defweak:
9434 target_sec = h->root.u.def.section;
9435 break;
9436 case bfd_link_hash_common:
9437 target_sec = bfd_com_section_ptr;
9438 break;
9439 case bfd_link_hash_undefined:
9440 case bfd_link_hash_undefweak:
9441 target_sec = bfd_und_section_ptr;
9442 break;
9443 default: /* New indirect warning. */
9444 target_sec = bfd_und_section_ptr;
9445 break;
9446 }
9447 }
9448 return target_sec;
9449 }
9450
9451
9452 static struct elf_link_hash_entry *
9453 get_elf_r_symndx_hash_entry (bfd *abfd, unsigned long r_symndx)
9454 {
9455 unsigned long indx;
9456 struct elf_link_hash_entry *h;
9457 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9458
9459 if (r_symndx < symtab_hdr->sh_info)
9460 return NULL;
9461
9462 indx = r_symndx - symtab_hdr->sh_info;
9463 h = elf_sym_hashes (abfd)[indx];
9464 while (h->root.type == bfd_link_hash_indirect
9465 || h->root.type == bfd_link_hash_warning)
9466 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9467 return h;
9468 }
9469
9470
9471 /* Get the section-relative offset for a symbol number. */
9472
9473 static bfd_vma
9474 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
9475 {
9476 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
9477 bfd_vma offset = 0;
9478
9479 if (r_symndx < symtab_hdr->sh_info)
9480 {
9481 Elf_Internal_Sym *isymbuf;
9482 isymbuf = retrieve_local_syms (abfd);
9483 offset = isymbuf[r_symndx].st_value;
9484 }
9485 else
9486 {
9487 unsigned long indx = r_symndx - symtab_hdr->sh_info;
9488 struct elf_link_hash_entry *h =
9489 elf_sym_hashes (abfd)[indx];
9490
9491 while (h->root.type == bfd_link_hash_indirect
9492 || h->root.type == bfd_link_hash_warning)
9493 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9494 if (h->root.type == bfd_link_hash_defined
9495 || h->root.type == bfd_link_hash_defweak)
9496 offset = h->root.u.def.value;
9497 }
9498 return offset;
9499 }
9500
9501
9502 static bfd_boolean
9503 is_reloc_sym_weak (bfd *abfd, Elf_Internal_Rela *rel)
9504 {
9505 unsigned long r_symndx = ELF32_R_SYM (rel->r_info);
9506 struct elf_link_hash_entry *h;
9507
9508 h = get_elf_r_symndx_hash_entry (abfd, r_symndx);
9509 if (h && h->root.type == bfd_link_hash_defweak)
9510 return TRUE;
9511 return FALSE;
9512 }
9513
9514
9515 static bfd_boolean
9516 pcrel_reloc_fits (xtensa_opcode opc,
9517 int opnd,
9518 bfd_vma self_address,
9519 bfd_vma dest_address)
9520 {
9521 xtensa_isa isa = xtensa_default_isa;
9522 uint32 valp = dest_address;
9523 if (xtensa_operand_do_reloc (isa, opc, opnd, &valp, self_address)
9524 || xtensa_operand_encode (isa, opc, opnd, &valp))
9525 return FALSE;
9526 return TRUE;
9527 }
9528
9529
9530 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
9531
9532 static bfd_boolean
9533 xtensa_is_property_section (asection *sec)
9534 {
9535 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
9536 || CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME)
9537 || CONST_STRNEQ (sec->name, XTENSA_PROP_SEC_NAME))
9538 return TRUE;
9539
9540 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0
9541 && (CONST_STRNEQ (&sec->name[linkonce_len], "x.")
9542 || CONST_STRNEQ (&sec->name[linkonce_len], "p.")
9543 || CONST_STRNEQ (&sec->name[linkonce_len], "prop.")))
9544 return TRUE;
9545
9546 return FALSE;
9547 }
9548
9549
9550 static bfd_boolean
9551 xtensa_is_littable_section (asection *sec)
9552 {
9553 if (CONST_STRNEQ (sec->name, XTENSA_LIT_SEC_NAME))
9554 return TRUE;
9555
9556 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0
9557 && sec->name[linkonce_len] == 'p'
9558 && sec->name[linkonce_len + 1] == '.')
9559 return TRUE;
9560
9561 return FALSE;
9562 }
9563
9564
9565 static int
9566 internal_reloc_compare (const void *ap, const void *bp)
9567 {
9568 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
9569 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
9570
9571 if (a->r_offset != b->r_offset)
9572 return (a->r_offset - b->r_offset);
9573
9574 /* We don't need to sort on these criteria for correctness,
9575 but enforcing a more strict ordering prevents unstable qsort
9576 from behaving differently with different implementations.
9577 Without the code below we get correct but different results
9578 on Solaris 2.7 and 2.8. We would like to always produce the
9579 same results no matter the host. */
9580
9581 if (a->r_info != b->r_info)
9582 return (a->r_info - b->r_info);
9583
9584 return (a->r_addend - b->r_addend);
9585 }
9586
9587
9588 static int
9589 internal_reloc_matches (const void *ap, const void *bp)
9590 {
9591 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
9592 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
9593
9594 /* Check if one entry overlaps with the other; this shouldn't happen
9595 except when searching for a match. */
9596 return (a->r_offset - b->r_offset);
9597 }
9598
9599
9600 /* Predicate function used to look up a section in a particular group. */
9601
9602 static bfd_boolean
9603 match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf)
9604 {
9605 const char *gname = inf;
9606 const char *group_name = elf_group_name (sec);
9607
9608 return (group_name == gname
9609 || (group_name != NULL
9610 && gname != NULL
9611 && strcmp (group_name, gname) == 0));
9612 }
9613
9614
9615 asection *
9616 xtensa_get_property_section (asection *sec, const char *base_name)
9617 {
9618 const char *suffix, *group_name;
9619 char *prop_sec_name;
9620 asection *prop_sec;
9621
9622 group_name = elf_group_name (sec);
9623 if (group_name)
9624 {
9625 suffix = strrchr (sec->name, '.');
9626 if (suffix == sec->name)
9627 suffix = 0;
9628 prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1
9629 + (suffix ? strlen (suffix) : 0));
9630 strcpy (prop_sec_name, base_name);
9631 if (suffix)
9632 strcat (prop_sec_name, suffix);
9633 }
9634 else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
9635 {
9636 char *linkonce_kind = 0;
9637
9638 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
9639 linkonce_kind = "x.";
9640 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
9641 linkonce_kind = "p.";
9642 else if (strcmp (base_name, XTENSA_PROP_SEC_NAME) == 0)
9643 linkonce_kind = "prop.";
9644 else
9645 abort ();
9646
9647 prop_sec_name = (char *) bfd_malloc (strlen (sec->name)
9648 + strlen (linkonce_kind) + 1);
9649 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
9650 strcpy (prop_sec_name + linkonce_len, linkonce_kind);
9651
9652 suffix = sec->name + linkonce_len;
9653 /* For backward compatibility, replace "t." instead of inserting
9654 the new linkonce_kind (but not for "prop" sections). */
9655 if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.')
9656 suffix += 2;
9657 strcat (prop_sec_name + linkonce_len, suffix);
9658 }
9659 else
9660 prop_sec_name = strdup (base_name);
9661
9662 /* Check if the section already exists. */
9663 prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name,
9664 match_section_group,
9665 (void *) group_name);
9666 /* If not, create it. */
9667 if (! prop_sec)
9668 {
9669 flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY);
9670 flags |= (bfd_get_section_flags (sec->owner, sec)
9671 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES));
9672
9673 prop_sec = bfd_make_section_anyway_with_flags
9674 (sec->owner, strdup (prop_sec_name), flags);
9675 if (! prop_sec)
9676 return 0;
9677
9678 elf_group_name (prop_sec) = group_name;
9679 }
9680
9681 free (prop_sec_name);
9682 return prop_sec;
9683 }
9684
9685
9686 flagword
9687 xtensa_get_property_predef_flags (asection *sec)
9688 {
9689 if (CONST_STRNEQ (sec->name, XTENSA_INSN_SEC_NAME)
9690 || CONST_STRNEQ (sec->name, ".gnu.linkonce.x."))
9691 return (XTENSA_PROP_INSN
9692 | XTENSA_PROP_INSN_NO_TRANSFORM
9693 | XTENSA_PROP_INSN_NO_REORDER);
9694
9695 if (xtensa_is_littable_section (sec))
9696 return (XTENSA_PROP_LITERAL
9697 | XTENSA_PROP_INSN_NO_TRANSFORM
9698 | XTENSA_PROP_INSN_NO_REORDER);
9699
9700 return 0;
9701 }
9702
9703 \f
9704 /* Other functions called directly by the linker. */
9705
9706 bfd_boolean
9707 xtensa_callback_required_dependence (bfd *abfd,
9708 asection *sec,
9709 struct bfd_link_info *link_info,
9710 deps_callback_t callback,
9711 void *closure)
9712 {
9713 Elf_Internal_Rela *internal_relocs;
9714 bfd_byte *contents;
9715 unsigned i;
9716 bfd_boolean ok = TRUE;
9717 bfd_size_type sec_size;
9718
9719 sec_size = bfd_get_section_limit (abfd, sec);
9720
9721 /* ".plt*" sections have no explicit relocations but they contain L32R
9722 instructions that reference the corresponding ".got.plt*" sections. */
9723 if ((sec->flags & SEC_LINKER_CREATED) != 0
9724 && CONST_STRNEQ (sec->name, ".plt"))
9725 {
9726 asection *sgotplt;
9727
9728 /* Find the corresponding ".got.plt*" section. */
9729 if (sec->name[4] == '\0')
9730 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
9731 else
9732 {
9733 char got_name[14];
9734 int chunk = 0;
9735
9736 BFD_ASSERT (sec->name[4] == '.');
9737 chunk = strtol (&sec->name[5], NULL, 10);
9738
9739 sprintf (got_name, ".got.plt.%u", chunk);
9740 sgotplt = bfd_get_section_by_name (sec->owner, got_name);
9741 }
9742 BFD_ASSERT (sgotplt);
9743
9744 /* Assume worst-case offsets: L32R at the very end of the ".plt"
9745 section referencing a literal at the very beginning of
9746 ".got.plt". This is very close to the real dependence, anyway. */
9747 (*callback) (sec, sec_size, sgotplt, 0, closure);
9748 }
9749
9750 internal_relocs = retrieve_internal_relocs (abfd, sec,
9751 link_info->keep_memory);
9752 if (internal_relocs == NULL
9753 || sec->reloc_count == 0)
9754 return ok;
9755
9756 /* Cache the contents for the duration of this scan. */
9757 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
9758 if (contents == NULL && sec_size != 0)
9759 {
9760 ok = FALSE;
9761 goto error_return;
9762 }
9763
9764 if (!xtensa_default_isa)
9765 xtensa_default_isa = xtensa_isa_init (0, 0);
9766
9767 for (i = 0; i < sec->reloc_count; i++)
9768 {
9769 Elf_Internal_Rela *irel = &internal_relocs[i];
9770 if (is_l32r_relocation (abfd, sec, contents, irel))
9771 {
9772 r_reloc l32r_rel;
9773 asection *target_sec;
9774 bfd_vma target_offset;
9775
9776 r_reloc_init (&l32r_rel, abfd, irel, contents, sec_size);
9777 target_sec = NULL;
9778 target_offset = 0;
9779 /* L32Rs must be local to the input file. */
9780 if (r_reloc_is_defined (&l32r_rel))
9781 {
9782 target_sec = r_reloc_get_section (&l32r_rel);
9783 target_offset = l32r_rel.target_offset;
9784 }
9785 (*callback) (sec, irel->r_offset, target_sec, target_offset,
9786 closure);
9787 }
9788 }
9789
9790 error_return:
9791 release_internal_relocs (sec, internal_relocs);
9792 release_contents (sec, contents);
9793 return ok;
9794 }
9795
9796 /* The default literal sections should always be marked as "code" (i.e.,
9797 SHF_EXECINSTR). This is particularly important for the Linux kernel
9798 module loader so that the literals are not placed after the text. */
9799 static const struct bfd_elf_special_section elf_xtensa_special_sections[] =
9800 {
9801 { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9802 { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9803 { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
9804 { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 },
9805 { NULL, 0, 0, 0, 0 }
9806 };
9807 \f
9808 #ifndef ELF_ARCH
9809 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
9810 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
9811 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
9812 #define TARGET_BIG_NAME "elf32-xtensa-be"
9813 #define ELF_ARCH bfd_arch_xtensa
9814
9815 #define ELF_MACHINE_CODE EM_XTENSA
9816 #define ELF_MACHINE_ALT1 EM_XTENSA_OLD
9817
9818 #if XCHAL_HAVE_MMU
9819 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
9820 #else /* !XCHAL_HAVE_MMU */
9821 #define ELF_MAXPAGESIZE 1
9822 #endif /* !XCHAL_HAVE_MMU */
9823 #endif /* ELF_ARCH */
9824
9825 #define elf_backend_can_gc_sections 1
9826 #define elf_backend_can_refcount 1
9827 #define elf_backend_plt_readonly 1
9828 #define elf_backend_got_header_size 4
9829 #define elf_backend_want_dynbss 0
9830 #define elf_backend_want_got_plt 1
9831
9832 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
9833
9834 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
9835 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
9836 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
9837 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
9838 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
9839 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
9840
9841 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
9842 #define elf_backend_check_relocs elf_xtensa_check_relocs
9843 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
9844 #define elf_backend_discard_info elf_xtensa_discard_info
9845 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
9846 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
9847 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
9848 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
9849 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
9850 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
9851 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
9852 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
9853 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
9854 #define elf_backend_object_p elf_xtensa_object_p
9855 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
9856 #define elf_backend_relocate_section elf_xtensa_relocate_section
9857 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
9858 #define elf_backend_omit_section_dynsym \
9859 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
9860 #define elf_backend_special_sections elf_xtensa_special_sections
9861 #define elf_backend_action_discarded elf_xtensa_action_discarded
9862
9863 #include "elf32-target.h"
git-cvsimport of binutils cvsroot