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