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