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