1 /* Xtensa-specific support for 32-bit ELF.
2 Copyright 2003, 2004 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., 59 Temple Place - Suite 330, Boston, MA
19 02111-1307, 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 /* Main interface functions. */
39 static void elf_xtensa_info_to_howto_rela
40 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
41 static reloc_howto_type *elf_xtensa_reloc_type_lookup
42 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
43 extern int xtensa_read_table_entries
44 PARAMS ((bfd *, asection *, property_table_entry **, const char *));
45 static bfd_boolean elf_xtensa_check_relocs
46 PARAMS ((bfd *, struct bfd_link_info *, asection *,
47 const Elf_Internal_Rela *));
48 static void elf_xtensa_hide_symbol
49 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
50 static asection *elf_xtensa_gc_mark_hook
51 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
52 struct elf_link_hash_entry *, Elf_Internal_Sym *));
53 static bfd_boolean elf_xtensa_gc_sweep_hook
54 PARAMS ((bfd *, struct bfd_link_info *, asection *,
55 const Elf_Internal_Rela *));
56 static bfd_boolean elf_xtensa_create_dynamic_sections
57 PARAMS ((bfd *, struct bfd_link_info *));
58 static bfd_boolean elf_xtensa_adjust_dynamic_symbol
59 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
60 static bfd_boolean elf_xtensa_size_dynamic_sections
61 PARAMS ((bfd *, struct bfd_link_info *));
62 static bfd_boolean elf_xtensa_modify_segment_map
63 PARAMS ((bfd *, struct bfd_link_info *));
64 static bfd_boolean elf_xtensa_relocate_section
65 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
66 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
67 static bfd_boolean elf_xtensa_relax_section
68 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *again));
69 static bfd_boolean elf_xtensa_finish_dynamic_symbol
70 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
71 Elf_Internal_Sym *));
72 static bfd_boolean elf_xtensa_finish_dynamic_sections
73 PARAMS ((bfd *, struct bfd_link_info *));
74 static bfd_boolean elf_xtensa_merge_private_bfd_data
75 PARAMS ((bfd *, bfd *));
76 static bfd_boolean elf_xtensa_set_private_flags
77 PARAMS ((bfd *, flagword));
78 extern flagword elf_xtensa_get_private_bfd_flags
79 PARAMS ((bfd *));
80 static bfd_boolean elf_xtensa_print_private_bfd_data
81 PARAMS ((bfd *, PTR));
82 static bfd_boolean elf_xtensa_object_p
83 PARAMS ((bfd *));
84 static void elf_xtensa_final_write_processing
85 PARAMS ((bfd *, bfd_boolean));
86 static enum elf_reloc_type_class elf_xtensa_reloc_type_class
87 PARAMS ((const Elf_Internal_Rela *));
88 static bfd_boolean elf_xtensa_discard_info
89 PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *));
90 static bfd_boolean elf_xtensa_ignore_discarded_relocs
91 PARAMS ((asection *));
92 static bfd_boolean elf_xtensa_grok_prstatus
93 PARAMS ((bfd *, Elf_Internal_Note *));
94 static bfd_boolean elf_xtensa_grok_psinfo
95 PARAMS ((bfd *, Elf_Internal_Note *));
96 static bfd_boolean elf_xtensa_new_section_hook
97 PARAMS ((bfd *, asection *));
98
99
100 /* Local helper functions. */
101
102 static bfd_boolean xtensa_elf_dynamic_symbol_p
103 PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *));
104 static int property_table_compare
105 PARAMS ((const PTR, const PTR));
106 static bfd_boolean elf_xtensa_in_literal_pool
107 PARAMS ((property_table_entry *, int, bfd_vma));
108 static void elf_xtensa_make_sym_local
109 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
110 static bfd_boolean add_extra_plt_sections
111 PARAMS ((bfd *, int));
112 static bfd_boolean elf_xtensa_fix_refcounts
113 PARAMS ((struct elf_link_hash_entry *, PTR));
114 static bfd_boolean elf_xtensa_allocate_plt_size
115 PARAMS ((struct elf_link_hash_entry *, PTR));
116 static bfd_boolean elf_xtensa_allocate_got_size
117 PARAMS ((struct elf_link_hash_entry *, PTR));
118 static void elf_xtensa_allocate_local_got_size
119 PARAMS ((struct bfd_link_info *, asection *));
120 static bfd_reloc_status_type elf_xtensa_do_reloc
121 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_vma, bfd_byte *,
122 bfd_vma, bfd_boolean, char **));
123 static char * vsprint_msg
124 VPARAMS ((const char *, const char *, int, ...));
125 static char *build_encoding_error_message
126 PARAMS ((xtensa_opcode, xtensa_encode_result));
127 static bfd_reloc_status_type bfd_elf_xtensa_reloc
128 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
129 static void do_fix_for_relocatable_link
130 PARAMS ((Elf_Internal_Rela *, bfd *, asection *));
131 static void do_fix_for_final_link
132 PARAMS ((Elf_Internal_Rela *, asection *, bfd_vma *));
133 static bfd_vma elf_xtensa_create_plt_entry
134 PARAMS ((bfd *, bfd *, unsigned));
135 static int elf_xtensa_combine_prop_entries
136 PARAMS ((bfd *, asection *, asection *));
137 static bfd_boolean elf_xtensa_discard_info_for_section
138 PARAMS ((bfd *, struct elf_reloc_cookie *, struct bfd_link_info *,
139 asection *));
140
141 /* Local functions to handle Xtensa configurability. */
142
143 static void init_call_opcodes
144 PARAMS ((void));
145 static bfd_boolean is_indirect_call_opcode
146 PARAMS ((xtensa_opcode));
147 static bfd_boolean is_direct_call_opcode
148 PARAMS ((xtensa_opcode));
149 static bfd_boolean is_windowed_call_opcode
150 PARAMS ((xtensa_opcode));
151 static xtensa_opcode get_l32r_opcode
152 PARAMS ((void));
153 static bfd_vma l32r_offset
154 PARAMS ((bfd_vma, bfd_vma));
155 static int get_relocation_opnd
156 PARAMS ((Elf_Internal_Rela *));
157 static xtensa_opcode get_relocation_opcode
158 PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *));
159 static bfd_boolean is_l32r_relocation
160 PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *));
161
162 /* Functions for link-time code simplifications. */
163
164 static bfd_reloc_status_type elf_xtensa_do_asm_simplify
165 PARAMS ((bfd_byte *, bfd_vma, bfd_vma));
166 static bfd_reloc_status_type contract_asm_expansion
167 PARAMS ((bfd_byte *, bfd_vma, Elf_Internal_Rela *));
168 static xtensa_opcode swap_callx_for_call_opcode
169 PARAMS ((xtensa_opcode));
170 static xtensa_opcode get_expanded_call_opcode
171 PARAMS ((bfd_byte *, int));
172
173 /* Access to internal relocations, section contents and symbols. */
174
175 static Elf_Internal_Rela *retrieve_internal_relocs
176 PARAMS ((bfd *, asection *, bfd_boolean));
177 static void pin_internal_relocs
178 PARAMS ((asection *, Elf_Internal_Rela *));
179 static void release_internal_relocs
180 PARAMS ((asection *, Elf_Internal_Rela *));
181 static bfd_byte *retrieve_contents
182 PARAMS ((bfd *, asection *, bfd_boolean));
183 static void pin_contents
184 PARAMS ((asection *, bfd_byte *));
185 static void release_contents
186 PARAMS ((asection *, bfd_byte *));
187 static Elf_Internal_Sym *retrieve_local_syms
188 PARAMS ((bfd *));
189
190 /* Miscellaneous utility functions. */
191
192 static asection *elf_xtensa_get_plt_section
193 PARAMS ((bfd *, int));
194 static asection *elf_xtensa_get_gotplt_section
195 PARAMS ((bfd *, int));
196 static asection *get_elf_r_symndx_section
197 PARAMS ((bfd *, unsigned long));
198 static struct elf_link_hash_entry *get_elf_r_symndx_hash_entry
199 PARAMS ((bfd *, unsigned long));
200 static bfd_vma get_elf_r_symndx_offset
201 PARAMS ((bfd *, unsigned long));
202 static bfd_boolean pcrel_reloc_fits
203 PARAMS ((xtensa_operand, bfd_vma, bfd_vma));
204 static bfd_boolean xtensa_is_property_section
205 PARAMS ((asection *));
206 static bfd_boolean xtensa_is_littable_section
207 PARAMS ((asection *));
208 static bfd_boolean is_literal_section
209 PARAMS ((asection *));
210 static int internal_reloc_compare
211 PARAMS ((const PTR, const PTR));
212 extern char *xtensa_get_property_section_name
213 PARAMS ((asection *, const char *));
214
215 /* Other functions called directly by the linker. */
216
217 typedef void (*deps_callback_t)
218 PARAMS ((asection *, bfd_vma, asection *, bfd_vma, PTR));
219 extern bfd_boolean xtensa_callback_required_dependence
220 PARAMS ((bfd *, asection *, struct bfd_link_info *,
221 deps_callback_t, PTR));
222
223
224 typedef struct xtensa_relax_info_struct xtensa_relax_info;
225
226
227 /* Total count of PLT relocations seen during check_relocs.
228 The actual PLT code must be split into multiple sections and all
229 the sections have to be created before size_dynamic_sections,
230 where we figure out the exact number of PLT entries that will be
231 needed. It is OK if this count is an overestimate, e.g., some
232 relocations may be removed by GC. */
233
234 static int plt_reloc_count = 0;
235
236
237 /* When this is true, relocations may have been modified to refer to
238 symbols from other input files. The per-section list of "fix"
239 records needs to be checked when resolving relocations. */
240
241 static bfd_boolean relaxing_section = FALSE;
242
243
244 static reloc_howto_type elf_howto_table[] =
245 {
246 HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
247 bfd_elf_xtensa_reloc, "R_XTENSA_NONE",
248 FALSE, 0x00000000, 0x00000000, FALSE),
249 HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
250 bfd_elf_xtensa_reloc, "R_XTENSA_32",
251 TRUE, 0xffffffff, 0xffffffff, FALSE),
252 /* Replace a 32-bit value with a value from the runtime linker (only
253 used by linker-generated stub functions). The r_addend value is
254 special: 1 means to substitute a pointer to the runtime linker's
255 dynamic resolver function; 2 means to substitute the link map for
256 the shared object. */
257 HOWTO (R_XTENSA_RTLD, 0, 2, 32, FALSE, 0, complain_overflow_dont,
258 NULL, "R_XTENSA_RTLD",
259 FALSE, 0x00000000, 0x00000000, FALSE),
260 HOWTO (R_XTENSA_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
261 bfd_elf_generic_reloc, "R_XTENSA_GLOB_DAT",
262 FALSE, 0xffffffff, 0xffffffff, FALSE),
263 HOWTO (R_XTENSA_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
264 bfd_elf_generic_reloc, "R_XTENSA_JMP_SLOT",
265 FALSE, 0xffffffff, 0xffffffff, FALSE),
266 HOWTO (R_XTENSA_RELATIVE, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
267 bfd_elf_generic_reloc, "R_XTENSA_RELATIVE",
268 FALSE, 0xffffffff, 0xffffffff, FALSE),
269 HOWTO (R_XTENSA_PLT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
270 bfd_elf_xtensa_reloc, "R_XTENSA_PLT",
271 FALSE, 0xffffffff, 0xffffffff, FALSE),
272 EMPTY_HOWTO (7),
273 HOWTO (R_XTENSA_OP0, 0, 0, 0, TRUE, 0, complain_overflow_dont,
274 bfd_elf_xtensa_reloc, "R_XTENSA_OP0",
275 FALSE, 0x00000000, 0x00000000, TRUE),
276 HOWTO (R_XTENSA_OP1, 0, 0, 0, TRUE, 0, complain_overflow_dont,
277 bfd_elf_xtensa_reloc, "R_XTENSA_OP1",
278 FALSE, 0x00000000, 0x00000000, TRUE),
279 HOWTO (R_XTENSA_OP2, 0, 0, 0, TRUE, 0, complain_overflow_dont,
280 bfd_elf_xtensa_reloc, "R_XTENSA_OP2",
281 FALSE, 0x00000000, 0x00000000, TRUE),
282 /* Assembly auto-expansion. */
283 HOWTO (R_XTENSA_ASM_EXPAND, 0, 0, 0, TRUE, 0, complain_overflow_dont,
284 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_EXPAND",
285 FALSE, 0x00000000, 0x00000000, FALSE),
286 /* Relax assembly auto-expansion. */
287 HOWTO (R_XTENSA_ASM_SIMPLIFY, 0, 0, 0, TRUE, 0, complain_overflow_dont,
288 bfd_elf_xtensa_reloc, "R_XTENSA_ASM_SIMPLIFY",
289 FALSE, 0x00000000, 0x00000000, TRUE),
290 EMPTY_HOWTO (13),
291 EMPTY_HOWTO (14),
292 /* GNU extension to record C++ vtable hierarchy. */
293 HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont,
294 NULL, "R_XTENSA_GNU_VTINHERIT",
295 FALSE, 0x00000000, 0x00000000, FALSE),
296 /* GNU extension to record C++ vtable member usage. */
297 HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont,
298 _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY",
299 FALSE, 0x00000000, 0x00000000, FALSE)
300 };
301
302 #ifdef DEBUG_GEN_RELOC
303 #define TRACE(str) \
304 fprintf (stderr, "Xtensa bfd reloc lookup %d (%s)\n", code, str)
305 #else
306 #define TRACE(str)
307 #endif
308
309 static reloc_howto_type *
elf_xtensa_reloc_type_lookup(abfd,code)310 elf_xtensa_reloc_type_lookup (abfd, code)
311 bfd *abfd ATTRIBUTE_UNUSED;
312 bfd_reloc_code_real_type code;
313 {
314 switch (code)
315 {
316 case BFD_RELOC_NONE:
317 TRACE ("BFD_RELOC_NONE");
318 return &elf_howto_table[(unsigned) R_XTENSA_NONE ];
319
320 case BFD_RELOC_32:
321 TRACE ("BFD_RELOC_32");
322 return &elf_howto_table[(unsigned) R_XTENSA_32 ];
323
324 case BFD_RELOC_XTENSA_RTLD:
325 TRACE ("BFD_RELOC_XTENSA_RTLD");
326 return &elf_howto_table[(unsigned) R_XTENSA_RTLD ];
327
328 case BFD_RELOC_XTENSA_GLOB_DAT:
329 TRACE ("BFD_RELOC_XTENSA_GLOB_DAT");
330 return &elf_howto_table[(unsigned) R_XTENSA_GLOB_DAT ];
331
332 case BFD_RELOC_XTENSA_JMP_SLOT:
333 TRACE ("BFD_RELOC_XTENSA_JMP_SLOT");
334 return &elf_howto_table[(unsigned) R_XTENSA_JMP_SLOT ];
335
336 case BFD_RELOC_XTENSA_RELATIVE:
337 TRACE ("BFD_RELOC_XTENSA_RELATIVE");
338 return &elf_howto_table[(unsigned) R_XTENSA_RELATIVE ];
339
340 case BFD_RELOC_XTENSA_PLT:
341 TRACE ("BFD_RELOC_XTENSA_PLT");
342 return &elf_howto_table[(unsigned) R_XTENSA_PLT ];
343
344 case BFD_RELOC_XTENSA_OP0:
345 TRACE ("BFD_RELOC_XTENSA_OP0");
346 return &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
347
348 case BFD_RELOC_XTENSA_OP1:
349 TRACE ("BFD_RELOC_XTENSA_OP1");
350 return &elf_howto_table[(unsigned) R_XTENSA_OP1 ];
351
352 case BFD_RELOC_XTENSA_OP2:
353 TRACE ("BFD_RELOC_XTENSA_OP2");
354 return &elf_howto_table[(unsigned) R_XTENSA_OP2 ];
355
356 case BFD_RELOC_XTENSA_ASM_EXPAND:
357 TRACE ("BFD_RELOC_XTENSA_ASM_EXPAND");
358 return &elf_howto_table[(unsigned) R_XTENSA_ASM_EXPAND ];
359
360 case BFD_RELOC_XTENSA_ASM_SIMPLIFY:
361 TRACE ("BFD_RELOC_XTENSA_ASM_SIMPLIFY");
362 return &elf_howto_table[(unsigned) R_XTENSA_ASM_SIMPLIFY ];
363
364 case BFD_RELOC_VTABLE_INHERIT:
365 TRACE ("BFD_RELOC_VTABLE_INHERIT");
366 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTINHERIT ];
367
368 case BFD_RELOC_VTABLE_ENTRY:
369 TRACE ("BFD_RELOC_VTABLE_ENTRY");
370 return &elf_howto_table[(unsigned) R_XTENSA_GNU_VTENTRY ];
371
372 default:
373 break;
374 }
375
376 TRACE ("Unknown");
377 return NULL;
378 }
379
380
381 /* Given an ELF "rela" relocation, find the corresponding howto and record
382 it in the BFD internal arelent representation of the relocation. */
383
384 static void
elf_xtensa_info_to_howto_rela(abfd,cache_ptr,dst)385 elf_xtensa_info_to_howto_rela (abfd, cache_ptr, dst)
386 bfd *abfd ATTRIBUTE_UNUSED;
387 arelent *cache_ptr;
388 Elf_Internal_Rela *dst;
389 {
390 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
391
392 BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max);
393 cache_ptr->howto = &elf_howto_table[r_type];
394 }
395
396
397 /* Functions for the Xtensa ELF linker. */
398
399 /* The name of the dynamic interpreter. This is put in the .interp
400 section. */
401
402 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
403
404 /* The size in bytes of an entry in the procedure linkage table.
405 (This does _not_ include the space for the literals associated with
406 the PLT entry.) */
407
408 #define PLT_ENTRY_SIZE 16
409
410 /* For _really_ large PLTs, we may need to alternate between literals
411 and code to keep the literals within the 256K range of the L32R
412 instructions in the code. It's unlikely that anyone would ever need
413 such a big PLT, but an arbitrary limit on the PLT size would be bad.
414 Thus, we split the PLT into chunks. Since there's very little
415 overhead (2 extra literals) for each chunk, the chunk size is kept
416 small so that the code for handling multiple chunks get used and
417 tested regularly. With 254 entries, there are 1K of literals for
418 each chunk, and that seems like a nice round number. */
419
420 #define PLT_ENTRIES_PER_CHUNK 254
421
422 /* PLT entries are actually used as stub functions for lazy symbol
423 resolution. Once the symbol is resolved, the stub function is never
424 invoked. Note: the 32-byte frame size used here cannot be changed
425 without a corresponding change in the runtime linker. */
426
427 static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] =
428 {
429 0x6c, 0x10, 0x04, /* entry sp, 32 */
430 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
431 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
432 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
433 0x0a, 0x80, 0x00, /* jx a8 */
434 0 /* unused */
435 };
436
437 static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] =
438 {
439 0x36, 0x41, 0x00, /* entry sp, 32 */
440 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */
441 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */
442 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */
443 0xa0, 0x08, 0x00, /* jx a8 */
444 0 /* unused */
445 };
446
447
448 static inline bfd_boolean
xtensa_elf_dynamic_symbol_p(h,info)449 xtensa_elf_dynamic_symbol_p (h, info)
450 struct elf_link_hash_entry *h;
451 struct bfd_link_info *info;
452 {
453 /* Check if we should do dynamic things to this symbol. The
454 "ignore_protected" argument need not be set, because Xtensa code
455 does not require special handling of STV_PROTECTED to make function
456 pointer comparisons work properly. The PLT addresses are never
457 used for function pointers. */
458
459 return _bfd_elf_dynamic_symbol_p (h, info, 0);
460 }
461
462
463 static int
property_table_compare(ap,bp)464 property_table_compare (ap, bp)
465 const PTR ap;
466 const PTR bp;
467 {
468 const property_table_entry *a = (const property_table_entry *) ap;
469 const property_table_entry *b = (const property_table_entry *) bp;
470
471 /* Check if one entry overlaps with the other; this shouldn't happen
472 except when searching for a match. */
473 if ((b->address >= a->address && b->address < (a->address + a->size))
474 || (a->address >= b->address && a->address < (b->address + b->size)))
475 return 0;
476
477 return (a->address - b->address);
478 }
479
480
481 /* Get the literal table or instruction table entries for the given
482 section. Sets TABLE_P and returns the number of entries. On error,
483 returns a negative value. */
484
485 int
xtensa_read_table_entries(abfd,section,table_p,sec_name)486 xtensa_read_table_entries (abfd, section, table_p, sec_name)
487 bfd *abfd;
488 asection *section;
489 property_table_entry **table_p;
490 const char *sec_name;
491 {
492 asection *table_section;
493 char *table_section_name;
494 bfd_size_type table_size = 0;
495 bfd_byte *table_data;
496 property_table_entry *blocks;
497 int block_count;
498 bfd_size_type num_records;
499 Elf_Internal_Rela *internal_relocs;
500 bfd_vma section_addr;
501
502 table_section_name =
503 xtensa_get_property_section_name (section, sec_name);
504 table_section = bfd_get_section_by_name (abfd, table_section_name);
505 free (table_section_name);
506 if (table_section != NULL)
507 table_size = (table_section->_cooked_size
508 ? table_section->_cooked_size : table_section->_raw_size);
509
510 if (table_size == 0)
511 {
512 *table_p = NULL;
513 return 0;
514 }
515
516 num_records = table_size / 8;
517 table_data = retrieve_contents (abfd, table_section, TRUE);
518 blocks = (property_table_entry *)
519 bfd_malloc (num_records * sizeof (property_table_entry));
520 block_count = 0;
521
522 section_addr = section->output_section->vma + section->output_offset;
523
524 /* If the file has not yet been relocated, process the relocations
525 and sort out the table entries that apply to the specified section. */
526 internal_relocs = retrieve_internal_relocs (abfd, table_section, TRUE);
527 if (internal_relocs && !table_section->reloc_done)
528 {
529 unsigned i;
530
531 for (i = 0; i < table_section->reloc_count; i++)
532 {
533 Elf_Internal_Rela *rel = &internal_relocs[i];
534 unsigned long r_symndx;
535
536 if (ELF32_R_TYPE (rel->r_info) == R_XTENSA_NONE)
537 continue;
538
539 BFD_ASSERT (ELF32_R_TYPE (rel->r_info) == R_XTENSA_32);
540 r_symndx = ELF32_R_SYM (rel->r_info);
541
542 if (get_elf_r_symndx_section (abfd, r_symndx) == section)
543 {
544 bfd_vma sym_off = get_elf_r_symndx_offset (abfd, r_symndx);
545 blocks[block_count].address =
546 (section_addr + sym_off + rel->r_addend
547 + bfd_get_32 (abfd, table_data + rel->r_offset));
548 blocks[block_count].size =
549 bfd_get_32 (abfd, table_data + rel->r_offset + 4);
550 block_count++;
551 }
552 }
553 }
554 else
555 {
556 /* The file has already been relocated and the addresses are
557 already in the table. */
558 bfd_vma off;
559
560 for (off = 0; off < table_size; off += 8)
561 {
562 bfd_vma address = bfd_get_32 (abfd, table_data + off);
563
564 if (address >= section_addr
565 && address < ( section_addr + section->_raw_size))
566 {
567 blocks[block_count].address = address;
568 blocks[block_count].size =
569 bfd_get_32 (abfd, table_data + off + 4);
570 block_count++;
571 }
572 }
573 }
574
575 release_contents (table_section, table_data);
576 release_internal_relocs (table_section, internal_relocs);
577
578 if (block_count > 0)
579 {
580 /* Now sort them into address order for easy reference. */
581 qsort (blocks, block_count, sizeof (property_table_entry),
582 property_table_compare);
583 }
584
585 *table_p = blocks;
586 return block_count;
587 }
588
589
590 static bfd_boolean
elf_xtensa_in_literal_pool(lit_table,lit_table_size,addr)591 elf_xtensa_in_literal_pool (lit_table, lit_table_size, addr)
592 property_table_entry *lit_table;
593 int lit_table_size;
594 bfd_vma addr;
595 {
596 property_table_entry entry;
597
598 if (lit_table_size == 0)
599 return FALSE;
600
601 entry.address = addr;
602 entry.size = 1;
603
604 if (bsearch (&entry, lit_table, lit_table_size,
605 sizeof (property_table_entry), property_table_compare))
606 return TRUE;
607
608 return FALSE;
609 }
610
611
612 /* Look through the relocs for a section during the first phase, and
613 calculate needed space in the dynamic reloc sections. */
614
615 static bfd_boolean
elf_xtensa_check_relocs(abfd,info,sec,relocs)616 elf_xtensa_check_relocs (abfd, info, sec, relocs)
617 bfd *abfd;
618 struct bfd_link_info *info;
619 asection *sec;
620 const Elf_Internal_Rela *relocs;
621 {
622 Elf_Internal_Shdr *symtab_hdr;
623 struct elf_link_hash_entry **sym_hashes;
624 const Elf_Internal_Rela *rel;
625 const Elf_Internal_Rela *rel_end;
626
627 if (info->relocatable)
628 return TRUE;
629
630 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
631 sym_hashes = elf_sym_hashes (abfd);
632
633 rel_end = relocs + sec->reloc_count;
634 for (rel = relocs; rel < rel_end; rel++)
635 {
636 unsigned int r_type;
637 unsigned long r_symndx;
638 struct elf_link_hash_entry *h;
639
640 r_symndx = ELF32_R_SYM (rel->r_info);
641 r_type = ELF32_R_TYPE (rel->r_info);
642
643 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
644 {
645 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
646 bfd_archive_filename (abfd),
647 r_symndx);
648 return FALSE;
649 }
650
651 if (r_symndx < symtab_hdr->sh_info)
652 h = NULL;
653 else
654 {
655 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
656 while (h->root.type == bfd_link_hash_indirect
657 || h->root.type == bfd_link_hash_warning)
658 h = (struct elf_link_hash_entry *) h->root.u.i.link;
659 }
660
661 switch (r_type)
662 {
663 case R_XTENSA_32:
664 if (h == NULL)
665 goto local_literal;
666
667 if ((sec->flags & SEC_ALLOC) != 0)
668 {
669 if (h->got.refcount <= 0)
670 h->got.refcount = 1;
671 else
672 h->got.refcount += 1;
673 }
674 break;
675
676 case R_XTENSA_PLT:
677 /* If this relocation is against a local symbol, then it's
678 exactly the same as a normal local GOT entry. */
679 if (h == NULL)
680 goto local_literal;
681
682 if ((sec->flags & SEC_ALLOC) != 0)
683 {
684 if (h->plt.refcount <= 0)
685 {
686 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
687 h->plt.refcount = 1;
688 }
689 else
690 h->plt.refcount += 1;
691
692 /* Keep track of the total PLT relocation count even if we
693 don't yet know whether the dynamic sections will be
694 created. */
695 plt_reloc_count += 1;
696
697 if (elf_hash_table (info)->dynamic_sections_created)
698 {
699 if (!add_extra_plt_sections (elf_hash_table (info)->dynobj,
700 plt_reloc_count))
701 return FALSE;
702 }
703 }
704 break;
705
706 local_literal:
707 if ((sec->flags & SEC_ALLOC) != 0)
708 {
709 bfd_signed_vma *local_got_refcounts;
710
711 /* This is a global offset table entry for a local symbol. */
712 local_got_refcounts = elf_local_got_refcounts (abfd);
713 if (local_got_refcounts == NULL)
714 {
715 bfd_size_type size;
716
717 size = symtab_hdr->sh_info;
718 size *= sizeof (bfd_signed_vma);
719 local_got_refcounts = ((bfd_signed_vma *)
720 bfd_zalloc (abfd, size));
721 if (local_got_refcounts == NULL)
722 return FALSE;
723 elf_local_got_refcounts (abfd) = local_got_refcounts;
724 }
725 local_got_refcounts[r_symndx] += 1;
726 }
727 break;
728
729 case R_XTENSA_OP0:
730 case R_XTENSA_OP1:
731 case R_XTENSA_OP2:
732 case R_XTENSA_ASM_EXPAND:
733 case R_XTENSA_ASM_SIMPLIFY:
734 /* Nothing to do for these. */
735 break;
736
737 case R_XTENSA_GNU_VTINHERIT:
738 /* This relocation describes the C++ object vtable hierarchy.
739 Reconstruct it for later use during GC. */
740 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
741 return FALSE;
742 break;
743
744 case R_XTENSA_GNU_VTENTRY:
745 /* This relocation describes which C++ vtable entries are actually
746 used. Record for later use during GC. */
747 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
748 return FALSE;
749 break;
750
751 default:
752 break;
753 }
754 }
755
756 return TRUE;
757 }
758
759
760 static void
elf_xtensa_hide_symbol(info,h,force_local)761 elf_xtensa_hide_symbol (info, h, force_local)
762 struct bfd_link_info *info;
763 struct elf_link_hash_entry *h;
764 bfd_boolean force_local;
765 {
766 /* For a shared link, move the plt refcount to the got refcount to leave
767 space for RELATIVE relocs. */
768 elf_xtensa_make_sym_local (info, h);
769
770 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
771 }
772
773
774 /* Return the section that should be marked against GC for a given
775 relocation. */
776
777 static asection *
elf_xtensa_gc_mark_hook(sec,info,rel,h,sym)778 elf_xtensa_gc_mark_hook (sec, info, rel, h, sym)
779 asection *sec;
780 struct bfd_link_info *info ATTRIBUTE_UNUSED;
781 Elf_Internal_Rela *rel;
782 struct elf_link_hash_entry *h;
783 Elf_Internal_Sym *sym;
784 {
785 if (h != NULL)
786 {
787 switch (ELF32_R_TYPE (rel->r_info))
788 {
789 case R_XTENSA_GNU_VTINHERIT:
790 case R_XTENSA_GNU_VTENTRY:
791 break;
792
793 default:
794 switch (h->root.type)
795 {
796 case bfd_link_hash_defined:
797 case bfd_link_hash_defweak:
798 return h->root.u.def.section;
799
800 case bfd_link_hash_common:
801 return h->root.u.c.p->section;
802
803 default:
804 break;
805 }
806 }
807 }
808 else
809 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
810
811 return NULL;
812 }
813
814 /* Update the GOT & PLT entry reference counts
815 for the section being removed. */
816
817 static bfd_boolean
elf_xtensa_gc_sweep_hook(abfd,info,sec,relocs)818 elf_xtensa_gc_sweep_hook (abfd, info, sec, relocs)
819 bfd *abfd;
820 struct bfd_link_info *info ATTRIBUTE_UNUSED;
821 asection *sec;
822 const Elf_Internal_Rela *relocs;
823 {
824 Elf_Internal_Shdr *symtab_hdr;
825 struct elf_link_hash_entry **sym_hashes;
826 bfd_signed_vma *local_got_refcounts;
827 const Elf_Internal_Rela *rel, *relend;
828
829 if ((sec->flags & SEC_ALLOC) == 0)
830 return TRUE;
831
832 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
833 sym_hashes = elf_sym_hashes (abfd);
834 local_got_refcounts = elf_local_got_refcounts (abfd);
835
836 relend = relocs + sec->reloc_count;
837 for (rel = relocs; rel < relend; rel++)
838 {
839 unsigned long r_symndx;
840 unsigned int r_type;
841 struct elf_link_hash_entry *h = NULL;
842
843 r_symndx = ELF32_R_SYM (rel->r_info);
844 if (r_symndx >= symtab_hdr->sh_info)
845 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
846
847 r_type = ELF32_R_TYPE (rel->r_info);
848 switch (r_type)
849 {
850 case R_XTENSA_32:
851 if (h == NULL)
852 goto local_literal;
853 if (h->got.refcount > 0)
854 h->got.refcount--;
855 break;
856
857 case R_XTENSA_PLT:
858 if (h == NULL)
859 goto local_literal;
860 if (h->plt.refcount > 0)
861 h->plt.refcount--;
862 break;
863
864 local_literal:
865 if (local_got_refcounts[r_symndx] > 0)
866 local_got_refcounts[r_symndx] -= 1;
867 break;
868
869 default:
870 break;
871 }
872 }
873
874 return TRUE;
875 }
876
877
878 /* Create all the dynamic sections. */
879
880 static bfd_boolean
elf_xtensa_create_dynamic_sections(dynobj,info)881 elf_xtensa_create_dynamic_sections (dynobj, info)
882 bfd *dynobj;
883 struct bfd_link_info *info;
884 {
885 flagword flags, noalloc_flags;
886 asection *s;
887
888 /* First do all the standard stuff. */
889 if (! _bfd_elf_create_dynamic_sections (dynobj, info))
890 return FALSE;
891
892 /* Create any extra PLT sections in case check_relocs has already
893 been called on all the non-dynamic input files. */
894 if (!add_extra_plt_sections (dynobj, plt_reloc_count))
895 return FALSE;
896
897 noalloc_flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
898 | SEC_LINKER_CREATED | SEC_READONLY);
899 flags = noalloc_flags | SEC_ALLOC | SEC_LOAD;
900
901 /* Mark the ".got.plt" section READONLY. */
902 s = bfd_get_section_by_name (dynobj, ".got.plt");
903 if (s == NULL
904 || ! bfd_set_section_flags (dynobj, s, flags))
905 return FALSE;
906
907 /* Create ".rela.got". */
908 s = bfd_make_section (dynobj, ".rela.got");
909 if (s == NULL
910 || ! bfd_set_section_flags (dynobj, s, flags)
911 || ! bfd_set_section_alignment (dynobj, s, 2))
912 return FALSE;
913
914 /* Create ".got.loc" (literal tables for use by dynamic linker). */
915 s = bfd_make_section (dynobj, ".got.loc");
916 if (s == NULL
917 || ! bfd_set_section_flags (dynobj, s, flags)
918 || ! bfd_set_section_alignment (dynobj, s, 2))
919 return FALSE;
920
921 /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */
922 s = bfd_make_section (dynobj, ".xt.lit.plt");
923 if (s == NULL
924 || ! bfd_set_section_flags (dynobj, s, noalloc_flags)
925 || ! bfd_set_section_alignment (dynobj, s, 2))
926 return FALSE;
927
928 return TRUE;
929 }
930
931
932 static bfd_boolean
add_extra_plt_sections(dynobj,count)933 add_extra_plt_sections (dynobj, count)
934 bfd *dynobj;
935 int count;
936 {
937 int chunk;
938
939 /* Iterate over all chunks except 0 which uses the standard ".plt" and
940 ".got.plt" sections. */
941 for (chunk = count / PLT_ENTRIES_PER_CHUNK; chunk > 0; chunk--)
942 {
943 char *sname;
944 flagword flags;
945 asection *s;
946
947 /* Stop when we find a section has already been created. */
948 if (elf_xtensa_get_plt_section (dynobj, chunk))
949 break;
950
951 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
952 | SEC_LINKER_CREATED | SEC_READONLY);
953
954 sname = (char *) bfd_malloc (10);
955 sprintf (sname, ".plt.%u", chunk);
956 s = bfd_make_section (dynobj, sname);
957 if (s == NULL
958 || ! bfd_set_section_flags (dynobj, s, flags | SEC_CODE)
959 || ! bfd_set_section_alignment (dynobj, s, 2))
960 return FALSE;
961
962 sname = (char *) bfd_malloc (14);
963 sprintf (sname, ".got.plt.%u", chunk);
964 s = bfd_make_section (dynobj, sname);
965 if (s == NULL
966 || ! bfd_set_section_flags (dynobj, s, flags)
967 || ! bfd_set_section_alignment (dynobj, s, 2))
968 return FALSE;
969 }
970
971 return TRUE;
972 }
973
974
975 /* Adjust a symbol defined by a dynamic object and referenced by a
976 regular object. The current definition is in some section of the
977 dynamic object, but we're not including those sections. We have to
978 change the definition to something the rest of the link can
979 understand. */
980
981 static bfd_boolean
elf_xtensa_adjust_dynamic_symbol(info,h)982 elf_xtensa_adjust_dynamic_symbol (info, h)
983 struct bfd_link_info *info ATTRIBUTE_UNUSED;
984 struct elf_link_hash_entry *h;
985 {
986 /* If this is a weak symbol, and there is a real definition, the
987 processor independent code will have arranged for us to see the
988 real definition first, and we can just use the same value. */
989 if (h->weakdef != NULL)
990 {
991 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
992 || h->weakdef->root.type == bfd_link_hash_defweak);
993 h->root.u.def.section = h->weakdef->root.u.def.section;
994 h->root.u.def.value = h->weakdef->root.u.def.value;
995 return TRUE;
996 }
997
998 /* This is a reference to a symbol defined by a dynamic object. The
999 reference must go through the GOT, so there's no need for COPY relocs,
1000 .dynbss, etc. */
1001
1002 return TRUE;
1003 }
1004
1005
1006 static void
elf_xtensa_make_sym_local(info,h)1007 elf_xtensa_make_sym_local (info, h)
1008 struct bfd_link_info *info;
1009 struct elf_link_hash_entry *h;
1010 {
1011 if (info->shared)
1012 {
1013 if (h->plt.refcount > 0)
1014 {
1015 /* Will use RELATIVE relocs instead of JMP_SLOT relocs. */
1016 if (h->got.refcount < 0)
1017 h->got.refcount = 0;
1018 h->got.refcount += h->plt.refcount;
1019 h->plt.refcount = 0;
1020 }
1021 }
1022 else
1023 {
1024 /* Don't need any dynamic relocations at all. */
1025 h->plt.refcount = 0;
1026 h->got.refcount = 0;
1027 }
1028 }
1029
1030
1031 static bfd_boolean
elf_xtensa_fix_refcounts(h,arg)1032 elf_xtensa_fix_refcounts (h, arg)
1033 struct elf_link_hash_entry *h;
1034 PTR arg;
1035 {
1036 struct bfd_link_info *info = (struct bfd_link_info *) arg;
1037
1038 if (h->root.type == bfd_link_hash_warning)
1039 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1040
1041 if (! xtensa_elf_dynamic_symbol_p (h, info))
1042 elf_xtensa_make_sym_local (info, h);
1043
1044 return TRUE;
1045 }
1046
1047
1048 static bfd_boolean
elf_xtensa_allocate_plt_size(h,arg)1049 elf_xtensa_allocate_plt_size (h, arg)
1050 struct elf_link_hash_entry *h;
1051 PTR arg;
1052 {
1053 asection *srelplt = (asection *) arg;
1054
1055 if (h->root.type == bfd_link_hash_warning)
1056 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1057
1058 if (h->plt.refcount > 0)
1059 srelplt->_raw_size += (h->plt.refcount * sizeof (Elf32_External_Rela));
1060
1061 return TRUE;
1062 }
1063
1064
1065 static bfd_boolean
elf_xtensa_allocate_got_size(h,arg)1066 elf_xtensa_allocate_got_size (h, arg)
1067 struct elf_link_hash_entry *h;
1068 PTR arg;
1069 {
1070 asection *srelgot = (asection *) arg;
1071
1072 if (h->root.type == bfd_link_hash_warning)
1073 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1074
1075 if (h->got.refcount > 0)
1076 srelgot->_raw_size += (h->got.refcount * sizeof (Elf32_External_Rela));
1077
1078 return TRUE;
1079 }
1080
1081
1082 static void
elf_xtensa_allocate_local_got_size(info,srelgot)1083 elf_xtensa_allocate_local_got_size (info, srelgot)
1084 struct bfd_link_info *info;
1085 asection *srelgot;
1086 {
1087 bfd *i;
1088
1089 for (i = info->input_bfds; i; i = i->link_next)
1090 {
1091 bfd_signed_vma *local_got_refcounts;
1092 bfd_size_type j, cnt;
1093 Elf_Internal_Shdr *symtab_hdr;
1094
1095 local_got_refcounts = elf_local_got_refcounts (i);
1096 if (!local_got_refcounts)
1097 continue;
1098
1099 symtab_hdr = &elf_tdata (i)->symtab_hdr;
1100 cnt = symtab_hdr->sh_info;
1101
1102 for (j = 0; j < cnt; ++j)
1103 {
1104 if (local_got_refcounts[j] > 0)
1105 srelgot->_raw_size += (local_got_refcounts[j]
1106 * sizeof (Elf32_External_Rela));
1107 }
1108 }
1109 }
1110
1111
1112 /* Set the sizes of the dynamic sections. */
1113
1114 static bfd_boolean
elf_xtensa_size_dynamic_sections(output_bfd,info)1115 elf_xtensa_size_dynamic_sections (output_bfd, info)
1116 bfd *output_bfd ATTRIBUTE_UNUSED;
1117 struct bfd_link_info *info;
1118 {
1119 bfd *dynobj, *abfd;
1120 asection *s, *srelplt, *splt, *sgotplt, *srelgot, *spltlittbl, *sgotloc;
1121 bfd_boolean relplt, relgot;
1122 int plt_entries, plt_chunks, chunk;
1123
1124 plt_entries = 0;
1125 plt_chunks = 0;
1126 srelgot = 0;
1127
1128 dynobj = elf_hash_table (info)->dynobj;
1129 if (dynobj == NULL)
1130 abort ();
1131
1132 if (elf_hash_table (info)->dynamic_sections_created)
1133 {
1134 /* Set the contents of the .interp section to the interpreter. */
1135 if (info->executable)
1136 {
1137 s = bfd_get_section_by_name (dynobj, ".interp");
1138 if (s == NULL)
1139 abort ();
1140 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1141 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1142 }
1143
1144 /* Allocate room for one word in ".got". */
1145 s = bfd_get_section_by_name (dynobj, ".got");
1146 if (s == NULL)
1147 abort ();
1148 s->_raw_size = 4;
1149
1150 /* Adjust refcounts for symbols that we now know are not "dynamic". */
1151 elf_link_hash_traverse (elf_hash_table (info),
1152 elf_xtensa_fix_refcounts,
1153 (PTR) info);
1154
1155 /* Allocate space in ".rela.got" for literals that reference
1156 global symbols. */
1157 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1158 if (srelgot == NULL)
1159 abort ();
1160 elf_link_hash_traverse (elf_hash_table (info),
1161 elf_xtensa_allocate_got_size,
1162 (PTR) srelgot);
1163
1164 /* If we are generating a shared object, we also need space in
1165 ".rela.got" for R_XTENSA_RELATIVE relocs for literals that
1166 reference local symbols. */
1167 if (info->shared)
1168 elf_xtensa_allocate_local_got_size (info, srelgot);
1169
1170 /* Allocate space in ".rela.plt" for literals that have PLT entries. */
1171 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1172 if (srelplt == NULL)
1173 abort ();
1174 elf_link_hash_traverse (elf_hash_table (info),
1175 elf_xtensa_allocate_plt_size,
1176 (PTR) srelplt);
1177
1178 /* Allocate space in ".plt" to match the size of ".rela.plt". For
1179 each PLT entry, we need the PLT code plus a 4-byte literal.
1180 For each chunk of ".plt", we also need two more 4-byte
1181 literals, two corresponding entries in ".rela.got", and an
1182 8-byte entry in ".xt.lit.plt". */
1183 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
1184 if (spltlittbl == NULL)
1185 abort ();
1186
1187 plt_entries = srelplt->_raw_size / sizeof (Elf32_External_Rela);
1188 plt_chunks =
1189 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
1190
1191 /* Iterate over all the PLT chunks, including any extra sections
1192 created earlier because the initial count of PLT relocations
1193 was an overestimate. */
1194 for (chunk = 0;
1195 (splt = elf_xtensa_get_plt_section (dynobj, chunk)) != NULL;
1196 chunk++)
1197 {
1198 int chunk_entries;
1199
1200 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1201 if (sgotplt == NULL)
1202 abort ();
1203
1204 if (chunk < plt_chunks - 1)
1205 chunk_entries = PLT_ENTRIES_PER_CHUNK;
1206 else if (chunk == plt_chunks - 1)
1207 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
1208 else
1209 chunk_entries = 0;
1210
1211 if (chunk_entries != 0)
1212 {
1213 sgotplt->_raw_size = 4 * (chunk_entries + 2);
1214 splt->_raw_size = PLT_ENTRY_SIZE * chunk_entries;
1215 srelgot->_raw_size += 2 * sizeof (Elf32_External_Rela);
1216 spltlittbl->_raw_size += 8;
1217 }
1218 else
1219 {
1220 sgotplt->_raw_size = 0;
1221 splt->_raw_size = 0;
1222 }
1223 }
1224
1225 /* Allocate space in ".got.loc" to match the total size of all the
1226 literal tables. */
1227 sgotloc = bfd_get_section_by_name (dynobj, ".got.loc");
1228 if (sgotloc == NULL)
1229 abort ();
1230 sgotloc->_raw_size = spltlittbl->_raw_size;
1231 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1232 {
1233 if (abfd->flags & DYNAMIC)
1234 continue;
1235 for (s = abfd->sections; s != NULL; s = s->next)
1236 {
1237 if (! elf_discarded_section (s)
1238 && xtensa_is_littable_section (s)
1239 && s != spltlittbl)
1240 sgotloc->_raw_size += s->_raw_size;
1241 }
1242 }
1243 }
1244
1245 /* Allocate memory for dynamic sections. */
1246 relplt = FALSE;
1247 relgot = FALSE;
1248 for (s = dynobj->sections; s != NULL; s = s->next)
1249 {
1250 const char *name;
1251 bfd_boolean strip;
1252
1253 if ((s->flags & SEC_LINKER_CREATED) == 0)
1254 continue;
1255
1256 /* It's OK to base decisions on the section name, because none
1257 of the dynobj section names depend upon the input files. */
1258 name = bfd_get_section_name (dynobj, s);
1259
1260 strip = FALSE;
1261
1262 if (strncmp (name, ".rela", 5) == 0)
1263 {
1264 if (strcmp (name, ".rela.plt") == 0)
1265 relplt = TRUE;
1266 else if (strcmp (name, ".rela.got") == 0)
1267 relgot = TRUE;
1268
1269 /* We use the reloc_count field as a counter if we need
1270 to copy relocs into the output file. */
1271 s->reloc_count = 0;
1272 }
1273 else if (strncmp (name, ".plt.", 5) == 0
1274 || strncmp (name, ".got.plt.", 9) == 0)
1275 {
1276 if (s->_raw_size == 0)
1277 {
1278 /* If we don't need this section, strip it from the output
1279 file. We must create the ".plt*" and ".got.plt*"
1280 sections in create_dynamic_sections and/or check_relocs
1281 based on a conservative estimate of the PLT relocation
1282 count, because the sections must be created before the
1283 linker maps input sections to output sections. The
1284 linker does that before size_dynamic_sections, where we
1285 compute the exact size of the PLT, so there may be more
1286 of these sections than are actually needed. */
1287 strip = TRUE;
1288 }
1289 }
1290 else if (strcmp (name, ".got") != 0
1291 && strcmp (name, ".plt") != 0
1292 && strcmp (name, ".got.plt") != 0
1293 && strcmp (name, ".xt.lit.plt") != 0
1294 && strcmp (name, ".got.loc") != 0)
1295 {
1296 /* It's not one of our sections, so don't allocate space. */
1297 continue;
1298 }
1299
1300 if (strip)
1301 _bfd_strip_section_from_output (info, s);
1302 else
1303 {
1304 /* Allocate memory for the section contents. */
1305 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1306 if (s->contents == NULL && s->_raw_size != 0)
1307 return FALSE;
1308 }
1309 }
1310
1311 if (elf_hash_table (info)->dynamic_sections_created)
1312 {
1313 /* Add the special XTENSA_RTLD relocations now. The offsets won't be
1314 known until finish_dynamic_sections, but we need to get the relocs
1315 in place before they are sorted. */
1316 if (srelgot == NULL)
1317 abort ();
1318 for (chunk = 0; chunk < plt_chunks; chunk++)
1319 {
1320 Elf_Internal_Rela irela;
1321 bfd_byte *loc;
1322
1323 irela.r_offset = 0;
1324 irela.r_info = ELF32_R_INFO (0, R_XTENSA_RTLD);
1325 irela.r_addend = 0;
1326
1327 loc = (srelgot->contents
1328 + srelgot->reloc_count * sizeof (Elf32_External_Rela));
1329 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
1330 bfd_elf32_swap_reloca_out (output_bfd, &irela,
1331 loc + sizeof (Elf32_External_Rela));
1332 srelgot->reloc_count += 2;
1333 }
1334
1335 /* Add some entries to the .dynamic section. We fill in the
1336 values later, in elf_xtensa_finish_dynamic_sections, but we
1337 must add the entries now so that we get the correct size for
1338 the .dynamic section. The DT_DEBUG entry is filled in by the
1339 dynamic linker and used by the debugger. */
1340 #define add_dynamic_entry(TAG, VAL) \
1341 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1342
1343 if (! info->shared)
1344 {
1345 if (!add_dynamic_entry (DT_DEBUG, 0))
1346 return FALSE;
1347 }
1348
1349 if (relplt)
1350 {
1351 if (!add_dynamic_entry (DT_PLTGOT, 0)
1352 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1353 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1354 || !add_dynamic_entry (DT_JMPREL, 0))
1355 return FALSE;
1356 }
1357
1358 if (relgot)
1359 {
1360 if (!add_dynamic_entry (DT_RELA, 0)
1361 || !add_dynamic_entry (DT_RELASZ, 0)
1362 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
1363 return FALSE;
1364 }
1365
1366 if (!add_dynamic_entry (DT_XTENSA_GOT_LOC_OFF, 0)
1367 || !add_dynamic_entry (DT_XTENSA_GOT_LOC_SZ, 0))
1368 return FALSE;
1369 }
1370 #undef add_dynamic_entry
1371
1372 return TRUE;
1373 }
1374
1375
1376 /* Remove any PT_LOAD segments with no allocated sections. Prior to
1377 binutils 2.13, this function used to remove the non-SEC_ALLOC
1378 sections from PT_LOAD segments, but that task has now been moved
1379 into elf.c. We still need this function to remove any empty
1380 segments that result, but there's nothing Xtensa-specific about
1381 this and it probably ought to be moved into elf.c as well. */
1382
1383 static bfd_boolean
elf_xtensa_modify_segment_map(abfd,info)1384 elf_xtensa_modify_segment_map (abfd, info)
1385 bfd *abfd;
1386 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1387 {
1388 struct elf_segment_map **m_p;
1389
1390 m_p = &elf_tdata (abfd)->segment_map;
1391 while (*m_p != NULL)
1392 {
1393 if ((*m_p)->p_type == PT_LOAD && (*m_p)->count == 0)
1394 *m_p = (*m_p)->next;
1395 else
1396 m_p = &(*m_p)->next;
1397 }
1398 return TRUE;
1399 }
1400
1401
1402 /* Perform the specified relocation. The instruction at (contents + address)
1403 is modified to set one operand to represent the value in "relocation". The
1404 operand position is determined by the relocation type recorded in the
1405 howto. */
1406
1407 #define CALL_SEGMENT_BITS (30)
1408 #define CALL_SEGMENT_SIZE (1<<CALL_SEGMENT_BITS)
1409
1410 static bfd_reloc_status_type
elf_xtensa_do_reloc(howto,abfd,input_section,relocation,contents,address,is_weak_undef,error_message)1411 elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
1412 contents, address, is_weak_undef, error_message)
1413 reloc_howto_type *howto;
1414 bfd *abfd;
1415 asection *input_section;
1416 bfd_vma relocation;
1417 bfd_byte *contents;
1418 bfd_vma address;
1419 bfd_boolean is_weak_undef;
1420 char **error_message;
1421 {
1422 xtensa_opcode opcode;
1423 xtensa_operand operand;
1424 xtensa_encode_result encode_result;
1425 xtensa_isa isa = xtensa_default_isa;
1426 xtensa_insnbuf ibuff;
1427 bfd_vma self_address;
1428 int opnd;
1429 uint32 newval;
1430
1431 switch (howto->type)
1432 {
1433 case R_XTENSA_NONE:
1434 return bfd_reloc_ok;
1435
1436 case R_XTENSA_ASM_EXPAND:
1437 if (!is_weak_undef)
1438 {
1439 /* Check for windowed CALL across a 1GB boundary. */
1440 xtensa_opcode opcode =
1441 get_expanded_call_opcode (contents + address,
1442 input_section->_raw_size - address);
1443 if (is_windowed_call_opcode (opcode))
1444 {
1445 self_address = (input_section->output_section->vma
1446 + input_section->output_offset
1447 + address);
1448 if ((self_address >> CALL_SEGMENT_BITS) !=
1449 (relocation >> CALL_SEGMENT_BITS))
1450 {
1451 *error_message = "windowed longcall crosses 1GB boundary; "
1452 "return may fail";
1453 return bfd_reloc_dangerous;
1454 }
1455 }
1456 }
1457 return bfd_reloc_ok;
1458
1459 case R_XTENSA_ASM_SIMPLIFY:
1460 {
1461 /* Convert the L32R/CALLX to CALL. */
1462 bfd_reloc_status_type retval =
1463 elf_xtensa_do_asm_simplify (contents, address,
1464 input_section->_raw_size);
1465 if (retval != bfd_reloc_ok)
1466 return retval;
1467
1468 /* The CALL needs to be relocated. Continue below for that part. */
1469 address += 3;
1470 howto = &elf_howto_table[(unsigned) R_XTENSA_OP0 ];
1471 }
1472 break;
1473
1474 case R_XTENSA_32:
1475 case R_XTENSA_PLT:
1476 {
1477 bfd_vma x;
1478 x = bfd_get_32 (abfd, contents + address);
1479 x = x + relocation;
1480 bfd_put_32 (abfd, x, contents + address);
1481 }
1482 return bfd_reloc_ok;
1483 }
1484
1485 /* Read the instruction into a buffer and decode the opcode. */
1486 ibuff = xtensa_insnbuf_alloc (isa);
1487 xtensa_insnbuf_from_chars (isa, ibuff, contents + address);
1488 opcode = xtensa_decode_insn (isa, ibuff);
1489
1490 /* Determine which operand is being relocated. */
1491 if (opcode == XTENSA_UNDEFINED)
1492 {
1493 *error_message = "cannot decode instruction";
1494 return bfd_reloc_dangerous;
1495 }
1496
1497 if (howto->type < R_XTENSA_OP0 || howto->type > R_XTENSA_OP2)
1498 {
1499 *error_message = "unexpected relocation";
1500 return bfd_reloc_dangerous;
1501 }
1502
1503 opnd = howto->type - R_XTENSA_OP0;
1504
1505 /* Calculate the PC address for this instruction. */
1506 if (!howto->pc_relative)
1507 {
1508 *error_message = "expected PC-relative relocation";
1509 return bfd_reloc_dangerous;
1510 }
1511
1512 self_address = (input_section->output_section->vma
1513 + input_section->output_offset
1514 + address);
1515
1516 /* Apply the relocation. */
1517 operand = xtensa_get_operand (isa, opcode, opnd);
1518 newval = xtensa_operand_do_reloc (operand, relocation, self_address);
1519 encode_result = xtensa_operand_encode (operand, &newval);
1520 xtensa_operand_set_field (operand, ibuff, newval);
1521
1522 /* Write the modified instruction back out of the buffer. */
1523 xtensa_insnbuf_to_chars (isa, ibuff, contents + address);
1524 free (ibuff);
1525
1526 if (encode_result != xtensa_encode_result_ok)
1527 {
1528 char *message = build_encoding_error_message (opcode, encode_result);
1529 *error_message = message;
1530 return bfd_reloc_dangerous;
1531 }
1532
1533 /* Final check for call. */
1534 if (is_direct_call_opcode (opcode)
1535 && is_windowed_call_opcode (opcode))
1536 {
1537 if ((self_address >> CALL_SEGMENT_BITS) !=
1538 (relocation >> CALL_SEGMENT_BITS))
1539 {
1540 *error_message = "windowed call crosses 1GB boundary; "
1541 "return may fail";
1542 return bfd_reloc_dangerous;
1543 }
1544 }
1545
1546 return bfd_reloc_ok;
1547 }
1548
1549
1550 static char *
vsprint_msg(const char * origmsg,const char * fmt,int arglen,...)1551 vsprint_msg VPARAMS ((const char *origmsg, const char *fmt, int arglen, ...))
1552 {
1553 /* To reduce the size of the memory leak,
1554 we only use a single message buffer. */
1555 static bfd_size_type alloc_size = 0;
1556 static char *message = NULL;
1557 bfd_size_type orig_len, len = 0;
1558 bfd_boolean is_append;
1559
1560 VA_OPEN (ap, arglen);
1561 VA_FIXEDARG (ap, const char *, origmsg);
1562
1563 is_append = (origmsg == message);
1564
1565 orig_len = strlen (origmsg);
1566 len = orig_len + strlen (fmt) + arglen + 20;
1567 if (len > alloc_size)
1568 {
1569 message = (char *) bfd_realloc (message, len);
1570 alloc_size = len;
1571 }
1572 if (!is_append)
1573 memcpy (message, origmsg, orig_len);
1574 vsprintf (message + orig_len, fmt, ap);
1575 VA_CLOSE (ap);
1576 return message;
1577 }
1578
1579
1580 static char *
build_encoding_error_message(opcode,encode_result)1581 build_encoding_error_message (opcode, encode_result)
1582 xtensa_opcode opcode;
1583 xtensa_encode_result encode_result;
1584 {
1585 const char *opname = xtensa_opcode_name (xtensa_default_isa, opcode);
1586 const char *msg = NULL;
1587
1588 switch (encode_result)
1589 {
1590 case xtensa_encode_result_ok:
1591 msg = "unexpected valid encoding";
1592 break;
1593 case xtensa_encode_result_align:
1594 msg = "misaligned encoding";
1595 break;
1596 case xtensa_encode_result_not_in_table:
1597 msg = "encoding not in lookup table";
1598 break;
1599 case xtensa_encode_result_too_low:
1600 msg = "encoding out of range: too low";
1601 break;
1602 case xtensa_encode_result_too_high:
1603 msg = "encoding out of range: too high";
1604 break;
1605 case xtensa_encode_result_not_ok:
1606 default:
1607 msg = "could not encode";
1608 break;
1609 }
1610
1611 if (is_direct_call_opcode (opcode)
1612 && (encode_result == xtensa_encode_result_too_low
1613 || encode_result == xtensa_encode_result_too_high))
1614
1615 msg = "direct call out of range";
1616
1617 else if (opcode == get_l32r_opcode ())
1618 {
1619 /* L32Rs have the strange interaction with encoding in that they
1620 have an unsigned immediate field, so libisa returns "too high"
1621 when the absolute value is out of range and never returns "too
1622 low", but I leave the "too low" message in case anything
1623 changes. */
1624 if (encode_result == xtensa_encode_result_too_low)
1625 msg = "literal out of range";
1626 else if (encode_result == xtensa_encode_result_too_high)
1627 msg = "literal placed after use";
1628 }
1629
1630 return vsprint_msg (opname, ": %s", strlen (msg) + 2, msg);
1631 }
1632
1633
1634 /* This function is registered as the "special_function" in the
1635 Xtensa howto for handling simplify operations.
1636 bfd_perform_relocation / bfd_install_relocation use it to
1637 perform (install) the specified relocation. Since this replaces the code
1638 in bfd_perform_relocation, it is basically an Xtensa-specific,
1639 stripped-down version of bfd_perform_relocation. */
1640
1641 static bfd_reloc_status_type
bfd_elf_xtensa_reloc(abfd,reloc_entry,symbol,data,input_section,output_bfd,error_message)1642 bfd_elf_xtensa_reloc (abfd, reloc_entry, symbol, data, input_section,
1643 output_bfd, error_message)
1644 bfd *abfd;
1645 arelent *reloc_entry;
1646 asymbol *symbol;
1647 PTR data;
1648 asection *input_section;
1649 bfd *output_bfd;
1650 char **error_message;
1651 {
1652 bfd_vma relocation;
1653 bfd_reloc_status_type flag;
1654 bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1655 bfd_vma output_base = 0;
1656 reloc_howto_type *howto = reloc_entry->howto;
1657 asection *reloc_target_output_section;
1658 bfd_boolean is_weak_undef;
1659
1660 /* ELF relocs are against symbols. If we are producing relocatable
1661 output, and the reloc is against an external symbol, the resulting
1662 reloc will also be against the same symbol. In such a case, we
1663 don't want to change anything about the way the reloc is handled,
1664 since it will all be done at final link time. This test is similar
1665 to what bfd_elf_generic_reloc does except that it lets relocs with
1666 howto->partial_inplace go through even if the addend is non-zero.
1667 (The real problem is that partial_inplace is set for XTENSA_32
1668 relocs to begin with, but that's a long story and there's little we
1669 can do about it now....) */
1670
1671 if (output_bfd != (bfd *) NULL
1672 && (symbol->flags & BSF_SECTION_SYM) == 0)
1673 {
1674 reloc_entry->address += input_section->output_offset;
1675 return bfd_reloc_ok;
1676 }
1677
1678 /* Is the address of the relocation really within the section? */
1679 if (reloc_entry->address > (input_section->_cooked_size
1680 / bfd_octets_per_byte (abfd)))
1681 return bfd_reloc_outofrange;
1682
1683 /* Work out which section the relocation is targeted at and the
1684 initial relocation command value. */
1685
1686 /* Get symbol value. (Common symbols are special.) */
1687 if (bfd_is_com_section (symbol->section))
1688 relocation = 0;
1689 else
1690 relocation = symbol->value;
1691
1692 reloc_target_output_section = symbol->section->output_section;
1693
1694 /* Convert input-section-relative symbol value to absolute. */
1695 if ((output_bfd && !howto->partial_inplace)
1696 || reloc_target_output_section == NULL)
1697 output_base = 0;
1698 else
1699 output_base = reloc_target_output_section->vma;
1700
1701 relocation += output_base + symbol->section->output_offset;
1702
1703 /* Add in supplied addend. */
1704 relocation += reloc_entry->addend;
1705
1706 /* Here the variable relocation holds the final address of the
1707 symbol we are relocating against, plus any addend. */
1708 if (output_bfd)
1709 {
1710 if (!howto->partial_inplace)
1711 {
1712 /* This is a partial relocation, and we want to apply the relocation
1713 to the reloc entry rather than the raw data. Everything except
1714 relocations against section symbols has already been handled
1715 above. */
1716
1717 BFD_ASSERT (symbol->flags & BSF_SECTION_SYM);
1718 reloc_entry->addend = relocation;
1719 reloc_entry->address += input_section->output_offset;
1720 return bfd_reloc_ok;
1721 }
1722 else
1723 {
1724 reloc_entry->address += input_section->output_offset;
1725 reloc_entry->addend = 0;
1726 }
1727 }
1728
1729 is_weak_undef = (bfd_is_und_section (symbol->section)
1730 && (symbol->flags & BSF_WEAK) != 0);
1731 flag = elf_xtensa_do_reloc (howto, abfd, input_section, relocation,
1732 (bfd_byte *) data, (bfd_vma) octets,
1733 is_weak_undef, error_message);
1734
1735 if (flag == bfd_reloc_dangerous)
1736 {
1737 /* Add the symbol name to the error message. */
1738 if (! *error_message)
1739 *error_message = "";
1740 *error_message = vsprint_msg (*error_message, ": (%s + 0x%lx)",
1741 strlen (symbol->name) + 17,
1742 symbol->name, reloc_entry->addend);
1743 }
1744
1745 return flag;
1746 }
1747
1748
1749 /* Set up an entry in the procedure linkage table. */
1750
1751 static bfd_vma
elf_xtensa_create_plt_entry(dynobj,output_bfd,reloc_index)1752 elf_xtensa_create_plt_entry (dynobj, output_bfd, reloc_index)
1753 bfd *dynobj;
1754 bfd *output_bfd;
1755 unsigned reloc_index;
1756 {
1757 asection *splt, *sgotplt;
1758 bfd_vma plt_base, got_base;
1759 bfd_vma code_offset, lit_offset;
1760 int chunk;
1761
1762 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
1763 splt = elf_xtensa_get_plt_section (dynobj, chunk);
1764 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
1765 BFD_ASSERT (splt != NULL && sgotplt != NULL);
1766
1767 plt_base = splt->output_section->vma + splt->output_offset;
1768 got_base = sgotplt->output_section->vma + sgotplt->output_offset;
1769
1770 lit_offset = 8 + (reloc_index % PLT_ENTRIES_PER_CHUNK) * 4;
1771 code_offset = (reloc_index % PLT_ENTRIES_PER_CHUNK) * PLT_ENTRY_SIZE;
1772
1773 /* Fill in the literal entry. This is the offset of the dynamic
1774 relocation entry. */
1775 bfd_put_32 (output_bfd, reloc_index * sizeof (Elf32_External_Rela),
1776 sgotplt->contents + lit_offset);
1777
1778 /* Fill in the entry in the procedure linkage table. */
1779 memcpy (splt->contents + code_offset,
1780 (bfd_big_endian (output_bfd)
1781 ? elf_xtensa_be_plt_entry
1782 : elf_xtensa_le_plt_entry),
1783 PLT_ENTRY_SIZE);
1784 bfd_put_16 (output_bfd, l32r_offset (got_base + 0,
1785 plt_base + code_offset + 3),
1786 splt->contents + code_offset + 4);
1787 bfd_put_16 (output_bfd, l32r_offset (got_base + 4,
1788 plt_base + code_offset + 6),
1789 splt->contents + code_offset + 7);
1790 bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset,
1791 plt_base + code_offset + 9),
1792 splt->contents + code_offset + 10);
1793
1794 return plt_base + code_offset;
1795 }
1796
1797
1798 /* Relocate an Xtensa ELF section. This is invoked by the linker for
1799 both relocatable and final links. */
1800
1801 static bfd_boolean
elf_xtensa_relocate_section(output_bfd,info,input_bfd,input_section,contents,relocs,local_syms,local_sections)1802 elf_xtensa_relocate_section (output_bfd, info, input_bfd,
1803 input_section, contents, relocs,
1804 local_syms, local_sections)
1805 bfd *output_bfd;
1806 struct bfd_link_info *info;
1807 bfd *input_bfd;
1808 asection *input_section;
1809 bfd_byte *contents;
1810 Elf_Internal_Rela *relocs;
1811 Elf_Internal_Sym *local_syms;
1812 asection **local_sections;
1813 {
1814 Elf_Internal_Shdr *symtab_hdr;
1815 Elf_Internal_Rela *rel;
1816 Elf_Internal_Rela *relend;
1817 struct elf_link_hash_entry **sym_hashes;
1818 asection *srelgot, *srelplt;
1819 bfd *dynobj;
1820 property_table_entry *lit_table = 0;
1821 int ltblsize = 0;
1822 char *error_message = NULL;
1823
1824 if (xtensa_default_isa == NULL)
1825 xtensa_isa_init ();
1826
1827 dynobj = elf_hash_table (info)->dynobj;
1828 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1829 sym_hashes = elf_sym_hashes (input_bfd);
1830
1831 srelgot = NULL;
1832 srelplt = NULL;
1833 if (dynobj != NULL)
1834 {
1835 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
1836 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
1837 }
1838
1839 if (elf_hash_table (info)->dynamic_sections_created)
1840 {
1841 ltblsize = xtensa_read_table_entries (input_bfd, input_section,
1842 &lit_table, XTENSA_LIT_SEC_NAME);
1843 if (ltblsize < 0)
1844 return FALSE;
1845 }
1846
1847 rel = relocs;
1848 relend = relocs + input_section->reloc_count;
1849 for (; rel < relend; rel++)
1850 {
1851 int r_type;
1852 reloc_howto_type *howto;
1853 unsigned long r_symndx;
1854 struct elf_link_hash_entry *h;
1855 Elf_Internal_Sym *sym;
1856 asection *sec;
1857 bfd_vma relocation;
1858 bfd_reloc_status_type r;
1859 bfd_boolean is_weak_undef;
1860 bfd_boolean unresolved_reloc;
1861 bfd_boolean warned;
1862
1863 r_type = ELF32_R_TYPE (rel->r_info);
1864 if (r_type == (int) R_XTENSA_GNU_VTINHERIT
1865 || r_type == (int) R_XTENSA_GNU_VTENTRY)
1866 continue;
1867
1868 if (r_type < 0 || r_type >= (int) R_XTENSA_max)
1869 {
1870 bfd_set_error (bfd_error_bad_value);
1871 return FALSE;
1872 }
1873 howto = &elf_howto_table[r_type];
1874
1875 r_symndx = ELF32_R_SYM (rel->r_info);
1876
1877 if (info->relocatable)
1878 {
1879 /* This is a relocatable link.
1880 1) If the reloc is against a section symbol, adjust
1881 according to the output section.
1882 2) If there is a new target for this relocation,
1883 the new target will be in the same output section.
1884 We adjust the relocation by the output section
1885 difference. */
1886
1887 if (relaxing_section)
1888 {
1889 /* Check if this references a section in another input file. */
1890 do_fix_for_relocatable_link (rel, input_bfd, input_section);
1891 r_type = ELF32_R_TYPE (rel->r_info);
1892 }
1893
1894 if (r_type == R_XTENSA_ASM_SIMPLIFY)
1895 {
1896 /* Convert ASM_SIMPLIFY into the simpler relocation
1897 so that they never escape a relaxing link. */
1898 contract_asm_expansion (contents, input_section->_raw_size, rel);
1899 r_type = ELF32_R_TYPE (rel->r_info);
1900 }
1901
1902 /* This is a relocatable link, so we don't have to change
1903 anything unless the reloc is against a section symbol,
1904 in which case we have to adjust according to where the
1905 section symbol winds up in the output section. */
1906 if (r_symndx < symtab_hdr->sh_info)
1907 {
1908 sym = local_syms + r_symndx;
1909 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1910 {
1911 sec = local_sections[r_symndx];
1912 rel->r_addend += sec->output_offset + sym->st_value;
1913 }
1914 }
1915
1916 /* If there is an addend with a partial_inplace howto,
1917 then move the addend to the contents. This is a hack
1918 to work around problems with DWARF in relocatable links
1919 with some previous version of BFD. Now we can't easily get
1920 rid of the hack without breaking backward compatibility.... */
1921 if (rel->r_addend)
1922 {
1923 howto = &elf_howto_table[r_type];
1924 if (howto->partial_inplace)
1925 {
1926 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
1927 rel->r_addend, contents,
1928 rel->r_offset, FALSE,
1929 &error_message);
1930 if (r != bfd_reloc_ok)
1931 {
1932 if (!((*info->callbacks->reloc_dangerous)
1933 (info, error_message, input_bfd, input_section,
1934 rel->r_offset)))
1935 return FALSE;
1936 }
1937 rel->r_addend = 0;
1938 }
1939 }
1940
1941 /* Done with work for relocatable link; continue with next reloc. */
1942 continue;
1943 }
1944
1945 /* This is a final link. */
1946
1947 h = NULL;
1948 sym = NULL;
1949 sec = NULL;
1950 is_weak_undef = FALSE;
1951 unresolved_reloc = FALSE;
1952 warned = FALSE;
1953
1954 if (howto->partial_inplace)
1955 {
1956 /* Because R_XTENSA_32 was made partial_inplace to fix some
1957 problems with DWARF info in partial links, there may be
1958 an addend stored in the contents. Take it out of there
1959 and move it back into the addend field of the reloc. */
1960 rel->r_addend += bfd_get_32 (input_bfd, contents + rel->r_offset);
1961 bfd_put_32 (input_bfd, 0, contents + rel->r_offset);
1962 }
1963
1964 if (r_symndx < symtab_hdr->sh_info)
1965 {
1966 sym = local_syms + r_symndx;
1967 sec = local_sections[r_symndx];
1968 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1969 }
1970 else
1971 {
1972 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1973 r_symndx, symtab_hdr, sym_hashes,
1974 h, sec, relocation,
1975 unresolved_reloc, warned);
1976
1977 if (relocation == 0
1978 && !unresolved_reloc
1979 && h->root.type == bfd_link_hash_undefweak)
1980 is_weak_undef = TRUE;
1981 }
1982
1983 if (relaxing_section)
1984 {
1985 /* Check if this references a section in another input file. */
1986 do_fix_for_final_link (rel, input_section, &relocation);
1987
1988 /* Update some already cached values. */
1989 r_type = ELF32_R_TYPE (rel->r_info);
1990 howto = &elf_howto_table[r_type];
1991 }
1992
1993 /* Sanity check the address. */
1994 if (rel->r_offset >= input_section->_raw_size
1995 && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE)
1996 {
1997 bfd_set_error (bfd_error_bad_value);
1998 return FALSE;
1999 }
2000
2001 /* Generate dynamic relocations. */
2002 if (elf_hash_table (info)->dynamic_sections_created)
2003 {
2004 bfd_boolean dynamic_symbol = xtensa_elf_dynamic_symbol_p (h, info);
2005
2006 if (dynamic_symbol && (r_type == R_XTENSA_OP0
2007 || r_type == R_XTENSA_OP1
2008 || r_type == R_XTENSA_OP2))
2009 {
2010 /* This is an error. The symbol's real value won't be known
2011 until runtime and it's likely to be out of range anyway. */
2012 const char *name = h->root.root.string;
2013 error_message = vsprint_msg ("invalid relocation for dynamic "
2014 "symbol", ": %s",
2015 strlen (name) + 2, name);
2016 if (!((*info->callbacks->reloc_dangerous)
2017 (info, error_message, input_bfd, input_section,
2018 rel->r_offset)))
2019 return FALSE;
2020 }
2021 else if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
2022 && (input_section->flags & SEC_ALLOC) != 0
2023 && (dynamic_symbol || info->shared))
2024 {
2025 Elf_Internal_Rela outrel;
2026 bfd_byte *loc;
2027 asection *srel;
2028
2029 if (dynamic_symbol && r_type == R_XTENSA_PLT)
2030 srel = srelplt;
2031 else
2032 srel = srelgot;
2033
2034 BFD_ASSERT (srel != NULL);
2035
2036 outrel.r_offset =
2037 _bfd_elf_section_offset (output_bfd, info,
2038 input_section, rel->r_offset);
2039
2040 if ((outrel.r_offset | 1) == (bfd_vma) -1)
2041 memset (&outrel, 0, sizeof outrel);
2042 else
2043 {
2044 outrel.r_offset += (input_section->output_section->vma
2045 + input_section->output_offset);
2046
2047 /* Complain if the relocation is in a read-only section
2048 and not in a literal pool. */
2049 if ((input_section->flags & SEC_READONLY) != 0
2050 && !elf_xtensa_in_literal_pool (lit_table, ltblsize,
2051 outrel.r_offset))
2052 {
2053 error_message =
2054 _("dynamic relocation in read-only section");
2055 if (!((*info->callbacks->reloc_dangerous)
2056 (info, error_message, input_bfd, input_section,
2057 rel->r_offset)))
2058 return FALSE;
2059 }
2060
2061 if (dynamic_symbol)
2062 {
2063 outrel.r_addend = rel->r_addend;
2064 rel->r_addend = 0;
2065
2066 if (r_type == R_XTENSA_32)
2067 {
2068 outrel.r_info =
2069 ELF32_R_INFO (h->dynindx, R_XTENSA_GLOB_DAT);
2070 relocation = 0;
2071 }
2072 else /* r_type == R_XTENSA_PLT */
2073 {
2074 outrel.r_info =
2075 ELF32_R_INFO (h->dynindx, R_XTENSA_JMP_SLOT);
2076
2077 /* Create the PLT entry and set the initial
2078 contents of the literal entry to the address of
2079 the PLT entry. */
2080 relocation =
2081 elf_xtensa_create_plt_entry (dynobj, output_bfd,
2082 srel->reloc_count);
2083 }
2084 unresolved_reloc = FALSE;
2085 }
2086 else
2087 {
2088 /* Generate a RELATIVE relocation. */
2089 outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE);
2090 outrel.r_addend = 0;
2091 }
2092 }
2093
2094 loc = (srel->contents
2095 + srel->reloc_count++ * sizeof (Elf32_External_Rela));
2096 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2097 BFD_ASSERT (sizeof (Elf32_External_Rela) * srel->reloc_count
2098 <= srel->_cooked_size);
2099 }
2100 }
2101
2102 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2103 because such sections are not SEC_ALLOC and thus ld.so will
2104 not process them. */
2105 if (unresolved_reloc
2106 && !((input_section->flags & SEC_DEBUGGING) != 0
2107 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2108 (*_bfd_error_handler)
2109 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2110 bfd_archive_filename (input_bfd),
2111 bfd_get_section_name (input_bfd, input_section),
2112 (long) rel->r_offset,
2113 h->root.root.string);
2114
2115 /* There's no point in calling bfd_perform_relocation here.
2116 Just go directly to our "special function". */
2117 r = elf_xtensa_do_reloc (howto, input_bfd, input_section,
2118 relocation + rel->r_addend,
2119 contents, rel->r_offset, is_weak_undef,
2120 &error_message);
2121
2122 if (r != bfd_reloc_ok && !warned)
2123 {
2124 const char *name;
2125
2126 BFD_ASSERT (r == bfd_reloc_dangerous);
2127 BFD_ASSERT (error_message != (char *) NULL);
2128
2129 if (h != NULL)
2130 name = h->root.root.string;
2131 else
2132 {
2133 name = bfd_elf_string_from_elf_section
2134 (input_bfd, symtab_hdr->sh_link, sym->st_name);
2135 if (name && *name == '\0')
2136 name = bfd_section_name (input_bfd, sec);
2137 }
2138 if (name)
2139 error_message = vsprint_msg (error_message, ": %s",
2140 strlen (name), name);
2141 if (!((*info->callbacks->reloc_dangerous)
2142 (info, error_message, input_bfd, input_section,
2143 rel->r_offset)))
2144 return FALSE;
2145 }
2146 }
2147
2148 if (lit_table)
2149 free (lit_table);
2150
2151 input_section->reloc_done = TRUE;
2152
2153 return TRUE;
2154 }
2155
2156
2157 /* Finish up dynamic symbol handling. There's not much to do here since
2158 the PLT and GOT entries are all set up by relocate_section. */
2159
2160 static bfd_boolean
elf_xtensa_finish_dynamic_symbol(output_bfd,info,h,sym)2161 elf_xtensa_finish_dynamic_symbol (output_bfd, info, h, sym)
2162 bfd *output_bfd ATTRIBUTE_UNUSED;
2163 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2164 struct elf_link_hash_entry *h;
2165 Elf_Internal_Sym *sym;
2166 {
2167 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
2168 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2169 {
2170 /* Mark the symbol as undefined, rather than as defined in
2171 the .plt section. Leave the value alone. */
2172 sym->st_shndx = SHN_UNDEF;
2173 }
2174
2175 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2176 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2177 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2178 sym->st_shndx = SHN_ABS;
2179
2180 return TRUE;
2181 }
2182
2183
2184 /* Combine adjacent literal table entries in the output. Adjacent
2185 entries within each input section may have been removed during
2186 relaxation, but we repeat the process here, even though it's too late
2187 to shrink the output section, because it's important to minimize the
2188 number of literal table entries to reduce the start-up work for the
2189 runtime linker. Returns the number of remaining table entries or -1
2190 on error. */
2191
2192 static int
elf_xtensa_combine_prop_entries(output_bfd,sxtlit,sgotloc)2193 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc)
2194 bfd *output_bfd;
2195 asection *sxtlit;
2196 asection *sgotloc;
2197 {
2198 bfd_byte *contents;
2199 property_table_entry *table;
2200 bfd_size_type section_size, sgotloc_size;
2201 bfd_vma offset;
2202 int n, m, num;
2203
2204 section_size = (sxtlit->_cooked_size != 0
2205 ? sxtlit->_cooked_size : sxtlit->_raw_size);
2206 BFD_ASSERT (section_size % 8 == 0);
2207 num = section_size / 8;
2208
2209 sgotloc_size = (sgotloc->_cooked_size != 0
2210 ? sgotloc->_cooked_size : sgotloc->_raw_size);
2211 if (sgotloc_size != section_size)
2212 {
2213 (*_bfd_error_handler)
2214 ("internal inconsistency in size of .got.loc section");
2215 return -1;
2216 }
2217
2218 contents = (bfd_byte *) bfd_malloc (section_size);
2219 table = (property_table_entry *)
2220 bfd_malloc (num * sizeof (property_table_entry));
2221 if (contents == 0 || table == 0)
2222 return -1;
2223
2224 /* The ".xt.lit.plt" section has the SEC_IN_MEMORY flag set and this
2225 propagates to the output section, where it doesn't really apply and
2226 where it breaks the following call to bfd_get_section_contents. */
2227 sxtlit->flags &= ~SEC_IN_MEMORY;
2228
2229 if (! bfd_get_section_contents (output_bfd, sxtlit, contents, 0,
2230 section_size))
2231 return -1;
2232
2233 /* There should never be any relocations left at this point, so this
2234 is quite a bit easier than what is done during relaxation. */
2235
2236 /* Copy the raw contents into a property table array and sort it. */
2237 offset = 0;
2238 for (n = 0; n < num; n++)
2239 {
2240 table[n].address = bfd_get_32 (output_bfd, &contents[offset]);
2241 table[n].size = bfd_get_32 (output_bfd, &contents[offset + 4]);
2242 offset += 8;
2243 }
2244 qsort (table, num, sizeof (property_table_entry), property_table_compare);
2245
2246 for (n = 0; n < num; n++)
2247 {
2248 bfd_boolean remove = FALSE;
2249
2250 if (table[n].size == 0)
2251 remove = TRUE;
2252 else if (n > 0 &&
2253 (table[n-1].address + table[n-1].size == table[n].address))
2254 {
2255 table[n-1].size += table[n].size;
2256 remove = TRUE;
2257 }
2258
2259 if (remove)
2260 {
2261 for (m = n; m < num - 1; m++)
2262 {
2263 table[m].address = table[m+1].address;
2264 table[m].size = table[m+1].size;
2265 }
2266
2267 n--;
2268 num--;
2269 }
2270 }
2271
2272 /* Copy the data back to the raw contents. */
2273 offset = 0;
2274 for (n = 0; n < num; n++)
2275 {
2276 bfd_put_32 (output_bfd, table[n].address, &contents[offset]);
2277 bfd_put_32 (output_bfd, table[n].size, &contents[offset + 4]);
2278 offset += 8;
2279 }
2280
2281 /* Clear the removed bytes. */
2282 if ((bfd_size_type) (num * 8) < section_size)
2283 {
2284 memset (&contents[num * 8], 0, section_size - num * 8);
2285 sxtlit->_cooked_size = num * 8;
2286 }
2287
2288 if (! bfd_set_section_contents (output_bfd, sxtlit, contents, 0,
2289 section_size))
2290 return -1;
2291
2292 /* Copy the contents to ".got.loc". */
2293 memcpy (sgotloc->contents, contents, section_size);
2294
2295 free (contents);
2296 free (table);
2297 return num;
2298 }
2299
2300
2301 /* Finish up the dynamic sections. */
2302
2303 static bfd_boolean
elf_xtensa_finish_dynamic_sections(output_bfd,info)2304 elf_xtensa_finish_dynamic_sections (output_bfd, info)
2305 bfd *output_bfd;
2306 struct bfd_link_info *info;
2307 {
2308 bfd *dynobj;
2309 asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc;
2310 Elf32_External_Dyn *dyncon, *dynconend;
2311 int num_xtlit_entries;
2312
2313 if (! elf_hash_table (info)->dynamic_sections_created)
2314 return TRUE;
2315
2316 dynobj = elf_hash_table (info)->dynobj;
2317 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2318 BFD_ASSERT (sdyn != NULL);
2319
2320 /* Set the first entry in the global offset table to the address of
2321 the dynamic section. */
2322 sgot = bfd_get_section_by_name (dynobj, ".got");
2323 if (sgot)
2324 {
2325 BFD_ASSERT (sgot->_raw_size == 4);
2326 if (sdyn == NULL)
2327 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2328 else
2329 bfd_put_32 (output_bfd,
2330 sdyn->output_section->vma + sdyn->output_offset,
2331 sgot->contents);
2332 }
2333
2334 srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
2335 if (srelplt != NULL && srelplt->_raw_size != 0)
2336 {
2337 asection *sgotplt, *srelgot, *spltlittbl;
2338 int chunk, plt_chunks, plt_entries;
2339 Elf_Internal_Rela irela;
2340 bfd_byte *loc;
2341 unsigned rtld_reloc;
2342
2343 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");;
2344 BFD_ASSERT (srelgot != NULL);
2345
2346 spltlittbl = bfd_get_section_by_name (dynobj, ".xt.lit.plt");
2347 BFD_ASSERT (spltlittbl != NULL);
2348
2349 /* Find the first XTENSA_RTLD relocation. Presumably the rest
2350 of them follow immediately after.... */
2351 for (rtld_reloc = 0; rtld_reloc < srelgot->reloc_count; rtld_reloc++)
2352 {
2353 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2354 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2355 if (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD)
2356 break;
2357 }
2358 BFD_ASSERT (rtld_reloc < srelgot->reloc_count);
2359
2360 plt_entries = (srelplt->_raw_size / sizeof (Elf32_External_Rela));
2361 plt_chunks =
2362 (plt_entries + PLT_ENTRIES_PER_CHUNK - 1) / PLT_ENTRIES_PER_CHUNK;
2363
2364 for (chunk = 0; chunk < plt_chunks; chunk++)
2365 {
2366 int chunk_entries = 0;
2367
2368 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
2369 BFD_ASSERT (sgotplt != NULL);
2370
2371 /* Emit special RTLD relocations for the first two entries in
2372 each chunk of the .got.plt section. */
2373
2374 loc = srelgot->contents + rtld_reloc * sizeof (Elf32_External_Rela);
2375 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2376 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2377 irela.r_offset = (sgotplt->output_section->vma
2378 + sgotplt->output_offset);
2379 irela.r_addend = 1; /* tell rtld to set value to resolver function */
2380 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2381 rtld_reloc += 1;
2382 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2383
2384 /* Next literal immediately follows the first. */
2385 loc += sizeof (Elf32_External_Rela);
2386 bfd_elf32_swap_reloca_in (output_bfd, loc, &irela);
2387 BFD_ASSERT (ELF32_R_TYPE (irela.r_info) == R_XTENSA_RTLD);
2388 irela.r_offset = (sgotplt->output_section->vma
2389 + sgotplt->output_offset + 4);
2390 /* Tell rtld to set value to object's link map. */
2391 irela.r_addend = 2;
2392 bfd_elf32_swap_reloca_out (output_bfd, &irela, loc);
2393 rtld_reloc += 1;
2394 BFD_ASSERT (rtld_reloc <= srelgot->reloc_count);
2395
2396 /* Fill in the literal table. */
2397 if (chunk < plt_chunks - 1)
2398 chunk_entries = PLT_ENTRIES_PER_CHUNK;
2399 else
2400 chunk_entries = plt_entries - (chunk * PLT_ENTRIES_PER_CHUNK);
2401
2402 BFD_ASSERT ((unsigned) (chunk + 1) * 8 <= spltlittbl->_cooked_size);
2403 bfd_put_32 (output_bfd,
2404 sgotplt->output_section->vma + sgotplt->output_offset,
2405 spltlittbl->contents + (chunk * 8) + 0);
2406 bfd_put_32 (output_bfd,
2407 8 + (chunk_entries * 4),
2408 spltlittbl->contents + (chunk * 8) + 4);
2409 }
2410
2411 /* All the dynamic relocations have been emitted at this point.
2412 Make sure the relocation sections are the correct size. */
2413 if (srelgot->_cooked_size != (sizeof (Elf32_External_Rela)
2414 * srelgot->reloc_count)
2415 || srelplt->_cooked_size != (sizeof (Elf32_External_Rela)
2416 * srelplt->reloc_count))
2417 abort ();
2418
2419 /* The .xt.lit.plt section has just been modified. This must
2420 happen before the code below which combines adjacent literal
2421 table entries, and the .xt.lit.plt contents have to be forced to
2422 the output here. */
2423 if (! bfd_set_section_contents (output_bfd,
2424 spltlittbl->output_section,
2425 spltlittbl->contents,
2426 spltlittbl->output_offset,
2427 spltlittbl->_raw_size))
2428 return FALSE;
2429 /* Clear SEC_HAS_CONTENTS so the contents won't be output again. */
2430 spltlittbl->flags &= ~SEC_HAS_CONTENTS;
2431 }
2432
2433 /* Combine adjacent literal table entries. */
2434 BFD_ASSERT (! info->relocatable);
2435 sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit");
2436 sgotloc = bfd_get_section_by_name (dynobj, ".got.loc");
2437 BFD_ASSERT (sxtlit && sgotloc);
2438 num_xtlit_entries =
2439 elf_xtensa_combine_prop_entries (output_bfd, sxtlit, sgotloc);
2440 if (num_xtlit_entries < 0)
2441 return FALSE;
2442
2443 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2444 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2445 for (; dyncon < dynconend; dyncon++)
2446 {
2447 Elf_Internal_Dyn dyn;
2448 const char *name;
2449 asection *s;
2450
2451 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2452
2453 switch (dyn.d_tag)
2454 {
2455 default:
2456 break;
2457
2458 case DT_XTENSA_GOT_LOC_SZ:
2459 dyn.d_un.d_val = num_xtlit_entries;
2460 break;
2461
2462 case DT_XTENSA_GOT_LOC_OFF:
2463 name = ".got.loc";
2464 goto get_vma;
2465 case DT_PLTGOT:
2466 name = ".got";
2467 goto get_vma;
2468 case DT_JMPREL:
2469 name = ".rela.plt";
2470 get_vma:
2471 s = bfd_get_section_by_name (output_bfd, name);
2472 BFD_ASSERT (s);
2473 dyn.d_un.d_ptr = s->vma;
2474 break;
2475
2476 case DT_PLTRELSZ:
2477 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2478 BFD_ASSERT (s);
2479 dyn.d_un.d_val = (s->_cooked_size ? s->_cooked_size : s->_raw_size);
2480 break;
2481
2482 case DT_RELASZ:
2483 /* Adjust RELASZ to not include JMPREL. This matches what
2484 glibc expects and what is done for several other ELF
2485 targets (e.g., i386, alpha), but the "correct" behavior
2486 seems to be unresolved. Since the linker script arranges
2487 for .rela.plt to follow all other relocation sections, we
2488 don't have to worry about changing the DT_RELA entry. */
2489 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2490 if (s)
2491 {
2492 dyn.d_un.d_val -=
2493 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
2494 }
2495 break;
2496 }
2497
2498 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2499 }
2500
2501 return TRUE;
2502 }
2503
2504
2505 /* Functions for dealing with the e_flags field. */
2506
2507 /* Merge backend specific data from an object file to the output
2508 object file when linking. */
2509
2510 static bfd_boolean
elf_xtensa_merge_private_bfd_data(ibfd,obfd)2511 elf_xtensa_merge_private_bfd_data (ibfd, obfd)
2512 bfd *ibfd;
2513 bfd *obfd;
2514 {
2515 unsigned out_mach, in_mach;
2516 flagword out_flag, in_flag;
2517
2518 /* Check if we have the same endianess. */
2519 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
2520 return FALSE;
2521
2522 /* Don't even pretend to support mixed-format linking. */
2523 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2524 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2525 return FALSE;
2526
2527 out_flag = elf_elfheader (obfd)->e_flags;
2528 in_flag = elf_elfheader (ibfd)->e_flags;
2529
2530 out_mach = out_flag & EF_XTENSA_MACH;
2531 in_mach = in_flag & EF_XTENSA_MACH;
2532 if (out_mach != in_mach)
2533 {
2534 (*_bfd_error_handler)
2535 ("%s: incompatible machine type. Output is 0x%x. Input is 0x%x",
2536 bfd_archive_filename (ibfd), out_mach, in_mach);
2537 bfd_set_error (bfd_error_wrong_format);
2538 return FALSE;
2539 }
2540
2541 if (! elf_flags_init (obfd))
2542 {
2543 elf_flags_init (obfd) = TRUE;
2544 elf_elfheader (obfd)->e_flags = in_flag;
2545
2546 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2547 && bfd_get_arch_info (obfd)->the_default)
2548 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2549 bfd_get_mach (ibfd));
2550
2551 return TRUE;
2552 }
2553
2554 if ((out_flag & EF_XTENSA_XT_INSN) !=
2555 (in_flag & EF_XTENSA_XT_INSN))
2556 elf_elfheader(obfd)->e_flags &= (~ EF_XTENSA_XT_INSN);
2557
2558 if ((out_flag & EF_XTENSA_XT_LIT) !=
2559 (in_flag & EF_XTENSA_XT_LIT))
2560 elf_elfheader(obfd)->e_flags &= (~ EF_XTENSA_XT_LIT);
2561
2562 return TRUE;
2563 }
2564
2565
2566 static bfd_boolean
elf_xtensa_set_private_flags(abfd,flags)2567 elf_xtensa_set_private_flags (abfd, flags)
2568 bfd *abfd;
2569 flagword flags;
2570 {
2571 BFD_ASSERT (!elf_flags_init (abfd)
2572 || elf_elfheader (abfd)->e_flags == flags);
2573
2574 elf_elfheader (abfd)->e_flags |= flags;
2575 elf_flags_init (abfd) = TRUE;
2576
2577 return TRUE;
2578 }
2579
2580
2581 extern flagword
2582 elf_xtensa_get_private_bfd_flags (abfd)
2583 bfd *abfd;
2584 {
2585 return elf_elfheader (abfd)->e_flags;
2586 }
2587
2588
2589 static bfd_boolean
elf_xtensa_print_private_bfd_data(abfd,farg)2590 elf_xtensa_print_private_bfd_data (abfd, farg)
2591 bfd *abfd;
2592 PTR farg;
2593 {
2594 FILE *f = (FILE *) farg;
2595 flagword e_flags = elf_elfheader (abfd)->e_flags;
2596
2597 fprintf (f, "\nXtensa header:\n");
2598 if ((e_flags & EF_XTENSA_MACH) == E_XTENSA_MACH)
2599 fprintf (f, "\nMachine = Base\n");
2600 else
2601 fprintf (f, "\nMachine Id = 0x%x\n", e_flags & EF_XTENSA_MACH);
2602
2603 fprintf (f, "Insn tables = %s\n",
2604 (e_flags & EF_XTENSA_XT_INSN) ? "true" : "false");
2605
2606 fprintf (f, "Literal tables = %s\n",
2607 (e_flags & EF_XTENSA_XT_LIT) ? "true" : "false");
2608
2609 return _bfd_elf_print_private_bfd_data (abfd, farg);
2610 }
2611
2612
2613 /* Set the right machine number for an Xtensa ELF file. */
2614
2615 static bfd_boolean
elf_xtensa_object_p(abfd)2616 elf_xtensa_object_p (abfd)
2617 bfd *abfd;
2618 {
2619 int mach;
2620 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH;
2621
2622 switch (arch)
2623 {
2624 case E_XTENSA_MACH:
2625 mach = bfd_mach_xtensa;
2626 break;
2627 default:
2628 return FALSE;
2629 }
2630
2631 (void) bfd_default_set_arch_mach (abfd, bfd_arch_xtensa, mach);
2632 return TRUE;
2633 }
2634
2635
2636 /* The final processing done just before writing out an Xtensa ELF object
2637 file. This gets the Xtensa architecture right based on the machine
2638 number. */
2639
2640 static void
elf_xtensa_final_write_processing(abfd,linker)2641 elf_xtensa_final_write_processing (abfd, linker)
2642 bfd *abfd;
2643 bfd_boolean linker ATTRIBUTE_UNUSED;
2644 {
2645 int mach;
2646 unsigned long val;
2647
2648 switch (mach = bfd_get_mach (abfd))
2649 {
2650 case bfd_mach_xtensa:
2651 val = E_XTENSA_MACH;
2652 break;
2653 default:
2654 return;
2655 }
2656
2657 elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH);
2658 elf_elfheader (abfd)->e_flags |= val;
2659 }
2660
2661
2662 static enum elf_reloc_type_class
elf_xtensa_reloc_type_class(rela)2663 elf_xtensa_reloc_type_class (rela)
2664 const Elf_Internal_Rela *rela;
2665 {
2666 switch ((int) ELF32_R_TYPE (rela->r_info))
2667 {
2668 case R_XTENSA_RELATIVE:
2669 return reloc_class_relative;
2670 case R_XTENSA_JMP_SLOT:
2671 return reloc_class_plt;
2672 default:
2673 return reloc_class_normal;
2674 }
2675 }
2676
2677
2678 static bfd_boolean
elf_xtensa_discard_info_for_section(abfd,cookie,info,sec)2679 elf_xtensa_discard_info_for_section (abfd, cookie, info, sec)
2680 bfd *abfd;
2681 struct elf_reloc_cookie *cookie;
2682 struct bfd_link_info *info;
2683 asection *sec;
2684 {
2685 bfd_byte *contents;
2686 bfd_vma section_size;
2687 bfd_vma offset, actual_offset;
2688 size_t removed_bytes = 0;
2689
2690 section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size);
2691 if (section_size == 0 || section_size % 8 != 0)
2692 return FALSE;
2693
2694 if (sec->output_section
2695 && bfd_is_abs_section (sec->output_section))
2696 return FALSE;
2697
2698 contents = retrieve_contents (abfd, sec, info->keep_memory);
2699 if (!contents)
2700 return FALSE;
2701
2702 cookie->rels = retrieve_internal_relocs (abfd, sec, info->keep_memory);
2703 if (!cookie->rels)
2704 {
2705 release_contents (sec, contents);
2706 return FALSE;
2707 }
2708
2709 cookie->rel = cookie->rels;
2710 cookie->relend = cookie->rels + sec->reloc_count;
2711
2712 for (offset = 0; offset < section_size; offset += 8)
2713 {
2714 actual_offset = offset - removed_bytes;
2715
2716 /* The ...symbol_deleted_p function will skip over relocs but it
2717 won't adjust their offsets, so do that here. */
2718 while (cookie->rel < cookie->relend
2719 && cookie->rel->r_offset < offset)
2720 {
2721 cookie->rel->r_offset -= removed_bytes;
2722 cookie->rel++;
2723 }
2724
2725 while (cookie->rel < cookie->relend
2726 && cookie->rel->r_offset == offset)
2727 {
2728 if (bfd_elf_reloc_symbol_deleted_p (offset, cookie))
2729 {
2730 /* Remove the table entry. (If the reloc type is NONE, then
2731 the entry has already been merged with another and deleted
2732 during relaxation.) */
2733 if (ELF32_R_TYPE (cookie->rel->r_info) != R_XTENSA_NONE)
2734 {
2735 /* Shift the contents up. */
2736 if (offset + 8 < section_size)
2737 memmove (&contents[actual_offset],
2738 &contents[actual_offset+8],
2739 section_size - offset - 8);
2740 removed_bytes += 8;
2741 }
2742
2743 /* Remove this relocation. */
2744 cookie->rel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
2745 }
2746
2747 /* Adjust the relocation offset for previous removals. This
2748 should not be done before calling ...symbol_deleted_p
2749 because it might mess up the offset comparisons there.
2750 Make sure the offset doesn't underflow in the case where
2751 the first entry is removed. */
2752 if (cookie->rel->r_offset >= removed_bytes)
2753 cookie->rel->r_offset -= removed_bytes;
2754 else
2755 cookie->rel->r_offset = 0;
2756
2757 cookie->rel++;
2758 }
2759 }
2760
2761 if (removed_bytes != 0)
2762 {
2763 /* Adjust any remaining relocs (shouldn't be any). */
2764 for (; cookie->rel < cookie->relend; cookie->rel++)
2765 {
2766 if (cookie->rel->r_offset >= removed_bytes)
2767 cookie->rel->r_offset -= removed_bytes;
2768 else
2769 cookie->rel->r_offset = 0;
2770 }
2771
2772 /* Clear the removed bytes. */
2773 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
2774
2775 pin_contents (sec, contents);
2776 pin_internal_relocs (sec, cookie->rels);
2777
2778 sec->_cooked_size = section_size - removed_bytes;
2779 /* Also shrink _raw_size. See comments in relax_property_section. */
2780 sec->_raw_size = sec->_cooked_size;
2781
2782 if (xtensa_is_littable_section (sec))
2783 {
2784 bfd *dynobj = elf_hash_table (info)->dynobj;
2785 if (dynobj)
2786 {
2787 asection *sgotloc =
2788 bfd_get_section_by_name (dynobj, ".got.loc");
2789 if (sgotloc)
2790 {
2791 bfd_size_type sgotloc_size =
2792 (sgotloc->_cooked_size ? sgotloc->_cooked_size
2793 : sgotloc->_raw_size);
2794 sgotloc->_cooked_size = sgotloc_size - removed_bytes;
2795 sgotloc->_raw_size = sgotloc_size - removed_bytes;
2796 }
2797 }
2798 }
2799 }
2800 else
2801 {
2802 release_contents (sec, contents);
2803 release_internal_relocs (sec, cookie->rels);
2804 }
2805
2806 return (removed_bytes != 0);
2807 }
2808
2809
2810 static bfd_boolean
elf_xtensa_discard_info(abfd,cookie,info)2811 elf_xtensa_discard_info (abfd, cookie, info)
2812 bfd *abfd;
2813 struct elf_reloc_cookie *cookie;
2814 struct bfd_link_info *info;
2815 {
2816 asection *sec;
2817 bfd_boolean changed = FALSE;
2818
2819 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2820 {
2821 if (xtensa_is_property_section (sec))
2822 {
2823 if (elf_xtensa_discard_info_for_section (abfd, cookie, info, sec))
2824 changed = TRUE;
2825 }
2826 }
2827
2828 return changed;
2829 }
2830
2831
2832 static bfd_boolean
elf_xtensa_ignore_discarded_relocs(sec)2833 elf_xtensa_ignore_discarded_relocs (sec)
2834 asection *sec;
2835 {
2836 return xtensa_is_property_section (sec);
2837 }
2838
2839
2840 /* Support for core dump NOTE sections. */
2841
2842 static bfd_boolean
elf_xtensa_grok_prstatus(abfd,note)2843 elf_xtensa_grok_prstatus (abfd, note)
2844 bfd *abfd;
2845 Elf_Internal_Note *note;
2846 {
2847 int offset;
2848 unsigned int raw_size;
2849
2850 /* The size for Xtensa is variable, so don't try to recognize the format
2851 based on the size. Just assume this is GNU/Linux. */
2852
2853 /* pr_cursig */
2854 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2855
2856 /* pr_pid */
2857 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
2858
2859 /* pr_reg */
2860 offset = 72;
2861 raw_size = note->descsz - offset - 4;
2862
2863 /* Make a ".reg/999" section. */
2864 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2865 raw_size, note->descpos + offset);
2866 }
2867
2868
2869 static bfd_boolean
elf_xtensa_grok_psinfo(abfd,note)2870 elf_xtensa_grok_psinfo (abfd, note)
2871 bfd *abfd;
2872 Elf_Internal_Note *note;
2873 {
2874 switch (note->descsz)
2875 {
2876 default:
2877 return FALSE;
2878
2879 case 128: /* GNU/Linux elf_prpsinfo */
2880 elf_tdata (abfd)->core_program
2881 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16);
2882 elf_tdata (abfd)->core_command
2883 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80);
2884 }
2885
2886 /* Note that for some reason, a spurious space is tacked
2887 onto the end of the args in some (at least one anyway)
2888 implementations, so strip it off if it exists. */
2889
2890 {
2891 char *command = elf_tdata (abfd)->core_command;
2892 int n = strlen (command);
2893
2894 if (0 < n && command[n - 1] == ' ')
2895 command[n - 1] = '\0';
2896 }
2897
2898 return TRUE;
2899 }
2900
2901
2902 /* Generic Xtensa configurability stuff. */
2903
2904 static xtensa_opcode callx0_op = XTENSA_UNDEFINED;
2905 static xtensa_opcode callx4_op = XTENSA_UNDEFINED;
2906 static xtensa_opcode callx8_op = XTENSA_UNDEFINED;
2907 static xtensa_opcode callx12_op = XTENSA_UNDEFINED;
2908 static xtensa_opcode call0_op = XTENSA_UNDEFINED;
2909 static xtensa_opcode call4_op = XTENSA_UNDEFINED;
2910 static xtensa_opcode call8_op = XTENSA_UNDEFINED;
2911 static xtensa_opcode call12_op = XTENSA_UNDEFINED;
2912
2913 static void
init_call_opcodes()2914 init_call_opcodes ()
2915 {
2916 if (callx0_op == XTENSA_UNDEFINED)
2917 {
2918 callx0_op = xtensa_opcode_lookup (xtensa_default_isa, "callx0");
2919 callx4_op = xtensa_opcode_lookup (xtensa_default_isa, "callx4");
2920 callx8_op = xtensa_opcode_lookup (xtensa_default_isa, "callx8");
2921 callx12_op = xtensa_opcode_lookup (xtensa_default_isa, "callx12");
2922 call0_op = xtensa_opcode_lookup (xtensa_default_isa, "call0");
2923 call4_op = xtensa_opcode_lookup (xtensa_default_isa, "call4");
2924 call8_op = xtensa_opcode_lookup (xtensa_default_isa, "call8");
2925 call12_op = xtensa_opcode_lookup (xtensa_default_isa, "call12");
2926 }
2927 }
2928
2929
2930 static bfd_boolean
is_indirect_call_opcode(opcode)2931 is_indirect_call_opcode (opcode)
2932 xtensa_opcode opcode;
2933 {
2934 init_call_opcodes ();
2935 return (opcode == callx0_op
2936 || opcode == callx4_op
2937 || opcode == callx8_op
2938 || opcode == callx12_op);
2939 }
2940
2941
2942 static bfd_boolean
is_direct_call_opcode(opcode)2943 is_direct_call_opcode (opcode)
2944 xtensa_opcode opcode;
2945 {
2946 init_call_opcodes ();
2947 return (opcode == call0_op
2948 || opcode == call4_op
2949 || opcode == call8_op
2950 || opcode == call12_op);
2951 }
2952
2953
2954 static bfd_boolean
is_windowed_call_opcode(opcode)2955 is_windowed_call_opcode (opcode)
2956 xtensa_opcode opcode;
2957 {
2958 init_call_opcodes ();
2959 return (opcode == call4_op
2960 || opcode == call8_op
2961 || opcode == call12_op
2962 || opcode == callx4_op
2963 || opcode == callx8_op
2964 || opcode == callx12_op);
2965 }
2966
2967
2968 static xtensa_opcode
get_l32r_opcode(void)2969 get_l32r_opcode (void)
2970 {
2971 static xtensa_opcode l32r_opcode = XTENSA_UNDEFINED;
2972 if (l32r_opcode == XTENSA_UNDEFINED)
2973 {
2974 l32r_opcode = xtensa_opcode_lookup (xtensa_default_isa, "l32r");
2975 BFD_ASSERT (l32r_opcode != XTENSA_UNDEFINED);
2976 }
2977 return l32r_opcode;
2978 }
2979
2980
2981 static bfd_vma
l32r_offset(addr,pc)2982 l32r_offset (addr, pc)
2983 bfd_vma addr;
2984 bfd_vma pc;
2985 {
2986 bfd_vma offset;
2987
2988 offset = addr - ((pc+3) & -4);
2989 BFD_ASSERT ((offset & ((1 << 2) - 1)) == 0);
2990 offset = (signed int) offset >> 2;
2991 BFD_ASSERT ((signed int) offset >> 16 == -1);
2992 return offset;
2993 }
2994
2995
2996 /* Get the operand number for a PC-relative relocation.
2997 If the relocation is not a PC-relative one, return (-1). */
2998
2999 static int
get_relocation_opnd(irel)3000 get_relocation_opnd (irel)
3001 Elf_Internal_Rela *irel;
3002 {
3003 if (ELF32_R_TYPE (irel->r_info) < R_XTENSA_OP0
3004 || ELF32_R_TYPE (irel->r_info) >= R_XTENSA_max)
3005 return -1;
3006 return ELF32_R_TYPE (irel->r_info) - R_XTENSA_OP0;
3007 }
3008
3009
3010 /* Get the opcode for a relocation. */
3011
3012 static xtensa_opcode
get_relocation_opcode(sec,contents,irel)3013 get_relocation_opcode (sec, contents, irel)
3014 asection *sec;
3015 bfd_byte *contents;
3016 Elf_Internal_Rela *irel;
3017 {
3018 static xtensa_insnbuf ibuff = NULL;
3019 xtensa_isa isa = xtensa_default_isa;
3020
3021 if (get_relocation_opnd (irel) == -1)
3022 return XTENSA_UNDEFINED;
3023
3024 if (contents == NULL)
3025 return XTENSA_UNDEFINED;
3026
3027 if (sec->_raw_size <= irel->r_offset)
3028 return XTENSA_UNDEFINED;
3029
3030 if (ibuff == NULL)
3031 ibuff = xtensa_insnbuf_alloc (isa);
3032
3033 /* Decode the instruction. */
3034 xtensa_insnbuf_from_chars (isa, ibuff, &contents[irel->r_offset]);
3035 return xtensa_decode_insn (isa, ibuff);
3036 }
3037
3038
3039 bfd_boolean
is_l32r_relocation(sec,contents,irel)3040 is_l32r_relocation (sec, contents, irel)
3041 asection *sec;
3042 bfd_byte *contents;
3043 Elf_Internal_Rela *irel;
3044 {
3045 xtensa_opcode opcode;
3046
3047 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_OP1)
3048 return FALSE;
3049
3050 opcode = get_relocation_opcode (sec, contents, irel);
3051 return (opcode == get_l32r_opcode ());
3052 }
3053
3054
3055 /* Code for transforming CALLs at link-time. */
3056
3057 static bfd_reloc_status_type
elf_xtensa_do_asm_simplify(contents,address,content_length)3058 elf_xtensa_do_asm_simplify (contents, address, content_length)
3059 bfd_byte *contents;
3060 bfd_vma address;
3061 bfd_vma content_length;
3062 {
3063 static xtensa_insnbuf insnbuf = NULL;
3064 xtensa_opcode opcode;
3065 xtensa_operand operand;
3066 xtensa_opcode direct_call_opcode;
3067 xtensa_isa isa = xtensa_default_isa;
3068 bfd_byte *chbuf = contents + address;
3069 int opn;
3070
3071 if (insnbuf == NULL)
3072 insnbuf = xtensa_insnbuf_alloc (isa);
3073
3074 if (content_length < address)
3075 {
3076 (*_bfd_error_handler)
3077 ("Attempt to convert L32R/CALLX to CALL failed");
3078 return bfd_reloc_other;
3079 }
3080
3081 opcode = get_expanded_call_opcode (chbuf, content_length - address);
3082 direct_call_opcode = swap_callx_for_call_opcode (opcode);
3083 if (direct_call_opcode == XTENSA_UNDEFINED)
3084 {
3085 (*_bfd_error_handler)
3086 ("Attempt to convert L32R/CALLX to CALL failed");
3087 return bfd_reloc_other;
3088 }
3089
3090 /* Assemble a NOP ("or a1, a1, a1") into the 0 byte offset. */
3091 opcode = xtensa_opcode_lookup (isa, "or");
3092 xtensa_encode_insn (isa, opcode, insnbuf);
3093 for (opn = 0; opn < 3; opn++)
3094 {
3095 operand = xtensa_get_operand (isa, opcode, opn);
3096 xtensa_operand_set_field (operand, insnbuf, 1);
3097 }
3098 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf);
3099
3100 /* Assemble a CALL ("callN 0") into the 3 byte offset. */
3101 xtensa_encode_insn (isa, direct_call_opcode, insnbuf);
3102 operand = xtensa_get_operand (isa, opcode, 0);
3103 xtensa_operand_set_field (operand, insnbuf, 0);
3104 xtensa_insnbuf_to_chars (isa, insnbuf, chbuf + 3);
3105
3106 return bfd_reloc_ok;
3107 }
3108
3109
3110 static bfd_reloc_status_type
contract_asm_expansion(contents,content_length,irel)3111 contract_asm_expansion (contents, content_length, irel)
3112 bfd_byte *contents;
3113 bfd_vma content_length;
3114 Elf_Internal_Rela *irel;
3115 {
3116 bfd_reloc_status_type retval =
3117 elf_xtensa_do_asm_simplify (contents, irel->r_offset, content_length);
3118
3119 if (retval != bfd_reloc_ok)
3120 return retval;
3121
3122 /* Update the irel->r_offset field so that the right immediate and
3123 the right instruction are modified during the relocation. */
3124 irel->r_offset += 3;
3125 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_XTENSA_OP0);
3126 return bfd_reloc_ok;
3127 }
3128
3129
3130 static xtensa_opcode
swap_callx_for_call_opcode(opcode)3131 swap_callx_for_call_opcode (opcode)
3132 xtensa_opcode opcode;
3133 {
3134 init_call_opcodes ();
3135
3136 if (opcode == callx0_op) return call0_op;
3137 if (opcode == callx4_op) return call4_op;
3138 if (opcode == callx8_op) return call8_op;
3139 if (opcode == callx12_op) return call12_op;
3140
3141 /* Return XTENSA_UNDEFINED if the opcode is not an indirect call. */
3142 return XTENSA_UNDEFINED;
3143 }
3144
3145
3146 /* Check if "buf" is pointing to a "L32R aN; CALLX aN" sequence, and
3147 if so, return the CALLX opcode. If not, return XTENSA_UNDEFINED. */
3148
3149 #define L32R_TARGET_REG_OPERAND 0
3150 #define CALLN_SOURCE_OPERAND 0
3151
3152 static xtensa_opcode
get_expanded_call_opcode(buf,bufsize)3153 get_expanded_call_opcode (buf, bufsize)
3154 bfd_byte *buf;
3155 int bufsize;
3156 {
3157 static xtensa_insnbuf insnbuf = NULL;
3158 xtensa_opcode opcode;
3159 xtensa_operand operand;
3160 xtensa_isa isa = xtensa_default_isa;
3161 uint32 regno, call_regno;
3162
3163 /* Buffer must be at least 6 bytes. */
3164 if (bufsize < 6)
3165 return XTENSA_UNDEFINED;
3166
3167 if (insnbuf == NULL)
3168 insnbuf = xtensa_insnbuf_alloc (isa);
3169
3170 xtensa_insnbuf_from_chars (isa, insnbuf, buf);
3171 opcode = xtensa_decode_insn (isa, insnbuf);
3172
3173 if (opcode != get_l32r_opcode ())
3174 return XTENSA_UNDEFINED;
3175
3176 operand = xtensa_get_operand (isa, opcode, L32R_TARGET_REG_OPERAND);
3177 regno = xtensa_operand_decode
3178 (operand, xtensa_operand_get_field (operand, insnbuf));
3179
3180 /* Next instruction should be an CALLXn with operand 0 == regno. */
3181 xtensa_insnbuf_from_chars (isa, insnbuf,
3182 buf + xtensa_insn_length (isa, opcode));
3183 opcode = xtensa_decode_insn (isa, insnbuf);
3184
3185 if (!is_indirect_call_opcode (opcode))
3186 return XTENSA_UNDEFINED;
3187
3188 operand = xtensa_get_operand (isa, opcode, CALLN_SOURCE_OPERAND);
3189 call_regno = xtensa_operand_decode
3190 (operand, xtensa_operand_get_field (operand, insnbuf));
3191 if (call_regno != regno)
3192 return XTENSA_UNDEFINED;
3193
3194 return opcode;
3195 }
3196
3197
3198 /* Data structures used during relaxation. */
3199
3200 /* r_reloc: relocation values. */
3201
3202 /* Through the relaxation process, we need to keep track of the values
3203 that will result from evaluating relocations. The standard ELF
3204 relocation structure is not sufficient for this purpose because we're
3205 operating on multiple input files at once, so we need to know which
3206 input file a relocation refers to. The r_reloc structure thus
3207 records both the input file (bfd) and ELF relocation.
3208
3209 For efficiency, an r_reloc also contains a "target_offset" field to
3210 cache the target-section-relative offset value that is represented by
3211 the relocation. */
3212
3213 typedef struct r_reloc_struct r_reloc;
3214
3215 struct r_reloc_struct
3216 {
3217 bfd *abfd;
3218 Elf_Internal_Rela rela;
3219 bfd_vma target_offset;
3220 };
3221
3222 static bfd_boolean r_reloc_is_const
3223 PARAMS ((const r_reloc *));
3224 static void r_reloc_init
3225 PARAMS ((r_reloc *, bfd *, Elf_Internal_Rela *));
3226 static bfd_vma r_reloc_get_target_offset
3227 PARAMS ((const r_reloc *));
3228 static asection *r_reloc_get_section
3229 PARAMS ((const r_reloc *));
3230 static bfd_boolean r_reloc_is_defined
3231 PARAMS ((const r_reloc *));
3232 static struct elf_link_hash_entry *r_reloc_get_hash_entry
3233 PARAMS ((const r_reloc *));
3234
3235
3236 /* The r_reloc structure is included by value in literal_value, but not
3237 every literal_value has an associated relocation -- some are simple
3238 constants. In such cases, we set all the fields in the r_reloc
3239 struct to zero. The r_reloc_is_const function should be used to
3240 detect this case. */
3241
3242 static bfd_boolean
r_reloc_is_const(r_rel)3243 r_reloc_is_const (r_rel)
3244 const r_reloc *r_rel;
3245 {
3246 return (r_rel->abfd == NULL);
3247 }
3248
3249
3250 static void
r_reloc_init(r_rel,abfd,irel)3251 r_reloc_init (r_rel, abfd, irel)
3252 r_reloc *r_rel;
3253 bfd *abfd;
3254 Elf_Internal_Rela *irel;
3255 {
3256 if (irel != NULL)
3257 {
3258 r_rel->rela = *irel;
3259 r_rel->abfd = abfd;
3260 r_rel->target_offset = r_reloc_get_target_offset (r_rel);
3261 }
3262 else
3263 memset (r_rel, 0, sizeof (r_reloc));
3264 }
3265
3266
3267 static bfd_vma
r_reloc_get_target_offset(r_rel)3268 r_reloc_get_target_offset (r_rel)
3269 const r_reloc *r_rel;
3270 {
3271 bfd_vma target_offset;
3272 unsigned long r_symndx;
3273
3274 BFD_ASSERT (!r_reloc_is_const (r_rel));
3275 r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3276 target_offset = get_elf_r_symndx_offset (r_rel->abfd, r_symndx);
3277 return (target_offset + r_rel->rela.r_addend);
3278 }
3279
3280
3281 static struct elf_link_hash_entry *
r_reloc_get_hash_entry(r_rel)3282 r_reloc_get_hash_entry (r_rel)
3283 const r_reloc *r_rel;
3284 {
3285 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3286 return get_elf_r_symndx_hash_entry (r_rel->abfd, r_symndx);
3287 }
3288
3289
3290 static asection *
r_reloc_get_section(r_rel)3291 r_reloc_get_section (r_rel)
3292 const r_reloc *r_rel;
3293 {
3294 unsigned long r_symndx = ELF32_R_SYM (r_rel->rela.r_info);
3295 return get_elf_r_symndx_section (r_rel->abfd, r_symndx);
3296 }
3297
3298
3299 static bfd_boolean
r_reloc_is_defined(r_rel)3300 r_reloc_is_defined (r_rel)
3301 const r_reloc *r_rel;
3302 {
3303 asection *sec = r_reloc_get_section (r_rel);
3304 if (sec == bfd_abs_section_ptr
3305 || sec == bfd_com_section_ptr
3306 || sec == bfd_und_section_ptr)
3307 return FALSE;
3308 return TRUE;
3309 }
3310
3311
3312 /* source_reloc: relocations that reference literal sections. */
3313
3314 /* To determine whether literals can be coalesced, we need to first
3315 record all the relocations that reference the literals. The
3316 source_reloc structure below is used for this purpose. The
3317 source_reloc entries are kept in a per-literal-section array, sorted
3318 by offset within the literal section (i.e., target offset).
3319
3320 The source_sec and r_rel.rela.r_offset fields identify the source of
3321 the relocation. The r_rel field records the relocation value, i.e.,
3322 the offset of the literal being referenced. The opnd field is needed
3323 to determine the range of the immediate field to which the relocation
3324 applies, so we can determine whether another literal with the same
3325 value is within range. The is_null field is true when the relocation
3326 is being removed (e.g., when an L32R is being removed due to a CALLX
3327 that is converted to a direct CALL). */
3328
3329 typedef struct source_reloc_struct source_reloc;
3330
3331 struct source_reloc_struct
3332 {
3333 asection *source_sec;
3334 r_reloc r_rel;
3335 xtensa_operand opnd;
3336 bfd_boolean is_null;
3337 };
3338
3339
3340 static void init_source_reloc
3341 PARAMS ((source_reloc *, asection *, const r_reloc *, xtensa_operand));
3342 static source_reloc *find_source_reloc
3343 PARAMS ((source_reloc *, int, asection *, Elf_Internal_Rela *));
3344 static int source_reloc_compare
3345 PARAMS ((const PTR, const PTR));
3346
3347
3348 static void
init_source_reloc(reloc,source_sec,r_rel,opnd)3349 init_source_reloc (reloc, source_sec, r_rel, opnd)
3350 source_reloc *reloc;
3351 asection *source_sec;
3352 const r_reloc *r_rel;
3353 xtensa_operand opnd;
3354 {
3355 reloc->source_sec = source_sec;
3356 reloc->r_rel = *r_rel;
3357 reloc->opnd = opnd;
3358 reloc->is_null = FALSE;
3359 }
3360
3361
3362 /* Find the source_reloc for a particular source offset and relocation
3363 type. Note that the array is sorted by _target_ offset, so this is
3364 just a linear search. */
3365
3366 static source_reloc *
find_source_reloc(src_relocs,src_count,sec,irel)3367 find_source_reloc (src_relocs, src_count, sec, irel)
3368 source_reloc *src_relocs;
3369 int src_count;
3370 asection *sec;
3371 Elf_Internal_Rela *irel;
3372 {
3373 int i;
3374
3375 for (i = 0; i < src_count; i++)
3376 {
3377 if (src_relocs[i].source_sec == sec
3378 && src_relocs[i].r_rel.rela.r_offset == irel->r_offset
3379 && (ELF32_R_TYPE (src_relocs[i].r_rel.rela.r_info)
3380 == ELF32_R_TYPE (irel->r_info)))
3381 return &src_relocs[i];
3382 }
3383
3384 return NULL;
3385 }
3386
3387
3388 static int
source_reloc_compare(ap,bp)3389 source_reloc_compare (ap, bp)
3390 const PTR ap;
3391 const PTR bp;
3392 {
3393 const source_reloc *a = (const source_reloc *) ap;
3394 const source_reloc *b = (const source_reloc *) bp;
3395
3396 return (a->r_rel.target_offset - b->r_rel.target_offset);
3397 }
3398
3399
3400 /* Literal values and value hash tables. */
3401
3402 /* Literals with the same value can be coalesced. The literal_value
3403 structure records the value of a literal: the "r_rel" field holds the
3404 information from the relocation on the literal (if there is one) and
3405 the "value" field holds the contents of the literal word itself.
3406
3407 The value_map structure records a literal value along with the
3408 location of a literal holding that value. The value_map hash table
3409 is indexed by the literal value, so that we can quickly check if a
3410 particular literal value has been seen before and is thus a candidate
3411 for coalescing. */
3412
3413 typedef struct literal_value_struct literal_value;
3414 typedef struct value_map_struct value_map;
3415 typedef struct value_map_hash_table_struct value_map_hash_table;
3416
3417 struct literal_value_struct
3418 {
3419 r_reloc r_rel;
3420 unsigned long value;
3421 };
3422
3423 struct value_map_struct
3424 {
3425 literal_value val; /* The literal value. */
3426 r_reloc loc; /* Location of the literal. */
3427 value_map *next;
3428 };
3429
3430 struct value_map_hash_table_struct
3431 {
3432 unsigned bucket_count;
3433 value_map **buckets;
3434 unsigned count;
3435 };
3436
3437
3438 static bfd_boolean is_same_value
3439 PARAMS ((const literal_value *, const literal_value *, bfd_boolean));
3440 static value_map_hash_table *value_map_hash_table_init
3441 PARAMS ((void));
3442 static unsigned hash_literal_value
3443 PARAMS ((const literal_value *));
3444 static unsigned hash_bfd_vma
3445 PARAMS ((bfd_vma));
3446 static value_map *get_cached_value
3447 PARAMS ((value_map_hash_table *, const literal_value *, bfd_boolean));
3448 static value_map *add_value_map
3449 PARAMS ((value_map_hash_table *, const literal_value *, const r_reloc *,
3450 bfd_boolean));
3451
3452
3453 static bfd_boolean
is_same_value(src1,src2,final_static_link)3454 is_same_value (src1, src2, final_static_link)
3455 const literal_value *src1;
3456 const literal_value *src2;
3457 bfd_boolean final_static_link;
3458 {
3459 struct elf_link_hash_entry *h1, *h2;
3460
3461 if (r_reloc_is_const (&src1->r_rel) != r_reloc_is_const (&src2->r_rel))
3462 return FALSE;
3463
3464 if (r_reloc_is_const (&src1->r_rel))
3465 return (src1->value == src2->value);
3466
3467 if (ELF32_R_TYPE (src1->r_rel.rela.r_info)
3468 != ELF32_R_TYPE (src2->r_rel.rela.r_info))
3469 return FALSE;
3470
3471 if (r_reloc_get_target_offset (&src1->r_rel)
3472 != r_reloc_get_target_offset (&src2->r_rel))
3473 return FALSE;
3474
3475 if (src1->value != src2->value)
3476 return FALSE;
3477
3478 /* Now check for the same section (if defined) or the same elf_hash
3479 (if undefined or weak). */
3480 h1 = r_reloc_get_hash_entry (&src1->r_rel);
3481 h2 = r_reloc_get_hash_entry (&src2->r_rel);
3482 if (r_reloc_is_defined (&src1->r_rel)
3483 && (final_static_link
3484 || ((!h1 || h1->root.type != bfd_link_hash_defweak)
3485 && (!h2 || h2->root.type != bfd_link_hash_defweak))))
3486 {
3487 if (r_reloc_get_section (&src1->r_rel)
3488 != r_reloc_get_section (&src2->r_rel))
3489 return FALSE;
3490 }
3491 else
3492 {
3493 /* Require that the hash entries (i.e., symbols) be identical. */
3494 if (h1 != h2 || h1 == 0)
3495 return FALSE;
3496 }
3497
3498 return TRUE;
3499 }
3500
3501
3502 /* Must be power of 2. */
3503 #define INITIAL_HASH_RELOC_BUCKET_COUNT 1024
3504
3505 static value_map_hash_table *
value_map_hash_table_init()3506 value_map_hash_table_init ()
3507 {
3508 value_map_hash_table *values;
3509
3510 values = (value_map_hash_table *)
3511 bfd_malloc (sizeof (value_map_hash_table));
3512
3513 values->bucket_count = INITIAL_HASH_RELOC_BUCKET_COUNT;
3514 values->count = 0;
3515 values->buckets = (value_map **)
3516 bfd_zmalloc (sizeof (value_map *) * values->bucket_count);
3517
3518 return values;
3519 }
3520
3521
3522 static unsigned
hash_bfd_vma(val)3523 hash_bfd_vma (val)
3524 bfd_vma val;
3525 {
3526 return (val >> 2) + (val >> 10);
3527 }
3528
3529
3530 static unsigned
hash_literal_value(src)3531 hash_literal_value (src)
3532 const literal_value *src;
3533 {
3534 unsigned hash_val;
3535
3536 if (r_reloc_is_const (&src->r_rel))
3537 return hash_bfd_vma (src->value);
3538
3539 hash_val = (hash_bfd_vma (r_reloc_get_target_offset (&src->r_rel))
3540 + hash_bfd_vma (src->value));
3541
3542 /* Now check for the same section and the same elf_hash. */
3543 if (r_reloc_is_defined (&src->r_rel))
3544 hash_val += hash_bfd_vma ((bfd_vma) (unsigned) r_reloc_get_section (&src->r_rel));
3545 else
3546 hash_val += hash_bfd_vma ((bfd_vma) (unsigned) r_reloc_get_hash_entry (&src->r_rel));
3547
3548 return hash_val;
3549 }
3550
3551
3552 /* Check if the specified literal_value has been seen before. */
3553
3554 static value_map *
get_cached_value(map,val,final_static_link)3555 get_cached_value (map, val, final_static_link)
3556 value_map_hash_table *map;
3557 const literal_value *val;
3558 bfd_boolean final_static_link;
3559 {
3560 value_map *map_e;
3561 value_map *bucket;
3562 unsigned idx;
3563
3564 idx = hash_literal_value (val);
3565 idx = idx & (map->bucket_count - 1);
3566 bucket = map->buckets[idx];
3567 for (map_e = bucket; map_e; map_e = map_e->next)
3568 {
3569 if (is_same_value (&map_e->val, val, final_static_link))
3570 return map_e;
3571 }
3572 return NULL;
3573 }
3574
3575
3576 /* Record a new literal value. It is illegal to call this if VALUE
3577 already has an entry here. */
3578
3579 static value_map *
add_value_map(map,val,loc,final_static_link)3580 add_value_map (map, val, loc, final_static_link)
3581 value_map_hash_table *map;
3582 const literal_value *val;
3583 const r_reloc *loc;
3584 bfd_boolean final_static_link;
3585 {
3586 value_map **bucket_p;
3587 unsigned idx;
3588
3589 value_map *val_e = (value_map *) bfd_zmalloc (sizeof (value_map));
3590
3591 BFD_ASSERT (get_cached_value (map, val, final_static_link) == NULL);
3592 val_e->val = *val;
3593 val_e->loc = *loc;
3594
3595 idx = hash_literal_value (val);
3596 idx = idx & (map->bucket_count - 1);
3597 bucket_p = &map->buckets[idx];
3598
3599 val_e->next = *bucket_p;
3600 *bucket_p = val_e;
3601 map->count++;
3602 /* FIXME: consider resizing the hash table if we get too many entries */
3603
3604 return val_e;
3605 }
3606
3607
3608 /* Lists of literals being coalesced or removed. */
3609
3610 /* In the usual case, the literal identified by "from" is being
3611 coalesced with another literal identified by "to". If the literal is
3612 unused and is being removed altogether, "to.abfd" will be NULL.
3613 The removed_literal entries are kept on a per-section list, sorted
3614 by the "from" offset field. */
3615
3616 typedef struct removed_literal_struct removed_literal;
3617 typedef struct removed_literal_list_struct removed_literal_list;
3618
3619 struct removed_literal_struct
3620 {
3621 r_reloc from;
3622 r_reloc to;
3623 removed_literal *next;
3624 };
3625
3626 struct removed_literal_list_struct
3627 {
3628 removed_literal *head;
3629 removed_literal *tail;
3630 };
3631
3632
3633 static void add_removed_literal
3634 PARAMS ((removed_literal_list *, const r_reloc *, const r_reloc *));
3635 static removed_literal *find_removed_literal
3636 PARAMS ((removed_literal_list *, bfd_vma));
3637 static bfd_vma offset_with_removed_literals
3638 PARAMS ((removed_literal_list *, bfd_vma));
3639
3640
3641 /* Record that the literal at "from" is being removed. If "to" is not
3642 NULL, the "from" literal is being coalesced with the "to" literal. */
3643
3644 static void
add_removed_literal(removed_list,from,to)3645 add_removed_literal (removed_list, from, to)
3646 removed_literal_list *removed_list;
3647 const r_reloc *from;
3648 const r_reloc *to;
3649 {
3650 removed_literal *r, *new_r, *next_r;
3651
3652 new_r = (removed_literal *) bfd_zmalloc (sizeof (removed_literal));
3653
3654 new_r->from = *from;
3655 if (to)
3656 new_r->to = *to;
3657 else
3658 new_r->to.abfd = NULL;
3659 new_r->next = NULL;
3660
3661 r = removed_list->head;
3662 if (r == NULL)
3663 {
3664 removed_list->head = new_r;
3665 removed_list->tail = new_r;
3666 }
3667 /* Special check for common case of append. */
3668 else if (removed_list->tail->from.target_offset < from->target_offset)
3669 {
3670 removed_list->tail->next = new_r;
3671 removed_list->tail = new_r;
3672 }
3673 else
3674 {
3675 while (r->from.target_offset < from->target_offset
3676 && r->next != NULL)
3677 {
3678 r = r->next;
3679 }
3680 next_r = r->next;
3681 r->next = new_r;
3682 new_r->next = next_r;
3683 if (next_r == NULL)
3684 removed_list->tail = new_r;
3685 }
3686 }
3687
3688
3689 /* Check if the list of removed literals contains an entry for the
3690 given address. Return the entry if found. */
3691
3692 static removed_literal *
find_removed_literal(removed_list,addr)3693 find_removed_literal (removed_list, addr)
3694 removed_literal_list *removed_list;
3695 bfd_vma addr;
3696 {
3697 removed_literal *r = removed_list->head;
3698 while (r && r->from.target_offset < addr)
3699 r = r->next;
3700 if (r && r->from.target_offset == addr)
3701 return r;
3702 return NULL;
3703 }
3704
3705
3706 /* Adjust an offset in a section to compensate for literals that are
3707 being removed. Search the list of removed literals and subtract
3708 4 bytes for every removed literal prior to the given address. */
3709
3710 static bfd_vma
offset_with_removed_literals(removed_list,addr)3711 offset_with_removed_literals (removed_list, addr)
3712 removed_literal_list *removed_list;
3713 bfd_vma addr;
3714 {
3715 removed_literal *r = removed_list->head;
3716 unsigned num_bytes = 0;
3717
3718 if (r == NULL)
3719 return addr;
3720
3721 while (r && r->from.target_offset <= addr)
3722 {
3723 num_bytes += 4;
3724 r = r->next;
3725 }
3726 if (num_bytes > addr)
3727 return 0;
3728 return (addr - num_bytes);
3729 }
3730
3731
3732 /* Coalescing literals may require a relocation to refer to a section in
3733 a different input file, but the standard relocation information
3734 cannot express that. Instead, the reloc_bfd_fix structures are used
3735 to "fix" the relocations that refer to sections in other input files.
3736 These structures are kept on per-section lists. The "src_type" field
3737 records the relocation type in case there are multiple relocations on
3738 the same location. FIXME: This is ugly; an alternative might be to
3739 add new symbols with the "owner" field to some other input file. */
3740
3741 typedef struct reloc_bfd_fix_struct reloc_bfd_fix;
3742
3743 struct reloc_bfd_fix_struct
3744 {
3745 asection *src_sec;
3746 bfd_vma src_offset;
3747 unsigned src_type; /* Relocation type. */
3748
3749 bfd *target_abfd;
3750 asection *target_sec;
3751 bfd_vma target_offset;
3752
3753 reloc_bfd_fix *next;
3754 };
3755
3756
3757 static reloc_bfd_fix *reloc_bfd_fix_init
3758 PARAMS ((asection *, bfd_vma, unsigned, bfd *, asection *, bfd_vma));
3759 static reloc_bfd_fix *get_bfd_fix
3760 PARAMS ((reloc_bfd_fix *, asection *, bfd_vma, unsigned));
3761
3762
3763 static reloc_bfd_fix *
reloc_bfd_fix_init(src_sec,src_offset,src_type,target_abfd,target_sec,target_offset)3764 reloc_bfd_fix_init (src_sec, src_offset, src_type,
3765 target_abfd, target_sec, target_offset)
3766 asection *src_sec;
3767 bfd_vma src_offset;
3768 unsigned src_type;
3769 bfd *target_abfd;
3770 asection *target_sec;
3771 bfd_vma target_offset;
3772 {
3773 reloc_bfd_fix *fix;
3774
3775 fix = (reloc_bfd_fix *) bfd_malloc (sizeof (reloc_bfd_fix));
3776 fix->src_sec = src_sec;
3777 fix->src_offset = src_offset;
3778 fix->src_type = src_type;
3779 fix->target_abfd = target_abfd;
3780 fix->target_sec = target_sec;
3781 fix->target_offset = target_offset;
3782
3783 return fix;
3784 }
3785
3786
3787 static reloc_bfd_fix *
get_bfd_fix(fix_list,sec,offset,type)3788 get_bfd_fix (fix_list, sec, offset, type)
3789 reloc_bfd_fix *fix_list;
3790 asection *sec;
3791 bfd_vma offset;
3792 unsigned type;
3793 {
3794 reloc_bfd_fix *r;
3795
3796 for (r = fix_list; r != NULL; r = r->next)
3797 {
3798 if (r->src_sec == sec
3799 && r->src_offset == offset
3800 && r->src_type == type)
3801 return r;
3802 }
3803 return NULL;
3804 }
3805
3806
3807 /* Per-section data for relaxation. */
3808
3809 struct xtensa_relax_info_struct
3810 {
3811 bfd_boolean is_relaxable_literal_section;
3812 int visited; /* Number of times visited. */
3813
3814 source_reloc *src_relocs; /* Array[src_count]. */
3815 int src_count;
3816 int src_next; /* Next src_relocs entry to assign. */
3817
3818 removed_literal_list removed_list;
3819
3820 reloc_bfd_fix *fix_list;
3821 };
3822
3823 struct elf_xtensa_section_data
3824 {
3825 struct bfd_elf_section_data elf;
3826 xtensa_relax_info relax_info;
3827 };
3828
3829 static void init_xtensa_relax_info
3830 PARAMS ((asection *));
3831 static xtensa_relax_info *get_xtensa_relax_info
3832 PARAMS ((asection *));
3833 static void add_fix
3834 PARAMS ((asection *, reloc_bfd_fix *));
3835
3836
3837 static bfd_boolean
elf_xtensa_new_section_hook(abfd,sec)3838 elf_xtensa_new_section_hook (abfd, sec)
3839 bfd *abfd;
3840 asection *sec;
3841 {
3842 struct elf_xtensa_section_data *sdata;
3843 bfd_size_type amt = sizeof (*sdata);
3844
3845 sdata = (struct elf_xtensa_section_data *) bfd_zalloc (abfd, amt);
3846 if (sdata == NULL)
3847 return FALSE;
3848 sec->used_by_bfd = (PTR) sdata;
3849
3850 return _bfd_elf_new_section_hook (abfd, sec);
3851 }
3852
3853
3854 static void
init_xtensa_relax_info(sec)3855 init_xtensa_relax_info (sec)
3856 asection *sec;
3857 {
3858 xtensa_relax_info *relax_info = get_xtensa_relax_info (sec);
3859
3860 relax_info->is_relaxable_literal_section = FALSE;
3861 relax_info->visited = 0;
3862
3863 relax_info->src_relocs = NULL;
3864 relax_info->src_count = 0;
3865 relax_info->src_next = 0;
3866
3867 relax_info->removed_list.head = NULL;
3868 relax_info->removed_list.tail = NULL;
3869
3870 relax_info->fix_list = NULL;
3871 }
3872
3873
3874 static xtensa_relax_info *
get_xtensa_relax_info(sec)3875 get_xtensa_relax_info (sec)
3876 asection *sec;
3877 {
3878 struct elf_xtensa_section_data *section_data;
3879
3880 /* No info available if no section or if it is an output section. */
3881 if (!sec || sec == sec->output_section)
3882 return NULL;
3883
3884 section_data = (struct elf_xtensa_section_data *) elf_section_data (sec);
3885 return §ion_data->relax_info;
3886 }
3887
3888
3889 static void
add_fix(src_sec,fix)3890 add_fix (src_sec, fix)
3891 asection *src_sec;
3892 reloc_bfd_fix *fix;
3893 {
3894 xtensa_relax_info *relax_info;
3895
3896 relax_info = get_xtensa_relax_info (src_sec);
3897 fix->next = relax_info->fix_list;
3898 relax_info->fix_list = fix;
3899 }
3900
3901
3902 /* Access to internal relocations, section contents and symbols. */
3903
3904 /* During relaxation, we need to modify relocations, section contents,
3905 and symbol definitions, and we need to keep the original values from
3906 being reloaded from the input files, i.e., we need to "pin" the
3907 modified values in memory. We also want to continue to observe the
3908 setting of the "keep-memory" flag. The following functions wrap the
3909 standard BFD functions to take care of this for us. */
3910
3911 static Elf_Internal_Rela *
retrieve_internal_relocs(abfd,sec,keep_memory)3912 retrieve_internal_relocs (abfd, sec, keep_memory)
3913 bfd *abfd;
3914 asection *sec;
3915 bfd_boolean keep_memory;
3916 {
3917 Elf_Internal_Rela *internal_relocs;
3918
3919 if ((sec->flags & SEC_LINKER_CREATED) != 0)
3920 return NULL;
3921
3922 internal_relocs = elf_section_data (sec)->relocs;
3923 if (internal_relocs == NULL)
3924 internal_relocs = (_bfd_elf_link_read_relocs
3925 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
3926 keep_memory));
3927 return internal_relocs;
3928 }
3929
3930
3931 static void
pin_internal_relocs(sec,internal_relocs)3932 pin_internal_relocs (sec, internal_relocs)
3933 asection *sec;
3934 Elf_Internal_Rela *internal_relocs;
3935 {
3936 elf_section_data (sec)->relocs = internal_relocs;
3937 }
3938
3939
3940 static void
release_internal_relocs(sec,internal_relocs)3941 release_internal_relocs (sec, internal_relocs)
3942 asection *sec;
3943 Elf_Internal_Rela *internal_relocs;
3944 {
3945 if (internal_relocs
3946 && elf_section_data (sec)->relocs != internal_relocs)
3947 free (internal_relocs);
3948 }
3949
3950
3951 static bfd_byte *
retrieve_contents(abfd,sec,keep_memory)3952 retrieve_contents (abfd, sec, keep_memory)
3953 bfd *abfd;
3954 asection *sec;
3955 bfd_boolean keep_memory;
3956 {
3957 bfd_byte *contents;
3958
3959 contents = elf_section_data (sec)->this_hdr.contents;
3960
3961 if (contents == NULL && sec->_raw_size != 0)
3962 {
3963 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
3964 if (contents != NULL)
3965 {
3966 if (! bfd_get_section_contents (abfd, sec, contents,
3967 (file_ptr) 0, sec->_raw_size))
3968 {
3969 free (contents);
3970 return NULL;
3971 }
3972 if (keep_memory)
3973 elf_section_data (sec)->this_hdr.contents = contents;
3974 }
3975 }
3976 return contents;
3977 }
3978
3979
3980 static void
pin_contents(sec,contents)3981 pin_contents (sec, contents)
3982 asection *sec;
3983 bfd_byte *contents;
3984 {
3985 elf_section_data (sec)->this_hdr.contents = contents;
3986 }
3987
3988
3989 static void
release_contents(sec,contents)3990 release_contents (sec, contents)
3991 asection *sec;
3992 bfd_byte *contents;
3993 {
3994 if (contents &&
3995 elf_section_data (sec)->this_hdr.contents != contents)
3996 free (contents);
3997 }
3998
3999
4000 static Elf_Internal_Sym *
retrieve_local_syms(input_bfd)4001 retrieve_local_syms (input_bfd)
4002 bfd *input_bfd;
4003 {
4004 Elf_Internal_Shdr *symtab_hdr;
4005 Elf_Internal_Sym *isymbuf;
4006 size_t locsymcount;
4007
4008 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4009 locsymcount = symtab_hdr->sh_info;
4010
4011 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4012 if (isymbuf == NULL && locsymcount != 0)
4013 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
4014 NULL, NULL, NULL);
4015
4016 /* Save the symbols for this input file so they won't be read again. */
4017 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
4018 symtab_hdr->contents = (unsigned char *) isymbuf;
4019
4020 return isymbuf;
4021 }
4022
4023
4024 /* Code for link-time relaxation. */
4025
4026 /* Local helper functions. */
4027 static bfd_boolean analyze_relocations
4028 PARAMS ((struct bfd_link_info *));
4029 static bfd_boolean find_relaxable_sections
4030 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
4031 static bfd_boolean collect_source_relocs
4032 PARAMS ((bfd *, asection *, struct bfd_link_info *));
4033 static bfd_boolean is_resolvable_asm_expansion
4034 PARAMS ((bfd *, asection *, bfd_byte *, Elf_Internal_Rela *,
4035 struct bfd_link_info *, bfd_boolean *));
4036 static bfd_boolean remove_literals
4037 PARAMS ((bfd *, asection *, struct bfd_link_info *, value_map_hash_table *));
4038 static bfd_boolean relax_section
4039 PARAMS ((bfd *, asection *, struct bfd_link_info *));
4040 static bfd_boolean relax_property_section
4041 PARAMS ((bfd *, asection *, struct bfd_link_info *));
4042 static bfd_boolean relax_section_symbols
4043 PARAMS ((bfd *, asection *));
4044 static bfd_boolean relocations_reach
4045 PARAMS ((source_reloc *, int, const r_reloc *));
4046 static void translate_reloc
4047 PARAMS ((const r_reloc *, r_reloc *));
4048 static Elf_Internal_Rela *get_irel_at_offset
4049 PARAMS ((asection *, Elf_Internal_Rela *, bfd_vma));
4050 static Elf_Internal_Rela *find_associated_l32r_irel
4051 PARAMS ((asection *, bfd_byte *, Elf_Internal_Rela *,
4052 Elf_Internal_Rela *));
4053 static void shrink_dynamic_reloc_sections
4054 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *));
4055
4056
4057 static bfd_boolean
elf_xtensa_relax_section(abfd,sec,link_info,again)4058 elf_xtensa_relax_section (abfd, sec, link_info, again)
4059 bfd *abfd;
4060 asection *sec;
4061 struct bfd_link_info *link_info;
4062 bfd_boolean *again;
4063 {
4064 static value_map_hash_table *values = NULL;
4065 xtensa_relax_info *relax_info;
4066
4067 if (!values)
4068 {
4069 /* Do some overall initialization for relaxation. */
4070 values = value_map_hash_table_init ();
4071 relaxing_section = TRUE;
4072 if (!analyze_relocations (link_info))
4073 return FALSE;
4074 }
4075 *again = FALSE;
4076
4077 /* Don't mess with linker-created sections. */
4078 if ((sec->flags & SEC_LINKER_CREATED) != 0)
4079 return TRUE;
4080
4081 relax_info = get_xtensa_relax_info (sec);
4082 BFD_ASSERT (relax_info != NULL);
4083
4084 switch (relax_info->visited)
4085 {
4086 case 0:
4087 /* Note: It would be nice to fold this pass into
4088 analyze_relocations, but it is important for this step that the
4089 sections be examined in link order. */
4090 if (!remove_literals (abfd, sec, link_info, values))
4091 return FALSE;
4092 *again = TRUE;
4093 break;
4094
4095 case 1:
4096 if (!relax_section (abfd, sec, link_info))
4097 return FALSE;
4098 *again = TRUE;
4099 break;
4100
4101 case 2:
4102 if (!relax_section_symbols (abfd, sec))
4103 return FALSE;
4104 break;
4105 }
4106
4107 relax_info->visited++;
4108 return TRUE;
4109 }
4110
4111 /* Initialization for relaxation. */
4112
4113 /* This function is called once at the start of relaxation. It scans
4114 all the input sections and marks the ones that are relaxable (i.e.,
4115 literal sections with L32R relocations against them). It then
4116 collect source_reloc information for all the relocations against
4117 those relaxable sections. */
4118
4119 static bfd_boolean
analyze_relocations(link_info)4120 analyze_relocations (link_info)
4121 struct bfd_link_info *link_info;
4122 {
4123 bfd *abfd;
4124 asection *sec;
4125 bfd_boolean is_relaxable = FALSE;
4126
4127 /* Initialize the per-section relaxation info. */
4128 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4129 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4130 {
4131 init_xtensa_relax_info (sec);
4132 }
4133
4134 /* Mark relaxable sections (and count relocations against each one). */
4135 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4136 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4137 {
4138 if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable))
4139 return FALSE;
4140 }
4141
4142 /* Bail out if there are no relaxable sections. */
4143 if (!is_relaxable)
4144 return TRUE;
4145
4146 /* Allocate space for source_relocs. */
4147 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4148 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4149 {
4150 xtensa_relax_info *relax_info;
4151
4152 relax_info = get_xtensa_relax_info (sec);
4153 if (relax_info->is_relaxable_literal_section)
4154 {
4155 relax_info->src_relocs = (source_reloc *)
4156 bfd_malloc (relax_info->src_count * sizeof (source_reloc));
4157 }
4158 }
4159
4160 /* Collect info on relocations against each relaxable section. */
4161 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next)
4162 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4163 {
4164 if (!collect_source_relocs (abfd, sec, link_info))
4165 return FALSE;
4166 }
4167
4168 return TRUE;
4169 }
4170
4171
4172 /* Find all the literal sections that might be relaxed. The motivation
4173 for this pass is that collect_source_relocs() needs to record _all_
4174 the relocations that target each relaxable section. That is
4175 expensive and unnecessary unless the target section is actually going
4176 to be relaxed. This pass identifies all such sections by checking if
4177 they have L32Rs pointing to them. In the process, the total number
4178 of relocations targeting each section is also counted so that we
4179 know how much space to allocate for source_relocs against each
4180 relaxable literal section. */
4181
4182 static bfd_boolean
find_relaxable_sections(abfd,sec,link_info,is_relaxable_p)4183 find_relaxable_sections (abfd, sec, link_info, is_relaxable_p)
4184 bfd *abfd;
4185 asection *sec;
4186 struct bfd_link_info *link_info;
4187 bfd_boolean *is_relaxable_p;
4188 {
4189 Elf_Internal_Rela *internal_relocs;
4190 bfd_byte *contents;
4191 bfd_boolean ok = TRUE;
4192 unsigned i;
4193
4194 internal_relocs = retrieve_internal_relocs (abfd, sec,
4195 link_info->keep_memory);
4196 if (internal_relocs == NULL)
4197 return ok;
4198
4199 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4200 if (contents == NULL && sec->_raw_size != 0)
4201 {
4202 ok = FALSE;
4203 goto error_return;
4204 }
4205
4206 for (i = 0; i < sec->reloc_count; i++)
4207 {
4208 Elf_Internal_Rela *irel = &internal_relocs[i];
4209 r_reloc r_rel;
4210 asection *target_sec;
4211 xtensa_relax_info *target_relax_info;
4212
4213 r_reloc_init (&r_rel, abfd, irel);
4214
4215 target_sec = r_reloc_get_section (&r_rel);
4216 target_relax_info = get_xtensa_relax_info (target_sec);
4217 if (!target_relax_info)
4218 continue;
4219
4220 /* Count relocations against the target section. */
4221 target_relax_info->src_count++;
4222
4223 if (is_literal_section (target_sec)
4224 && is_l32r_relocation (sec, contents, irel)
4225 && r_reloc_is_defined (&r_rel))
4226 {
4227 /* Mark the target section as relaxable. */
4228 target_relax_info->is_relaxable_literal_section = TRUE;
4229 *is_relaxable_p = TRUE;
4230 }
4231 }
4232
4233 error_return:
4234 release_contents (sec, contents);
4235 release_internal_relocs (sec, internal_relocs);
4236 return ok;
4237 }
4238
4239
4240 /* Record _all_ the relocations that point to relaxable literal
4241 sections, and get rid of ASM_EXPAND relocs by either converting them
4242 to ASM_SIMPLIFY or by removing them. */
4243
4244 static bfd_boolean
collect_source_relocs(abfd,sec,link_info)4245 collect_source_relocs (abfd, sec, link_info)
4246 bfd *abfd;
4247 asection *sec;
4248 struct bfd_link_info *link_info;
4249 {
4250 Elf_Internal_Rela *internal_relocs;
4251 bfd_byte *contents;
4252 bfd_boolean ok = TRUE;
4253 unsigned i;
4254
4255 internal_relocs = retrieve_internal_relocs (abfd, sec,
4256 link_info->keep_memory);
4257 if (internal_relocs == NULL)
4258 return ok;
4259
4260 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4261 if (contents == NULL && sec->_raw_size != 0)
4262 {
4263 ok = FALSE;
4264 goto error_return;
4265 }
4266
4267 /* Record relocations against relaxable literal sections. */
4268 for (i = 0; i < sec->reloc_count; i++)
4269 {
4270 Elf_Internal_Rela *irel = &internal_relocs[i];
4271 r_reloc r_rel;
4272 asection *target_sec;
4273 xtensa_relax_info *target_relax_info;
4274
4275 r_reloc_init (&r_rel, abfd, irel);
4276
4277 target_sec = r_reloc_get_section (&r_rel);
4278 target_relax_info = get_xtensa_relax_info (target_sec);
4279
4280 if (target_relax_info
4281 && target_relax_info->is_relaxable_literal_section)
4282 {
4283 xtensa_opcode opcode;
4284 xtensa_operand opnd;
4285 source_reloc *s_reloc;
4286 int src_next;
4287
4288 src_next = target_relax_info->src_next++;
4289 s_reloc = &target_relax_info->src_relocs[src_next];
4290
4291 opcode = get_relocation_opcode (sec, contents, irel);
4292 if (opcode == XTENSA_UNDEFINED)
4293 opnd = NULL;
4294 else
4295 opnd = xtensa_get_operand (xtensa_default_isa, opcode,
4296 get_relocation_opnd (irel));
4297
4298 init_source_reloc (s_reloc, sec, &r_rel, opnd);
4299 }
4300 }
4301
4302 /* Now get rid of ASM_EXPAND relocations. At this point, the
4303 src_relocs array for the target literal section may still be
4304 incomplete, but it must at least contain the entries for the L32R
4305 relocations associated with ASM_EXPANDs because they were just
4306 added in the preceding loop over the relocations. */
4307
4308 for (i = 0; i < sec->reloc_count; i++)
4309 {
4310 Elf_Internal_Rela *irel = &internal_relocs[i];
4311 bfd_boolean is_reachable;
4312
4313 if (!is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
4314 &is_reachable))
4315 continue;
4316
4317 if (is_reachable)
4318 {
4319 Elf_Internal_Rela *l32r_irel;
4320 r_reloc r_rel;
4321 asection *target_sec;
4322 xtensa_relax_info *target_relax_info;
4323
4324 /* Mark the source_reloc for the L32R so that it will be
4325 removed in remove_literals(), along with the associated
4326 literal. */
4327 l32r_irel = find_associated_l32r_irel (sec, contents,
4328 irel, internal_relocs);
4329 if (l32r_irel == NULL)
4330 continue;
4331
4332 r_reloc_init (&r_rel, abfd, l32r_irel);
4333
4334 target_sec = r_reloc_get_section (&r_rel);
4335 target_relax_info = get_xtensa_relax_info (target_sec);
4336
4337 if (target_relax_info
4338 && target_relax_info->is_relaxable_literal_section)
4339 {
4340 source_reloc *s_reloc;
4341
4342 /* Search the source_relocs for the entry corresponding to
4343 the l32r_irel. Note: The src_relocs array is not yet
4344 sorted, but it wouldn't matter anyway because we're
4345 searching by source offset instead of target offset. */
4346 s_reloc = find_source_reloc (target_relax_info->src_relocs,
4347 target_relax_info->src_next,
4348 sec, l32r_irel);
4349 BFD_ASSERT (s_reloc);
4350 s_reloc->is_null = TRUE;
4351 }
4352
4353 /* Convert this reloc to ASM_SIMPLIFY. */
4354 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4355 R_XTENSA_ASM_SIMPLIFY);
4356 l32r_irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4357
4358 pin_internal_relocs (sec, internal_relocs);
4359 }
4360 else
4361 {
4362 /* It is resolvable but doesn't reach. We resolve now
4363 by eliminating the relocation -- the call will remain
4364 expanded into L32R/CALLX. */
4365 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4366 pin_internal_relocs (sec, internal_relocs);
4367 }
4368 }
4369
4370 error_return:
4371 release_contents (sec, contents);
4372 release_internal_relocs (sec, internal_relocs);
4373 return ok;
4374 }
4375
4376
4377 /* Return TRUE if the asm expansion can be resolved. Generally it can
4378 be resolved on a final link or when a partial link locates it in the
4379 same section as the target. Set "is_reachable" flag if the target of
4380 the call is within the range of a direct call, given the current VMA
4381 for this section and the target section. */
4382
4383 bfd_boolean
is_resolvable_asm_expansion(abfd,sec,contents,irel,link_info,is_reachable_p)4384 is_resolvable_asm_expansion (abfd, sec, contents, irel, link_info,
4385 is_reachable_p)
4386 bfd *abfd;
4387 asection *sec;
4388 bfd_byte *contents;
4389 Elf_Internal_Rela *irel;
4390 struct bfd_link_info *link_info;
4391 bfd_boolean *is_reachable_p;
4392 {
4393 asection *target_sec;
4394 bfd_vma target_offset;
4395 r_reloc r_rel;
4396 xtensa_opcode opcode, direct_call_opcode;
4397 bfd_vma self_address;
4398 bfd_vma dest_address;
4399
4400 *is_reachable_p = FALSE;
4401
4402 if (contents == NULL)
4403 return FALSE;
4404
4405 if (ELF32_R_TYPE (irel->r_info) != R_XTENSA_ASM_EXPAND)
4406 return FALSE;
4407
4408 opcode = get_expanded_call_opcode (contents + irel->r_offset,
4409 sec->_raw_size - irel->r_offset);
4410
4411 direct_call_opcode = swap_callx_for_call_opcode (opcode);
4412 if (direct_call_opcode == XTENSA_UNDEFINED)
4413 return FALSE;
4414
4415 /* Check and see that the target resolves. */
4416 r_reloc_init (&r_rel, abfd, irel);
4417 if (!r_reloc_is_defined (&r_rel))
4418 return FALSE;
4419
4420 target_sec = r_reloc_get_section (&r_rel);
4421 target_offset = r_reloc_get_target_offset (&r_rel);
4422
4423 /* If the target is in a shared library, then it doesn't reach. This
4424 isn't supposed to come up because the compiler should never generate
4425 non-PIC calls on systems that use shared libraries, but the linker
4426 shouldn't crash regardless. */
4427 if (!target_sec->output_section)
4428 return FALSE;
4429
4430 /* For relocatable sections, we can only simplify when the output
4431 section of the target is the same as the output section of the
4432 source. */
4433 if (link_info->relocatable
4434 && (target_sec->output_section != sec->output_section))
4435 return FALSE;
4436
4437 self_address = (sec->output_section->vma
4438 + sec->output_offset + irel->r_offset + 3);
4439 dest_address = (target_sec->output_section->vma
4440 + target_sec->output_offset + target_offset);
4441
4442 *is_reachable_p = pcrel_reloc_fits
4443 (xtensa_get_operand (xtensa_default_isa, direct_call_opcode, 0),
4444 self_address, dest_address);
4445
4446 if ((self_address >> CALL_SEGMENT_BITS) !=
4447 (dest_address >> CALL_SEGMENT_BITS))
4448 return FALSE;
4449
4450 return TRUE;
4451 }
4452
4453
4454 static Elf_Internal_Rela *
find_associated_l32r_irel(sec,contents,other_irel,internal_relocs)4455 find_associated_l32r_irel (sec, contents, other_irel, internal_relocs)
4456 asection *sec;
4457 bfd_byte *contents;
4458 Elf_Internal_Rela *other_irel;
4459 Elf_Internal_Rela *internal_relocs;
4460 {
4461 unsigned i;
4462
4463 for (i = 0; i < sec->reloc_count; i++)
4464 {
4465 Elf_Internal_Rela *irel = &internal_relocs[i];
4466
4467 if (irel == other_irel)
4468 continue;
4469 if (irel->r_offset != other_irel->r_offset)
4470 continue;
4471 if (is_l32r_relocation (sec, contents, irel))
4472 return irel;
4473 }
4474
4475 return NULL;
4476 }
4477
4478 /* First relaxation pass. */
4479
4480 /* If the section is relaxable (i.e., a literal section), check each
4481 literal to see if it has the same value as another literal that has
4482 already been seen, either in the current section or a previous one.
4483 If so, add an entry to the per-section list of removed literals. The
4484 actual changes are deferred until the next pass. */
4485
4486 static bfd_boolean
remove_literals(abfd,sec,link_info,values)4487 remove_literals (abfd, sec, link_info, values)
4488 bfd *abfd;
4489 asection *sec;
4490 struct bfd_link_info *link_info;
4491 value_map_hash_table *values;
4492 {
4493 xtensa_relax_info *relax_info;
4494 bfd_byte *contents;
4495 Elf_Internal_Rela *internal_relocs;
4496 source_reloc *src_relocs;
4497 bfd_boolean final_static_link;
4498 bfd_boolean ok = TRUE;
4499 int i;
4500
4501 /* Do nothing if it is not a relaxable literal section. */
4502 relax_info = get_xtensa_relax_info (sec);
4503 BFD_ASSERT (relax_info);
4504
4505 if (!relax_info->is_relaxable_literal_section)
4506 return ok;
4507
4508 internal_relocs = retrieve_internal_relocs (abfd, sec,
4509 link_info->keep_memory);
4510
4511 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4512 if (contents == NULL && sec->_raw_size != 0)
4513 {
4514 ok = FALSE;
4515 goto error_return;
4516 }
4517
4518 final_static_link =
4519 (!link_info->relocatable
4520 && !elf_hash_table (link_info)->dynamic_sections_created);
4521
4522 /* Sort the source_relocs by target offset. */
4523 src_relocs = relax_info->src_relocs;
4524 qsort (src_relocs, relax_info->src_count,
4525 sizeof (source_reloc), source_reloc_compare);
4526
4527 for (i = 0; i < relax_info->src_count; i++)
4528 {
4529 source_reloc *rel;
4530 Elf_Internal_Rela *irel = NULL;
4531 literal_value val;
4532 value_map *val_map;
4533
4534 rel = &src_relocs[i];
4535 irel = get_irel_at_offset (sec, internal_relocs,
4536 rel->r_rel.target_offset);
4537
4538 /* If the target_offset for this relocation is the same as the
4539 previous relocation, then we've already considered whether the
4540 literal can be coalesced. Skip to the next one.... */
4541 if (i != 0 && (src_relocs[i-1].r_rel.target_offset
4542 == rel->r_rel.target_offset))
4543 continue;
4544
4545 /* Check if the relocation was from an L32R that is being removed
4546 because a CALLX was converted to a direct CALL, and check if
4547 there are no other relocations to the literal. */
4548 if (rel->is_null
4549 && (i == relax_info->src_count - 1
4550 || (src_relocs[i+1].r_rel.target_offset
4551 != rel->r_rel.target_offset)))
4552 {
4553 /* Mark the unused literal so that it will be removed. */
4554 add_removed_literal (&relax_info->removed_list, &rel->r_rel, NULL);
4555
4556 /* Zero out the relocation on this literal location. */
4557 if (irel)
4558 {
4559 if (elf_hash_table (link_info)->dynamic_sections_created)
4560 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
4561
4562 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4563 }
4564
4565 continue;
4566 }
4567
4568 /* Find the literal value. */
4569 r_reloc_init (&val.r_rel, abfd, irel);
4570 BFD_ASSERT (rel->r_rel.target_offset < sec->_raw_size);
4571 val.value = bfd_get_32 (abfd, contents + rel->r_rel.target_offset);
4572
4573 /* Check if we've seen another literal with the same value. */
4574 val_map = get_cached_value (values, &val, final_static_link);
4575 if (val_map != NULL)
4576 {
4577 /* First check that THIS and all the other relocs to this
4578 literal will FIT if we move them to the new address. */
4579
4580 if (relocations_reach (rel, relax_info->src_count - i,
4581 &val_map->loc))
4582 {
4583 /* Mark that the literal will be coalesced. */
4584 add_removed_literal (&relax_info->removed_list,
4585 &rel->r_rel, &val_map->loc);
4586 }
4587 else
4588 {
4589 /* Relocations do not reach -- do not remove this literal. */
4590 val_map->loc = rel->r_rel;
4591 }
4592 }
4593 else
4594 {
4595 /* This is the first time we've seen this literal value. */
4596 BFD_ASSERT (sec == r_reloc_get_section (&rel->r_rel));
4597 add_value_map (values, &val, &rel->r_rel, final_static_link);
4598 }
4599 }
4600
4601 error_return:
4602 release_contents (sec, contents);
4603 release_internal_relocs (sec, internal_relocs);
4604 return ok;
4605 }
4606
4607
4608 /* Check if the original relocations (presumably on L32R instructions)
4609 identified by reloc[0..N] can be changed to reference the literal
4610 identified by r_rel. If r_rel is out of range for any of the
4611 original relocations, then we don't want to coalesce the original
4612 literal with the one at r_rel. We only check reloc[0..N], where the
4613 offsets are all the same as for reloc[0] (i.e., they're all
4614 referencing the same literal) and where N is also bounded by the
4615 number of remaining entries in the "reloc" array. The "reloc" array
4616 is sorted by target offset so we know all the entries for the same
4617 literal will be contiguous. */
4618
4619 static bfd_boolean
relocations_reach(reloc,remaining_relocs,r_rel)4620 relocations_reach (reloc, remaining_relocs, r_rel)
4621 source_reloc *reloc;
4622 int remaining_relocs;
4623 const r_reloc *r_rel;
4624 {
4625 bfd_vma from_offset, source_address, dest_address;
4626 asection *sec;
4627 int i;
4628
4629 if (!r_reloc_is_defined (r_rel))
4630 return FALSE;
4631
4632 sec = r_reloc_get_section (r_rel);
4633 from_offset = reloc[0].r_rel.target_offset;
4634
4635 for (i = 0; i < remaining_relocs; i++)
4636 {
4637 if (reloc[i].r_rel.target_offset != from_offset)
4638 break;
4639
4640 /* Ignore relocations that have been removed. */
4641 if (reloc[i].is_null)
4642 continue;
4643
4644 /* The original and new output section for these must be the same
4645 in order to coalesce. */
4646 if (r_reloc_get_section (&reloc[i].r_rel)->output_section
4647 != sec->output_section)
4648 return FALSE;
4649
4650 /* A NULL operand means it is not a PC-relative relocation, so
4651 the literal can be moved anywhere. */
4652 if (reloc[i].opnd)
4653 {
4654 /* Otherwise, check to see that it fits. */
4655 source_address = (reloc[i].source_sec->output_section->vma
4656 + reloc[i].source_sec->output_offset
4657 + reloc[i].r_rel.rela.r_offset);
4658 dest_address = (sec->output_section->vma
4659 + sec->output_offset
4660 + r_rel->target_offset);
4661
4662 if (!pcrel_reloc_fits (reloc[i].opnd, source_address, dest_address))
4663 return FALSE;
4664 }
4665 }
4666
4667 return TRUE;
4668 }
4669
4670
4671 /* WARNING: linear search here. If the relocation are in order by
4672 address, we can use a faster binary search. ALSO, we assume that
4673 there is only 1 non-NONE relocation per address. */
4674
4675 static Elf_Internal_Rela *
get_irel_at_offset(sec,internal_relocs,offset)4676 get_irel_at_offset (sec, internal_relocs, offset)
4677 asection *sec;
4678 Elf_Internal_Rela *internal_relocs;
4679 bfd_vma offset;
4680 {
4681 unsigned i;
4682 if (!internal_relocs)
4683 return NULL;
4684 for (i = 0; i < sec->reloc_count; i++)
4685 {
4686 Elf_Internal_Rela *irel = &internal_relocs[i];
4687 if (irel->r_offset == offset
4688 && ELF32_R_TYPE (irel->r_info) != R_XTENSA_NONE)
4689 return irel;
4690 }
4691 return NULL;
4692 }
4693
4694
4695 /* Second relaxation pass. */
4696
4697 /* Modify all of the relocations to point to the right spot, and if this
4698 is a relaxable section, delete the unwanted literals and fix the
4699 cooked_size. */
4700
4701 bfd_boolean
relax_section(abfd,sec,link_info)4702 relax_section (abfd, sec, link_info)
4703 bfd *abfd;
4704 asection *sec;
4705 struct bfd_link_info *link_info;
4706 {
4707 Elf_Internal_Rela *internal_relocs;
4708 xtensa_relax_info *relax_info;
4709 bfd_byte *contents;
4710 bfd_boolean ok = TRUE;
4711 unsigned i;
4712
4713 relax_info = get_xtensa_relax_info (sec);
4714 BFD_ASSERT (relax_info);
4715
4716 /* Handle property sections (e.g., literal tables) specially. */
4717 if (xtensa_is_property_section (sec))
4718 {
4719 BFD_ASSERT (!relax_info->is_relaxable_literal_section);
4720 return relax_property_section (abfd, sec, link_info);
4721 }
4722
4723 internal_relocs = retrieve_internal_relocs (abfd, sec,
4724 link_info->keep_memory);
4725 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
4726 if (contents == NULL && sec->_raw_size != 0)
4727 {
4728 ok = FALSE;
4729 goto error_return;
4730 }
4731
4732 if (internal_relocs)
4733 {
4734 for (i = 0; i < sec->reloc_count; i++)
4735 {
4736 Elf_Internal_Rela *irel;
4737 xtensa_relax_info *target_relax_info;
4738 bfd_vma source_offset;
4739 r_reloc r_rel;
4740 unsigned r_type;
4741 asection *target_sec;
4742
4743 /* Locally change the source address.
4744 Translate the target to the new target address.
4745 If it points to this section and has been removed,
4746 NULLify it.
4747 Write it back. */
4748
4749 irel = &internal_relocs[i];
4750 source_offset = irel->r_offset;
4751
4752 r_type = ELF32_R_TYPE (irel->r_info);
4753 r_reloc_init (&r_rel, abfd, irel);
4754
4755 if (relax_info->is_relaxable_literal_section)
4756 {
4757 if (r_type != R_XTENSA_NONE
4758 && find_removed_literal (&relax_info->removed_list,
4759 irel->r_offset))
4760 {
4761 /* Remove this relocation. */
4762 if (elf_hash_table (link_info)->dynamic_sections_created)
4763 shrink_dynamic_reloc_sections (link_info, abfd, sec, irel);
4764 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
4765 irel->r_offset = offset_with_removed_literals
4766 (&relax_info->removed_list, irel->r_offset);
4767 continue;
4768 }
4769 source_offset =
4770 offset_with_removed_literals (&relax_info->removed_list,
4771 irel->r_offset);
4772 irel->r_offset = source_offset;
4773 }
4774
4775 target_sec = r_reloc_get_section (&r_rel);
4776 target_relax_info = get_xtensa_relax_info (target_sec);
4777
4778 if (target_relax_info
4779 && target_relax_info->is_relaxable_literal_section)
4780 {
4781 r_reloc new_rel;
4782 reloc_bfd_fix *fix;
4783
4784 translate_reloc (&r_rel, &new_rel);
4785
4786 /* FIXME: If the relocation still references a section in
4787 the same input file, the relocation should be modified
4788 directly instead of adding a "fix" record. */
4789
4790 fix = reloc_bfd_fix_init (sec, source_offset, r_type, 0,
4791 r_reloc_get_section (&new_rel),
4792 new_rel.target_offset);
4793 add_fix (sec, fix);
4794 }
4795
4796 pin_internal_relocs (sec, internal_relocs);
4797 }
4798 }
4799
4800 if (relax_info->is_relaxable_literal_section)
4801 {
4802 /* Walk through the contents and delete literals that are not needed
4803 anymore. */
4804
4805 unsigned long size = sec->_cooked_size;
4806 unsigned long removed = 0;
4807
4808 removed_literal *reloc = relax_info->removed_list.head;
4809 for (; reloc; reloc = reloc->next)
4810 {
4811 unsigned long upper = sec->_raw_size;
4812 bfd_vma start = reloc->from.target_offset + 4;
4813 if (reloc->next)
4814 upper = reloc->next->from.target_offset;
4815 if (upper - start != 0)
4816 {
4817 BFD_ASSERT (start <= upper);
4818 memmove (contents + start - removed - 4,
4819 contents + start,
4820 upper - start );
4821 pin_contents (sec, contents);
4822 }
4823 removed += 4;
4824 size -= 4;
4825 }
4826
4827 /* Change the section size. */
4828 sec->_cooked_size = size;
4829 /* Also shrink _raw_size. (The code in relocate_section that
4830 checks that relocations are within the section must use
4831 _raw_size because of the way the stabs sections are relaxed;
4832 shrinking _raw_size means that these checks will not be
4833 unnecessarily lax.) */
4834 sec->_raw_size = size;
4835 }
4836
4837 error_return:
4838 release_internal_relocs (sec, internal_relocs);
4839 release_contents (sec, contents);
4840 return ok;
4841 }
4842
4843
4844 /* Fix up a relocation to take account of removed literals. */
4845
4846 static void
translate_reloc(orig_rel,new_rel)4847 translate_reloc (orig_rel, new_rel)
4848 const r_reloc *orig_rel;
4849 r_reloc *new_rel;
4850 {
4851 asection *sec;
4852 xtensa_relax_info *relax_info;
4853 removed_literal *removed;
4854 unsigned long new_offset;
4855
4856 *new_rel = *orig_rel;
4857
4858 if (!r_reloc_is_defined (orig_rel))
4859 return;
4860 sec = r_reloc_get_section (orig_rel);
4861
4862 relax_info = get_xtensa_relax_info (sec);
4863 BFD_ASSERT (relax_info);
4864
4865 if (!relax_info->is_relaxable_literal_section)
4866 return;
4867
4868 /* Check if the original relocation is against a literal being removed. */
4869 removed = find_removed_literal (&relax_info->removed_list,
4870 orig_rel->target_offset);
4871 if (removed)
4872 {
4873 asection *new_sec;
4874
4875 /* The fact that there is still a relocation to this literal indicates
4876 that the literal is being coalesced, not simply removed. */
4877 BFD_ASSERT (removed->to.abfd != NULL);
4878
4879 /* This was moved to some other address (possibly in another section). */
4880 *new_rel = removed->to;
4881 new_sec = r_reloc_get_section (new_rel);
4882 if (new_sec != sec)
4883 {
4884 sec = new_sec;
4885 relax_info = get_xtensa_relax_info (sec);
4886 if (!relax_info || !relax_info->is_relaxable_literal_section)
4887 return;
4888 }
4889 }
4890
4891 /* ...and the target address may have been moved within its section. */
4892 new_offset = offset_with_removed_literals (&relax_info->removed_list,
4893 new_rel->target_offset);
4894
4895 /* Modify the offset and addend. */
4896 new_rel->target_offset = new_offset;
4897 new_rel->rela.r_addend += (new_offset - new_rel->target_offset);
4898 }
4899
4900
4901 /* For dynamic links, there may be a dynamic relocation for each
4902 literal. The number of dynamic relocations must be computed in
4903 size_dynamic_sections, which occurs before relaxation. When a
4904 literal is removed, this function checks if there is a corresponding
4905 dynamic relocation and shrinks the size of the appropriate dynamic
4906 relocation section accordingly. At this point, the contents of the
4907 dynamic relocation sections have not yet been filled in, so there's
4908 nothing else that needs to be done. */
4909
4910 static void
shrink_dynamic_reloc_sections(info,abfd,input_section,rel)4911 shrink_dynamic_reloc_sections (info, abfd, input_section, rel)
4912 struct bfd_link_info *info;
4913 bfd *abfd;
4914 asection *input_section;
4915 Elf_Internal_Rela *rel;
4916 {
4917 Elf_Internal_Shdr *symtab_hdr;
4918 struct elf_link_hash_entry **sym_hashes;
4919 unsigned long r_symndx;
4920 int r_type;
4921 struct elf_link_hash_entry *h;
4922 bfd_boolean dynamic_symbol;
4923
4924 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4925 sym_hashes = elf_sym_hashes (abfd);
4926
4927 r_type = ELF32_R_TYPE (rel->r_info);
4928 r_symndx = ELF32_R_SYM (rel->r_info);
4929
4930 if (r_symndx < symtab_hdr->sh_info)
4931 h = NULL;
4932 else
4933 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4934
4935 dynamic_symbol = xtensa_elf_dynamic_symbol_p (h, info);
4936
4937 if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT)
4938 && (input_section->flags & SEC_ALLOC) != 0
4939 && (dynamic_symbol || info->shared))
4940 {
4941 bfd *dynobj;
4942 const char *srel_name;
4943 asection *srel;
4944 bfd_boolean is_plt = FALSE;
4945
4946 dynobj = elf_hash_table (info)->dynobj;
4947 BFD_ASSERT (dynobj != NULL);
4948
4949 if (dynamic_symbol && r_type == R_XTENSA_PLT)
4950 {
4951 srel_name = ".rela.plt";
4952 is_plt = TRUE;
4953 }
4954 else
4955 srel_name = ".rela.got";
4956
4957 /* Reduce size of the .rela.* section by one reloc. */
4958 srel = bfd_get_section_by_name (dynobj, srel_name);
4959 BFD_ASSERT (srel != NULL);
4960 BFD_ASSERT (srel->_cooked_size >= sizeof (Elf32_External_Rela));
4961 srel->_cooked_size -= sizeof (Elf32_External_Rela);
4962
4963 /* Also shrink _raw_size. (This seems wrong but other bfd code seems
4964 to assume that linker-created sections will never be relaxed and
4965 hence _raw_size must always equal _cooked_size.) */
4966 srel->_raw_size = srel->_cooked_size;
4967
4968 if (is_plt)
4969 {
4970 asection *splt, *sgotplt, *srelgot;
4971 int reloc_index, chunk;
4972
4973 /* Find the PLT reloc index of the entry being removed. This
4974 is computed from the size of ".rela.plt". It is needed to
4975 figure out which PLT chunk to resize. Usually "last index
4976 = size - 1" since the index starts at zero, but in this
4977 context, the size has just been decremented so there's no
4978 need to subtract one. */
4979 reloc_index = srel->_cooked_size / sizeof (Elf32_External_Rela);
4980
4981 chunk = reloc_index / PLT_ENTRIES_PER_CHUNK;
4982 splt = elf_xtensa_get_plt_section (dynobj, chunk);
4983 sgotplt = elf_xtensa_get_gotplt_section (dynobj, chunk);
4984 BFD_ASSERT (splt != NULL && sgotplt != NULL);
4985
4986 /* Check if an entire PLT chunk has just been eliminated. */
4987 if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0)
4988 {
4989 /* The two magic GOT entries for that chunk can go away. */
4990 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4991 BFD_ASSERT (srelgot != NULL);
4992 srelgot->reloc_count -= 2;
4993 srelgot->_cooked_size -= 2 * sizeof (Elf32_External_Rela);
4994 /* Shrink _raw_size (see comment above). */
4995 srelgot->_raw_size = srelgot->_cooked_size;
4996
4997 sgotplt->_cooked_size -= 8;
4998
4999 /* There should be only one entry left (and it will be
5000 removed below). */
5001 BFD_ASSERT (sgotplt->_cooked_size == 4);
5002 BFD_ASSERT (splt->_cooked_size == PLT_ENTRY_SIZE);
5003 }
5004
5005 BFD_ASSERT (sgotplt->_cooked_size >= 4);
5006 BFD_ASSERT (splt->_cooked_size >= PLT_ENTRY_SIZE);
5007
5008 sgotplt->_cooked_size -= 4;
5009 splt->_cooked_size -= PLT_ENTRY_SIZE;
5010
5011 /* Shrink _raw_sizes (see comment above). */
5012 sgotplt->_raw_size = sgotplt->_cooked_size;
5013 splt->_raw_size = splt->_cooked_size;
5014 }
5015 }
5016 }
5017
5018
5019 /* This is similar to relax_section except that when a target is moved,
5020 we shift addresses up. We also need to modify the size. This
5021 algorithm does NOT allow for relocations into the middle of the
5022 property sections. */
5023
5024 static bfd_boolean
relax_property_section(abfd,sec,link_info)5025 relax_property_section (abfd, sec, link_info)
5026 bfd *abfd;
5027 asection *sec;
5028 struct bfd_link_info *link_info;
5029 {
5030 Elf_Internal_Rela *internal_relocs;
5031 bfd_byte *contents;
5032 unsigned i, nexti;
5033 bfd_boolean ok = TRUE;
5034
5035 internal_relocs = retrieve_internal_relocs (abfd, sec,
5036 link_info->keep_memory);
5037 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5038 if (contents == NULL && sec->_raw_size != 0)
5039 {
5040 ok = FALSE;
5041 goto error_return;
5042 }
5043
5044 if (internal_relocs)
5045 {
5046 for (i = 0; i < sec->reloc_count; i++)
5047 {
5048 Elf_Internal_Rela *irel;
5049 xtensa_relax_info *target_relax_info;
5050 r_reloc r_rel;
5051 unsigned r_type;
5052 asection *target_sec;
5053
5054 /* Locally change the source address.
5055 Translate the target to the new target address.
5056 If it points to this section and has been removed, MOVE IT.
5057 Also, don't forget to modify the associated SIZE at
5058 (offset + 4). */
5059
5060 irel = &internal_relocs[i];
5061 r_type = ELF32_R_TYPE (irel->r_info);
5062 if (r_type == R_XTENSA_NONE)
5063 continue;
5064
5065 r_reloc_init (&r_rel, abfd, irel);
5066
5067 target_sec = r_reloc_get_section (&r_rel);
5068 target_relax_info = get_xtensa_relax_info (target_sec);
5069
5070 if (target_relax_info
5071 && target_relax_info->is_relaxable_literal_section)
5072 {
5073 /* Translate the relocation's destination. */
5074 bfd_vma new_offset;
5075 bfd_vma new_end_offset;
5076 bfd_byte *size_p;
5077 long old_size, new_size;
5078
5079 new_offset =
5080 offset_with_removed_literals (&target_relax_info->removed_list,
5081 r_rel.target_offset);
5082
5083 /* Assert that we are not out of bounds. */
5084 size_p = &contents[irel->r_offset + 4];
5085 old_size = bfd_get_32 (abfd, &contents[irel->r_offset + 4]);
5086
5087 new_end_offset =
5088 offset_with_removed_literals (&target_relax_info->removed_list,
5089 r_rel.target_offset + old_size);
5090
5091 new_size = new_end_offset - new_offset;
5092 if (new_size != old_size)
5093 {
5094 bfd_put_32 (abfd, new_size, size_p);
5095 pin_contents (sec, contents);
5096 }
5097
5098 if (new_offset != r_rel.target_offset)
5099 {
5100 bfd_vma diff = new_offset - r_rel.target_offset;
5101 irel->r_addend += diff;
5102 pin_internal_relocs (sec, internal_relocs);
5103 }
5104 }
5105 }
5106 }
5107
5108 /* Combine adjacent property table entries. This is also done in
5109 finish_dynamic_sections() but at that point it's too late to
5110 reclaim the space in the output section, so we do this twice. */
5111
5112 if (internal_relocs)
5113 {
5114 Elf_Internal_Rela *last_irel = NULL;
5115 int removed_bytes = 0;
5116 bfd_vma offset, last_irel_offset;
5117 bfd_vma section_size;
5118
5119 /* Walk over memory and irels at the same time.
5120 This REQUIRES that the internal_relocs be sorted by offset. */
5121 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
5122 internal_reloc_compare);
5123 nexti = 0; /* Index into internal_relocs. */
5124
5125 pin_internal_relocs (sec, internal_relocs);
5126 pin_contents (sec, contents);
5127
5128 last_irel_offset = (bfd_vma) -1;
5129 section_size = (sec->_cooked_size ? sec->_cooked_size : sec->_raw_size);
5130 BFD_ASSERT (section_size % 8 == 0);
5131
5132 for (offset = 0; offset < section_size; offset += 8)
5133 {
5134 Elf_Internal_Rela *irel, *next_irel;
5135 bfd_vma bytes_to_remove, size, actual_offset;
5136 bfd_boolean remove_this_irel;
5137
5138 irel = NULL;
5139 next_irel = NULL;
5140
5141 /* Find the next two relocations (if there are that many left),
5142 skipping over any R_XTENSA_NONE relocs. On entry, "nexti" is
5143 the starting reloc index. After these two loops, "i"
5144 is the index of the first non-NONE reloc past that starting
5145 index, and "nexti" is the index for the next non-NONE reloc
5146 after "i". */
5147
5148 for (i = nexti; i < sec->reloc_count; i++)
5149 {
5150 if (ELF32_R_TYPE (internal_relocs[i].r_info) != R_XTENSA_NONE)
5151 {
5152 irel = &internal_relocs[i];
5153 break;
5154 }
5155 internal_relocs[i].r_offset -= removed_bytes;
5156 }
5157
5158 for (nexti = i + 1; nexti < sec->reloc_count; nexti++)
5159 {
5160 if (ELF32_R_TYPE (internal_relocs[nexti].r_info)
5161 != R_XTENSA_NONE)
5162 {
5163 next_irel = &internal_relocs[nexti];
5164 break;
5165 }
5166 internal_relocs[nexti].r_offset -= removed_bytes;
5167 }
5168
5169 remove_this_irel = FALSE;
5170 bytes_to_remove = 0;
5171 actual_offset = offset - removed_bytes;
5172 size = bfd_get_32 (abfd, &contents[actual_offset + 4]);
5173
5174 /* Check that the irels are sorted by offset,
5175 with only one per address. */
5176 BFD_ASSERT (!irel || (int) irel->r_offset > (int) last_irel_offset);
5177 BFD_ASSERT (!next_irel || next_irel->r_offset > irel->r_offset);
5178
5179 /* Make sure there isn't a reloc on the size field. */
5180 if (irel && irel->r_offset == offset + 4)
5181 {
5182 irel->r_offset -= removed_bytes;
5183 last_irel_offset = irel->r_offset;
5184 }
5185 else if (next_irel && next_irel->r_offset == offset + 4)
5186 {
5187 nexti += 1;
5188 irel->r_offset -= removed_bytes;
5189 next_irel->r_offset -= removed_bytes;
5190 last_irel_offset = next_irel->r_offset;
5191 }
5192 else if (size == 0)
5193 {
5194 /* Always remove entries with zero size. */
5195 bytes_to_remove = 8;
5196 if (irel && irel->r_offset == offset)
5197 {
5198 remove_this_irel = TRUE;
5199
5200 irel->r_offset -= removed_bytes;
5201 last_irel_offset = irel->r_offset;
5202 }
5203 }
5204 else if (irel && irel->r_offset == offset)
5205 {
5206 if (ELF32_R_TYPE (irel->r_info) == R_XTENSA_32)
5207 {
5208 if (last_irel)
5209 {
5210 bfd_vma old_size =
5211 bfd_get_32 (abfd, &contents[last_irel->r_offset + 4]);
5212 bfd_vma old_address =
5213 (last_irel->r_addend
5214 + bfd_get_32 (abfd, &contents[last_irel->r_offset]));
5215 bfd_vma new_address =
5216 (irel->r_addend
5217 + bfd_get_32 (abfd, &contents[actual_offset]));
5218
5219 if ((ELF32_R_SYM (irel->r_info) ==
5220 ELF32_R_SYM (last_irel->r_info))
5221 && (old_address + old_size == new_address))
5222 {
5223 /* fix the old size */
5224 bfd_put_32 (abfd, old_size + size,
5225 &contents[last_irel->r_offset + 4]);
5226 bytes_to_remove = 8;
5227 remove_this_irel = TRUE;
5228 }
5229 else
5230 last_irel = irel;
5231 }
5232 else
5233 last_irel = irel;
5234 }
5235
5236 irel->r_offset -= removed_bytes;
5237 last_irel_offset = irel->r_offset;
5238 }
5239
5240 if (remove_this_irel)
5241 {
5242 irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE);
5243 irel->r_offset -= bytes_to_remove;
5244 }
5245
5246 if (bytes_to_remove != 0)
5247 {
5248 removed_bytes += bytes_to_remove;
5249 if (offset + 8 < section_size)
5250 memmove (&contents[actual_offset],
5251 &contents[actual_offset+8],
5252 section_size - offset - 8);
5253 }
5254 }
5255
5256 if (removed_bytes)
5257 {
5258 /* Clear the removed bytes. */
5259 memset (&contents[section_size - removed_bytes], 0, removed_bytes);
5260
5261 sec->_cooked_size = section_size - removed_bytes;
5262 /* Also shrink _raw_size. (The code in relocate_section that
5263 checks that relocations are within the section must use
5264 _raw_size because of the way the stabs sections are
5265 relaxed; shrinking _raw_size means that these checks will
5266 not be unnecessarily lax.) */
5267 sec->_raw_size = sec->_cooked_size;
5268
5269 if (xtensa_is_littable_section (sec))
5270 {
5271 bfd *dynobj = elf_hash_table (link_info)->dynobj;
5272 if (dynobj)
5273 {
5274 asection *sgotloc =
5275 bfd_get_section_by_name (dynobj, ".got.loc");
5276 if (sgotloc)
5277 {
5278 bfd_size_type sgotloc_size =
5279 (sgotloc->_cooked_size ? sgotloc->_cooked_size
5280 : sgotloc->_raw_size);
5281 sgotloc->_cooked_size = sgotloc_size - removed_bytes;
5282 sgotloc->_raw_size = sgotloc_size - removed_bytes;
5283 }
5284 }
5285 }
5286 }
5287 }
5288
5289 error_return:
5290 release_internal_relocs (sec, internal_relocs);
5291 release_contents (sec, contents);
5292 return ok;
5293 }
5294
5295
5296 /* Third relaxation pass. */
5297
5298 /* Change symbol values to account for removed literals. */
5299
5300 bfd_boolean
relax_section_symbols(abfd,sec)5301 relax_section_symbols (abfd, sec)
5302 bfd *abfd;
5303 asection *sec;
5304 {
5305 xtensa_relax_info *relax_info;
5306 unsigned int sec_shndx;
5307 Elf_Internal_Shdr *symtab_hdr;
5308 Elf_Internal_Sym *isymbuf;
5309 unsigned i, num_syms, num_locals;
5310
5311 relax_info = get_xtensa_relax_info (sec);
5312 BFD_ASSERT (relax_info);
5313
5314 if (!relax_info->is_relaxable_literal_section)
5315 return TRUE;
5316
5317 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5318
5319 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5320 isymbuf = retrieve_local_syms (abfd);
5321
5322 num_syms = symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
5323 num_locals = symtab_hdr->sh_info;
5324
5325 /* Adjust the local symbols defined in this section. */
5326 for (i = 0; i < num_locals; i++)
5327 {
5328 Elf_Internal_Sym *isym = &isymbuf[i];
5329
5330 if (isym->st_shndx == sec_shndx)
5331 {
5332 bfd_vma new_address = offset_with_removed_literals
5333 (&relax_info->removed_list, isym->st_value);
5334 if (new_address != isym->st_value)
5335 isym->st_value = new_address;
5336 }
5337 }
5338
5339 /* Now adjust the global symbols defined in this section. */
5340 for (i = 0; i < (num_syms - num_locals); i++)
5341 {
5342 struct elf_link_hash_entry *sym_hash;
5343
5344 sym_hash = elf_sym_hashes (abfd)[i];
5345
5346 if (sym_hash->root.type == bfd_link_hash_warning)
5347 sym_hash = (struct elf_link_hash_entry *) sym_hash->root.u.i.link;
5348
5349 if ((sym_hash->root.type == bfd_link_hash_defined
5350 || sym_hash->root.type == bfd_link_hash_defweak)
5351 && sym_hash->root.u.def.section == sec)
5352 {
5353 bfd_vma new_address = offset_with_removed_literals
5354 (&relax_info->removed_list, sym_hash->root.u.def.value);
5355 if (new_address != sym_hash->root.u.def.value)
5356 sym_hash->root.u.def.value = new_address;
5357 }
5358 }
5359
5360 return TRUE;
5361 }
5362
5363
5364 /* "Fix" handling functions, called while performing relocations. */
5365
5366 static void
do_fix_for_relocatable_link(rel,input_bfd,input_section)5367 do_fix_for_relocatable_link (rel, input_bfd, input_section)
5368 Elf_Internal_Rela *rel;
5369 bfd *input_bfd;
5370 asection *input_section;
5371 {
5372 r_reloc r_rel;
5373 asection *sec, *old_sec;
5374 bfd_vma old_offset;
5375 int r_type = ELF32_R_TYPE (rel->r_info);
5376 reloc_bfd_fix *fix_list;
5377 reloc_bfd_fix *fix;
5378
5379 if (r_type == R_XTENSA_NONE)
5380 return;
5381
5382 fix_list = (get_xtensa_relax_info (input_section))->fix_list;
5383 if (fix_list == NULL)
5384 return;
5385
5386 fix = get_bfd_fix (fix_list, input_section, rel->r_offset, r_type);
5387 if (fix == NULL)
5388 return;
5389
5390 r_reloc_init (&r_rel, input_bfd, rel);
5391 old_sec = r_reloc_get_section (&r_rel);
5392 old_offset = r_reloc_get_target_offset (&r_rel);
5393
5394 if (old_sec == NULL || !r_reloc_is_defined (&r_rel))
5395 {
5396 BFD_ASSERT (r_type == R_XTENSA_ASM_EXPAND);
5397 /* Leave it be. Resolution will happen in a later stage. */
5398 }
5399 else
5400 {
5401 sec = fix->target_sec;
5402 rel->r_addend += ((sec->output_offset + fix->target_offset)
5403 - (old_sec->output_offset + old_offset));
5404 }
5405 }
5406
5407
5408 static void
do_fix_for_final_link(rel,input_section,relocationp)5409 do_fix_for_final_link (rel, input_section, relocationp)
5410 Elf_Internal_Rela *rel;
5411 asection *input_section;
5412 bfd_vma *relocationp;
5413 {
5414 asection *sec;
5415 int r_type = ELF32_R_TYPE (rel->r_info);
5416 reloc_bfd_fix *fix_list;
5417 reloc_bfd_fix *fix;
5418
5419 if (r_type == R_XTENSA_NONE)
5420 return;
5421
5422 fix_list = (get_xtensa_relax_info (input_section))->fix_list;
5423 if (fix_list == NULL)
5424 return;
5425
5426 fix = get_bfd_fix (fix_list, input_section, rel->r_offset, r_type);
5427 if (fix == NULL)
5428 return;
5429
5430 sec = fix->target_sec;
5431 *relocationp = (sec->output_section->vma
5432 + sec->output_offset
5433 + fix->target_offset - rel->r_addend);
5434 }
5435
5436
5437 /* Miscellaneous utility functions.... */
5438
5439 static asection *
elf_xtensa_get_plt_section(dynobj,chunk)5440 elf_xtensa_get_plt_section (dynobj, chunk)
5441 bfd *dynobj;
5442 int chunk;
5443 {
5444 char plt_name[10];
5445
5446 if (chunk == 0)
5447 return bfd_get_section_by_name (dynobj, ".plt");
5448
5449 sprintf (plt_name, ".plt.%u", chunk);
5450 return bfd_get_section_by_name (dynobj, plt_name);
5451 }
5452
5453
5454 static asection *
elf_xtensa_get_gotplt_section(dynobj,chunk)5455 elf_xtensa_get_gotplt_section (dynobj, chunk)
5456 bfd *dynobj;
5457 int chunk;
5458 {
5459 char got_name[14];
5460
5461 if (chunk == 0)
5462 return bfd_get_section_by_name (dynobj, ".got.plt");
5463
5464 sprintf (got_name, ".got.plt.%u", chunk);
5465 return bfd_get_section_by_name (dynobj, got_name);
5466 }
5467
5468
5469 /* Get the input section for a given symbol index.
5470 If the symbol is:
5471 . a section symbol, return the section;
5472 . a common symbol, return the common section;
5473 . an undefined symbol, return the undefined section;
5474 . an indirect symbol, follow the links;
5475 . an absolute value, return the absolute section. */
5476
5477 static asection *
get_elf_r_symndx_section(abfd,r_symndx)5478 get_elf_r_symndx_section (abfd, r_symndx)
5479 bfd *abfd;
5480 unsigned long r_symndx;
5481 {
5482 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5483 asection *target_sec = NULL;
5484 if (r_symndx < symtab_hdr->sh_info)
5485 {
5486 Elf_Internal_Sym *isymbuf;
5487 unsigned int section_index;
5488
5489 isymbuf = retrieve_local_syms (abfd);
5490 section_index = isymbuf[r_symndx].st_shndx;
5491
5492 if (section_index == SHN_UNDEF)
5493 target_sec = bfd_und_section_ptr;
5494 else if (section_index > 0 && section_index < SHN_LORESERVE)
5495 target_sec = bfd_section_from_elf_index (abfd, section_index);
5496 else if (section_index == SHN_ABS)
5497 target_sec = bfd_abs_section_ptr;
5498 else if (section_index == SHN_COMMON)
5499 target_sec = bfd_com_section_ptr;
5500 else
5501 /* Who knows? */
5502 target_sec = NULL;
5503 }
5504 else
5505 {
5506 unsigned long indx = r_symndx - symtab_hdr->sh_info;
5507 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
5508
5509 while (h->root.type == bfd_link_hash_indirect
5510 || h->root.type == bfd_link_hash_warning)
5511 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5512
5513 switch (h->root.type)
5514 {
5515 case bfd_link_hash_defined:
5516 case bfd_link_hash_defweak:
5517 target_sec = h->root.u.def.section;
5518 break;
5519 case bfd_link_hash_common:
5520 target_sec = bfd_com_section_ptr;
5521 break;
5522 case bfd_link_hash_undefined:
5523 case bfd_link_hash_undefweak:
5524 target_sec = bfd_und_section_ptr;
5525 break;
5526 default: /* New indirect warning. */
5527 target_sec = bfd_und_section_ptr;
5528 break;
5529 }
5530 }
5531 return target_sec;
5532 }
5533
5534
5535 static struct elf_link_hash_entry *
get_elf_r_symndx_hash_entry(abfd,r_symndx)5536 get_elf_r_symndx_hash_entry (abfd, r_symndx)
5537 bfd *abfd;
5538 unsigned long r_symndx;
5539 {
5540 unsigned long indx;
5541 struct elf_link_hash_entry *h;
5542 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5543
5544 if (r_symndx < symtab_hdr->sh_info)
5545 return NULL;
5546
5547 indx = r_symndx - symtab_hdr->sh_info;
5548 h = elf_sym_hashes (abfd)[indx];
5549 while (h->root.type == bfd_link_hash_indirect
5550 || h->root.type == bfd_link_hash_warning)
5551 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5552 return h;
5553 }
5554
5555
5556 /* Get the section-relative offset for a symbol number. */
5557
5558 static bfd_vma
get_elf_r_symndx_offset(abfd,r_symndx)5559 get_elf_r_symndx_offset (abfd, r_symndx)
5560 bfd *abfd;
5561 unsigned long r_symndx;
5562 {
5563 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5564 bfd_vma offset = 0;
5565
5566 if (r_symndx < symtab_hdr->sh_info)
5567 {
5568 Elf_Internal_Sym *isymbuf;
5569 isymbuf = retrieve_local_syms (abfd);
5570 offset = isymbuf[r_symndx].st_value;
5571 }
5572 else
5573 {
5574 unsigned long indx = r_symndx - symtab_hdr->sh_info;
5575 struct elf_link_hash_entry *h =
5576 elf_sym_hashes (abfd)[indx];
5577
5578 while (h->root.type == bfd_link_hash_indirect
5579 || h->root.type == bfd_link_hash_warning)
5580 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5581 if (h->root.type == bfd_link_hash_defined
5582 || h->root.type == bfd_link_hash_defweak)
5583 offset = h->root.u.def.value;
5584 }
5585 return offset;
5586 }
5587
5588
5589 static bfd_boolean
pcrel_reloc_fits(opnd,self_address,dest_address)5590 pcrel_reloc_fits (opnd, self_address, dest_address)
5591 xtensa_operand opnd;
5592 bfd_vma self_address;
5593 bfd_vma dest_address;
5594 {
5595 uint32 new_address =
5596 xtensa_operand_do_reloc (opnd, dest_address, self_address);
5597 return (xtensa_operand_encode (opnd, &new_address)
5598 == xtensa_encode_result_ok);
5599 }
5600
5601
5602 static int linkonce_len = sizeof (".gnu.linkonce.") - 1;
5603 static int insn_sec_len = sizeof (XTENSA_INSN_SEC_NAME) - 1;
5604 static int lit_sec_len = sizeof (XTENSA_LIT_SEC_NAME) - 1;
5605
5606
5607 static bfd_boolean
xtensa_is_property_section(sec)5608 xtensa_is_property_section (sec)
5609 asection *sec;
5610 {
5611 if (strncmp (XTENSA_INSN_SEC_NAME, sec->name, insn_sec_len) == 0
5612 || strncmp (XTENSA_LIT_SEC_NAME, sec->name, lit_sec_len) == 0)
5613 return TRUE;
5614
5615 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0
5616 && (sec->name[linkonce_len] == 'x'
5617 || sec->name[linkonce_len] == 'p')
5618 && sec->name[linkonce_len + 1] == '.')
5619 return TRUE;
5620
5621 return FALSE;
5622 }
5623
5624
5625 static bfd_boolean
xtensa_is_littable_section(sec)5626 xtensa_is_littable_section (sec)
5627 asection *sec;
5628 {
5629 if (strncmp (XTENSA_LIT_SEC_NAME, sec->name, lit_sec_len) == 0)
5630 return TRUE;
5631
5632 if (strncmp (".gnu.linkonce.", sec->name, linkonce_len) == 0
5633 && sec->name[linkonce_len] == 'p'
5634 && sec->name[linkonce_len + 1] == '.')
5635 return TRUE;
5636
5637 return FALSE;
5638 }
5639
5640
5641 static bfd_boolean
is_literal_section(sec)5642 is_literal_section (sec)
5643 asection *sec;
5644 {
5645 /* FIXME: the current definition of this leaves a lot to be desired.... */
5646 if (sec == NULL || sec->name == NULL)
5647 return FALSE;
5648 return (strstr (sec->name, "literal") != NULL);
5649 }
5650
5651
5652 static int
internal_reloc_compare(ap,bp)5653 internal_reloc_compare (ap, bp)
5654 const PTR ap;
5655 const PTR bp;
5656 {
5657 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
5658 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
5659
5660 return (a->r_offset - b->r_offset);
5661 }
5662
5663
5664 char *
xtensa_get_property_section_name(sec,base_name)5665 xtensa_get_property_section_name (sec, base_name)
5666 asection *sec;
5667 const char *base_name;
5668 {
5669 if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0)
5670 {
5671 char *prop_sec_name;
5672 const char *suffix;
5673 char linkonce_kind = 0;
5674
5675 if (strcmp (base_name, XTENSA_INSN_SEC_NAME) == 0)
5676 linkonce_kind = 'x';
5677 else if (strcmp (base_name, XTENSA_LIT_SEC_NAME) == 0)
5678 linkonce_kind = 'p';
5679 else
5680 abort ();
5681
5682 prop_sec_name = (char *) bfd_malloc (strlen (sec->name) + 1);
5683 memcpy (prop_sec_name, ".gnu.linkonce.", linkonce_len);
5684 prop_sec_name[linkonce_len] = linkonce_kind;
5685 prop_sec_name[linkonce_len + 1] = '.';
5686
5687 suffix = sec->name + linkonce_len;
5688 while (*suffix)
5689 {
5690 suffix += 1;
5691 if (suffix[-1] == '.')
5692 break;
5693 }
5694 strcpy (prop_sec_name + linkonce_len + 2, suffix);
5695
5696 return prop_sec_name;
5697 }
5698
5699 return strdup (base_name);
5700 }
5701
5702
5703 /* Other functions called directly by the linker. */
5704
5705 bfd_boolean
xtensa_callback_required_dependence(abfd,sec,link_info,callback,closure)5706 xtensa_callback_required_dependence (abfd, sec, link_info, callback, closure)
5707 bfd *abfd;
5708 asection *sec;
5709 struct bfd_link_info *link_info;
5710 deps_callback_t callback;
5711 PTR closure;
5712 {
5713 Elf_Internal_Rela *internal_relocs;
5714 bfd_byte *contents;
5715 unsigned i;
5716 bfd_boolean ok = TRUE;
5717
5718 /* ".plt*" sections have no explicit relocations but they contain L32R
5719 instructions that reference the corresponding ".got.plt*" sections. */
5720 if ((sec->flags & SEC_LINKER_CREATED) != 0
5721 && strncmp (sec->name, ".plt", 4) == 0)
5722 {
5723 asection *sgotplt;
5724
5725 /* Find the corresponding ".got.plt*" section. */
5726 if (sec->name[4] == '\0')
5727 sgotplt = bfd_get_section_by_name (sec->owner, ".got.plt");
5728 else
5729 {
5730 char got_name[14];
5731 int chunk = 0;
5732
5733 BFD_ASSERT (sec->name[4] == '.');
5734 chunk = strtol (&sec->name[5], NULL, 10);
5735
5736 sprintf (got_name, ".got.plt.%u", chunk);
5737 sgotplt = bfd_get_section_by_name (sec->owner, got_name);
5738 }
5739 BFD_ASSERT (sgotplt);
5740
5741 /* Assume worst-case offsets: L32R at the very end of the ".plt"
5742 section referencing a literal at the very beginning of
5743 ".got.plt". This is very close to the real dependence, anyway. */
5744 (*callback) (sec, sec->_raw_size, sgotplt, 0, closure);
5745 }
5746
5747 internal_relocs = retrieve_internal_relocs (abfd, sec,
5748 link_info->keep_memory);
5749 if (internal_relocs == NULL
5750 || sec->reloc_count == 0)
5751 return ok;
5752
5753 /* Cache the contents for the duration of this scan. */
5754 contents = retrieve_contents (abfd, sec, link_info->keep_memory);
5755 if (contents == NULL && sec->_raw_size != 0)
5756 {
5757 ok = FALSE;
5758 goto error_return;
5759 }
5760
5761 if (xtensa_default_isa == NULL)
5762 xtensa_isa_init ();
5763
5764 for (i = 0; i < sec->reloc_count; i++)
5765 {
5766 Elf_Internal_Rela *irel = &internal_relocs[i];
5767 if (is_l32r_relocation (sec, contents, irel))
5768 {
5769 r_reloc l32r_rel;
5770 asection *target_sec;
5771 bfd_vma target_offset;
5772
5773 r_reloc_init (&l32r_rel, abfd, irel);
5774 target_sec = NULL;
5775 target_offset = 0;
5776 /* L32Rs must be local to the input file. */
5777 if (r_reloc_is_defined (&l32r_rel))
5778 {
5779 target_sec = r_reloc_get_section (&l32r_rel);
5780 target_offset = r_reloc_get_target_offset (&l32r_rel);
5781 }
5782 (*callback) (sec, irel->r_offset, target_sec, target_offset,
5783 closure);
5784 }
5785 }
5786
5787 error_return:
5788 release_internal_relocs (sec, internal_relocs);
5789 release_contents (sec, contents);
5790 return ok;
5791 }
5792
5793 /* The default literal sections should always be marked as "code" (i.e.,
5794 SHF_EXECINSTR). This is particularly important for the Linux kernel
5795 module loader so that the literals are not placed after the text. */
5796 static struct bfd_elf_special_section const elf_xtensa_special_sections[]=
5797 {
5798 { ".literal", 8, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
5799 { ".init.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
5800 { ".fini.literal", 13, 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
5801 { NULL, 0, 0, 0, 0 }
5802 };
5803
5804
5805 #ifndef ELF_ARCH
5806 #define TARGET_LITTLE_SYM bfd_elf32_xtensa_le_vec
5807 #define TARGET_LITTLE_NAME "elf32-xtensa-le"
5808 #define TARGET_BIG_SYM bfd_elf32_xtensa_be_vec
5809 #define TARGET_BIG_NAME "elf32-xtensa-be"
5810 #define ELF_ARCH bfd_arch_xtensa
5811
5812 /* The new EM_XTENSA value will be recognized beginning in the Xtensa T1040
5813 release. However, we still have to generate files with the EM_XTENSA_OLD
5814 value so that pre-T1040 tools can read the files. As soon as we stop
5815 caring about pre-T1040 tools, the following two values should be
5816 swapped. At the same time, any other code that uses EM_XTENSA_OLD
5817 (e.g., prep_headers() in elf.c) should be changed to use EM_XTENSA. */
5818 #define ELF_MACHINE_CODE EM_XTENSA_OLD
5819 #define ELF_MACHINE_ALT1 EM_XTENSA
5820
5821 #if XCHAL_HAVE_MMU
5822 #define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE)
5823 #else /* !XCHAL_HAVE_MMU */
5824 #define ELF_MAXPAGESIZE 1
5825 #endif /* !XCHAL_HAVE_MMU */
5826 #endif /* ELF_ARCH */
5827
5828 #define elf_backend_can_gc_sections 1
5829 #define elf_backend_can_refcount 1
5830 #define elf_backend_plt_readonly 1
5831 #define elf_backend_got_header_size 4
5832 #define elf_backend_want_dynbss 0
5833 #define elf_backend_want_got_plt 1
5834
5835 #define elf_info_to_howto elf_xtensa_info_to_howto_rela
5836
5837 #define bfd_elf32_bfd_merge_private_bfd_data elf_xtensa_merge_private_bfd_data
5838 #define bfd_elf32_new_section_hook elf_xtensa_new_section_hook
5839 #define bfd_elf32_bfd_print_private_bfd_data elf_xtensa_print_private_bfd_data
5840 #define bfd_elf32_bfd_relax_section elf_xtensa_relax_section
5841 #define bfd_elf32_bfd_reloc_type_lookup elf_xtensa_reloc_type_lookup
5842 #define bfd_elf32_bfd_set_private_flags elf_xtensa_set_private_flags
5843
5844 #define elf_backend_adjust_dynamic_symbol elf_xtensa_adjust_dynamic_symbol
5845 #define elf_backend_check_relocs elf_xtensa_check_relocs
5846 #define elf_backend_create_dynamic_sections elf_xtensa_create_dynamic_sections
5847 #define elf_backend_discard_info elf_xtensa_discard_info
5848 #define elf_backend_ignore_discarded_relocs elf_xtensa_ignore_discarded_relocs
5849 #define elf_backend_final_write_processing elf_xtensa_final_write_processing
5850 #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections
5851 #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol
5852 #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook
5853 #define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook
5854 #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus
5855 #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo
5856 #define elf_backend_hide_symbol elf_xtensa_hide_symbol
5857 #define elf_backend_modify_segment_map elf_xtensa_modify_segment_map
5858 #define elf_backend_object_p elf_xtensa_object_p
5859 #define elf_backend_reloc_type_class elf_xtensa_reloc_type_class
5860 #define elf_backend_relocate_section elf_xtensa_relocate_section
5861 #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections
5862 #define elf_backend_special_sections elf_xtensa_special_sections
5863
5864 #include "elf32-target.h"
5865